Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions  Download package

genfile.c
/*-------------------------------------------------------------------------
 *
 * genfile.c
 *          Functions for direct access to files
 *
 *
 * Copyright (c) 2004-2009, PostgreSQL Global Development Group
 *
 * Author: Andreas Pflug <pgadmin@pse-consulting.de>
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/utils/adt/genfile.c,v 1.21 2009/01/01 17:23:49 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <sys/file.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>

#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "postmaster/syslogger.h"
#include "storage/fd.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"

typedef struct
{
      char     *location;
      DIR            *dirdesc;
} directory_fctx;


/*
 * Convert a "text" filename argument to C string, and check it's allowable.
 *
 * Filename may be absolute or relative to the DataDir, but we only allow
 * absolute paths that match DataDir or Log_directory.
 */
static char *
convert_and_check_filename(text *arg)
{
      char     *filename;

      filename = text_to_cstring(arg);
      canonicalize_path(filename);  /* filename can change length here */

      /* Disallow ".." in the path */
      if (path_contains_parent_reference(filename))
            ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  (errmsg("reference to parent directory (\"..\") not allowed"))));

      if (is_absolute_path(filename))
      {
            /* Allow absolute references within DataDir */
            if (path_is_prefix_of_path(DataDir, filename))
                  return filename;
            /* The log directory might be outside our datadir, but allow it */
            if (is_absolute_path(Log_directory) &&
                  path_is_prefix_of_path(Log_directory, filename))
                  return filename;

            ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         (errmsg("absolute path not allowed"))));
            return NULL;                  /* keep compiler quiet */
      }
      else
      {
            return filename;
      }
}


/*
 * Read a section of a file, returning it as text
 */
Datum
pg_read_file(PG_FUNCTION_ARGS)
{
      text     *filename_t = PG_GETARG_TEXT_P(0);
      int64       seek_offset = PG_GETARG_INT64(1);
      int64       bytes_to_read = PG_GETARG_INT64(2);
      char     *buf;
      size_t            nbytes;
      FILE     *file;
      char     *filename;

      if (!superuser())
            ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         (errmsg("must be superuser to read files"))));

      filename = convert_and_check_filename(filename_t);

      if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)
            ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not open file \"%s\" for reading: %m",
                                    filename)));

      if (fseeko(file, (off_t) seek_offset,
                     (seek_offset >= 0) ? SEEK_SET : SEEK_END) != 0)
            ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not seek in file \"%s\": %m", filename)));

      if (bytes_to_read < 0)
            ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("requested length cannot be negative")));

      /* not sure why anyone thought that int64 length was a good idea */
      if (bytes_to_read > (MaxAllocSize - VARHDRSZ))
            ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("requested length too large")));

      buf = palloc((Size) bytes_to_read + VARHDRSZ);

      nbytes = fread(VARDATA(buf), 1, (size_t) bytes_to_read, file);

      if (ferror(file))
            ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not read file \"%s\": %m", filename)));

      SET_VARSIZE(buf, nbytes + VARHDRSZ);

      FreeFile(file);
      pfree(filename);

      PG_RETURN_TEXT_P(buf);
}

/*
 * stat a file
 */
Datum
pg_stat_file(PG_FUNCTION_ARGS)
{
      text     *filename_t = PG_GETARG_TEXT_P(0);
      char     *filename;
      struct stat fst;
      Datum       values[6];
      bool        isnull[6];
      HeapTuple   tuple;
      TupleDesc   tupdesc;

      if (!superuser())
            ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         (errmsg("must be superuser to get file information"))));

      filename = convert_and_check_filename(filename_t);

      if (stat(filename, &fst) < 0)
            ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not stat file \"%s\": %m", filename)));

      /*
       * This record type had better match the output parameters declared for me
       * in pg_proc.h.
       */
      tupdesc = CreateTemplateTupleDesc(6, false);
      TupleDescInitEntry(tupdesc, (AttrNumber) 1,
                                 "size", INT8OID, -1, 0);
      TupleDescInitEntry(tupdesc, (AttrNumber) 2,
                                 "access", TIMESTAMPTZOID, -1, 0);
      TupleDescInitEntry(tupdesc, (AttrNumber) 3,
                                 "modification", TIMESTAMPTZOID, -1, 0);
      TupleDescInitEntry(tupdesc, (AttrNumber) 4,
                                 "change", TIMESTAMPTZOID, -1, 0);
      TupleDescInitEntry(tupdesc, (AttrNumber) 5,
                                 "creation", TIMESTAMPTZOID, -1, 0);
      TupleDescInitEntry(tupdesc, (AttrNumber) 6,
                                 "isdir", BOOLOID, -1, 0);
      BlessTupleDesc(tupdesc);

      memset(isnull, false, sizeof(isnull));

      values[0] = Int64GetDatum((int64) fst.st_size);
      values[1] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_atime));
      values[2] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_mtime));
      /* Unix has file status change time, while Win32 has creation time */
#if !defined(WIN32) && !defined(__CYGWIN__)
      values[3] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));
      isnull[4] = true;
#else
      isnull[3] = true;
      values[4] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));
#endif
      values[5] = BoolGetDatum(S_ISDIR(fst.st_mode));

      tuple = heap_form_tuple(tupdesc, values, isnull);

      pfree(filename);

      PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
}


/*
 * List a directory (returns the filenames only)
 */
Datum
pg_ls_dir(PG_FUNCTION_ARGS)
{
      FuncCallContext *funcctx;
      struct dirent *de;
      directory_fctx *fctx;

      if (!superuser())
            ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         (errmsg("must be superuser to get directory listings"))));

      if (SRF_IS_FIRSTCALL())
      {
            MemoryContext oldcontext;

            funcctx = SRF_FIRSTCALL_INIT();
            oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

            fctx = palloc(sizeof(directory_fctx));
            fctx->location = convert_and_check_filename(PG_GETARG_TEXT_P(0));

            fctx->dirdesc = AllocateDir(fctx->location);

            if (!fctx->dirdesc)
                  ereport(ERROR,
                              (errcode_for_file_access(),
                               errmsg("could not open directory \"%s\": %m",
                                          fctx->location)));

            funcctx->user_fctx = fctx;
            MemoryContextSwitchTo(oldcontext);
      }

      funcctx = SRF_PERCALL_SETUP();
      fctx = (directory_fctx *) funcctx->user_fctx;

      while ((de = ReadDir(fctx->dirdesc, fctx->location)) != NULL)
      {
            if (strcmp(de->d_name, ".") == 0 ||
                  strcmp(de->d_name, "..") == 0)
                  continue;

            SRF_RETURN_NEXT(funcctx, CStringGetTextDatum(de->d_name));
      }

      FreeDir(fctx->dirdesc);

      SRF_RETURN_DONE(funcctx);
}

Generated by  Doxygen 1.6.0   Back to index