testlo64.c File Reference

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "libpq-fe.h"
#include "libpq/libpq-fs.h"

Include dependency graph for testlo64.c:

Go to the source code of this file.

Macros
#define	BUFSIZE   1024

Functions
static Oid	importFile (PGconn *conn, char *filename)
static void	pickout (PGconn *conn, Oid lobjId, int64_t start, int len)
static void	overwrite (PGconn *conn, Oid lobjId, int64_t start, int len)
static void	my_truncate (PGconn *conn, Oid lobjId, int64_t len)
static void	exportFile (PGconn *conn, Oid lobjId, char *filename)
static void	exit_nicely (PGconn *conn)
int	main (int argc, char **argv)

Macro Definition Documentation

BUFSIZE

#define BUFSIZE   1024

Definition at line 27 of file testlo64.c.

Function Documentation

exit_nicely()

static void exit_nicely ( PGconn *  conn )

static

Definition at line 216 of file testlo64.c.

{
    PQfinish(conn);
    exit(1);
}

References conn, and PQfinish().

Referenced by main().

exportFile()

static void exportFile ( PGconn *  conn, Oid  lobjId, char *  filename  )

static

Definition at line 173 of file testlo64.c.

{
    int         lobj_fd;
    char        buf[BUFSIZE];
    int         nbytes,
                tmp;
    int         fd;
 
    /*
     * open the large object
     */
    lobj_fd = lo_open(conn, lobjId, INV_READ);
    if (lobj_fd < 0)
        fprintf(stderr, "cannot open large object %u", lobjId);
 
    /*
     * open the file to be written to
     */
    fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
    if (fd < 0)
    {                           /* error */
        fprintf(stderr, "cannot open unix file\"%s\"",
                filename);
    }
 
    /*
     * read in from the inversion file and write to the Unix file
     */
    while ((nbytes = lo_read(conn, lobj_fd, buf, BUFSIZE)) > 0)
    {
        tmp = write(fd, buf, nbytes);
        if (tmp < nbytes)
        {
            fprintf(stderr, "error while writing \"%s\"",
                    filename);
        }
    }
 
    lo_close(conn, lobj_fd);
    close(fd);
}

References buf, BUFSIZE, close, conn, fd(), filename, fprintf, INV_READ, lo_close(), lo_open(), lo_read(), and write.

importFile()

static Oid importFile ( PGconn *  conn, char *  filename  )

static

Definition at line 35 of file testlo64.c.

{
    Oid         lobjId;
    int         lobj_fd;
    char        buf[BUFSIZE];
    int         nbytes,
                tmp;
    int         fd;
 
    /*
     * open the file to be read in
     */
    fd = open(filename, O_RDONLY, 0666);
    if (fd < 0)
    {                           /* error */
        fprintf(stderr, "cannot open unix file\"%s\"\n", filename);
    }
 
    /*
     * create the large object
     */
    lobjId = lo_creat(conn, INV_READ | INV_WRITE);
    if (lobjId == 0)
        fprintf(stderr, "cannot create large object");
 
    lobj_fd = lo_open(conn, lobjId, INV_WRITE);
 
    /*
     * read in from the Unix file and write to the inversion file
     */
    while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
    {
        tmp = lo_write(conn, lobj_fd, buf, nbytes);
        if (tmp < nbytes)
            fprintf(stderr, "error while reading \"%s\"", filename);
    }
 
    close(fd);
    lo_close(conn, lobj_fd);
 
    return lobjId;
}

References buf, BUFSIZE, close, conn, fd(), filename, fprintf, INV_READ, INV_WRITE, lo_close(), lo_creat(), lo_open(), lo_write(), and read.

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 223 of file testlo64.c.

{
    char       *in_filename,
               *out_filename,
               *out_filename2;
    char       *database;
    Oid         lobjOid;
    PGconn     *conn;
    PGresult   *res;
 
    if (argc != 5)
    {
        fprintf(stderr, "Usage: %s database_name in_filename out_filename out_filename2\n",
                argv[0]);
        exit(1);
    }
 
    database = argv[1];
    in_filename = argv[2];
    out_filename = argv[3];
    out_filename2 = argv[4];
 
    /*
     * set up the connection
     */
    conn = PQsetdb(NULL, NULL, NULL, NULL, database);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(conn) != CONNECTION_OK)
    {
        fprintf(stderr, "%s", PQerrorMessage(conn));
        exit_nicely(conn);
    }
 
    /* Set always-secure search path, so malicious users can't take control. */
    res = PQexec(conn,
                 "SELECT pg_catalog.set_config('search_path', '', false)");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
        PQclear(res);
        exit_nicely(conn);
    }
    PQclear(res);
 
    res = PQexec(conn, "begin");
    PQclear(res);
    printf("importing file \"%s\" ...\n", in_filename);
/*  lobjOid = importFile(conn, in_filename); */
    lobjOid = lo_import(conn, in_filename);
    if (lobjOid == 0)
        fprintf(stderr, "%s\n", PQerrorMessage(conn));
    else
    {
        printf("\tas large object %u.\n", lobjOid);
 
        printf("picking out bytes 4294967000-4294968000 of the large object\n");
        pickout(conn, lobjOid, 4294967000U, 1000);
 
        printf("overwriting bytes 4294967000-4294968000 of the large object with X's\n");
        overwrite(conn, lobjOid, 4294967000U, 1000);
 
        printf("exporting large object to file \"%s\" ...\n", out_filename);
/*      exportFile(conn, lobjOid, out_filename); */
        if (lo_export(conn, lobjOid, out_filename) < 0)
            fprintf(stderr, "%s\n", PQerrorMessage(conn));
 
        printf("truncating to 3294968000 bytes\n");
        my_truncate(conn, lobjOid, 3294968000U);
 
        printf("exporting truncated large object to file \"%s\" ...\n", out_filename2);
        if (lo_export(conn, lobjOid, out_filename2) < 0)
            fprintf(stderr, "%s\n", PQerrorMessage(conn));
    }
 
    res = PQexec(conn, "end");
    PQclear(res);
    PQfinish(conn);
    return 0;
}

References conn, CONNECTION_OK, exit_nicely(), fprintf, lo_export(), lo_import(), my_truncate(), overwrite(), PGRES_TUPLES_OK, pickout(), PQclear, PQerrorMessage(), PQexec(), PQfinish(), PQresultStatus, PQsetdb, PQstatus(), and printf.

my_truncate()

static void my_truncate ( PGconn *  conn, Oid  lobjId, int64_t  len  )

static

Definition at line 152 of file testlo64.c.

{
    int         lobj_fd;
 
    lobj_fd = lo_open(conn, lobjId, INV_READ | INV_WRITE);
    if (lobj_fd < 0)
        fprintf(stderr, "cannot open large object %u", lobjId);
 
    if (lo_truncate64(conn, lobj_fd, len) < 0)
        fprintf(stderr, "error in lo_truncate64: %s", PQerrorMessage(conn));
 
    lo_close(conn, lobj_fd);
}

References conn, fprintf, INV_READ, INV_WRITE, len, lo_close(), lo_open(), lo_truncate64(), and PQerrorMessage().

Referenced by main().

overwrite()

static void overwrite ( PGconn *  conn, Oid  lobjId, int64_t  start, int  len  )

static

Definition at line 114 of file testlo64.c.

{
    int         lobj_fd;
    char       *buf;
    int         nbytes;
    int         nwritten;
    int         i;
 
    lobj_fd = lo_open(conn, lobjId, INV_WRITE);
    if (lobj_fd < 0)
        fprintf(stderr, "cannot open large object %u", lobjId);
 
    if (lo_lseek64(conn, lobj_fd, start, SEEK_SET) < 0)
        fprintf(stderr, "error in lo_lseek64: %s", PQerrorMessage(conn));
 
    buf = malloc(len + 1);
 
    for (i = 0; i < len; i++)
        buf[i] = 'X';
    buf[i] = '\0';
 
    nwritten = 0;
    while (len - nwritten > 0)
    {
        nbytes = lo_write(conn, lobj_fd, buf + nwritten, len - nwritten);
        nwritten += nbytes;
        if (nbytes <= 0)
        {
            fprintf(stderr, "\nWRITE FAILED!\n");
            break;
        }
    }
    free(buf);
    fprintf(stderr, "\n");
    lo_close(conn, lobj_fd);
}

References buf, conn, fprintf, free, i, INV_WRITE, len, lo_close(), lo_lseek64(), lo_open(), lo_write(), malloc, PQerrorMessage(), and start.

Referenced by main().

pickout()

static void pickout ( PGconn *  conn, Oid  lobjId, int64_t  start, int  len  )

static

Definition at line 79 of file testlo64.c.

{
    int         lobj_fd;
    char       *buf;
    int         nbytes;
    int         nread;
 
    lobj_fd = lo_open(conn, lobjId, INV_READ);
    if (lobj_fd < 0)
        fprintf(stderr, "cannot open large object %u", lobjId);
 
    if (lo_lseek64(conn, lobj_fd, start, SEEK_SET) < 0)
        fprintf(stderr, "error in lo_lseek64: %s", PQerrorMessage(conn));
 
    if (lo_tell64(conn, lobj_fd) != start)
        fprintf(stderr, "error in lo_tell64: %s", PQerrorMessage(conn));
 
    buf = malloc(len + 1);
 
    nread = 0;
    while (len - nread > 0)
    {
        nbytes = lo_read(conn, lobj_fd, buf, len - nread);
        buf[nbytes] = '\0';
        fprintf(stderr, ">>> %s", buf);
        nread += nbytes;
        if (nbytes <= 0)
            break;              /* no more data? */
    }
    free(buf);
    fprintf(stderr, "\n");
    lo_close(conn, lobj_fd);
}

References buf, conn, fprintf, free, INV_READ, len, lo_close(), lo_lseek64(), lo_open(), lo_read(), lo_tell64(), malloc, PQerrorMessage(), and start.

Referenced by main().