#include "postgres.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "libpq/be-fsstubs.h"
#include "libpq/libpq-fs.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/large_object.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/memutils.h"

Include dependency graph for be-fsstubs.c:

Macros
#define	BUFSIZE 8192

#define	CreateFSContext()

Functions
static int	newLOfd (LargeObjectDesc *lobjCookie)

static void	deleteLOfd (int fd)

static Oid	lo_import_internal (text *filename, Oid lobjOid)

Datum	be_lo_open (PG_FUNCTION_ARGS)

Datum	be_lo_close (PG_FUNCTION_ARGS)

int	lo_read (int fd, char *buf, int len)

int	lo_write (int fd, const char *buf, int len)

Datum	be_lo_lseek (PG_FUNCTION_ARGS)

Datum	be_lo_lseek64 (PG_FUNCTION_ARGS)

Datum	be_lo_creat (PG_FUNCTION_ARGS)

Datum	be_lo_create (PG_FUNCTION_ARGS)

Datum	be_lo_tell (PG_FUNCTION_ARGS)

Datum	be_lo_tell64 (PG_FUNCTION_ARGS)

Datum	be_lo_unlink (PG_FUNCTION_ARGS)

Datum	be_loread (PG_FUNCTION_ARGS)

Datum	be_lowrite (PG_FUNCTION_ARGS)

Datum	be_lo_import (PG_FUNCTION_ARGS)

Datum	be_lo_import_with_oid (PG_FUNCTION_ARGS)

Datum	be_lo_export (PG_FUNCTION_ARGS)

static void	lo_truncate_internal (int32 fd, int64 len)

Datum	be_lo_truncate (PG_FUNCTION_ARGS)

Datum	be_lo_truncate64 (PG_FUNCTION_ARGS)

void	AtEOXact_LargeObject (bool isCommit)

void	AtEOSubXact_LargeObject (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)

static bytea *	lo_get_fragment_internal (Oid loOid, int64 offset, int32 nbytes)

Datum	be_lo_get (PG_FUNCTION_ARGS)

Datum	be_lo_get_fragment (PG_FUNCTION_ARGS)

Datum	be_lo_from_bytea (PG_FUNCTION_ARGS)

Datum	be_lo_put (PG_FUNCTION_ARGS)

Variables
bool	lo_compat_privileges

static LargeObjectDesc **	cookies = NULL

static int	cookies_size = 0

static MemoryContext	fscxt = NULL

Macro Definition Documentation

#define BUFSIZE 8192

Definition at line 62 of file be-fsstubs.c.

Referenced by be_lo_export(), and lo_import_internal().

#define CreateFSContext ( )

Value:

do { \
        if (fscxt == NULL) \
			fscxt = AllocSetContextCreate(TopMemoryContext, \
                                          "Filesystem", \
                                          ALLOCSET_DEFAULT_SIZES); \
    } while (0)

Definition at line 77 of file be-fsstubs.c.

Referenced by be_lo_creat(), be_lo_create(), be_lo_export(), be_lo_from_bytea(), be_lo_open(), be_lo_put(), lo_get_fragment_internal(), and lo_import_internal().

Function Documentation

void AtEOSubXact_LargeObject	(	bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

Definition at line 674 of file be-fsstubs.c.

References cookies_size, deleteLOfd(), i, inv_close(), NULL, and LargeObjectDesc::subid.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

 {
     int         i;
 
     if (fscxt == NULL)          /* no LO operations in this xact */
         return;
 
     for (i = 0; i < cookies_size; i++)
     {
         LargeObjectDesc *lo = cookies[i];
 
         if (lo != NULL && lo->subid == mySubid)
         {
             if (isCommit)
                 lo->subid = parentSubid;
             else
             {
                 /*
                  * Make sure we do not call inv_close twice if it errors out
                  * for some reason.  Better a leak than a crash.
                  */
                 deleteLOfd(i);
                 inv_close(lo);
             }
         }
     }
 }

void AtEOXact_LargeObject ( bool isCommit )

Definition at line 633 of file be-fsstubs.c.

References close_lo_relation(), cookies_size, deleteLOfd(), i, inv_close(), MemoryContextDelete(), and NULL.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

 {
     int         i;
 
     if (fscxt == NULL)
         return;                 /* no LO operations in this xact */
 
     /*
      * Close LO fds and clear cookies array so that LO fds are no longer good.
      * On abort we skip the close step.
      */
     for (i = 0; i < cookies_size; i++)
     {
         if (cookies[i] != NULL)
         {
             if (isCommit)
                 inv_close(cookies[i]);
             deleteLOfd(i);
         }
     }
 
     /* Needn't actually pfree since we're about to zap context */
     cookies = NULL;
     cookies_size = 0;
 
     /* Release the LO memory context to prevent permanent memory leaks. */
     MemoryContextDelete(fscxt);
     fscxt = NULL;
 
     /* Give inv_api.c a chance to clean up, too */
     close_lo_relation(isCommit);
 }

Datum be_lo_close ( PG_FUNCTION_ARGS )

Definition at line 125 of file be-fsstubs.c.

References cookies_size, DEBUG4, deleteLOfd(), elog, ereport, errcode(), errmsg(), ERROR, fd(), inv_close(), NULL, PG_GETARG_INT32, and PG_RETURN_INT32.

 {
     int32       fd = PG_GETARG_INT32(0);
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
 
 #if FSDB
     elog(DEBUG4, "lo_close(%d)", fd);
 #endif
 
     inv_close(cookies[fd]);
 
     deleteLOfd(fd);
 
     PG_RETURN_INT32(0);
 }

Datum be_lo_creat ( PG_FUNCTION_ARGS )

Definition at line 270 of file be-fsstubs.c.

References CreateFSContext, inv_create(), InvalidOid, and PG_RETURN_OID.

 {
     Oid         lobjId;
 
     /*
      * We don't actually need to store into fscxt, but create it anyway to
      * ensure that AtEOXact_LargeObject knows there is state to clean up
      */
     CreateFSContext();
 
     lobjId = inv_create(InvalidOid);
 
     PG_RETURN_OID(lobjId);
 }

Datum be_lo_create ( PG_FUNCTION_ARGS )

Definition at line 286 of file be-fsstubs.c.

References CreateFSContext, inv_create(), PG_GETARG_OID, and PG_RETURN_OID.

 {
     Oid         lobjId = PG_GETARG_OID(0);
 
     /*
      * We don't actually need to store into fscxt, but create it anyway to
      * ensure that AtEOXact_LargeObject knows there is state to clean up
      */
     CreateFSContext();
 
     lobjId = inv_create(lobjId);
 
     PG_RETURN_OID(lobjId);
 }

Datum be_lo_export ( PG_FUNCTION_ARGS )

Definition at line 505 of file be-fsstubs.c.

References buf, BUFSIZE, CloseTransientFile(), CreateFSContext, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, fd(), filename, inv_close(), inv_open(), INV_READ, inv_read(), MAXPGPATH, OpenTransientFile(), PG_BINARY, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_INT32, S_IRGRP, S_IROTH, S_IWGRP, S_IWOTH, superuser(), text_to_cstring_buffer(), and write.

 {
     Oid         lobjId = PG_GETARG_OID(0);
     text       *filename = PG_GETARG_TEXT_PP(1);
     int         fd;
     int         nbytes,
                 tmp;
     char        buf[BUFSIZE];
     char        fnamebuf[MAXPGPATH];
     LargeObjectDesc *lobj;
     mode_t      oumask;
 
 #ifndef ALLOW_DANGEROUS_LO_FUNCTIONS
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to use server-side lo_export()"),
                  errhint("Anyone can use the client-side lo_export() provided by libpq.")));
 #endif
 
     CreateFSContext();
 
     /*
      * open the inversion object (no need to test for failure)
      */
     lobj = inv_open(lobjId, INV_READ, fscxt);
 
     /*
      * open the file to be written to
      *
      * Note: we reduce backend's normal 077 umask to the slightly friendlier
      * 022. This code used to drop it all the way to 0, but creating
      * world-writable export files doesn't seem wise.
      */
     text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
     oumask = umask(S_IWGRP | S_IWOTH);
     fd = OpenTransientFile(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY,
                            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
     umask(oumask);
     if (fd < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not create server file \"%s\": %m",
                         fnamebuf)));
 
     /*
      * read in from the inversion file and write to the filesystem
      */
     while ((nbytes = inv_read(lobj, buf, BUFSIZE)) > 0)
     {
         tmp = write(fd, buf, nbytes);
         if (tmp != nbytes)
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not write server file \"%s\": %m",
                             fnamebuf)));
     }
 
     CloseTransientFile(fd);
     inv_close(lobj);
 
     PG_RETURN_INT32(1);
 }

Datum be_lo_from_bytea ( PG_FUNCTION_ARGS )

Definition at line 866 of file be-fsstubs.c.

References Assert, CreateFSContext, inv_close(), inv_create(), inv_open(), INV_WRITE, inv_write(), PG_GETARG_BYTEA_PP, PG_GETARG_OID, PG_RETURN_OID, PG_USED_FOR_ASSERTS_ONLY, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

 {
     Oid         loOid = PG_GETARG_OID(0);
     bytea      *str = PG_GETARG_BYTEA_PP(1);
     LargeObjectDesc *loDesc;
     int         written PG_USED_FOR_ASSERTS_ONLY;
 
     CreateFSContext();
 
     loOid = inv_create(loOid);
     loDesc = inv_open(loOid, INV_WRITE, fscxt);
     written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str));
     Assert(written == VARSIZE_ANY_EXHDR(str));
     inv_close(loDesc);
 
     PG_RETURN_OID(loOid);
 }

Datum be_lo_get ( PG_FUNCTION_ARGS )

Definition at line 831 of file be-fsstubs.c.

References lo_get_fragment_internal(), PG_GETARG_OID, PG_RETURN_BYTEA_P, and result.

 {
     Oid         loOid = PG_GETARG_OID(0);
     bytea      *result;
 
     result = lo_get_fragment_internal(loOid, 0, -1);
 
     PG_RETURN_BYTEA_P(result);
 }

Datum be_lo_get_fragment ( PG_FUNCTION_ARGS )

Definition at line 845 of file be-fsstubs.c.

References ereport, errcode(), errmsg(), ERROR, lo_get_fragment_internal(), PG_GETARG_INT32, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_BYTEA_P, and result.

 {
     Oid         loOid = PG_GETARG_OID(0);
     int64       offset = PG_GETARG_INT64(1);
     int32       nbytes = PG_GETARG_INT32(2);
     bytea      *result;
 
     if (nbytes < 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("requested length cannot be negative")));
 
     result = lo_get_fragment_internal(loOid, offset, nbytes);
 
     PG_RETURN_BYTEA_P(result);
 }

Datum be_lo_import ( PG_FUNCTION_ARGS )

Definition at line 420 of file be-fsstubs.c.

References filename, InvalidOid, lo_import_internal(), PG_GETARG_TEXT_PP, and PG_RETURN_OID.

 {
     text       *filename = PG_GETARG_TEXT_PP(0);
 
     PG_RETURN_OID(lo_import_internal(filename, InvalidOid));
 }

Datum be_lo_import_with_oid ( PG_FUNCTION_ARGS )

Definition at line 432 of file be-fsstubs.c.

References filename, lo_import_internal(), PG_GETARG_OID, PG_GETARG_TEXT_PP, and PG_RETURN_OID.

 {
     text       *filename = PG_GETARG_TEXT_PP(0);
     Oid         oid = PG_GETARG_OID(1);
 
     PG_RETURN_OID(lo_import_internal(filename, oid));
 }

Datum be_lo_lseek ( PG_FUNCTION_ARGS )

Definition at line 227 of file be-fsstubs.c.

References cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_seek(), NULL, PG_GETARG_INT32, PG_RETURN_INT32, and status().

 {
     int32       fd = PG_GETARG_INT32(0);
     int32       offset = PG_GETARG_INT32(1);
     int32       whence = PG_GETARG_INT32(2);
     int64       status;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
 
     status = inv_seek(cookies[fd], offset, whence);
 
     /* guard against result overflow */
     if (status != (int32) status)
         ereport(ERROR,
                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                  errmsg("lo_lseek result out of range for large-object descriptor %d",
                         fd)));
 
     PG_RETURN_INT32((int32) status);
 }

Datum be_lo_lseek64 ( PG_FUNCTION_ARGS )

Definition at line 252 of file be-fsstubs.c.

References cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_seek(), NULL, PG_GETARG_INT32, PG_GETARG_INT64, PG_RETURN_INT64, and status().

 {
     int32       fd = PG_GETARG_INT32(0);
     int64       offset = PG_GETARG_INT64(1);
     int32       whence = PG_GETARG_INT32(2);
     int64       status;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
 
     status = inv_seek(cookies[fd], offset, whence);
 
     PG_RETURN_INT64(status);
 }

Datum be_lo_open ( PG_FUNCTION_ARGS )

Definition at line 96 of file be-fsstubs.c.

References CreateFSContext, DEBUG4, elog, fd(), inv_open(), newLOfd(), NULL, PG_GETARG_INT32, PG_GETARG_OID, and PG_RETURN_INT32.

 {
     Oid         lobjId = PG_GETARG_OID(0);
     int32       mode = PG_GETARG_INT32(1);
     LargeObjectDesc *lobjDesc;
     int         fd;
 
 #if FSDB
     elog(DEBUG4, "lo_open(%u,%d)", lobjId, mode);
 #endif
 
     CreateFSContext();
 
     lobjDesc = inv_open(lobjId, mode, fscxt);
 
     if (lobjDesc == NULL)
     {                           /* lookup failed */
 #if FSDB
         elog(DEBUG4, "could not open large object %u", lobjId);
 #endif
         PG_RETURN_INT32(-1);
     }
 
     fd = newLOfd(lobjDesc);
 
     PG_RETURN_INT32(fd);
 }

Datum be_lo_put ( PG_FUNCTION_ARGS )

Definition at line 888 of file be-fsstubs.c.

References Assert, CreateFSContext, inv_close(), inv_open(), inv_seek(), INV_WRITE, inv_write(), PG_GETARG_BYTEA_PP, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_VOID, PG_USED_FOR_ASSERTS_ONLY, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

 {
     Oid         loOid = PG_GETARG_OID(0);
     int64       offset = PG_GETARG_INT64(1);
     bytea      *str = PG_GETARG_BYTEA_PP(2);
     LargeObjectDesc *loDesc;
     int         written PG_USED_FOR_ASSERTS_ONLY;
 
     CreateFSContext();
 
     loDesc = inv_open(loOid, INV_WRITE, fscxt);
     inv_seek(loDesc, offset, SEEK_SET);
     written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str));
     Assert(written == VARSIZE_ANY_EXHDR(str));
     inv_close(loDesc);
 
     PG_RETURN_VOID();
 }

Datum be_lo_tell ( PG_FUNCTION_ARGS )

Definition at line 302 of file be-fsstubs.c.

References cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_tell(), NULL, PG_GETARG_INT32, and PG_RETURN_INT32.

 {
     int32       fd = PG_GETARG_INT32(0);
     int64       offset;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
 
     offset = inv_tell(cookies[fd]);
 
     /* guard against result overflow */
     if (offset != (int32) offset)
         ereport(ERROR,
                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                  errmsg("lo_tell result out of range for large-object descriptor %d",
                         fd)));
 
     PG_RETURN_INT32((int32) offset);
 }

Datum be_lo_tell64 ( PG_FUNCTION_ARGS )

Definition at line 325 of file be-fsstubs.c.

References cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_tell(), NULL, PG_GETARG_INT32, and PG_RETURN_INT64.

 {
     int32       fd = PG_GETARG_INT32(0);
     int64       offset;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
 
     offset = inv_tell(cookies[fd]);
 
     PG_RETURN_INT64(offset);
 }

Datum be_lo_truncate ( PG_FUNCTION_ARGS )

Definition at line 609 of file be-fsstubs.c.

References fd(), lo_truncate_internal(), PG_GETARG_INT32, and PG_RETURN_INT32.

 {
     int32       fd = PG_GETARG_INT32(0);
     int32       len = PG_GETARG_INT32(1);
 
     lo_truncate_internal(fd, len);
     PG_RETURN_INT32(0);
 }

Datum be_lo_truncate64 ( PG_FUNCTION_ARGS )

Definition at line 619 of file be-fsstubs.c.

References fd(), lo_truncate_internal(), PG_GETARG_INT32, PG_GETARG_INT64, and PG_RETURN_INT32.

 {
     int32       fd = PG_GETARG_INT32(0);
     int64       len = PG_GETARG_INT64(1);
 
     lo_truncate_internal(fd, len);
     PG_RETURN_INT32(0);
 }

Datum be_lo_unlink ( PG_FUNCTION_ARGS )

Definition at line 341 of file be-fsstubs.c.

References cookies_size, deleteLOfd(), ereport, errcode(), errmsg(), ERROR, GetUserId(), i, inv_close(), inv_drop(), lo_compat_privileges, NULL, PG_GETARG_OID, pg_largeobject_ownercheck(), and PG_RETURN_INT32.

Referenced by lo_manage().

 {
     Oid         lobjId = PG_GETARG_OID(0);
 
     /* Must be owner of the largeobject */
     if (!lo_compat_privileges &&
         !pg_largeobject_ownercheck(lobjId, GetUserId()))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be owner of large object %u", lobjId)));
 
     /*
      * If there are any open LO FDs referencing that ID, close 'em.
      */
     if (fscxt != NULL)
     {
         int         i;
 
         for (i = 0; i < cookies_size; i++)
         {
             if (cookies[i] != NULL && cookies[i]->id == lobjId)
             {
                 inv_close(cookies[i]);
                 deleteLOfd(i);
             }
         }
     }
 
     /*
      * inv_drop does not create a need for end-of-transaction cleanup and
      * hence we don't need to have created fscxt.
      */
     PG_RETURN_INT32(inv_drop(lobjId));
 }

Datum be_loread ( PG_FUNCTION_ARGS )

Definition at line 381 of file be-fsstubs.c.

References fd(), lo_read(), palloc(), PG_GETARG_INT32, PG_RETURN_BYTEA_P, SET_VARSIZE, VARDATA, and VARHDRSZ.

 {
     int32       fd = PG_GETARG_INT32(0);
     int32       len = PG_GETARG_INT32(1);
     bytea      *retval;
     int         totalread;
 
     if (len < 0)
         len = 0;
 
     retval = (bytea *) palloc(VARHDRSZ + len);
     totalread = lo_read(fd, VARDATA(retval), len);
     SET_VARSIZE(retval, totalread + VARHDRSZ);
 
     PG_RETURN_BYTEA_P(retval);
 }

Datum be_lowrite ( PG_FUNCTION_ARGS )

Definition at line 399 of file be-fsstubs.c.

References fd(), lo_write(), PG_GETARG_BYTEA_PP, PG_GETARG_INT32, PG_RETURN_INT32, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

 {
     int32       fd = PG_GETARG_INT32(0);
     bytea      *wbuf = PG_GETARG_BYTEA_PP(1);
     int         bytestowrite;
     int         totalwritten;
 
     bytestowrite = VARSIZE_ANY_EXHDR(wbuf);
     totalwritten = lo_write(fd, VARDATA_ANY(wbuf), bytestowrite);
     PG_RETURN_INT32(totalwritten);
 }

static void deleteLOfd ( int fd )

static

Definition at line 751 of file be-fsstubs.c.

References fd(), and NULL.

Referenced by AtEOSubXact_LargeObject(), AtEOXact_LargeObject(), be_lo_close(), and be_lo_unlink().

 {
     cookies[fd] = NULL;
 }

static bytea* lo_get_fragment_internal	(	Oid	loOid,
		int64	offset,
		int32	nbytes
	)

static

Definition at line 764 of file be-fsstubs.c.

References ACL_SELECT, ACLCHECK_OK, Assert, CreateFSContext, ereport, errcode(), errmsg(), ERROR, GetUserId(), LargeObjectDesc::id, inv_close(), inv_open(), INV_READ, inv_read(), inv_seek(), lo_compat_privileges, MaxAllocSize, NULL, palloc(), pg_largeobject_aclcheck_snapshot(), PG_USED_FOR_ASSERTS_ONLY, result, SET_VARSIZE, LargeObjectDesc::snapshot, VARDATA, and VARHDRSZ.

Referenced by be_lo_get(), and be_lo_get_fragment().

 {
     LargeObjectDesc *loDesc;
     int64       loSize;
     int64       result_length;
     int         total_read PG_USED_FOR_ASSERTS_ONLY;
     bytea      *result = NULL;
 
     /*
      * We don't actually need to store into fscxt, but create it anyway to
      * ensure that AtEOXact_LargeObject knows there is state to clean up
      */
     CreateFSContext();
 
     loDesc = inv_open(loOid, INV_READ, fscxt);
 
     /* Permission check */
     if (!lo_compat_privileges &&
         pg_largeobject_aclcheck_snapshot(loDesc->id,
                                          GetUserId(),
                                          ACL_SELECT,
                                          loDesc->snapshot) != ACLCHECK_OK)
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied for large object %u",
                         loDesc->id)));
 
     /*
      * Compute number of bytes we'll actually read, accommodating nbytes == -1
      * and reads beyond the end of the LO.
      */
     loSize = inv_seek(loDesc, 0, SEEK_END);
     if (loSize > offset)
     {
         if (nbytes >= 0 && nbytes <= loSize - offset)
             result_length = nbytes; /* request is wholly inside LO */
         else
             result_length = loSize - offset;    /* adjust to end of LO */
     }
     else
         result_length = 0;      /* request is wholly outside LO */
 
     /*
      * A result_length calculated from loSize may not fit in a size_t.  Check
      * that the size will satisfy this and subsequently-enforced size limits.
      */
     if (result_length > MaxAllocSize - VARHDRSZ)
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("large object read request is too large")));
 
     result = (bytea *) palloc(VARHDRSZ + result_length);
 
     inv_seek(loDesc, offset, SEEK_SET);
     total_read = inv_read(loDesc, VARDATA(result), result_length);
     Assert(total_read == result_length);
     SET_VARSIZE(result, result_length + VARHDRSZ);
 
     inv_close(loDesc);
 
     return result;
 }

static Oid lo_import_internal	(	text *	filename,
		Oid	lobjOid
	)

static

Definition at line 441 of file be-fsstubs.c.

References Assert, buf, BUFSIZE, CloseTransientFile(), CreateFSContext, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, fd(), inv_close(), inv_create(), inv_open(), INV_WRITE, inv_write(), MAXPGPATH, OpenTransientFile(), PG_BINARY, PG_USED_FOR_ASSERTS_ONLY, read, superuser(), and text_to_cstring_buffer().

Referenced by be_lo_import(), and be_lo_import_with_oid().

 {
     int         fd;
     int         nbytes,
                 tmp PG_USED_FOR_ASSERTS_ONLY;
     char        buf[BUFSIZE];
     char        fnamebuf[MAXPGPATH];
     LargeObjectDesc *lobj;
     Oid         oid;
 
 #ifndef ALLOW_DANGEROUS_LO_FUNCTIONS
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to use server-side lo_import()"),
                  errhint("Anyone can use the client-side lo_import() provided by libpq.")));
 #endif
 
     CreateFSContext();
 
     /*
      * open the file to be read in
      */
     text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
     fd = OpenTransientFile(fnamebuf, O_RDONLY | PG_BINARY, S_IRWXU);
     if (fd < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not open server file \"%s\": %m",
                         fnamebuf)));
 
     /*
      * create an inversion object
      */
     oid = inv_create(lobjOid);
 
     /*
      * read in from the filesystem and write to the inversion object
      */
     lobj = inv_open(oid, INV_WRITE, fscxt);
 
     while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
     {
         tmp = inv_write(lobj, buf, nbytes);
         Assert(tmp == nbytes);
     }
 
     if (nbytes < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not read server file \"%s\": %m",
                         fnamebuf)));
 
     inv_close(lobj);
     CloseTransientFile(fd);
 
     return oid;
 }

int lo_read	(	int	fd,
		char *	buf,
		int	len
	)

Definition at line 155 of file be-fsstubs.c.

References ACL_SELECT, ACLCHECK_OK, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, GetUserId(), LargeObjectDesc::id, IFS_RD_PERM_OK, inv_read(), lo_compat_privileges, NULL, pg_largeobject_aclcheck_snapshot(), LargeObjectDesc::snapshot, and status().

Referenced by be_loread(), dumpBlobs(), exportFile(), and pickout().

 {
     int         status;
     LargeObjectDesc *lobj;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
     lobj = cookies[fd];
 
     /* We don't bother to check IFS_RDLOCK, since it's always set */
 
     /* Permission checks --- first time through only */
     if ((lobj->flags & IFS_RD_PERM_OK) == 0)
     {
         if (!lo_compat_privileges &&
             pg_largeobject_aclcheck_snapshot(lobj->id,
                                              GetUserId(),
                                              ACL_SELECT,
                                              lobj->snapshot) != ACLCHECK_OK)
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("permission denied for large object %u",
                             lobj->id)));
         lobj->flags |= IFS_RD_PERM_OK;
     }
 
     status = inv_read(lobj, buf, len);
 
     return status;
 }

static void lo_truncate_internal	(	int32	fd,
		int64	len
	)

static

Definition at line 574 of file be-fsstubs.c.

References ACL_UPDATE, ACLCHECK_OK, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, GetUserId(), LargeObjectDesc::id, IFS_WR_PERM_OK, IFS_WRLOCK, inv_truncate(), lo_compat_privileges, NULL, pg_largeobject_aclcheck_snapshot(), and LargeObjectDesc::snapshot.

Referenced by be_lo_truncate(), and be_lo_truncate64().

 {
     LargeObjectDesc *lobj;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
     lobj = cookies[fd];
 
     if ((lobj->flags & IFS_WRLOCK) == 0)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("large object descriptor %d was not opened for writing",
                         fd)));
 
     /* Permission checks --- first time through only */
     if ((lobj->flags & IFS_WR_PERM_OK) == 0)
     {
         if (!lo_compat_privileges &&
             pg_largeobject_aclcheck_snapshot(lobj->id,
                                              GetUserId(),
                                              ACL_UPDATE,
                                              lobj->snapshot) != ACLCHECK_OK)
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("permission denied for large object %u",
                             lobj->id)));
         lobj->flags |= IFS_WR_PERM_OK;
     }
 
     inv_truncate(lobj, len);
 }

int lo_write	(	int	fd,
		const char *	buf,
		int	len
	)

Definition at line 189 of file be-fsstubs.c.

References ACL_UPDATE, ACLCHECK_OK, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, GetUserId(), LargeObjectDesc::id, IFS_WR_PERM_OK, IFS_WRLOCK, inv_write(), lo_compat_privileges, NULL, pg_largeobject_aclcheck_snapshot(), LargeObjectDesc::snapshot, and status().

Referenced by be_lowrite(), dump_lo_buf(), importFile(), and overwrite().

 {
     int         status;
     LargeObjectDesc *lobj;
 
     if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("invalid large-object descriptor: %d", fd)));
     lobj = cookies[fd];
 
     if ((lobj->flags & IFS_WRLOCK) == 0)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("large object descriptor %d was not opened for writing",
                         fd)));
 
     /* Permission checks --- first time through only */
     if ((lobj->flags & IFS_WR_PERM_OK) == 0)
     {
         if (!lo_compat_privileges &&
             pg_largeobject_aclcheck_snapshot(lobj->id,
                                              GetUserId(),
                                              ACL_UPDATE,
                                              lobj->snapshot) != ACLCHECK_OK)
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("permission denied for large object %u",
                             lobj->id)));
         lobj->flags |= IFS_WR_PERM_OK;
     }
 
     status = inv_write(lobj, buf, len);
 
     return status;
 }

static int newLOfd ( LargeObjectDesc * lobjCookie )

static

Definition at line 708 of file be-fsstubs.c.

References Assert, cookies_size, i, MemoryContextAllocZero(), MemSet, NULL, and repalloc().

Referenced by be_lo_open().

 {
     int         i,
                 newsize;
 
     /* Try to find a free slot */
     for (i = 0; i < cookies_size; i++)
     {
         if (cookies[i] == NULL)
         {
             cookies[i] = lobjCookie;
             return i;
         }
     }
 
     /* No free slot, so make the array bigger */
     if (cookies_size <= 0)
     {
         /* First time through, arbitrarily make 64-element array */
         i = 0;
         newsize = 64;
         cookies = (LargeObjectDesc **)
             MemoryContextAllocZero(fscxt, newsize * sizeof(LargeObjectDesc *));
         cookies_size = newsize;
     }
     else
     {
         /* Double size of array */
         i = cookies_size;
         newsize = cookies_size * 2;
         cookies = (LargeObjectDesc **)
             repalloc(cookies, newsize * sizeof(LargeObjectDesc *));
         MemSet(cookies + cookies_size, 0,
                (newsize - cookies_size) * sizeof(LargeObjectDesc *));
         cookies_size = newsize;
     }
 
     Assert(cookies[i] == NULL);
     cookies[i] = lobjCookie;
     return i;
 }