PostgreSQL Source Code  git master
dfmgr.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * dfmgr.c
4  * Dynamic function manager code.
5  *
6  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/fmgr/dfmgr.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include <sys/stat.h>
18 
19 #ifndef WIN32
20 #include <dlfcn.h>
21 
22 /*
23  * On macOS, <dlfcn.h> insists on including <stdbool.h>. If we're not
24  * using stdbool, undef bool to undo the damage.
25  */
26 #ifndef PG_USE_STDBOOL
27 #ifdef bool
28 #undef bool
29 #endif
30 #endif
31 #endif /* !WIN32 */
32 
33 #include "fmgr.h"
34 #include "lib/stringinfo.h"
35 #include "miscadmin.h"
36 #include "storage/shmem.h"
37 #include "utils/hsearch.h"
38 
39 
40 /* signature for PostgreSQL-specific library init function */
41 typedef void (*PG_init_t) (void);
42 
43 /* hashtable entry for rendezvous variables */
44 typedef struct
45 {
46  char varName[NAMEDATALEN]; /* hash key (must be first) */
47  void *varValue;
49 
50 /*
51  * List of dynamically loaded files (kept in malloc'd memory).
52  */
53 
54 typedef struct df_files
55 {
56  struct df_files *next; /* List link */
57  dev_t device; /* Device file is on */
58 #ifndef WIN32 /* ensures we never again depend on this under
59  * win32 */
60  ino_t inode; /* Inode number of file */
61 #endif
62  void *handle; /* a handle for pg_dl* functions */
63  char filename[FLEXIBLE_ARRAY_MEMBER]; /* Full pathname of file */
65 
66 static DynamicFileList *file_list = NULL;
67 static DynamicFileList *file_tail = NULL;
68 
69 /* stat() call under Win32 returns an st_ino field, but it has no meaning */
70 #ifndef WIN32
71 #define SAME_INODE(A,B) ((A).st_ino == (B).inode && (A).st_dev == (B).device)
72 #else
73 #define SAME_INODE(A,B) false
74 #endif
75 
77 
78 static void *internal_load_library(const char *libname);
79 static void incompatible_module_error(const char *libname,
80  const Pg_magic_struct *module_magic_data) pg_attribute_noreturn();
81 static bool file_exists(const char *name);
82 static char *expand_dynamic_library_name(const char *name);
83 static void check_restricted_library_name(const char *name);
84 static char *substitute_libpath_macro(const char *name);
85 static char *find_in_dynamic_libpath(const char *basename);
86 
87 /* Magic structure that module needs to match to be accepted */
89 
90 
91 /*
92  * Load the specified dynamic-link library file, and look for a function
93  * named funcname in it.
94  *
95  * If the function is not found, we raise an error if signalNotFound is true,
96  * else return NULL. Note that errors in loading the library
97  * will provoke ereport() regardless of signalNotFound.
98  *
99  * If filehandle is not NULL, then *filehandle will be set to a handle
100  * identifying the library file. The filehandle can be used with
101  * lookup_external_function to lookup additional functions in the same file
102  * at less cost than repeating load_external_function.
103  */
104 void *
105 load_external_function(const char *filename, const char *funcname,
106  bool signalNotFound, void **filehandle)
107 {
108  char *fullname;
109  void *lib_handle;
110  void *retval;
111 
112  /* Expand the possibly-abbreviated filename to an exact path name */
114 
115  /* Load the shared library, unless we already did */
116  lib_handle = internal_load_library(fullname);
117 
118  /* Return handle if caller wants it */
119  if (filehandle)
120  *filehandle = lib_handle;
121 
122  /* Look up the function within the library. */
123  retval = dlsym(lib_handle, funcname);
124 
125  if (retval == NULL && signalNotFound)
126  ereport(ERROR,
127  (errcode(ERRCODE_UNDEFINED_FUNCTION),
128  errmsg("could not find function \"%s\" in file \"%s\"",
129  funcname, fullname)));
130 
131  pfree(fullname);
132  return retval;
133 }
134 
135 /*
136  * This function loads a shlib file without looking up any particular
137  * function in it. If the same shlib has previously been loaded,
138  * unload and reload it.
139  *
140  * When 'restricted' is true, only libraries in the presumed-secure
141  * directory $libdir/plugins may be referenced.
142  */
143 void
144 load_file(const char *filename, bool restricted)
145 {
146  char *fullname;
147 
148  /* Apply security restriction if requested */
149  if (restricted)
151 
152  /* Expand the possibly-abbreviated filename to an exact path name */
154 
155  /* Load the shared library */
156  (void) internal_load_library(fullname);
157 
158  pfree(fullname);
159 }
160 
161 /*
162  * Lookup a function whose library file is already loaded.
163  * Return NULL if not found.
164  */
165 void *
166 lookup_external_function(void *filehandle, const char *funcname)
167 {
168  return dlsym(filehandle, funcname);
169 }
170 
171 
172 /*
173  * Load the specified dynamic-link library file, unless it already is
174  * loaded. Return the pg_dl* handle for the file.
175  *
176  * Note: libname is expected to be an exact name for the library file.
177  *
178  * NB: There is presently no way to unload a dynamically loaded file. We might
179  * add one someday if we can convince ourselves we have safe protocols for un-
180  * hooking from hook function pointers, releasing custom GUC variables, and
181  * perhaps other things that are definitely unsafe currently.
182  */
183 static void *
184 internal_load_library(const char *libname)
185 {
186  DynamicFileList *file_scanner;
187  PGModuleMagicFunction magic_func;
188  char *load_error;
189  struct stat stat_buf;
190  PG_init_t PG_init;
191 
192  /*
193  * Scan the list of loaded FILES to see if the file has been loaded.
194  */
195  for (file_scanner = file_list;
196  file_scanner != NULL &&
197  strcmp(libname, file_scanner->filename) != 0;
198  file_scanner = file_scanner->next)
199  ;
200 
201  if (file_scanner == NULL)
202  {
203  /*
204  * Check for same files - different paths (ie, symlink or link)
205  */
206  if (stat(libname, &stat_buf) == -1)
207  ereport(ERROR,
209  errmsg("could not access file \"%s\": %m",
210  libname)));
211 
212  for (file_scanner = file_list;
213  file_scanner != NULL &&
214  !SAME_INODE(stat_buf, *file_scanner);
215  file_scanner = file_scanner->next)
216  ;
217  }
218 
219  if (file_scanner == NULL)
220  {
221  /*
222  * File not loaded yet.
223  */
224  file_scanner = (DynamicFileList *)
225  malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1);
226  if (file_scanner == NULL)
227  ereport(ERROR,
228  (errcode(ERRCODE_OUT_OF_MEMORY),
229  errmsg("out of memory")));
230 
231  MemSet(file_scanner, 0, offsetof(DynamicFileList, filename));
232  strcpy(file_scanner->filename, libname);
233  file_scanner->device = stat_buf.st_dev;
234 #ifndef WIN32
235  file_scanner->inode = stat_buf.st_ino;
236 #endif
237  file_scanner->next = NULL;
238 
239  file_scanner->handle = dlopen(file_scanner->filename, RTLD_NOW | RTLD_GLOBAL);
240  if (file_scanner->handle == NULL)
241  {
242  load_error = dlerror();
243  free(file_scanner);
244  /* errcode_for_file_access might not be appropriate here? */
245  ereport(ERROR,
247  errmsg("could not load library \"%s\": %s",
248  libname, load_error)));
249  }
250 
251  /* Check the magic function to determine compatibility */
252  magic_func = (PGModuleMagicFunction)
254  if (magic_func)
255  {
256  const Pg_magic_struct *magic_data_ptr = (*magic_func) ();
257 
258  if (magic_data_ptr->len != magic_data.len ||
259  memcmp(magic_data_ptr, &magic_data, magic_data.len) != 0)
260  {
261  /* copy data block before unlinking library */
262  Pg_magic_struct module_magic_data = *magic_data_ptr;
263 
264  /* try to close library */
265  dlclose(file_scanner->handle);
266  free(file_scanner);
267 
268  /* issue suitable complaint */
269  incompatible_module_error(libname, &module_magic_data);
270  }
271  }
272  else
273  {
274  /* try to close library */
275  dlclose(file_scanner->handle);
276  free(file_scanner);
277  /* complain */
278  ereport(ERROR,
279  (errmsg("incompatible library \"%s\": missing magic block",
280  libname),
281  errhint("Extension libraries are required to use the PG_MODULE_MAGIC macro.")));
282  }
283 
284  /*
285  * If the library has a _PG_init() function, call it.
286  */
287  PG_init = (PG_init_t) dlsym(file_scanner->handle, "_PG_init");
288  if (PG_init)
289  (*PG_init) ();
290 
291  /* OK to link it into list */
292  if (file_list == NULL)
293  file_list = file_scanner;
294  else
295  file_tail->next = file_scanner;
296  file_tail = file_scanner;
297  }
298 
299  return file_scanner->handle;
300 }
301 
302 /*
303  * Report a suitable error for an incompatible magic block.
304  */
305 static void
306 incompatible_module_error(const char *libname,
307  const Pg_magic_struct *module_magic_data)
308 {
309  StringInfoData details;
310 
311  /*
312  * If the version doesn't match, just report that, because the rest of the
313  * block might not even have the fields we expect.
314  */
315  if (magic_data.version != module_magic_data->version)
316  {
317  char library_version[32];
318 
319  if (module_magic_data->version >= 1000)
320  snprintf(library_version, sizeof(library_version), "%d",
321  module_magic_data->version / 100);
322  else
323  snprintf(library_version, sizeof(library_version), "%d.%d",
324  module_magic_data->version / 100,
325  module_magic_data->version % 100);
326  ereport(ERROR,
327  (errmsg("incompatible library \"%s\": version mismatch",
328  libname),
329  errdetail("Server is version %d, library is version %s.",
330  magic_data.version / 100, library_version)));
331  }
332 
333  /*
334  * Similarly, if the ABI extra field doesn't match, error out. Other
335  * fields below might also mismatch, but that isn't useful information if
336  * you're using the wrong product altogether.
337  */
338  if (strcmp(module_magic_data->abi_extra, magic_data.abi_extra) != 0)
339  {
340  ereport(ERROR,
341  (errmsg("incompatible library \"%s\": ABI mismatch",
342  libname),
343  errdetail("Server has ABI \"%s\", library has \"%s\".",
345  module_magic_data->abi_extra)));
346  }
347 
348  /*
349  * Otherwise, spell out which fields don't agree.
350  *
351  * XXX this code has to be adjusted any time the set of fields in a magic
352  * block change!
353  */
354  initStringInfo(&details);
355 
356  if (module_magic_data->funcmaxargs != magic_data.funcmaxargs)
357  {
358  if (details.len)
359  appendStringInfoChar(&details, '\n');
360  appendStringInfo(&details,
361  _("Server has FUNC_MAX_ARGS = %d, library has %d."),
363  module_magic_data->funcmaxargs);
364  }
365  if (module_magic_data->indexmaxkeys != magic_data.indexmaxkeys)
366  {
367  if (details.len)
368  appendStringInfoChar(&details, '\n');
369  appendStringInfo(&details,
370  _("Server has INDEX_MAX_KEYS = %d, library has %d."),
372  module_magic_data->indexmaxkeys);
373  }
374  if (module_magic_data->namedatalen != magic_data.namedatalen)
375  {
376  if (details.len)
377  appendStringInfoChar(&details, '\n');
378  appendStringInfo(&details,
379  _("Server has NAMEDATALEN = %d, library has %d."),
381  module_magic_data->namedatalen);
382  }
383  if (module_magic_data->float8byval != magic_data.float8byval)
384  {
385  if (details.len)
386  appendStringInfoChar(&details, '\n');
387  appendStringInfo(&details,
388  _("Server has FLOAT8PASSBYVAL = %s, library has %s."),
389  magic_data.float8byval ? "true" : "false",
390  module_magic_data->float8byval ? "true" : "false");
391  }
392 
393  if (details.len == 0)
394  appendStringInfoString(&details,
395  _("Magic block has unexpected length or padding difference."));
396 
397  ereport(ERROR,
398  (errmsg("incompatible library \"%s\": magic block mismatch",
399  libname),
400  errdetail_internal("%s", details.data)));
401 }
402 
403 static bool
404 file_exists(const char *name)
405 {
406  struct stat st;
407 
408  Assert(name != NULL);
409 
410  if (stat(name, &st) == 0)
411  return !S_ISDIR(st.st_mode);
412  else if (!(errno == ENOENT || errno == ENOTDIR || errno == EACCES))
413  ereport(ERROR,
415  errmsg("could not access file \"%s\": %m", name)));
416 
417  return false;
418 }
419 
420 
421 /*
422  * If name contains a slash, check if the file exists, if so return
423  * the name. Else (no slash) try to expand using search path (see
424  * find_in_dynamic_libpath below); if that works, return the fully
425  * expanded file name. If the previous failed, append DLSUFFIX and
426  * try again. If all fails, just return the original name.
427  *
428  * The result will always be freshly palloc'd.
429  */
430 static char *
432 {
433  bool have_slash;
434  char *new;
435  char *full;
436 
437  Assert(name);
438 
439  have_slash = (first_dir_separator(name) != NULL);
440 
441  if (!have_slash)
442  {
444  if (full)
445  return full;
446  }
447  else
448  {
450  if (file_exists(full))
451  return full;
452  pfree(full);
453  }
454 
455  new = psprintf("%s%s", name, DLSUFFIX);
456 
457  if (!have_slash)
458  {
459  full = find_in_dynamic_libpath(new);
460  pfree(new);
461  if (full)
462  return full;
463  }
464  else
465  {
466  full = substitute_libpath_macro(new);
467  pfree(new);
468  if (file_exists(full))
469  return full;
470  pfree(full);
471  }
472 
473  /*
474  * If we can't find the file, just return the string as-is. The ensuing
475  * load attempt will fail and report a suitable message.
476  */
477  return pstrdup(name);
478 }
479 
480 /*
481  * Check a restricted library name. It must begin with "$libdir/plugins/"
482  * and there must not be any directory separators after that (this is
483  * sufficient to prevent ".." style attacks).
484  */
485 static void
487 {
488  if (strncmp(name, "$libdir/plugins/", 16) != 0 ||
489  first_dir_separator(name + 16) != NULL)
490  ereport(ERROR,
491  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
492  errmsg("access to library \"%s\" is not allowed",
493  name)));
494 }
495 
496 /*
497  * Substitute for any macros appearing in the given string.
498  * Result is always freshly palloc'd.
499  */
500 static char *
502 {
503  const char *sep_ptr;
504 
505  Assert(name != NULL);
506 
507  /* Currently, we only recognize $libdir at the start of the string */
508  if (name[0] != '$')
509  return pstrdup(name);
510 
511  if ((sep_ptr = first_dir_separator(name)) == NULL)
512  sep_ptr = name + strlen(name);
513 
514  if (strlen("$libdir") != sep_ptr - name ||
515  strncmp(name, "$libdir", strlen("$libdir")) != 0)
516  ereport(ERROR,
517  (errcode(ERRCODE_INVALID_NAME),
518  errmsg("invalid macro name in dynamic library path: %s",
519  name)));
520 
521  return psprintf("%s%s", pkglib_path, sep_ptr);
522 }
523 
524 
525 /*
526  * Search for a file called 'basename' in the colon-separated search
527  * path Dynamic_library_path. If the file is found, the full file name
528  * is returned in freshly palloc'd memory. If the file is not found,
529  * return NULL.
530  */
531 static char *
532 find_in_dynamic_libpath(const char *basename)
533 {
534  const char *p;
535  size_t baselen;
536 
537  Assert(basename != NULL);
538  Assert(first_dir_separator(basename) == NULL);
539  Assert(Dynamic_library_path != NULL);
540 
542  if (strlen(p) == 0)
543  return NULL;
544 
545  baselen = strlen(basename);
546 
547  for (;;)
548  {
549  size_t len;
550  char *piece;
551  char *mangled;
552  char *full;
553 
554  piece = first_path_var_separator(p);
555  if (piece == p)
556  ereport(ERROR,
557  (errcode(ERRCODE_INVALID_NAME),
558  errmsg("zero-length component in parameter \"dynamic_library_path\"")));
559 
560  if (piece == NULL)
561  len = strlen(p);
562  else
563  len = piece - p;
564 
565  piece = palloc(len + 1);
566  strlcpy(piece, p, len + 1);
567 
568  mangled = substitute_libpath_macro(piece);
569  pfree(piece);
570 
571  canonicalize_path(mangled);
572 
573  /* only absolute paths */
574  if (!is_absolute_path(mangled))
575  ereport(ERROR,
576  (errcode(ERRCODE_INVALID_NAME),
577  errmsg("component in parameter \"dynamic_library_path\" is not an absolute path")));
578 
579  full = palloc(strlen(mangled) + 1 + baselen + 1);
580  sprintf(full, "%s/%s", mangled, basename);
581  pfree(mangled);
582 
583  elog(DEBUG3, "find_in_dynamic_libpath: trying \"%s\"", full);
584 
585  if (file_exists(full))
586  return full;
587 
588  pfree(full);
589 
590  if (p[len] == '\0')
591  break;
592  else
593  p += len + 1;
594  }
595 
596  return NULL;
597 }
598 
599 
600 /*
601  * Find (or create) a rendezvous variable that one dynamically
602  * loaded library can use to meet up with another.
603  *
604  * On the first call of this function for a particular varName,
605  * a "rendezvous variable" is created with the given name.
606  * The value of the variable is a void pointer (initially set to NULL).
607  * Subsequent calls with the same varName just return the address of
608  * the existing variable. Once created, a rendezvous variable lasts
609  * for the life of the process.
610  *
611  * Dynamically loaded libraries can use rendezvous variables
612  * to find each other and share information: they just need to agree
613  * on the variable name and the data it will point to.
614  */
615 void **
616 find_rendezvous_variable(const char *varName)
617 {
618  static HTAB *rendezvousHash = NULL;
619 
620  rendezvousHashEntry *hentry;
621  bool found;
622 
623  /* Create a hashtable if we haven't already done so in this process */
624  if (rendezvousHash == NULL)
625  {
626  HASHCTL ctl;
627 
628  ctl.keysize = NAMEDATALEN;
629  ctl.entrysize = sizeof(rendezvousHashEntry);
630  rendezvousHash = hash_create("Rendezvous variable hash",
631  16,
632  &ctl,
634  }
635 
636  /* Find or create the hashtable entry for this varName */
637  hentry = (rendezvousHashEntry *) hash_search(rendezvousHash,
638  varName,
639  HASH_ENTER,
640  &found);
641 
642  /* Initialize to NULL if first time */
643  if (!found)
644  hentry->varValue = NULL;
645 
646  return &hentry->varValue;
647 }
648 
649 /*
650  * Estimate the amount of space needed to serialize the list of libraries
651  * we have loaded.
652  */
653 Size
655 {
656  DynamicFileList *file_scanner;
657  Size size = 1;
658 
659  for (file_scanner = file_list;
660  file_scanner != NULL;
661  file_scanner = file_scanner->next)
662  size = add_size(size, strlen(file_scanner->filename) + 1);
663 
664  return size;
665 }
666 
667 /*
668  * Serialize the list of libraries we have loaded to a chunk of memory.
669  */
670 void
671 SerializeLibraryState(Size maxsize, char *start_address)
672 {
673  DynamicFileList *file_scanner;
674 
675  for (file_scanner = file_list;
676  file_scanner != NULL;
677  file_scanner = file_scanner->next)
678  {
679  Size len;
680 
681  len = strlcpy(start_address, file_scanner->filename, maxsize) + 1;
682  Assert(len < maxsize);
683  maxsize -= len;
684  start_address += len;
685  }
686  start_address[0] = '\0';
687 }
688 
689 /*
690  * Load every library the serializing backend had loaded.
691  */
692 void
693 RestoreLibraryState(char *start_address)
694 {
695  while (*start_address != '\0')
696  {
697  internal_load_library(start_address);
698  start_address += strlen(start_address) + 1;
699  }
700 }
#define pg_attribute_noreturn()
Definition: c.h:201
#define FLEXIBLE_ARRAY_MEMBER
Definition: c.h:362
#define MemSet(start, val, len)
Definition: c.h:953
size_t Size
Definition: c.h:541
static char * expand_dynamic_library_name(const char *name)
Definition: dfmgr.c:431
static DynamicFileList * file_tail
Definition: dfmgr.c:67
static char * find_in_dynamic_libpath(const char *basename)
Definition: dfmgr.c:532
void RestoreLibraryState(char *start_address)
Definition: dfmgr.c:693
void * load_external_function(const char *filename, const char *funcname, bool signalNotFound, void **filehandle)
Definition: dfmgr.c:105
char * Dynamic_library_path
Definition: dfmgr.c:76
static char * substitute_libpath_macro(const char *name)
Definition: dfmgr.c:501
static void incompatible_module_error(const char *libname, const Pg_magic_struct *module_magic_data) pg_attribute_noreturn()
Definition: dfmgr.c:306
static void * internal_load_library(const char *libname)
Definition: dfmgr.c:184
void SerializeLibraryState(Size maxsize, char *start_address)
Definition: dfmgr.c:671
void load_file(const char *filename, bool restricted)
Definition: dfmgr.c:144
static const Pg_magic_struct magic_data
Definition: dfmgr.c:88
Size EstimateLibraryStateSpace(void)
Definition: dfmgr.c:654
void ** find_rendezvous_variable(const char *varName)
Definition: dfmgr.c:616
static DynamicFileList * file_list
Definition: dfmgr.c:66
void(* PG_init_t)(void)
Definition: dfmgr.c:41
struct df_files DynamicFileList
static void check_restricted_library_name(const char *name)
Definition: dfmgr.c:486
#define SAME_INODE(A, B)
Definition: dfmgr.c:71
void * lookup_external_function(void *filehandle, const char *funcname)
Definition: dfmgr.c:166
static bool file_exists(const char *name)
Definition: dfmgr.c:404
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:953
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:350
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1066
int errcode_for_file_access(void)
Definition: elog.c:718
int errdetail(const char *fmt,...)
Definition: elog.c:1039
int errhint(const char *fmt,...)
Definition: elog.c:1153
int errcode(int sqlerrcode)
Definition: elog.c:695
int errmsg(const char *fmt,...)
Definition: elog.c:906
#define _(x)
Definition: elog.c:90
#define DEBUG3
Definition: elog.h:24
#define ERROR
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:145
const char * name
Definition: encode.c:561
#define PG_MAGIC_FUNCTION_NAME_STRING
Definition: fmgr.h:497
const Pg_magic_struct *(* PGModuleMagicFunction)(void)
Definition: fmgr.h:494
#define PG_MODULE_MAGIC_DATA
Definition: fmgr.h:476
char pkglib_path[MAXPGPATH]
Definition: globals.c:77
#define free(a)
Definition: header.h:65
#define malloc(a)
Definition: header.h:50
#define HASH_STRINGS
Definition: hsearch.h:96
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_ELEM
Definition: hsearch.h:95
Assert(fmt[strlen(fmt) - 1] !='\n')
char * pstrdup(const char *in)
Definition: mcxt.c:1483
void pfree(void *pointer)
Definition: mcxt.c:1306
void * palloc(Size size)
Definition: mcxt.c:1199
#define NAMEDATALEN
const void size_t len
static char * filename
Definition: pg_dumpall.c:119
#define is_absolute_path(filename)
Definition: port.h:103
char * first_dir_separator(const char *filename)
Definition: path.c:104
#define sprintf
Definition: port.h:240
void canonicalize_path(char *path)
Definition: path.c:264
char * first_path_var_separator(const char *pathlist)
Definition: path.c:121
#define snprintf
Definition: port.h:238
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
Size add_size(Size s1, Size s2)
Definition: shmem.c:502
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
Definition: dynahash.c:220
char abi_extra[32]
Definition: fmgr.h:472
int float8byval
Definition: fmgr.h:471
int funcmaxargs
Definition: fmgr.h:468
int indexmaxkeys
Definition: fmgr.h:469
int namedatalen
Definition: fmgr.h:470
int version
Definition: fmgr.h:467
Definition: dfmgr.c:55
dev_t device
Definition: dfmgr.c:57
ino_t inode
Definition: dfmgr.c:60
void * handle
Definition: dfmgr.c:62
struct df_files * next
Definition: dfmgr.c:56
char filename[FLEXIBLE_ARRAY_MEMBER]
Definition: dfmgr.c:63
void * varValue
Definition: dfmgr.c:47
unsigned short st_mode
Definition: win32_port.h:270
_dev_t st_dev
Definition: win32_port.h:268
_ino_t st_ino
Definition: win32_port.h:269
#define stat
Definition: win32_port.h:286
char * dlerror(void)
Definition: win32dlopen.c:40
#define S_ISDIR(m)
Definition: win32_port.h:327
void * dlsym(void *handle, const char *symbol)
Definition: win32dlopen.c:61
void * dlopen(const char *file, int mode)
Definition: win32dlopen.c:76
#define RTLD_NOW
Definition: win32_port.h:522
#define RTLD_GLOBAL
Definition: win32_port.h:523
int dlclose(void *handle)
Definition: win32dlopen.c:49