LCOV - code coverage report
Current view: top level - src/backend/utils/adt - genfile.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 159 232 68.5 %
Date: 2021-01-26 02:06:48 Functions: 13 21 61.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * genfile.c
       4             :  *      Functions for direct access to files
       5             :  *
       6             :  *
       7             :  * Copyright (c) 2004-2021, PostgreSQL Global Development Group
       8             :  *
       9             :  * Author: Andreas Pflug <pgadmin@pse-consulting.de>
      10             :  *
      11             :  * IDENTIFICATION
      12             :  *    src/backend/utils/adt/genfile.c
      13             :  *
      14             :  *-------------------------------------------------------------------------
      15             :  */
      16             : #include "postgres.h"
      17             : 
      18             : #include <sys/file.h>
      19             : #include <sys/stat.h>
      20             : #include <unistd.h>
      21             : #include <dirent.h>
      22             : 
      23             : #include "access/htup_details.h"
      24             : #include "access/xlog_internal.h"
      25             : #include "catalog/pg_authid.h"
      26             : #include "catalog/pg_tablespace_d.h"
      27             : #include "catalog/pg_type.h"
      28             : #include "funcapi.h"
      29             : #include "mb/pg_wchar.h"
      30             : #include "miscadmin.h"
      31             : #include "postmaster/syslogger.h"
      32             : #include "storage/fd.h"
      33             : #include "utils/acl.h"
      34             : #include "utils/builtins.h"
      35             : #include "utils/memutils.h"
      36             : #include "utils/syscache.h"
      37             : #include "utils/timestamp.h"
      38             : 
      39             : 
      40             : /*
      41             :  * Convert a "text" filename argument to C string, and check it's allowable.
      42             :  *
      43             :  * Filename may be absolute or relative to the DataDir, but we only allow
      44             :  * absolute paths that match DataDir or Log_directory.
      45             :  *
      46             :  * This does a privilege check against the 'pg_read_server_files' role, so
      47             :  * this function is really only appropriate for callers who are only checking
      48             :  * 'read' access.  Do not use this function if you are looking for a check
      49             :  * for 'write' or 'program' access without updating it to access the type
      50             :  * of check as an argument and checking the appropriate role membership.
      51             :  */
      52             : static char *
      53       18240 : convert_and_check_filename(text *arg)
      54             : {
      55             :     char       *filename;
      56             : 
      57       18240 :     filename = text_to_cstring(arg);
      58       18240 :     canonicalize_path(filename);    /* filename can change length here */
      59             : 
      60             :     /*
      61             :      * Members of the 'pg_read_server_files' role are allowed to access any
      62             :      * files on the server as the PG user, so no need to do any further checks
      63             :      * here.
      64             :      */
      65       18240 :     if (is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_SERVER_FILES))
      66        5254 :         return filename;
      67             : 
      68             :     /* User isn't a member of the default role, so check if it's allowable */
      69       12986 :     if (is_absolute_path(filename))
      70             :     {
      71             :         /* Disallow '/a/b/data/..' */
      72           0 :         if (path_contains_parent_reference(filename))
      73           0 :             ereport(ERROR,
      74             :                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      75             :                      errmsg("reference to parent directory (\"..\") not allowed")));
      76             : 
      77             :         /*
      78             :          * Allow absolute paths if within DataDir or Log_directory, even
      79             :          * though Log_directory might be outside DataDir.
      80             :          */
      81           0 :         if (!path_is_prefix_of_path(DataDir, filename) &&
      82           0 :             (!is_absolute_path(Log_directory) ||
      83           0 :              !path_is_prefix_of_path(Log_directory, filename)))
      84           0 :             ereport(ERROR,
      85             :                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      86             :                      errmsg("absolute path not allowed")));
      87             :     }
      88       12986 :     else if (!path_is_relative_and_below_cwd(filename))
      89           0 :         ereport(ERROR,
      90             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      91             :                  errmsg("path must be in or below the current directory")));
      92             : 
      93       12986 :     return filename;
      94             : }
      95             : 
      96             : 
      97             : /*
      98             :  * Read a section of a file, returning it as bytea
      99             :  *
     100             :  * Caller is responsible for all permissions checking.
     101             :  *
     102             :  * We read the whole of the file when bytes_to_read is negative.
     103             :  */
     104             : static bytea *
     105        4398 : read_binary_file(const char *filename, int64 seek_offset, int64 bytes_to_read,
     106             :                  bool missing_ok)
     107             : {
     108             :     bytea      *buf;
     109        4398 :     size_t      nbytes = 0;
     110             :     FILE       *file;
     111             : 
     112             :     /* clamp request size to what we can actually deliver */
     113        4398 :     if (bytes_to_read > (int64) (MaxAllocSize - VARHDRSZ))
     114           0 :         ereport(ERROR,
     115             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     116             :                  errmsg("requested length too large")));
     117             : 
     118        4398 :     if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)
     119             :     {
     120           4 :         if (missing_ok && errno == ENOENT)
     121           0 :             return NULL;
     122             :         else
     123           4 :             ereport(ERROR,
     124             :                     (errcode_for_file_access(),
     125             :                      errmsg("could not open file \"%s\" for reading: %m",
     126             :                             filename)));
     127             :     }
     128             : 
     129        4394 :     if (fseeko(file, (off_t) seek_offset,
     130             :                (seek_offset >= 0) ? SEEK_SET : SEEK_END) != 0)
     131           0 :         ereport(ERROR,
     132             :                 (errcode_for_file_access(),
     133             :                  errmsg("could not seek in file \"%s\": %m", filename)));
     134             : 
     135        4394 :     if (bytes_to_read >= 0)
     136             :     {
     137             :         /* If passed explicit read size just do it */
     138        4348 :         buf = (bytea *) palloc((Size) bytes_to_read + VARHDRSZ);
     139             : 
     140        4348 :         nbytes = fread(VARDATA(buf), 1, (size_t) bytes_to_read, file);
     141             :     }
     142             :     else
     143             :     {
     144             :         /* Negative read size, read rest of file */
     145             :         StringInfoData sbuf;
     146             : 
     147          46 :         initStringInfo(&sbuf);
     148             :         /* Leave room in the buffer for the varlena length word */
     149          46 :         sbuf.len += VARHDRSZ;
     150             :         Assert(sbuf.len < sbuf.maxlen);
     151             : 
     152         116 :         while (!(feof(file) || ferror(file)))
     153             :         {
     154             :             size_t      rbytes;
     155             : 
     156             :             /* Minimum amount to read at a time */
     157             : #define MIN_READ_SIZE 4096
     158             : 
     159             :             /*
     160             :              * If not at end of file, and sbuf.len is equal to
     161             :              * MaxAllocSize - 1, then either the file is too large, or
     162             :              * there is nothing left to read. Attempt to read one more
     163             :              * byte to see if the end of file has been reached. If not,
     164             :              * the file is too large; we'd rather give the error message
     165             :              * for that ourselves.
     166             :              */
     167          70 :             if (sbuf.len == MaxAllocSize - 1)
     168             :             {
     169             :                 char    rbuf[1];
     170             : 
     171           0 :                 if (fread(rbuf, 1, 1, file) != 0 || !feof(file))
     172           0 :                     ereport(ERROR,
     173             :                             (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     174             :                              errmsg("file length too large")));
     175             :                 else
     176             :                     break;
     177             :             }
     178             : 
     179             :             /* OK, ensure that we can read at least MIN_READ_SIZE */
     180          70 :             enlargeStringInfo(&sbuf, MIN_READ_SIZE);
     181             : 
     182             :             /*
     183             :              * stringinfo.c likes to allocate in powers of 2, so it's likely
     184             :              * that much more space is available than we asked for.  Use all
     185             :              * of it, rather than making more fread calls than necessary.
     186             :              */
     187          70 :             rbytes = fread(sbuf.data + sbuf.len, 1,
     188          70 :                            (size_t) (sbuf.maxlen - sbuf.len - 1), file);
     189          70 :             sbuf.len += rbytes;
     190          70 :             nbytes += rbytes;
     191             :         }
     192             : 
     193             :         /* Now we can commandeer the stringinfo's buffer as the result */
     194          46 :         buf = (bytea *) sbuf.data;
     195             :     }
     196             : 
     197        4394 :     if (ferror(file))
     198           0 :         ereport(ERROR,
     199             :                 (errcode_for_file_access(),
     200             :                  errmsg("could not read file \"%s\": %m", filename)));
     201             : 
     202        4394 :     SET_VARSIZE(buf, nbytes + VARHDRSZ);
     203             : 
     204        4394 :     FreeFile(file);
     205             : 
     206        4394 :     return buf;
     207             : }
     208             : 
     209             : /*
     210             :  * Similar to read_binary_file, but we verify that the contents are valid
     211             :  * in the database encoding.
     212             :  */
     213             : static text *
     214          16 : read_text_file(const char *filename, int64 seek_offset, int64 bytes_to_read,
     215             :                bool missing_ok)
     216             : {
     217             :     bytea      *buf;
     218             : 
     219          16 :     buf = read_binary_file(filename, seek_offset, bytes_to_read, missing_ok);
     220             : 
     221          12 :     if (buf != NULL)
     222             :     {
     223             :         /* Make sure the input is valid */
     224          12 :         pg_verifymbstr(VARDATA(buf), VARSIZE(buf) - VARHDRSZ, false);
     225             : 
     226             :         /* OK, we can cast it to text safely */
     227          12 :         return (text *) buf;
     228             :     }
     229             :     else
     230           0 :         return NULL;
     231             : }
     232             : 
     233             : /*
     234             :  * Read a section of a file, returning it as text
     235             :  *
     236             :  * This function is kept to support adminpack 1.0.
     237             :  */
     238             : Datum
     239           0 : pg_read_file(PG_FUNCTION_ARGS)
     240             : {
     241           0 :     text       *filename_t = PG_GETARG_TEXT_PP(0);
     242           0 :     int64       seek_offset = 0;
     243           0 :     int64       bytes_to_read = -1;
     244           0 :     bool        missing_ok = false;
     245             :     char       *filename;
     246             :     text       *result;
     247             : 
     248           0 :     if (!superuser())
     249           0 :         ereport(ERROR,
     250             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     251             :                  errmsg("must be superuser to read files with adminpack 1.0"),
     252             :         /* translator: %s is a SQL function name */
     253             :                  errhint("Consider using %s, which is part of core, instead.",
     254             :                          "pg_file_read()")));
     255             : 
     256             :     /* handle optional arguments */
     257           0 :     if (PG_NARGS() >= 3)
     258             :     {
     259           0 :         seek_offset = PG_GETARG_INT64(1);
     260           0 :         bytes_to_read = PG_GETARG_INT64(2);
     261             : 
     262           0 :         if (bytes_to_read < 0)
     263           0 :             ereport(ERROR,
     264             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     265             :                      errmsg("requested length cannot be negative")));
     266             :     }
     267           0 :     if (PG_NARGS() >= 4)
     268           0 :         missing_ok = PG_GETARG_BOOL(3);
     269             : 
     270           0 :     filename = convert_and_check_filename(filename_t);
     271             : 
     272           0 :     result = read_text_file(filename, seek_offset, bytes_to_read, missing_ok);
     273           0 :     if (result)
     274           0 :         PG_RETURN_TEXT_P(result);
     275             :     else
     276           0 :         PG_RETURN_NULL();
     277             : }
     278             : 
     279             : /*
     280             :  * Read a section of a file, returning it as text
     281             :  *
     282             :  * No superuser check done here- instead privileges are handled by the
     283             :  * GRANT system.
     284             :  */
     285             : Datum
     286          16 : pg_read_file_v2(PG_FUNCTION_ARGS)
     287             : {
     288          16 :     text       *filename_t = PG_GETARG_TEXT_PP(0);
     289          16 :     int64       seek_offset = 0;
     290          16 :     int64       bytes_to_read = -1;
     291          16 :     bool        missing_ok = false;
     292             :     char       *filename;
     293             :     text       *result;
     294             : 
     295             :     /* handle optional arguments */
     296          16 :     if (PG_NARGS() >= 3)
     297             :     {
     298           0 :         seek_offset = PG_GETARG_INT64(1);
     299           0 :         bytes_to_read = PG_GETARG_INT64(2);
     300             : 
     301           0 :         if (bytes_to_read < 0)
     302           0 :             ereport(ERROR,
     303             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     304             :                      errmsg("requested length cannot be negative")));
     305             :     }
     306          16 :     if (PG_NARGS() >= 4)
     307           0 :         missing_ok = PG_GETARG_BOOL(3);
     308             : 
     309          16 :     filename = convert_and_check_filename(filename_t);
     310             : 
     311          16 :     result = read_text_file(filename, seek_offset, bytes_to_read, missing_ok);
     312          12 :     if (result)
     313          12 :         PG_RETURN_TEXT_P(result);
     314             :     else
     315           0 :         PG_RETURN_NULL();
     316             : }
     317             : 
     318             : /*
     319             :  * Read a section of a file, returning it as bytea
     320             :  */
     321             : Datum
     322        4382 : pg_read_binary_file(PG_FUNCTION_ARGS)
     323             : {
     324        4382 :     text       *filename_t = PG_GETARG_TEXT_PP(0);
     325        4382 :     int64       seek_offset = 0;
     326        4382 :     int64       bytes_to_read = -1;
     327        4382 :     bool        missing_ok = false;
     328             :     char       *filename;
     329             :     bytea      *result;
     330             : 
     331             :     /* handle optional arguments */
     332        4382 :     if (PG_NARGS() >= 3)
     333             :     {
     334        4348 :         seek_offset = PG_GETARG_INT64(1);
     335        4348 :         bytes_to_read = PG_GETARG_INT64(2);
     336             : 
     337        4348 :         if (bytes_to_read < 0)
     338           0 :             ereport(ERROR,
     339             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     340             :                      errmsg("requested length cannot be negative")));
     341             :     }
     342        4382 :     if (PG_NARGS() >= 4)
     343        4348 :         missing_ok = PG_GETARG_BOOL(3);
     344             : 
     345        4382 :     filename = convert_and_check_filename(filename_t);
     346             : 
     347        4382 :     result = read_binary_file(filename, seek_offset,
     348             :                               bytes_to_read, missing_ok);
     349        4382 :     if (result)
     350        4382 :         PG_RETURN_BYTEA_P(result);
     351             :     else
     352           0 :         PG_RETURN_NULL();
     353             : }
     354             : 
     355             : 
     356             : /*
     357             :  * Wrapper functions for the 1 and 3 argument variants of pg_read_file_v2()
     358             :  * and pg_read_binary_file().
     359             :  *
     360             :  * These are necessary to pass the sanity check in opr_sanity, which checks
     361             :  * that all built-in functions that share the implementing C function take
     362             :  * the same number of arguments.
     363             :  */
     364             : Datum
     365           0 : pg_read_file_off_len(PG_FUNCTION_ARGS)
     366             : {
     367           0 :     return pg_read_file_v2(fcinfo);
     368             : }
     369             : 
     370             : Datum
     371          16 : pg_read_file_all(PG_FUNCTION_ARGS)
     372             : {
     373          16 :     return pg_read_file_v2(fcinfo);
     374             : }
     375             : 
     376             : Datum
     377           0 : pg_read_binary_file_off_len(PG_FUNCTION_ARGS)
     378             : {
     379           0 :     return pg_read_binary_file(fcinfo);
     380             : }
     381             : 
     382             : Datum
     383          34 : pg_read_binary_file_all(PG_FUNCTION_ARGS)
     384             : {
     385          34 :     return pg_read_binary_file(fcinfo);
     386             : }
     387             : 
     388             : /*
     389             :  * stat a file
     390             :  */
     391             : Datum
     392       13508 : pg_stat_file(PG_FUNCTION_ARGS)
     393             : {
     394       13508 :     text       *filename_t = PG_GETARG_TEXT_PP(0);
     395             :     char       *filename;
     396             :     struct stat fst;
     397             :     Datum       values[6];
     398             :     bool        isnull[6];
     399             :     HeapTuple   tuple;
     400             :     TupleDesc   tupdesc;
     401       13508 :     bool        missing_ok = false;
     402             : 
     403             :     /* check the optional argument */
     404       13508 :     if (PG_NARGS() == 2)
     405       13508 :         missing_ok = PG_GETARG_BOOL(1);
     406             : 
     407       13508 :     filename = convert_and_check_filename(filename_t);
     408             : 
     409       13508 :     if (stat(filename, &fst) < 0)
     410             :     {
     411           0 :         if (missing_ok && errno == ENOENT)
     412           0 :             PG_RETURN_NULL();
     413             :         else
     414           0 :             ereport(ERROR,
     415             :                     (errcode_for_file_access(),
     416             :                      errmsg("could not stat file \"%s\": %m", filename)));
     417             :     }
     418             : 
     419             :     /*
     420             :      * This record type had better match the output parameters declared for me
     421             :      * in pg_proc.h.
     422             :      */
     423       13508 :     tupdesc = CreateTemplateTupleDesc(6);
     424       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 1,
     425             :                        "size", INT8OID, -1, 0);
     426       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 2,
     427             :                        "access", TIMESTAMPTZOID, -1, 0);
     428       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 3,
     429             :                        "modification", TIMESTAMPTZOID, -1, 0);
     430       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 4,
     431             :                        "change", TIMESTAMPTZOID, -1, 0);
     432       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 5,
     433             :                        "creation", TIMESTAMPTZOID, -1, 0);
     434       13508 :     TupleDescInitEntry(tupdesc, (AttrNumber) 6,
     435             :                        "isdir", BOOLOID, -1, 0);
     436       13508 :     BlessTupleDesc(tupdesc);
     437             : 
     438       13508 :     memset(isnull, false, sizeof(isnull));
     439             : 
     440       13508 :     values[0] = Int64GetDatum((int64) fst.st_size);
     441       13508 :     values[1] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_atime));
     442       13508 :     values[2] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_mtime));
     443             :     /* Unix has file status change time, while Win32 has creation time */
     444             : #if !defined(WIN32) && !defined(__CYGWIN__)
     445       13508 :     values[3] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));
     446       13508 :     isnull[4] = true;
     447             : #else
     448             :     isnull[3] = true;
     449             :     values[4] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));
     450             : #endif
     451       13508 :     values[5] = BoolGetDatum(S_ISDIR(fst.st_mode));
     452             : 
     453       13508 :     tuple = heap_form_tuple(tupdesc, values, isnull);
     454             : 
     455       13508 :     pfree(filename);
     456             : 
     457       13508 :     PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
     458             : }
     459             : 
     460             : /*
     461             :  * stat a file (1 argument version)
     462             :  *
     463             :  * note: this wrapper is necessary to pass the sanity check in opr_sanity,
     464             :  * which checks that all built-in functions that share the implementing C
     465             :  * function take the same number of arguments
     466             :  */
     467             : Datum
     468           0 : pg_stat_file_1arg(PG_FUNCTION_ARGS)
     469             : {
     470           0 :     return pg_stat_file(fcinfo);
     471             : }
     472             : 
     473             : /*
     474             :  * List a directory (returns the filenames only)
     475             :  */
     476             : Datum
     477         334 : pg_ls_dir(PG_FUNCTION_ARGS)
     478             : {
     479         334 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
     480             :     char       *location;
     481         334 :     bool        missing_ok = false;
     482         334 :     bool        include_dot_dirs = false;
     483             :     bool        randomAccess;
     484             :     TupleDesc   tupdesc;
     485             :     Tuplestorestate *tupstore;
     486             :     DIR        *dirdesc;
     487             :     struct dirent *de;
     488             :     MemoryContext oldcontext;
     489             : 
     490         334 :     location = convert_and_check_filename(PG_GETARG_TEXT_PP(0));
     491             : 
     492             :     /* check the optional arguments */
     493         334 :     if (PG_NARGS() == 3)
     494             :     {
     495         330 :         if (!PG_ARGISNULL(1))
     496         330 :             missing_ok = PG_GETARG_BOOL(1);
     497         330 :         if (!PG_ARGISNULL(2))
     498         330 :             include_dot_dirs = PG_GETARG_BOOL(2);
     499             :     }
     500             : 
     501             :     /* check to see if caller supports us returning a tuplestore */
     502         334 :     if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
     503           0 :         ereport(ERROR,
     504             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     505             :                  errmsg("set-valued function called in context that cannot accept a set")));
     506         334 :     if (!(rsinfo->allowedModes & SFRM_Materialize))
     507           0 :         ereport(ERROR,
     508             :                 (errcode(ERRCODE_SYNTAX_ERROR),
     509             :                  errmsg("materialize mode required, but it is not allowed in this context")));
     510             : 
     511             :     /* The tupdesc and tuplestore must be created in ecxt_per_query_memory */
     512         334 :     oldcontext = MemoryContextSwitchTo(rsinfo->econtext->ecxt_per_query_memory);
     513             : 
     514         334 :     tupdesc = CreateTemplateTupleDesc(1);
     515         334 :     TupleDescInitEntry(tupdesc, (AttrNumber) 1, "pg_ls_dir", TEXTOID, -1, 0);
     516             : 
     517         334 :     randomAccess = (rsinfo->allowedModes & SFRM_Materialize_Random) != 0;
     518         334 :     tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
     519         334 :     rsinfo->returnMode = SFRM_Materialize;
     520         334 :     rsinfo->setResult = tupstore;
     521         334 :     rsinfo->setDesc = tupdesc;
     522             : 
     523         334 :     MemoryContextSwitchTo(oldcontext);
     524             : 
     525         334 :     dirdesc = AllocateDir(location);
     526         334 :     if (!dirdesc)
     527             :     {
     528             :         /* Return empty tuplestore if appropriate */
     529           0 :         if (missing_ok && errno == ENOENT)
     530           0 :             return (Datum) 0;
     531             :         /* Otherwise, we can let ReadDir() throw the error */
     532             :     }
     533             : 
     534       14606 :     while ((de = ReadDir(dirdesc, location)) != NULL)
     535             :     {
     536             :         Datum       values[1];
     537             :         bool        nulls[1];
     538             : 
     539       14272 :         if (!include_dot_dirs &&
     540       14272 :             (strcmp(de->d_name, ".") == 0 ||
     541       13938 :              strcmp(de->d_name, "..") == 0))
     542         668 :             continue;
     543             : 
     544       13604 :         values[0] = CStringGetTextDatum(de->d_name);
     545       13604 :         nulls[0] = false;
     546             : 
     547       13604 :         tuplestore_putvalues(tupstore, tupdesc, values, nulls);
     548             :     }
     549             : 
     550         334 :     FreeDir(dirdesc);
     551         334 :     return (Datum) 0;
     552             : }
     553             : 
     554             : /*
     555             :  * List a directory (1 argument version)
     556             :  *
     557             :  * note: this wrapper is necessary to pass the sanity check in opr_sanity,
     558             :  * which checks that all built-in functions that share the implementing C
     559             :  * function take the same number of arguments.
     560             :  */
     561             : Datum
     562           4 : pg_ls_dir_1arg(PG_FUNCTION_ARGS)
     563             : {
     564           4 :     return pg_ls_dir(fcinfo);
     565             : }
     566             : 
     567             : /*
     568             :  * Generic function to return a directory listing of files.
     569             :  *
     570             :  * If the directory isn't there, silently return an empty set if missing_ok.
     571             :  * Other unreadable-directory cases throw an error.
     572             :  */
     573             : static Datum
     574          20 : pg_ls_dir_files(FunctionCallInfo fcinfo, const char *dir, bool missing_ok)
     575             : {
     576          20 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
     577             :     bool        randomAccess;
     578             :     TupleDesc   tupdesc;
     579             :     Tuplestorestate *tupstore;
     580             :     DIR        *dirdesc;
     581             :     struct dirent *de;
     582             :     MemoryContext oldcontext;
     583             : 
     584             :     /* check to see if caller supports us returning a tuplestore */
     585          20 :     if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
     586           0 :         ereport(ERROR,
     587             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     588             :                  errmsg("set-valued function called in context that cannot accept a set")));
     589          20 :     if (!(rsinfo->allowedModes & SFRM_Materialize))
     590           0 :         ereport(ERROR,
     591             :                 (errcode(ERRCODE_SYNTAX_ERROR),
     592             :                  errmsg("materialize mode required, but it is not allowed in this context")));
     593             : 
     594             :     /* The tupdesc and tuplestore must be created in ecxt_per_query_memory */
     595          20 :     oldcontext = MemoryContextSwitchTo(rsinfo->econtext->ecxt_per_query_memory);
     596             : 
     597          20 :     if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
     598           0 :         elog(ERROR, "return type must be a row type");
     599             : 
     600          20 :     randomAccess = (rsinfo->allowedModes & SFRM_Materialize_Random) != 0;
     601          20 :     tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
     602          20 :     rsinfo->returnMode = SFRM_Materialize;
     603          20 :     rsinfo->setResult = tupstore;
     604          20 :     rsinfo->setDesc = tupdesc;
     605             : 
     606          20 :     MemoryContextSwitchTo(oldcontext);
     607             : 
     608             :     /*
     609             :      * Now walk the directory.  Note that we must do this within a single SRF
     610             :      * call, not leave the directory open across multiple calls, since we
     611             :      * can't count on the SRF being run to completion.
     612             :      */
     613          20 :     dirdesc = AllocateDir(dir);
     614          20 :     if (!dirdesc)
     615             :     {
     616             :         /* Return empty tuplestore if appropriate */
     617           0 :         if (missing_ok && errno == ENOENT)
     618           0 :             return (Datum) 0;
     619             :         /* Otherwise, we can let ReadDir() throw the error */
     620             :     }
     621             : 
     622         660 :     while ((de = ReadDir(dirdesc, dir)) != NULL)
     623             :     {
     624             :         Datum       values[3];
     625             :         bool        nulls[3];
     626             :         char        path[MAXPGPATH * 2];
     627             :         struct stat attrib;
     628             : 
     629             :         /* Skip hidden files */
     630         640 :         if (de->d_name[0] == '.')
     631          56 :             continue;
     632             : 
     633             :         /* Get the file info */
     634         600 :         snprintf(path, sizeof(path), "%s/%s", dir, de->d_name);
     635         600 :         if (stat(path, &attrib) < 0)
     636             :         {
     637             :             /* Ignore concurrently-deleted files, else complain */
     638           0 :             if (errno == ENOENT)
     639           0 :                 continue;
     640           0 :             ereport(ERROR,
     641             :                     (errcode_for_file_access(),
     642             :                      errmsg("could not stat file \"%s\": %m", path)));
     643             :         }
     644             : 
     645             :         /* Ignore anything but regular files */
     646         600 :         if (!S_ISREG(attrib.st_mode))
     647          16 :             continue;
     648             : 
     649         584 :         values[0] = CStringGetTextDatum(de->d_name);
     650         584 :         values[1] = Int64GetDatum((int64) attrib.st_size);
     651         584 :         values[2] = TimestampTzGetDatum(time_t_to_timestamptz(attrib.st_mtime));
     652         584 :         memset(nulls, 0, sizeof(nulls));
     653             : 
     654         584 :         tuplestore_putvalues(tupstore, tupdesc, values, nulls);
     655             :     }
     656             : 
     657          20 :     FreeDir(dirdesc);
     658          20 :     return (Datum) 0;
     659             : }
     660             : 
     661             : /* Function to return the list of files in the log directory */
     662             : Datum
     663           0 : pg_ls_logdir(PG_FUNCTION_ARGS)
     664             : {
     665           0 :     return pg_ls_dir_files(fcinfo, Log_directory, false);
     666             : }
     667             : 
     668             : /* Function to return the list of files in the WAL directory */
     669             : Datum
     670          16 : pg_ls_waldir(PG_FUNCTION_ARGS)
     671             : {
     672          16 :     return pg_ls_dir_files(fcinfo, XLOGDIR, false);
     673             : }
     674             : 
     675             : /*
     676             :  * Generic function to return the list of files in pgsql_tmp
     677             :  */
     678             : static Datum
     679           0 : pg_ls_tmpdir(FunctionCallInfo fcinfo, Oid tblspc)
     680             : {
     681             :     char        path[MAXPGPATH];
     682             : 
     683           0 :     if (!SearchSysCacheExists1(TABLESPACEOID, ObjectIdGetDatum(tblspc)))
     684           0 :         ereport(ERROR,
     685             :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
     686             :                  errmsg("tablespace with OID %u does not exist",
     687             :                         tblspc)));
     688             : 
     689           0 :     TempTablespacePath(path, tblspc);
     690           0 :     return pg_ls_dir_files(fcinfo, path, true);
     691             : }
     692             : 
     693             : /*
     694             :  * Function to return the list of temporary files in the pg_default tablespace's
     695             :  * pgsql_tmp directory
     696             :  */
     697             : Datum
     698           0 : pg_ls_tmpdir_noargs(PG_FUNCTION_ARGS)
     699             : {
     700           0 :     return pg_ls_tmpdir(fcinfo, DEFAULTTABLESPACE_OID);
     701             : }
     702             : 
     703             : /*
     704             :  * Function to return the list of temporary files in the specified tablespace's
     705             :  * pgsql_tmp directory
     706             :  */
     707             : Datum
     708           0 : pg_ls_tmpdir_1arg(PG_FUNCTION_ARGS)
     709             : {
     710           0 :     return pg_ls_tmpdir(fcinfo, PG_GETARG_OID(0));
     711             : }
     712             : 
     713             : /*
     714             :  * Function to return the list of files in the WAL archive status directory.
     715             :  */
     716             : Datum
     717           4 : pg_ls_archive_statusdir(PG_FUNCTION_ARGS)
     718             : {
     719           4 :     return pg_ls_dir_files(fcinfo, XLOGDIR "/archive_status", true);
     720             : }

Generated by: LCOV version 1.13