NTSTATUS pdb_init_plugin(PDB_CONTEXT *pdb_context, PDB_METHODS **pdb_method, const char *location)
{
void * dl_handle;
char *plugin_location, *plugin_name, *p;
pdb_init_function plugin_init;
int (*plugin_version)(void);
if (location == NULL) {
DEBUG(0, ("The plugin module needs an argument!\n"));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_name = smb_xstrdup(location);
p = strchr(plugin_name, ':');
if (p) {
*p = 0;
plugin_location = p+1;
trim_char(plugin_location, ' ', ' ');
} else {
plugin_location = NULL;
}
trim_char(plugin_name, ' ', ' ');
DEBUG(5, ("Trying to load sam plugin %s\n", plugin_name));
dl_handle = sys_dlopen(plugin_name, RTLD_NOW );
if (!dl_handle) {
DEBUG(0, ("Failed to load sam plugin %s using sys_dlopen (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_version = sys_dlsym(dl_handle, "pdb_version");
if (!plugin_version) {
sys_dlclose(dl_handle);
DEBUG(0, ("Failed to find function 'pdb_version' using sys_dlsym in sam plugin %s (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
if (plugin_version() != PASSDB_INTERFACE_VERSION) {
sys_dlclose(dl_handle);
DEBUG(0, ("Wrong PASSDB_INTERFACE_VERSION! sam plugin has version %d and version %d is needed! Please update!\n",
plugin_version(),PASSDB_INTERFACE_VERSION));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_init = sys_dlsym(dl_handle, "pdb_init");
if (!plugin_init) {
sys_dlclose(dl_handle);
DEBUG(0, ("Failed to find function 'pdb_init' using sys_dlsym in sam plugin %s (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
DEBUG(5, ("Starting sam plugin %s with location %s\n", plugin_name, plugin_location));
return plugin_init(pdb_context, pdb_method, plugin_location);
}
// load one specific plugin
bool Plugins::load_plugin (const string& path)
{
typedef const char* (*__plugin_version__)(void);
typedef Sass_Function_List (*__plugin_load_fns__)(void);
typedef Sass_Importer_List (*__plugin_load_imps__)(void);
if (LOAD_LIB(plugin, path))
{
// try to load initial function to query libsass version suppor
if (LOAD_LIB_FN(__plugin_version__, plugin_version, "libsass_get_version"))
{
// get the libsass version of the plugin
if (!compatibility(plugin_version())) return false;
// try to get import address for "libsass_load_functions"
if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, "libsass_load_functions"))
{
Sass_Function_List fns = plugin_load_functions();
while (fns && *fns) { functions.push_back(*fns); ++ fns; }
}
// try to get import address for "libsass_load_importers"
if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
{
Sass_Importer_List imps = plugin_load_importers();
while (imps && *imps) { importers.push_back(*imps); ++ imps; }
}
// try to get import address for "libsass_load_headers"
if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, "libsass_load_headers"))
{
Sass_Importer_List imps = plugin_load_headers();
while (imps && *imps) { headers.push_back(*imps); ++ imps; }
}
// success
return true;
}
else
{
// print debug message to stderr (should not happen)
cerr << "failed loading 'libsass_support' in <" << path << ">" << endl;
if (const char* dlsym_error = dlerror()) cerr << dlsym_error << endl;
CLOSE_LIB(plugin);
}
}
else
{
// print debug message to stderr (should not happen)
cerr << "failed loading plugin <" << path << ">" << endl;
if (const char* dlopen_error = dlerror()) cerr << dlopen_error << endl;
}
return false;
}
int
main (int argc, char *argv[])
{
int c;
int option_index;
int help = 0, version = 0;
tls_init ();
for (;;) {
c = getopt_long (argc, argv, short_options, long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0: /* options which are long only */
if (strcmp (long_options[option_index].name, "dump-config") == 0) {
dump_config ();
exit (EXIT_SUCCESS);
}
else if (strcmp (long_options[option_index].name, "run") == 0) {
run = optarg;
foreground = 1;
}
else {
fprintf (stderr, "%s: unknown long option: %s (%d)\n",
program_name, long_options[option_index].name, option_index);
exit (EXIT_FAILURE);
}
break;
case 'f':
foreground = 1;
break;
case 'g':
group = optarg;
break;
case 'i':
ipaddr = optarg;
break;
case 'n':
newstyle = 1;
break;
case 'o':
/* XXX When we add support for exportnames, we will need to
* ensure that the user does not use -o + --export.
*/
newstyle = 0;
break;
case 'P':
pidfile = nbdkit_absolute_path (optarg);
if (pidfile == NULL)
exit (EXIT_FAILURE);
break;
case 'p':
port = optarg;
break;
case 'r':
readonly = 1;
break;
case 's':
listen_stdin = 1;
break;
case 'U':
if (strcmp (optarg, "-") == 0)
unixsocket = make_random_fifo ();
else
unixsocket = nbdkit_absolute_path (optarg);
if (unixsocket == NULL)
exit (EXIT_FAILURE);
break;
case 'u':
user = optarg;
break;
case 'v':
verbose = 1;
break;
case 'V':
version = 1;
break;
case HELP_OPTION:
help = 1;
break;
default:
usage ();
exit (EXIT_FAILURE);
}
}
/* No extra parameters. */
if (optind >= argc) {
if (help) {
usage ();
exit (EXIT_SUCCESS);
}
if (version) {
display_version ();
exit (EXIT_SUCCESS);
}
/* Otherwise this is an error. */
fprintf (stderr,
"%s: no plugins given on the command line.\nRead nbdkit(1) for documentation.\n",
program_name);
exit (EXIT_FAILURE);
}
/* Remaining command line arguments define the plugins and plugin
* configuration. If --help or --version was specified, we still
* partially parse these in order that we can display the per-plugin
* help/version information. In future (when the new protocol and
* export names are permitted) we will allow multiple plugins to be
* given, but at the moment only one plugin is allowed.
*/
while (optind < argc) {
const char *filename = argv[optind];
char *p;
open_plugin_so (filename);
/* Find key=value configuration parameters for this plugin. */
++optind;
while (optind < argc && (p = strchr (argv[optind], '=')) != NULL) {
if (help || version)
continue;
*p = '\0';
plugin_config (argv[optind], p+1);
++optind;
}
if (help) {
usage ();
printf ("\n%s:\n\n", filename);
plugin_usage ();
exit (EXIT_SUCCESS);
}
if (version) {
display_version ();
plugin_version ();
exit (EXIT_SUCCESS);
}
plugin_config_complete ();
/* If we supported export names, then we'd continue in the loop
* here, but at the moment only one plugin may be used per server
* so exit if there are any more.
*/
++optind;
if (optind < argc) {
fprintf (stderr, "%s: this server only supports a single plugin\n",
program_name);
exit (EXIT_FAILURE);
}
}
start_serving ();
plugin_cleanup ();
free (unixsocket);
free (pidfile);
if (random_fifo) {
unlink (random_fifo);
free (random_fifo);
}
if (random_fifo_dir) {
rmdir (random_fifo_dir);
free (random_fifo_dir);
}
exit (EXIT_SUCCESS);
}
