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