mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
05bc4de083
This library was tiny - containing just two public functions than were themselves trivial. The amount of overhead this causes isn't really worth the benefits of sharing the code with other projects like OpenChange. In addition, this code isn't really generically useful anyway, as it can only load from the module path set for Samba at configure time. Adding a new library was breaking the API/ABI anyway, so OpenChange had to be updated to cope with the new situation one way or another. I've added a simpler (compatible) routine for loading modules to OpenChange, which is less than 100 lines of code. Autobuild-User: Jelmer Vernooij <jelmer@samba.org> Autobuild-Date: Sat Dec 3 08:36:33 CET 2011 on sn-devel-104
241 lines
5.6 KiB
C
241 lines
5.6 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
Samba utility functions
|
|
Copyright (C) Jelmer Vernooij 2002-2003,2005-2007
|
|
Copyright (C) Stefan (metze) Metzmacher 2003
|
|
Copyright (C) Andrew Bartlett 2011
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include "dynconfig/dynconfig.h"
|
|
#include "lib/util/samba_modules.h"
|
|
#include "system/filesys.h"
|
|
#include "system/dir.h"
|
|
|
|
/**
|
|
* Obtain the init function from a shared library file
|
|
*/
|
|
init_module_fn load_module(const char *path, bool is_probe, void **handle_out)
|
|
{
|
|
void *handle;
|
|
void *init_fn;
|
|
char *error;
|
|
|
|
#if _SAMBA_BUILD_ == 3
|
|
/* Always try to use LAZY symbol resolving; if the plugin has
|
|
* backwards compatibility, there might be symbols in the
|
|
* plugin referencing to old (removed) functions
|
|
*/
|
|
handle = dlopen(path, RTLD_LAZY);
|
|
#else
|
|
/* This should be a WAF build, where modules should be built
|
|
* with no undefined symbols and are already linked against
|
|
* the libraries that they are loaded by */
|
|
handle = dlopen(path, RTLD_NOW);
|
|
#endif
|
|
|
|
/* This call should reset any possible non-fatal errors that
|
|
occured since last call to dl* functions */
|
|
error = dlerror();
|
|
|
|
if (handle == NULL) {
|
|
int level = is_probe ? 5 : 0;
|
|
DEBUG(level, ("Error loading module '%s': %s\n", path, error ? error : ""));
|
|
return NULL;
|
|
}
|
|
|
|
init_fn = (init_module_fn)dlsym(handle, SAMBA_INIT_MODULE);
|
|
|
|
/* we could check dlerror() to determine if it worked, because
|
|
dlsym() can validly return NULL, but what would we do with
|
|
a NULL pointer as a module init function? */
|
|
|
|
if (init_fn == NULL) {
|
|
DEBUG(0, ("Unable to find %s() in %s: %s\n",
|
|
SAMBA_INIT_MODULE, path, dlerror()));
|
|
DEBUG(1, ("Loading module '%s' failed\n", path));
|
|
dlclose(handle);
|
|
return NULL;
|
|
}
|
|
|
|
if (handle_out) {
|
|
*handle_out = handle;
|
|
}
|
|
|
|
return (init_module_fn)init_fn;
|
|
}
|
|
|
|
/**
|
|
* Obtain list of init functions from the modules in the specified
|
|
* directory
|
|
*/
|
|
static init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path)
|
|
{
|
|
DIR *dir;
|
|
struct dirent *entry;
|
|
char *filename;
|
|
int success = 0;
|
|
init_module_fn *ret = talloc_array(mem_ctx, init_module_fn, 2);
|
|
|
|
ret[0] = NULL;
|
|
|
|
dir = opendir(path);
|
|
if (dir == NULL) {
|
|
talloc_free(ret);
|
|
return NULL;
|
|
}
|
|
|
|
while((entry = readdir(dir))) {
|
|
if (ISDOT(entry->d_name) || ISDOTDOT(entry->d_name))
|
|
continue;
|
|
|
|
filename = talloc_asprintf(mem_ctx, "%s/%s", path, entry->d_name);
|
|
|
|
ret[success] = load_module(filename, true, NULL);
|
|
if (ret[success]) {
|
|
ret = talloc_realloc(mem_ctx, ret, init_module_fn, success+2);
|
|
success++;
|
|
ret[success] = NULL;
|
|
}
|
|
|
|
talloc_free(filename);
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Run the specified init functions.
|
|
*
|
|
* @return true if all functions ran successfully, false otherwise
|
|
*/
|
|
bool run_init_functions(init_module_fn *fns)
|
|
{
|
|
int i;
|
|
bool ret = true;
|
|
|
|
if (fns == NULL)
|
|
return true;
|
|
|
|
for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i]()); }
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Load the initialization functions from DSO files for a specific subsystem.
|
|
*
|
|
* Will return an array of function pointers to initialization functions
|
|
*/
|
|
|
|
init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, const char *subsystem)
|
|
{
|
|
char *path = modules_path(mem_ctx, subsystem);
|
|
init_module_fn *ret;
|
|
|
|
ret = load_modules(mem_ctx, path);
|
|
|
|
talloc_free(path);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Load a dynamic module. Only log a level 0 error if we are not checking
|
|
for the existence of a module (probling). */
|
|
|
|
static NTSTATUS do_smb_load_module(const char *module_name, bool is_probe)
|
|
{
|
|
void *handle;
|
|
init_module_fn init;
|
|
NTSTATUS status;
|
|
|
|
init = load_module(module_name, is_probe, &handle);
|
|
if (!init) {
|
|
return NT_STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
DEBUG(2, ("Module '%s' loaded\n", module_name));
|
|
|
|
status = init();
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(0, ("Module '%s' initialization failed: %s\n",
|
|
module_name, get_friendly_nt_error_msg(status)));
|
|
dlclose(handle);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/* Load all modules in list and return number of
|
|
* modules that has been successfully loaded */
|
|
int smb_load_modules(const char **modules)
|
|
{
|
|
int i;
|
|
int success = 0;
|
|
|
|
for(i = 0; modules[i]; i++){
|
|
if(NT_STATUS_IS_OK(do_smb_load_module(modules[i], false))) {
|
|
success++;
|
|
}
|
|
}
|
|
|
|
DEBUG(2, ("%d modules successfully loaded\n", success));
|
|
|
|
return success;
|
|
}
|
|
|
|
NTSTATUS smb_probe_module(const char *subsystem, const char *module)
|
|
{
|
|
char *full_path = NULL;
|
|
TALLOC_CTX *ctx = talloc_stackframe();
|
|
NTSTATUS status;
|
|
|
|
/* Check for absolute path */
|
|
|
|
/* if we make any 'samba multibyte string'
|
|
calls here, we break
|
|
for loading string modules */
|
|
|
|
DEBUG(5, ("Probing module '%s'\n", module));
|
|
|
|
if (module[0] == '/') {
|
|
status = do_smb_load_module(module, true);
|
|
TALLOC_FREE(ctx);
|
|
return status;
|
|
}
|
|
|
|
full_path = talloc_asprintf(ctx,
|
|
"%s/%s.%s",
|
|
modules_path(ctx, subsystem),
|
|
module,
|
|
shlib_ext());
|
|
if (!full_path) {
|
|
TALLOC_FREE(ctx);
|
|
return NT_STATUS_NO_MEMORY;
|
|
}
|
|
|
|
DEBUG(5, ("Probing module '%s': Trying to load from %s\n",
|
|
module, full_path));
|
|
|
|
status = do_smb_load_module(full_path, true);
|
|
|
|
TALLOC_FREE(ctx);
|
|
return status;
|
|
}
|