lib/util/internal_module.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Jelmer Vernooij 2002-2003,2005-2007
   5    Copyright (C) Stefan (metze) Metzmacher 2003
   6    Copyright (C) Andrew Bartlett 2011
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "dynconfig/dynconfig.h"
  24 #include "lib/util/internal_module.h"
  25 #include "system/filesys.h"
  26 #include "system/dir.h"
  27
  28 /**
  29  * Obtain the init function from a shared library file
  30  */
  31 samba_module_init_fn load_module(const char *path, bool is_probe, void **handle_out)
  32 {
  33         void *handle;
  34         void *init_fn;
  35         char *error;
  36
  37 #if _SAMBA_BUILD_ == 3
  38         /* Always try to use LAZY symbol resolving; if the plugin has
  39          * backwards compatibility, there might be symbols in the
  40          * plugin referencing to old (removed) functions
  41          */
  42         handle = dlopen(path, RTLD_LAZY);
  43 #else
  44         /* This should be a WAF build, where modules should be built
  45          * with no undefined symbols and are already linked against
  46          * the libraries that they are loaded by */
  47         handle = dlopen(path, RTLD_NOW);
  48 #endif
  49
  50         /* This call should reset any possible non-fatal errors that
  51            occured since last call to dl* functions */
  52         error = dlerror();
  53
  54         if (handle == NULL) {
  55                 int level = is_probe ? 5 : 0;
  56                 DEBUG(level, ("Error loading module '%s': %s\n", path, error ? error : ""));
  57                 return NULL;
  58         }
  59
  60         init_fn = (samba_module_init_fn)dlsym(handle, SAMBA_MODULE_INIT);
  61
  62         /* we could check dlerror() to determine if it worked, because
  63            dlsym() can validly return NULL, but what would we do with
  64            a NULL pointer as a module init function? */
  65
  66         if (init_fn == NULL) {
  67                 DEBUG(0, ("Unable to find %s() in %s: %s\n",
  68                           SAMBA_MODULE_INIT, path, dlerror()));
  69                 DEBUG(1, ("Loading module '%s' failed\n", path));
  70                 dlclose(handle);
  71                 return NULL;
  72         }
  73
  74         if (handle_out) {
  75                 *handle_out = handle;
  76         }
  77
  78         return (samba_module_init_fn)init_fn;
  79 }
  80
  81 /**
  82  * Obtain list of init functions from the modules in the specified
  83  * directory
  84  */
  85 samba_module_init_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path)
  86 {
  87         DIR *dir;
  88         struct dirent *entry;
  89         char *filename;
  90         int success = 0;
  91         samba_module_init_fn *ret = talloc_array(mem_ctx, samba_module_init_fn, 2);
  92
  93         ret[0] = NULL;
  94
  95         dir = opendir(path);
  96         if (dir == NULL) {
  97                 talloc_free(ret);
  98                 return NULL;
  99         }
 100
 101         while((entry = readdir(dir))) {
 102                 if (ISDOT(entry->d_name) || ISDOTDOT(entry->d_name))
 103                         continue;
 104
 105                 filename = talloc_asprintf(mem_ctx, "%s/%s", path, entry->d_name);
 106
 107                 ret[success] = load_module(filename, true, NULL);
 108                 if (ret[success]) {
 109                         ret = talloc_realloc(mem_ctx, ret, samba_module_init_fn, success+2);
 110                         success++;
 111                         ret[success] = NULL;
 112                 }
 113
 114                 talloc_free(filename);
 115         }
 116
 117         closedir(dir);
 118
 119         return ret;
 120 }
 121
 122 /* Load a dynamic module.  Only log a level 0 error if we are not checking
 123    for the existence of a module (probling). */
 124
 125 static NTSTATUS do_smb_load_module(const char *module_name, bool is_probe)
 126 {
 127         void *handle;
 128         samba_module_init_fn init;
 129         NTSTATUS status;
 130
 131         init = load_module(module_name, is_probe, &handle);
 132         if (!init) {
 133                 return NT_STATUS_UNSUCCESSFUL;
 134         }
 135
 136         DEBUG(2, ("Module '%s' loaded\n", module_name));
 137
 138         status = init();
 139         if (!NT_STATUS_IS_OK(status)) {
 140                 DEBUG(0, ("Module '%s' initialization failed: %s\n",
 141                             module_name, get_friendly_nt_error_msg(status)));
 142                 dlclose(handle);
 143         }
 144
 145         return status;
 146 }
 147
 148 /* Load all modules in list and return number of
 149  * modules that has been successfully loaded */
 150 int smb_load_modules(const char **modules)
 151 {
 152         int i;
 153         int success = 0;
 154
 155         for(i = 0; modules[i]; i++){
 156                 if(NT_STATUS_IS_OK(do_smb_load_module(modules[i], false))) {
 157                         success++;
 158                 }
 159         }
 160
 161         DEBUG(2, ("%d modules successfully loaded\n", success));
 162
 163         return success;
 164 }
 165
 166 NTSTATUS smb_probe_module(const char *subsystem, const char *module)
 167 {
 168         char *full_path = NULL;
 169         TALLOC_CTX *ctx = talloc_stackframe();
 170         NTSTATUS status;
 171
 172         /* Check for absolute path */
 173
 174         /* if we make any 'samba multibyte string'
 175            calls here, we break
 176            for loading string modules */
 177
 178         DEBUG(5, ("Probing module '%s'\n", module));
 179
 180         if (module[0] == '/') {
 181                 status = do_smb_load_module(module, true);
 182                 TALLOC_FREE(ctx);
 183                 return status;
 184         }
 185
 186         full_path = talloc_asprintf(ctx,
 187                                     "%s/%s.%s",
 188                                     modules_path(ctx, subsystem),
 189                                     module,
 190                                     shlib_ext());
 191         if (!full_path) {
 192                 TALLOC_FREE(ctx);
 193                 return NT_STATUS_NO_MEMORY;
 194         }
 195
 196         DEBUG(5, ("Probing module '%s': Trying to load from %s\n",
 197                 module, full_path));
 198
 199         status = do_smb_load_module(full_path, true);
 200
 201         TALLOC_FREE(ctx);
 202         return status;
 203 }