/*-------------------------------------------------------------------------

 *

 * be-fsstubs.c

 *    Builtin functions for open/close/read/write operations on large objects

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/libpq/be-fsstubs.c

 *

 * NOTES

 *    This should be moved to a more appropriate place.  It is here

 *    for lack of a better place.

 *

 *    These functions store LargeObjectDesc structs in a private MemoryContext,

 *    which means that large object descriptors hang around until we destroy

 *    the context at transaction end.  It'd be possible to prolong the lifetime

 *    of the context so that LO FDs are good across transactions (for example,

 *    we could release the context only if we see that no FDs remain open).

 *    But we'd need additional state in order to do the right thing at the

 *    end of an aborted transaction.  FDs opened during an aborted xact would

 *    still need to be closed, since they might not be pointing at valid

 *    relations at all.  Locking semantics are also an interesting problem

 *    if LOs stay open across transactions.  For now, we'll stick with the

 *    existing documented semantics of LO FDs: they're only good within a

 *    transaction.

 *

 *    As of PostgreSQL 8.0, much of the angst expressed above is no longer

 *    relevant, and in fact it'd be pretty easy to allow LO FDs to stay

 *    open across transactions.  (Snapshot relevancy would still be an issue.)

 *    However backwards compatibility suggests that we should stick to the

 *    status quo.

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <fcntl.h>

#include <sys/stat.h>

#include <unistd.h>

#include "access/xact.h"

#include "catalog/pg_largeobject.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 "utils/snapmgr.h"

#include "varatt.h"

/* define this to enable debug logging */

/* #define FSDB 1 */

/* chunk size for lo_import/lo_export transfers */

#define BUFSIZE     8192

/*

 * LO "FD"s are indexes into the cookies array.

 *

 * A non-null entry is a pointer to a LargeObjectDesc allocated in the

 * LO private memory context "fscxt".  The cookies array itself is also

 * dynamically allocated in that context.  Its current allocated size is

 * cookies_size entries, of which any unused entries will be NULL.

 */

static LargeObjectDesc **cookies = NULL;

static int  cookies_size = 0;

static bool lo_cleanup_needed = false;

static MemoryContext fscxt = NULL;

static int  newLOfd(void);

static void closeLOfd(int fd);

static Oid  lo_import_internal(text *filename, Oid lobjOid);

/*****************************************************************************

 *  File Interfaces for Large Objects

 *****************************************************************************/

Datum

be_lo_open(PG_FUNCTION_ARGS)

{

  Oid     lobjId = PG_GETARG_OID(0);

  int32   mode = PG_GETARG_INT32(1);

  LargeObjectDesc *lobjDesc;

  int     fd;

#ifdef FSDB

  elog(DEBUG4, "lo_open(%u,%d)", lobjId, mode);

#endif

  if (mode & INV_WRITE)

    PreventCommandIfReadOnly("lo_open(INV_WRITE)");

  /*

   * Allocate a large object descriptor first.  This will also create

   * 'fscxt' if this is the first LO opened in this transaction.

   */

  fd = newLOfd();

  lobjDesc = inv_open(lobjId, mode, fscxt);

  lobjDesc->subid = GetCurrentSubTransactionId();

  /*

   * We must register the snapshot in TopTransaction's resowner so that it

   * stays alive until the LO is closed rather than until the current portal

   * shuts down.

   */

  if (lobjDesc->snapshot)

    lobjDesc->snapshot = RegisterSnapshotOnOwner(lobjDesc->snapshot,

                           TopTransactionResourceOwner);

  Assert(cookies[fd] == NULL);

  cookies[fd] = lobjDesc;

  PG_RETURN_INT32(fd);

}

Datum

be_lo_close(PG_FUNCTION_ARGS)

{

  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)));

#ifdef FSDB

  elog(DEBUG4, "lo_close(%d)", fd);

#endif

  closeLOfd(fd);

  PG_RETURN_INT32(0);

}

/*****************************************************************************

 *  Bare Read/Write operations --- these are not fmgr-callable!

 *

 *  We assume the large object supports byte oriented reads and seeks so

 *  that our work is easier.

 *

 *****************************************************************************/

int

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

{

  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];

  /*

   * Check state.  inv_read() would throw an error anyway, but we want the

   * error to be about the FD's state not the underlying privilege; it might

   * be that the privilege exists but user forgot to ask for read mode.

   */

  if ((lobj->flags & IFS_RDLOCK) == 0)

    ereport(ERROR,

        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),

         errmsg("large object descriptor %d was not opened for reading",

            fd)));

  status = inv_read(lobj, buf, len);

  return status;

}

int

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

{

  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];

  /* see comment in lo_read() */

  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)));

  status = inv_write(lobj, buf, len);

  return status;

}

Datum

be_lo_lseek(PG_FUNCTION_ARGS)

{

  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)

{

  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_creat(PG_FUNCTION_ARGS)

{

  Oid     lobjId;

  PreventCommandIfReadOnly("lo_creat()");

  lo_cleanup_needed = true;

  lobjId = inv_create(InvalidOid);

  PG_RETURN_OID(lobjId);

}

Datum

be_lo_create(PG_FUNCTION_ARGS)

{

  Oid     lobjId = PG_GETARG_OID(0);

  PreventCommandIfReadOnly("lo_create()");

  lo_cleanup_needed = true;

  lobjId = inv_create(lobjId);

  PG_RETURN_OID(lobjId);

}

Datum

be_lo_tell(PG_FUNCTION_ARGS)

{

  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)

{

  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_unlink(PG_FUNCTION_ARGS)

{

  Oid     lobjId = PG_GETARG_OID(0);

  PreventCommandIfReadOnly("lo_unlink()");

  if (!LargeObjectExists(lobjId))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("large object %u does not exist", lobjId)));

  /*

   * Must be owner of the large object.  It would be cleaner to check this

   * in inv_drop(), but we want to throw the error before not after closing

   * relevant FDs.

   */

  if (!lo_compat_privileges &&

    !object_ownercheck(LargeObjectRelationId, 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)

        closeLOfd(i);

    }

  }

  /*

   * inv_drop does not create a need for end-of-transaction cleanup and

   * hence we don't need to set lo_cleanup_needed.

   */

  PG_RETURN_INT32(inv_drop(lobjId));

}

/*****************************************************************************

 *  Read/Write using bytea

 *****************************************************************************/

Datum

be_loread(PG_FUNCTION_ARGS)

{

  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)

{

  int32   fd = PG_GETARG_INT32(0);

  bytea    *wbuf = PG_GETARG_BYTEA_PP(1);

  int     bytestowrite;

  int     totalwritten;

  PreventCommandIfReadOnly("lowrite()");

  bytestowrite = VARSIZE_ANY_EXHDR(wbuf);

  totalwritten = lo_write(fd, VARDATA_ANY(wbuf), bytestowrite);

  PG_RETURN_INT32(totalwritten);

}

/*****************************************************************************

 *   Import/Export of Large Object

 *****************************************************************************/

/*

 * lo_import -

 *    imports a file as an (inversion) large object.

 */

Datum

be_lo_import(PG_FUNCTION_ARGS)

{

  text     *filename = PG_GETARG_TEXT_PP(0);

  PG_RETURN_OID(lo_import_internal(filename, InvalidOid));

}

/*

 * lo_import_with_oid -

 *    imports a file as an (inversion) large object specifying oid.

 */

Datum

be_lo_import_with_oid(PG_FUNCTION_ARGS)

{

  text     *filename = PG_GETARG_TEXT_PP(0);

  Oid     oid = PG_GETARG_OID(1);

  PG_RETURN_OID(lo_import_internal(filename, oid));

}

static Oid

lo_import_internal(text *filename, Oid lobjOid)

{

  int     fd;

  int     nbytes,

        tmp PG_USED_FOR_ASSERTS_ONLY;

  char    buf[BUFSIZE];

  char    fnamebuf[MAXPGPATH];

  LargeObjectDesc *lobj;

  Oid     oid;

  PreventCommandIfReadOnly("lo_import()");

  /*

   * open the file to be read in

   */

  text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));

  fd = OpenTransientFile(fnamebuf, O_RDONLY | PG_BINARY);

  if (fd < 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not open server file \"%s\": %m",

            fnamebuf)));

  /*

   * create an inversion object

   */

  lo_cleanup_needed = true;

  oid = inv_create(lobjOid);

  /*

   * read in from the filesystem and write to the inversion object

   */

  lobj = inv_open(oid, INV_WRITE, CurrentMemoryContext);

  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);

  if (CloseTransientFile(fd) != 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not close file \"%s\": %m",

            fnamebuf)));

  return oid;

}

/*

 * lo_export -

 *    exports an (inversion) large object.

 */

Datum

be_lo_export(PG_FUNCTION_ARGS)

{

  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;

  /*

   * open the inversion object (no need to test for failure)

   */

  lo_cleanup_needed = true;

  lobj = inv_open(lobjId, INV_READ, CurrentMemoryContext);

  /*

   * 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);

  PG_TRY();

  {

    fd = OpenTransientFilePerm(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY,

                   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

  }

  PG_FINALLY();

  {

    umask(oumask);

  }

  PG_END_TRY();

  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)));

  }

  if (CloseTransientFile(fd) != 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not close file \"%s\": %m",

            fnamebuf)));

  inv_close(lobj);

  PG_RETURN_INT32(1);

}

/*

 * lo_truncate -

 *    truncate a large object to a specified length

 */

static void

lo_truncate_internal(int32 fd, int64 len)

{

  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];

  /* see comment in lo_read() */

  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)));

  inv_truncate(lobj, len);

}

Datum

be_lo_truncate(PG_FUNCTION_ARGS)

{

  int32   fd = PG_GETARG_INT32(0);

  int32   len = PG_GETARG_INT32(1);

  PreventCommandIfReadOnly("lo_truncate()");

  lo_truncate_internal(fd, len);

  PG_RETURN_INT32(0);

}

Datum

be_lo_truncate64(PG_FUNCTION_ARGS)

{

  int32   fd = PG_GETARG_INT32(0);

  int64   len = PG_GETARG_INT64(1);

  PreventCommandIfReadOnly("lo_truncate64()");

  lo_truncate_internal(fd, len);

  PG_RETURN_INT32(0);

}

/*

 * AtEOXact_LargeObject -

 *     prepares large objects for transaction commit

 */

void

AtEOXact_LargeObject(bool isCommit)

{

  int     i;

  if (!lo_cleanup_needed)

    return;         /* no LO operations in this xact */

  /*

   * Close LO fds and clear cookies array so that LO fds are no longer good.

   * The memory context and resource owner holding them are going away at

   * the end-of-transaction anyway, but on commit, we need to close them to

   * avoid warnings about leaked resources at commit.  On abort we can skip

   * this step.

   */

  if (isCommit)

  {

    for (i = 0; i < cookies_size; i++)

    {

      if (cookies[i] != NULL)

        closeLOfd(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. */

  if (fscxt)

    MemoryContextDelete(fscxt);

  fscxt = NULL;

  /* Give inv_api.c a chance to clean up, too */

  close_lo_relation(isCommit);

  lo_cleanup_needed = false;

}

/*

 * AtEOSubXact_LargeObject

 *    Take care of large objects at subtransaction commit/abort

 *

 * Reassign LOs created/opened during a committing subtransaction

 * to the parent subtransaction.  On abort, just close them.

 */

void

AtEOSubXact_LargeObject(bool isCommit, SubTransactionId mySubid,

            SubTransactionId parentSubid)

{

  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

        closeLOfd(i);

    }

  }

}

/*****************************************************************************

 *  Support routines for this file

 *****************************************************************************/

static int

newLOfd(void)

{

  int     i,

        newsize;

  lo_cleanup_needed = true;

  if (fscxt == NULL)

    fscxt = AllocSetContextCreate(TopMemoryContext,

                    "Filesystem",

                    ALLOCSET_DEFAULT_SIZES);

  /* Try to find a free slot */

  for (i = 0; i < cookies_size; i++)

  {

    if (cookies[i] == NULL)

      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 *));

  }

  else

  {

    /* Double size of array */

    i = cookies_size;

    newsize = cookies_size * 2;

    cookies =

      repalloc0_array(cookies, LargeObjectDesc *, cookies_size, newsize);

  }

  cookies_size = newsize;

  return i;

}

static void

closeLOfd(int fd)

{

  LargeObjectDesc *lobj;

  /*

   * Make sure we do not try to free twice if this errors out for some

   * reason.  Better a leak than a crash.

   */

  lobj = cookies[fd];

  cookies[fd] = NULL;

  if (lobj->snapshot)

    UnregisterSnapshotFromOwner(lobj->snapshot,

                  TopTransactionResourceOwner);

  inv_close(lobj);

}

/*****************************************************************************

 *  Wrappers oriented toward SQL callers

 *****************************************************************************/

/*

 * Read [offset, offset+nbytes) within LO; when nbytes is -1, read to end.

 */

static bytea *

lo_get_fragment_internal(Oid loOid, int64 offset, int32 nbytes)

{

  LargeObjectDesc *loDesc;

  int64   loSize;

  int64   result_length;

  int     total_read PG_USED_FOR_ASSERTS_ONLY;

  bytea    *result = NULL;

  lo_cleanup_needed = true;

  loDesc = inv_open(loOid, INV_READ, CurrentMemoryContext);

  /*

   * 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;

}

/*

 * Read entire LO

 */

Datum

be_lo_get(PG_FUNCTION_ARGS)

{

  Oid     loOid = PG_GETARG_OID(0);

  bytea    *result;

  result = lo_get_fragment_internal(loOid, 0, -1);

  PG_RETURN_BYTEA_P(result);

}

/*

 * Read range within LO

 */

Datum

be_lo_get_fragment(PG_FUNCTION_ARGS)

{

  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);

}

/*

 * Create LO with initial contents given by a bytea argument

 */

Datum

be_lo_from_bytea(PG_FUNCTION_ARGS)

{

  Oid     loOid = PG_GETARG_OID(0);

  bytea    *str = PG_GETARG_BYTEA_PP(1);

  LargeObjectDesc *loDesc;

  int     written PG_USED_FOR_ASSERTS_ONLY;

  PreventCommandIfReadOnly("lo_from_bytea()");

  lo_cleanup_needed = true;

  loOid = inv_create(loOid);

  loDesc = inv_open(loOid, INV_WRITE, CurrentMemoryContext);

  written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str));

  Assert(written == VARSIZE_ANY_EXHDR(str));

  inv_close(loDesc);

  PG_RETURN_OID(loOid);

}

/*

 * Update range within LO

 */

Datum

be_lo_put(PG_FUNCTION_ARGS)

{

  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;

  PreventCommandIfReadOnly("lo_put()");

  lo_cleanup_needed = true;

  loDesc = inv_open(loOid, INV_WRITE, CurrentMemoryContext);

  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();

}