LCOV - code coverage report
Current view: top level - src/backend/utils/fmgr - dfmgr.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 143 206 69.4 %
Date: 2020-05-29 00:07:09 Functions: 13 15 86.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * dfmgr.c
       4             :  *    Dynamic function manager code.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2020, 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             : #ifdef HAVE_DLOPEN
      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                          /* HAVE_DLOPEN */
      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             : /* signatures for PostgreSQL-specific library init/fini functions */
      41             : typedef void (*PG_init_t) (void);
      42             : typedef void (*PG_fini_t) (void);
      43             : 
      44             : /* hashtable entry for rendezvous variables */
      45             : typedef struct
      46             : {
      47             :     char        varName[NAMEDATALEN];   /* hash key (must be first) */
      48             :     void       *varValue;
      49             : } rendezvousHashEntry;
      50             : 
      51             : /*
      52             :  * List of dynamically loaded files (kept in malloc'd memory).
      53             :  */
      54             : 
      55             : typedef struct df_files
      56             : {
      57             :     struct df_files *next;      /* List link */
      58             :     dev_t       device;         /* Device file is on */
      59             : #ifndef WIN32                   /* ensures we never again depend on this under
      60             :                                  * win32 */
      61             :     ino_t       inode;          /* Inode number of file */
      62             : #endif
      63             :     void       *handle;         /* a handle for pg_dl* functions */
      64             :     char        filename[FLEXIBLE_ARRAY_MEMBER];    /* Full pathname of file */
      65             : } DynamicFileList;
      66             : 
      67             : static DynamicFileList *file_list = NULL;
      68             : static DynamicFileList *file_tail = NULL;
      69             : 
      70             : /* stat() call under Win32 returns an st_ino field, but it has no meaning */
      71             : #ifndef WIN32
      72             : #define SAME_INODE(A,B) ((A).st_ino == (B).inode && (A).st_dev == (B).device)
      73             : #else
      74             : #define SAME_INODE(A,B) false
      75             : #endif
      76             : 
      77             : char       *Dynamic_library_path;
      78             : 
      79             : static void *internal_load_library(const char *libname);
      80             : static void incompatible_module_error(const char *libname,
      81             :                                       const Pg_magic_struct *module_magic_data) pg_attribute_noreturn();
      82             : static void internal_unload_library(const char *libname);
      83             : static bool file_exists(const char *name);
      84             : static char *expand_dynamic_library_name(const char *name);
      85             : static void check_restricted_library_name(const char *name);
      86             : static char *substitute_libpath_macro(const char *name);
      87             : static char *find_in_dynamic_libpath(const char *basename);
      88             : 
      89             : /* Magic structure that module needs to match to be accepted */
      90             : static const Pg_magic_struct magic_data = PG_MODULE_MAGIC_DATA;
      91             : 
      92             : 
      93             : /*
      94             :  * Load the specified dynamic-link library file, and look for a function
      95             :  * named funcname in it.
      96             :  *
      97             :  * If the function is not found, we raise an error if signalNotFound is true,
      98             :  * else return (PGFunction) NULL.  Note that errors in loading the library
      99             :  * will provoke ereport() regardless of signalNotFound.
     100             :  *
     101             :  * If filehandle is not NULL, then *filehandle will be set to a handle
     102             :  * identifying the library file.  The filehandle can be used with
     103             :  * lookup_external_function to lookup additional functions in the same file
     104             :  * at less cost than repeating load_external_function.
     105             :  */
     106             : PGFunction
     107        9710 : load_external_function(const char *filename, const char *funcname,
     108             :                        bool signalNotFound, void **filehandle)
     109             : {
     110             :     char       *fullname;
     111             :     void       *lib_handle;
     112             :     PGFunction  retval;
     113             : 
     114             :     /* Expand the possibly-abbreviated filename to an exact path name */
     115        9710 :     fullname = expand_dynamic_library_name(filename);
     116             : 
     117             :     /* Load the shared library, unless we already did */
     118        9710 :     lib_handle = internal_load_library(fullname);
     119             : 
     120             :     /* Return handle if caller wants it */
     121        9704 :     if (filehandle)
     122        8504 :         *filehandle = lib_handle;
     123             : 
     124             :     /* Look up the function within the library. */
     125        9704 :     retval = (PGFunction) dlsym(lib_handle, funcname);
     126             : 
     127        9704 :     if (retval == NULL && signalNotFound)
     128           4 :         ereport(ERROR,
     129             :                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
     130             :                  errmsg("could not find function \"%s\" in file \"%s\"",
     131             :                         funcname, fullname)));
     132             : 
     133        9700 :     pfree(fullname);
     134        9700 :     return retval;
     135             : }
     136             : 
     137             : /*
     138             :  * This function loads a shlib file without looking up any particular
     139             :  * function in it.  If the same shlib has previously been loaded,
     140             :  * unload and reload it.
     141             :  *
     142             :  * When 'restricted' is true, only libraries in the presumed-secure
     143             :  * directory $libdir/plugins may be referenced.
     144             :  */
     145             : void
     146         488 : load_file(const char *filename, bool restricted)
     147             : {
     148             :     char       *fullname;
     149             : 
     150             :     /* Apply security restriction if requested */
     151         488 :     if (restricted)
     152           0 :         check_restricted_library_name(filename);
     153             : 
     154             :     /* Expand the possibly-abbreviated filename to an exact path name */
     155         488 :     fullname = expand_dynamic_library_name(filename);
     156             : 
     157             :     /* Unload the library if currently loaded */
     158         488 :     internal_unload_library(fullname);
     159             : 
     160             :     /* Load the shared library */
     161         488 :     (void) internal_load_library(fullname);
     162             : 
     163         488 :     pfree(fullname);
     164         488 : }
     165             : 
     166             : /*
     167             :  * Lookup a function whose library file is already loaded.
     168             :  * Return (PGFunction) NULL if not found.
     169             :  */
     170             : PGFunction
     171        8500 : lookup_external_function(void *filehandle, const char *funcname)
     172             : {
     173        8500 :     return (PGFunction) dlsym(filehandle, funcname);
     174             : }
     175             : 
     176             : 
     177             : /*
     178             :  * Load the specified dynamic-link library file, unless it already is
     179             :  * loaded.  Return the pg_dl* handle for the file.
     180             :  *
     181             :  * Note: libname is expected to be an exact name for the library file.
     182             :  */
     183             : static void *
     184       12606 : 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       18710 :     for (file_scanner = file_list;
     196       13334 :          file_scanner != NULL &&
     197       13334 :          strcmp(libname, file_scanner->filename) != 0;
     198        6104 :          file_scanner = file_scanner->next)
     199             :         ;
     200             : 
     201       12606 :     if (file_scanner == NULL)
     202             :     {
     203             :         /*
     204             :          * Check for same files - different paths (ie, symlink or link)
     205             :          */
     206        5376 :         if (stat(libname, &stat_buf) == -1)
     207           6 :             ereport(ERROR,
     208             :                     (errcode_for_file_access(),
     209             :                      errmsg("could not access file \"%s\": %m",
     210             :                             libname)));
     211             : 
     212        8314 :         for (file_scanner = file_list;
     213        2944 :              file_scanner != NULL &&
     214        2944 :              !SAME_INODE(stat_buf, *file_scanner);
     215        2944 :              file_scanner = file_scanner->next)
     216             :             ;
     217             :     }
     218             : 
     219       12600 :     if (file_scanner == NULL)
     220             :     {
     221             :         /*
     222             :          * File not loaded yet.
     223             :          */
     224             :         file_scanner = (DynamicFileList *)
     225        5370 :             malloc(offsetof(DynamicFileList, filename) + strlen(libname) + 1);
     226        5370 :         if (file_scanner == NULL)
     227           0 :             ereport(ERROR,
     228             :                     (errcode(ERRCODE_OUT_OF_MEMORY),
     229             :                      errmsg("out of memory")));
     230             : 
     231       26850 :         MemSet(file_scanner, 0, offsetof(DynamicFileList, filename));
     232        5370 :         strcpy(file_scanner->filename, libname);
     233        5370 :         file_scanner->device = stat_buf.st_dev;
     234             : #ifndef WIN32
     235        5370 :         file_scanner->inode = stat_buf.st_ino;
     236             : #endif
     237        5370 :         file_scanner->next = NULL;
     238             : 
     239        5370 :         file_scanner->handle = dlopen(file_scanner->filename, RTLD_NOW | RTLD_GLOBAL);
     240        5370 :         if (file_scanner->handle == NULL)
     241             :         {
     242           0 :             load_error = dlerror();
     243           0 :             free((char *) file_scanner);
     244             :             /* errcode_for_file_access might not be appropriate here? */
     245           0 :             ereport(ERROR,
     246             :                     (errcode_for_file_access(),
     247             :                      errmsg("could not load library \"%s\": %s",
     248             :                             libname, load_error)));
     249             :         }
     250             : 
     251             :         /* Check the magic function to determine compatibility */
     252        5370 :         magic_func = (PGModuleMagicFunction)
     253        5370 :             dlsym(file_scanner->handle, PG_MAGIC_FUNCTION_NAME_STRING);
     254        5370 :         if (magic_func)
     255             :         {
     256        5370 :             const Pg_magic_struct *magic_data_ptr = (*magic_func) ();
     257             : 
     258        5370 :             if (magic_data_ptr->len != magic_data.len ||
     259        5370 :                 memcmp(magic_data_ptr, &magic_data, magic_data.len) != 0)
     260             :             {
     261             :                 /* copy data block before unlinking library */
     262           0 :                 Pg_magic_struct module_magic_data = *magic_data_ptr;
     263             : 
     264             :                 /* try to close library */
     265           0 :                 dlclose(file_scanner->handle);
     266           0 :                 free((char *) file_scanner);
     267             : 
     268             :                 /* issue suitable complaint */
     269           0 :                 incompatible_module_error(libname, &module_magic_data);
     270             :             }
     271             :         }
     272             :         else
     273             :         {
     274             :             /* try to close library */
     275           0 :             dlclose(file_scanner->handle);
     276           0 :             free((char *) file_scanner);
     277             :             /* complain */
     278           0 :             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        5370 :         PG_init = (PG_init_t) dlsym(file_scanner->handle, "_PG_init");
     288        5370 :         if (PG_init)
     289        2852 :             (*PG_init) ();
     290             : 
     291             :         /* OK to link it into list */
     292        5370 :         if (file_list == NULL)
     293        3588 :             file_list = file_scanner;
     294             :         else
     295        1782 :             file_tail->next = file_scanner;
     296        5370 :         file_tail = file_scanner;
     297             :     }
     298             : 
     299       12600 :     return file_scanner->handle;
     300             : }
     301             : 
     302             : /*
     303             :  * Report a suitable error for an incompatible magic block.
     304             :  */
     305             : static void
     306           0 : 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           0 :     if (magic_data.version != module_magic_data->version)
     316             :     {
     317             :         char        library_version[32];
     318             : 
     319           0 :         if (module_magic_data->version >= 1000)
     320           0 :             snprintf(library_version, sizeof(library_version), "%d",
     321           0 :                      module_magic_data->version / 100);
     322             :         else
     323           0 :             snprintf(library_version, sizeof(library_version), "%d.%d",
     324           0 :                      module_magic_data->version / 100,
     325           0 :                      module_magic_data->version % 100);
     326           0 :         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             :      * Otherwise, spell out which fields don't agree.
     335             :      *
     336             :      * XXX this code has to be adjusted any time the set of fields in a magic
     337             :      * block change!
     338             :      */
     339           0 :     initStringInfo(&details);
     340             : 
     341           0 :     if (module_magic_data->funcmaxargs != magic_data.funcmaxargs)
     342             :     {
     343           0 :         if (details.len)
     344           0 :             appendStringInfoChar(&details, '\n');
     345           0 :         appendStringInfo(&details,
     346           0 :                          _("Server has FUNC_MAX_ARGS = %d, library has %d."),
     347             :                          magic_data.funcmaxargs,
     348             :                          module_magic_data->funcmaxargs);
     349             :     }
     350           0 :     if (module_magic_data->indexmaxkeys != magic_data.indexmaxkeys)
     351             :     {
     352           0 :         if (details.len)
     353           0 :             appendStringInfoChar(&details, '\n');
     354           0 :         appendStringInfo(&details,
     355           0 :                          _("Server has INDEX_MAX_KEYS = %d, library has %d."),
     356             :                          magic_data.indexmaxkeys,
     357             :                          module_magic_data->indexmaxkeys);
     358             :     }
     359           0 :     if (module_magic_data->namedatalen != magic_data.namedatalen)
     360             :     {
     361           0 :         if (details.len)
     362           0 :             appendStringInfoChar(&details, '\n');
     363           0 :         appendStringInfo(&details,
     364           0 :                          _("Server has NAMEDATALEN = %d, library has %d."),
     365             :                          magic_data.namedatalen,
     366             :                          module_magic_data->namedatalen);
     367             :     }
     368           0 :     if (module_magic_data->float8byval != magic_data.float8byval)
     369             :     {
     370           0 :         if (details.len)
     371           0 :             appendStringInfoChar(&details, '\n');
     372           0 :         appendStringInfo(&details,
     373           0 :                          _("Server has FLOAT8PASSBYVAL = %s, library has %s."),
     374           0 :                          magic_data.float8byval ? "true" : "false",
     375           0 :                          module_magic_data->float8byval ? "true" : "false");
     376             :     }
     377             : 
     378           0 :     if (details.len == 0)
     379           0 :         appendStringInfoString(&details,
     380           0 :                                _("Magic block has unexpected length or padding difference."));
     381             : 
     382           0 :     ereport(ERROR,
     383             :             (errmsg("incompatible library \"%s\": magic block mismatch",
     384             :                     libname),
     385             :              errdetail_internal("%s", details.data)));
     386             : }
     387             : 
     388             : /*
     389             :  * Unload the specified dynamic-link library file, if it is loaded.
     390             :  *
     391             :  * Note: libname is expected to be an exact name for the library file.
     392             :  *
     393             :  * XXX for the moment, this is disabled, resulting in LOAD of an already-loaded
     394             :  * library always being a no-op.  We might re-enable it someday if we can
     395             :  * convince ourselves we have safe protocols for un-hooking from hook function
     396             :  * pointers, releasing custom GUC variables, and perhaps other things that
     397             :  * are definitely unsafe currently.
     398             :  */
     399             : static void
     400         488 : internal_unload_library(const char *libname)
     401             : {
     402             : #ifdef NOT_USED
     403             :     DynamicFileList *file_scanner,
     404             :                *prv,
     405             :                *nxt;
     406             :     struct stat stat_buf;
     407             :     PG_fini_t   PG_fini;
     408             : 
     409             :     /*
     410             :      * We need to do stat() in order to determine whether this is the same
     411             :      * file as a previously loaded file; it's also handy so as to give a good
     412             :      * error message if bogus file name given.
     413             :      */
     414             :     if (stat(libname, &stat_buf) == -1)
     415             :         ereport(ERROR,
     416             :                 (errcode_for_file_access(),
     417             :                  errmsg("could not access file \"%s\": %m", libname)));
     418             : 
     419             :     /*
     420             :      * We have to zap all entries in the list that match on either filename or
     421             :      * inode, else internal_load_library() will still think it's present.
     422             :      */
     423             :     prv = NULL;
     424             :     for (file_scanner = file_list; file_scanner != NULL; file_scanner = nxt)
     425             :     {
     426             :         nxt = file_scanner->next;
     427             :         if (strcmp(libname, file_scanner->filename) == 0 ||
     428             :             SAME_INODE(stat_buf, *file_scanner))
     429             :         {
     430             :             if (prv)
     431             :                 prv->next = nxt;
     432             :             else
     433             :                 file_list = nxt;
     434             : 
     435             :             /*
     436             :              * If the library has a _PG_fini() function, call it.
     437             :              */
     438             :             PG_fini = (PG_fini_t) dlsym(file_scanner->handle, "_PG_fini");
     439             :             if (PG_fini)
     440             :                 (*PG_fini) ();
     441             : 
     442             :             clear_external_function_hash(file_scanner->handle);
     443             :             dlclose(file_scanner->handle);
     444             :             free((char *) file_scanner);
     445             :             /* prv does not change */
     446             :         }
     447             :         else
     448             :             prv = file_scanner;
     449             :     }
     450             : #endif                          /* NOT_USED */
     451         488 : }
     452             : 
     453             : static bool
     454       19682 : file_exists(const char *name)
     455             : {
     456             :     struct stat st;
     457             : 
     458             :     AssertArg(name != NULL);
     459             : 
     460       19682 :     if (stat(name, &st) == 0)
     461       10192 :         return S_ISDIR(st.st_mode) ? false : true;
     462        9490 :     else if (!(errno == ENOENT || errno == ENOTDIR || errno == EACCES))
     463           0 :         ereport(ERROR,
     464             :                 (errcode_for_file_access(),
     465             :                  errmsg("could not access file \"%s\": %m", name)));
     466             : 
     467        9490 :     return false;
     468             : }
     469             : 
     470             : 
     471             : /* Example format: ".so" */
     472             : #ifndef DLSUFFIX
     473             : #error "DLSUFFIX must be defined to compile this file."
     474             : #endif
     475             : 
     476             : /*
     477             :  * If name contains a slash, check if the file exists, if so return
     478             :  * the name.  Else (no slash) try to expand using search path (see
     479             :  * find_in_dynamic_libpath below); if that works, return the fully
     480             :  * expanded file name.  If the previous failed, append DLSUFFIX and
     481             :  * try again.  If all fails, just return the original name.
     482             :  *
     483             :  * The result will always be freshly palloc'd.
     484             :  */
     485             : static char *
     486       10198 : expand_dynamic_library_name(const char *name)
     487             : {
     488             :     bool        have_slash;
     489             :     char       *new;
     490             :     char       *full;
     491             : 
     492             :     AssertArg(name);
     493             : 
     494       10198 :     have_slash = (first_dir_separator(name) != NULL);
     495             : 
     496       10198 :     if (!have_slash)
     497             :     {
     498        1094 :         full = find_in_dynamic_libpath(name);
     499        1094 :         if (full)
     500           0 :             return full;
     501             :     }
     502             :     else
     503             :     {
     504        9104 :         full = substitute_libpath_macro(name);
     505        9104 :         if (file_exists(full))
     506         714 :             return full;
     507        8390 :         pfree(full);
     508             :     }
     509             : 
     510        9484 :     new = psprintf("%s%s", name, DLSUFFIX);
     511             : 
     512        9484 :     if (!have_slash)
     513             :     {
     514        1094 :         full = find_in_dynamic_libpath(new);
     515        1094 :         pfree(new);
     516        1094 :         if (full)
     517        1088 :             return full;
     518             :     }
     519             :     else
     520             :     {
     521        8390 :         full = substitute_libpath_macro(new);
     522        8390 :         pfree(new);
     523        8390 :         if (file_exists(full))
     524        8390 :             return full;
     525           0 :         pfree(full);
     526             :     }
     527             : 
     528             :     /*
     529             :      * If we can't find the file, just return the string as-is. The ensuing
     530             :      * load attempt will fail and report a suitable message.
     531             :      */
     532           6 :     return pstrdup(name);
     533             : }
     534             : 
     535             : /*
     536             :  * Check a restricted library name.  It must begin with "$libdir/plugins/"
     537             :  * and there must not be any directory separators after that (this is
     538             :  * sufficient to prevent ".." style attacks).
     539             :  */
     540             : static void
     541           0 : check_restricted_library_name(const char *name)
     542             : {
     543           0 :     if (strncmp(name, "$libdir/plugins/", 16) != 0 ||
     544           0 :         first_dir_separator(name + 16) != NULL)
     545           0 :         ereport(ERROR,
     546             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     547             :                  errmsg("access to library \"%s\" is not allowed",
     548             :                         name)));
     549           0 : }
     550             : 
     551             : /*
     552             :  * Substitute for any macros appearing in the given string.
     553             :  * Result is always freshly palloc'd.
     554             :  */
     555             : static char *
     556       19682 : substitute_libpath_macro(const char *name)
     557             : {
     558             :     const char *sep_ptr;
     559             : 
     560             :     AssertArg(name != NULL);
     561             : 
     562             :     /* Currently, we only recognize $libdir at the start of the string */
     563       19682 :     if (name[0] != '$')
     564         714 :         return pstrdup(name);
     565             : 
     566       18968 :     if ((sep_ptr = first_dir_separator(name)) == NULL)
     567        2188 :         sep_ptr = name + strlen(name);
     568             : 
     569       18968 :     if (strlen("$libdir") != sep_ptr - name ||
     570       18968 :         strncmp(name, "$libdir", strlen("$libdir")) != 0)
     571           0 :         ereport(ERROR,
     572             :                 (errcode(ERRCODE_INVALID_NAME),
     573             :                  errmsg("invalid macro name in dynamic library path: %s",
     574             :                         name)));
     575             : 
     576       18968 :     return psprintf("%s%s", pkglib_path, sep_ptr);
     577             : }
     578             : 
     579             : 
     580             : /*
     581             :  * Search for a file called 'basename' in the colon-separated search
     582             :  * path Dynamic_library_path.  If the file is found, the full file name
     583             :  * is returned in freshly palloc'd memory.  If the file is not found,
     584             :  * return NULL.
     585             :  */
     586             : static char *
     587        2188 : find_in_dynamic_libpath(const char *basename)
     588             : {
     589             :     const char *p;
     590             :     size_t      baselen;
     591             : 
     592             :     AssertArg(basename != NULL);
     593             :     AssertArg(first_dir_separator(basename) == NULL);
     594             :     AssertState(Dynamic_library_path != NULL);
     595             : 
     596        2188 :     p = Dynamic_library_path;
     597        2188 :     if (strlen(p) == 0)
     598           0 :         return NULL;
     599             : 
     600        2188 :     baselen = strlen(basename);
     601             : 
     602             :     for (;;)
     603           0 :     {
     604             :         size_t      len;
     605             :         char       *piece;
     606             :         char       *mangled;
     607             :         char       *full;
     608             : 
     609        2188 :         piece = first_path_var_separator(p);
     610        2188 :         if (piece == p)
     611           0 :             ereport(ERROR,
     612             :                     (errcode(ERRCODE_INVALID_NAME),
     613             :                      errmsg("zero-length component in parameter \"dynamic_library_path\"")));
     614             : 
     615        2188 :         if (piece == NULL)
     616        2188 :             len = strlen(p);
     617             :         else
     618           0 :             len = piece - p;
     619             : 
     620        2188 :         piece = palloc(len + 1);
     621        2188 :         strlcpy(piece, p, len + 1);
     622             : 
     623        2188 :         mangled = substitute_libpath_macro(piece);
     624        2188 :         pfree(piece);
     625             : 
     626        2188 :         canonicalize_path(mangled);
     627             : 
     628             :         /* only absolute paths */
     629        2188 :         if (!is_absolute_path(mangled))
     630           0 :             ereport(ERROR,
     631             :                     (errcode(ERRCODE_INVALID_NAME),
     632             :                      errmsg("component in parameter \"dynamic_library_path\" is not an absolute path")));
     633             : 
     634        2188 :         full = palloc(strlen(mangled) + 1 + baselen + 1);
     635        2188 :         sprintf(full, "%s/%s", mangled, basename);
     636        2188 :         pfree(mangled);
     637             : 
     638        2188 :         elog(DEBUG3, "find_in_dynamic_libpath: trying \"%s\"", full);
     639             : 
     640        2188 :         if (file_exists(full))
     641        1088 :             return full;
     642             : 
     643        1100 :         pfree(full);
     644             : 
     645        1100 :         if (p[len] == '\0')
     646        1100 :             break;
     647             :         else
     648           0 :             p += len + 1;
     649             :     }
     650             : 
     651        1100 :     return NULL;
     652             : }
     653             : 
     654             : 
     655             : /*
     656             :  * Find (or create) a rendezvous variable that one dynamically
     657             :  * loaded library can use to meet up with another.
     658             :  *
     659             :  * On the first call of this function for a particular varName,
     660             :  * a "rendezvous variable" is created with the given name.
     661             :  * The value of the variable is a void pointer (initially set to NULL).
     662             :  * Subsequent calls with the same varName just return the address of
     663             :  * the existing variable.  Once created, a rendezvous variable lasts
     664             :  * for the life of the process.
     665             :  *
     666             :  * Dynamically loaded libraries can use rendezvous variables
     667             :  * to find each other and share information: they just need to agree
     668             :  * on the variable name and the data it will point to.
     669             :  */
     670             : void      **
     671        2216 : find_rendezvous_variable(const char *varName)
     672             : {
     673             :     static HTAB *rendezvousHash = NULL;
     674             : 
     675             :     rendezvousHashEntry *hentry;
     676             :     bool        found;
     677             : 
     678             :     /* Create a hashtable if we haven't already done so in this process */
     679        2216 :     if (rendezvousHash == NULL)
     680             :     {
     681             :         HASHCTL     ctl;
     682             : 
     683       30968 :         MemSet(&ctl, 0, sizeof(ctl));
     684        2212 :         ctl.keysize = NAMEDATALEN;
     685        2212 :         ctl.entrysize = sizeof(rendezvousHashEntry);
     686        2212 :         rendezvousHash = hash_create("Rendezvous variable hash",
     687             :                                      16,
     688             :                                      &ctl,
     689             :                                      HASH_ELEM);
     690             :     }
     691             : 
     692             :     /* Find or create the hashtable entry for this varName */
     693        2216 :     hentry = (rendezvousHashEntry *) hash_search(rendezvousHash,
     694             :                                                  varName,
     695             :                                                  HASH_ENTER,
     696             :                                                  &found);
     697             : 
     698             :     /* Initialize to NULL if first time */
     699        2216 :     if (!found)
     700        2216 :         hentry->varValue = NULL;
     701             : 
     702        2216 :     return &hentry->varValue;
     703             : }
     704             : 
     705             : /*
     706             :  * Estimate the amount of space needed to serialize the list of libraries
     707             :  * we have loaded.
     708             :  */
     709             : Size
     710         470 : EstimateLibraryStateSpace(void)
     711             : {
     712             :     DynamicFileList *file_scanner;
     713         470 :     Size        size = 1;
     714             : 
     715        1026 :     for (file_scanner = file_list;
     716             :          file_scanner != NULL;
     717         556 :          file_scanner = file_scanner->next)
     718         556 :         size = add_size(size, strlen(file_scanner->filename) + 1);
     719             : 
     720         470 :     return size;
     721             : }
     722             : 
     723             : /*
     724             :  * Serialize the list of libraries we have loaded to a chunk of memory.
     725             :  */
     726             : void
     727         470 : SerializeLibraryState(Size maxsize, char *start_address)
     728             : {
     729             :     DynamicFileList *file_scanner;
     730             : 
     731        1026 :     for (file_scanner = file_list;
     732             :          file_scanner != NULL;
     733         556 :          file_scanner = file_scanner->next)
     734             :     {
     735             :         Size        len;
     736             : 
     737         556 :         len = strlcpy(start_address, file_scanner->filename, maxsize) + 1;
     738             :         Assert(len < maxsize);
     739         556 :         maxsize -= len;
     740         556 :         start_address += len;
     741             :     }
     742         470 :     start_address[0] = '\0';
     743         470 : }
     744             : 
     745             : /*
     746             :  * Load every library the serializing backend had loaded.
     747             :  */
     748             : void
     749        1570 : RestoreLibraryState(char *start_address)
     750             : {
     751        3978 :     while (*start_address != '\0')
     752             :     {
     753        2408 :         internal_load_library(start_address);
     754        2408 :         start_address += strlen(start_address) + 1;
     755             :     }
     756        1570 : }

Generated by: LCOV version 1.13