Annotation of embedaddon/strongswan/src/libstrongswan/plugins/plugin_loader.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2010-2014 Tobias Brunner
! 3: * Copyright (C) 2007 Martin Willi
! 4: * HSR Hochschule fuer Technik Rapperswil
! 5: *
! 6: * This program is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2 of the License, or (at your
! 9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 10: *
! 11: * This program is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 14: * for more details.
! 15: */
! 16:
! 17: #define _GNU_SOURCE
! 18: #include "plugin_loader.h"
! 19:
! 20: #include <sys/types.h>
! 21: #include <sys/stat.h>
! 22: #include <unistd.h>
! 23: #include <string.h>
! 24: #ifdef HAVE_DLADDR
! 25: #include <dlfcn.h>
! 26: #endif
! 27: #include <limits.h>
! 28: #include <stdio.h>
! 29:
! 30: #include <utils/debug.h>
! 31: #include <library.h>
! 32: #include <collections/hashtable.h>
! 33: #include <collections/array.h>
! 34: #include <collections/linked_list.h>
! 35: #include <plugins/plugin.h>
! 36: #include <utils/integrity_checker.h>
! 37:
! 38: typedef struct private_plugin_loader_t private_plugin_loader_t;
! 39: typedef struct registered_feature_t registered_feature_t;
! 40: typedef struct provided_feature_t provided_feature_t;
! 41: typedef struct plugin_entry_t plugin_entry_t;
! 42:
! 43: #ifdef STATIC_PLUGIN_CONSTRUCTORS
! 44: /**
! 45: * Statically registered constructors
! 46: */
! 47: static hashtable_t *plugin_constructors = NULL;
! 48: #endif
! 49:
! 50: /**
! 51: * private data of plugin_loader
! 52: */
! 53: struct private_plugin_loader_t {
! 54:
! 55: /**
! 56: * public functions
! 57: */
! 58: plugin_loader_t public;
! 59:
! 60: /**
! 61: * List of plugins, as plugin_entry_t
! 62: */
! 63: linked_list_t *plugins;
! 64:
! 65: /**
! 66: * Hashtable for registered features, as registered_feature_t
! 67: */
! 68: hashtable_t *features;
! 69:
! 70: /**
! 71: * Loaded features (stored in reverse order), as provided_feature_t
! 72: */
! 73: linked_list_t *loaded;
! 74:
! 75: /**
! 76: * List of paths to search for plugins
! 77: */
! 78: linked_list_t *paths;
! 79:
! 80: /**
! 81: * List of names of loaded plugins
! 82: */
! 83: char *loaded_plugins;
! 84:
! 85: /**
! 86: * Statistics collected while loading features
! 87: */
! 88: struct {
! 89: /** Number of features that failed to load */
! 90: int failed;
! 91: /** Number of features that failed because of unmet dependencies */
! 92: int depends;
! 93: /** Number of features in critical plugins that failed to load */
! 94: int critical;
! 95: } stats;
! 96: };
! 97:
! 98: /**
! 99: * Registered plugin feature
! 100: */
! 101: struct registered_feature_t {
! 102:
! 103: /**
! 104: * The registered feature
! 105: */
! 106: plugin_feature_t *feature;
! 107:
! 108: /**
! 109: * List of plugins providing this feature, as provided_feature_t
! 110: */
! 111: linked_list_t *plugins;
! 112: };
! 113:
! 114: /**
! 115: * Hash a registered feature
! 116: */
! 117: static u_int registered_feature_hash(registered_feature_t *this)
! 118: {
! 119: return plugin_feature_hash(this->feature);
! 120: }
! 121:
! 122: /**
! 123: * Compare two registered features
! 124: */
! 125: static bool registered_feature_equals(registered_feature_t *a,
! 126: registered_feature_t *b)
! 127: {
! 128: return plugin_feature_equals(a->feature, b->feature);
! 129: }
! 130:
! 131: /**
! 132: * Feature as provided by a plugin
! 133: */
! 134: struct provided_feature_t {
! 135:
! 136: /**
! 137: * Plugin providing the feature
! 138: */
! 139: plugin_entry_t *entry;
! 140:
! 141: /**
! 142: * FEATURE_REGISTER or FEATURE_CALLBACK entry
! 143: */
! 144: plugin_feature_t *reg;
! 145:
! 146: /**
! 147: * The provided feature (followed by dependencies)
! 148: */
! 149: plugin_feature_t *feature;
! 150:
! 151: /**
! 152: * Maximum number of dependencies (following feature)
! 153: */
! 154: int dependencies;
! 155:
! 156: /**
! 157: * TRUE if currently loading this feature (to prevent loops)
! 158: */
! 159: bool loading;
! 160:
! 161: /**
! 162: * TRUE if feature loaded
! 163: */
! 164: bool loaded;
! 165:
! 166: /**
! 167: * TRUE if feature failed to load
! 168: */
! 169: bool failed;
! 170: };
! 171:
! 172: /**
! 173: * Entry for a plugin
! 174: */
! 175: struct plugin_entry_t {
! 176:
! 177: /**
! 178: * Plugin instance
! 179: */
! 180: plugin_t *plugin;
! 181:
! 182: /**
! 183: * TRUE, if the plugin is marked as critical
! 184: */
! 185: bool critical;
! 186:
! 187: /**
! 188: * dlopen handle, if in separate lib
! 189: */
! 190: void *handle;
! 191:
! 192: /**
! 193: * List of features, as provided_feature_t
! 194: */
! 195: linked_list_t *features;
! 196: };
! 197:
! 198: /**
! 199: * Destroy a plugin entry
! 200: */
! 201: static void plugin_entry_destroy(plugin_entry_t *entry)
! 202: {
! 203: DESTROY_IF(entry->plugin);
! 204: if (entry->handle)
! 205: {
! 206: dlclose(entry->handle);
! 207: }
! 208: entry->features->destroy(entry->features);
! 209: free(entry);
! 210: }
! 211:
! 212: /**
! 213: * Wrapper for static plugin features
! 214: */
! 215: typedef struct {
! 216:
! 217: /**
! 218: * Implements plugin_t interface
! 219: */
! 220: plugin_t public;
! 221:
! 222: /**
! 223: * Name of the module registering these features
! 224: */
! 225: char *name;
! 226:
! 227: /**
! 228: * Optional reload function for features
! 229: */
! 230: bool (*reload)(void *data);
! 231:
! 232: /**
! 233: * User data to pass to reload function
! 234: */
! 235: void *reload_data;
! 236:
! 237: /**
! 238: * Static plugin features
! 239: */
! 240: plugin_feature_t *features;
! 241:
! 242: /**
! 243: * Number of plugin features
! 244: */
! 245: int count;
! 246:
! 247: } static_features_t;
! 248:
! 249: METHOD(plugin_t, get_static_name, char*,
! 250: static_features_t *this)
! 251: {
! 252: return this->name;
! 253: }
! 254:
! 255: METHOD(plugin_t, get_static_features, int,
! 256: static_features_t *this, plugin_feature_t *features[])
! 257: {
! 258: *features = this->features;
! 259: return this->count;
! 260: }
! 261:
! 262: METHOD(plugin_t, static_reload, bool,
! 263: static_features_t *this)
! 264: {
! 265: if (this->reload)
! 266: {
! 267: return this->reload(this->reload_data);
! 268: }
! 269: return FALSE;
! 270: }
! 271:
! 272: METHOD(plugin_t, static_destroy, void,
! 273: static_features_t *this)
! 274: {
! 275: free(this->features);
! 276: free(this->name);
! 277: free(this);
! 278: }
! 279:
! 280: /**
! 281: * Create a wrapper around static plugin features.
! 282: */
! 283: static plugin_t *static_features_create(const char *name,
! 284: plugin_feature_t features[], int count,
! 285: bool (*reload)(void*), void *reload_data)
! 286: {
! 287: static_features_t *this;
! 288:
! 289: INIT(this,
! 290: .public = {
! 291: .get_name = _get_static_name,
! 292: .get_features = _get_static_features,
! 293: .reload = _static_reload,
! 294: .destroy = _static_destroy,
! 295: },
! 296: .name = strdup(name),
! 297: .reload = reload,
! 298: .reload_data = reload_data,
! 299: .features = calloc(count, sizeof(plugin_feature_t)),
! 300: .count = count,
! 301: );
! 302:
! 303: memcpy(this->features, features, sizeof(plugin_feature_t) * count);
! 304:
! 305: return &this->public;
! 306: }
! 307:
! 308: #ifdef STATIC_PLUGIN_CONSTRUCTORS
! 309: /*
! 310: * Described in header.
! 311: */
! 312: void plugin_constructor_register(char *name, void *constructor)
! 313: {
! 314: bool old = FALSE;
! 315:
! 316: if (lib && lib->leak_detective)
! 317: {
! 318: old = lib->leak_detective->set_state(lib->leak_detective, FALSE);
! 319: }
! 320:
! 321: if (!plugin_constructors)
! 322: {
! 323: chunk_hash_seed();
! 324: plugin_constructors = hashtable_create(hashtable_hash_str,
! 325: hashtable_equals_str, 32);
! 326: }
! 327: if (constructor)
! 328: {
! 329: plugin_constructors->put(plugin_constructors, name, constructor);
! 330: }
! 331: else
! 332: {
! 333: plugin_constructors->remove(plugin_constructors, name);
! 334: if (!plugin_constructors->get_count(plugin_constructors))
! 335: {
! 336: plugin_constructors->destroy(plugin_constructors);
! 337: plugin_constructors = NULL;
! 338: }
! 339: }
! 340:
! 341: if (lib && lib->leak_detective)
! 342: {
! 343: lib->leak_detective->set_state(lib->leak_detective, old);
! 344: }
! 345: }
! 346: #endif
! 347:
! 348: /**
! 349: * create a plugin
! 350: * returns: NOT_FOUND, if the constructor was not found
! 351: * FAILED, if the plugin could not be constructed
! 352: */
! 353: static status_t create_plugin(private_plugin_loader_t *this, void *handle,
! 354: char *name, bool integrity, bool critical,
! 355: plugin_entry_t **entry)
! 356: {
! 357: char create[128];
! 358: plugin_t *plugin;
! 359: plugin_constructor_t constructor = NULL;
! 360:
! 361: if (snprintf(create, sizeof(create), "%s_plugin_create",
! 362: name) >= sizeof(create))
! 363: {
! 364: return FAILED;
! 365: }
! 366: translate(create, "-", "_");
! 367: #ifdef STATIC_PLUGIN_CONSTRUCTORS
! 368: if (plugin_constructors)
! 369: {
! 370: constructor = plugin_constructors->get(plugin_constructors, name);
! 371: }
! 372: if (!constructor)
! 373: #endif
! 374: {
! 375: constructor = dlsym(handle, create);
! 376: }
! 377: if (!constructor)
! 378: {
! 379: return NOT_FOUND;
! 380: }
! 381: if (integrity && lib->integrity)
! 382: {
! 383: if (!lib->integrity->check_segment(lib->integrity, name, constructor))
! 384: {
! 385: DBG1(DBG_LIB, "plugin '%s': failed segment integrity test", name);
! 386: return FAILED;
! 387: }
! 388: DBG1(DBG_LIB, "plugin '%s': passed file and segment integrity tests",
! 389: name);
! 390: }
! 391: plugin = constructor();
! 392: if (plugin == NULL)
! 393: {
! 394: DBG1(DBG_LIB, "plugin '%s': failed to load - %s returned NULL", name,
! 395: create);
! 396: return FAILED;
! 397: }
! 398: INIT(*entry,
! 399: .plugin = plugin,
! 400: .critical = critical,
! 401: .features = linked_list_create(),
! 402: );
! 403: DBG2(DBG_LIB, "plugin '%s': loaded successfully", name);
! 404: return SUCCESS;
! 405: }
! 406:
! 407: /**
! 408: * load a single plugin
! 409: */
! 410: static plugin_entry_t *load_plugin(private_plugin_loader_t *this, char *name,
! 411: char *file, bool critical)
! 412: {
! 413: plugin_entry_t *entry;
! 414: void *handle;
! 415: int flag = RTLD_LAZY;
! 416:
! 417: switch (create_plugin(this, RTLD_DEFAULT, name, FALSE, critical, &entry))
! 418: {
! 419: case SUCCESS:
! 420: this->plugins->insert_last(this->plugins, entry);
! 421: return entry;
! 422: case NOT_FOUND:
! 423: if (file)
! 424: { /* try to load the plugin from a file */
! 425: break;
! 426: }
! 427: /* fall-through */
! 428: default:
! 429: return NULL;
! 430: }
! 431: if (lib->integrity)
! 432: {
! 433: if (!lib->integrity->check_file(lib->integrity, name, file))
! 434: {
! 435: DBG1(DBG_LIB, "plugin '%s': failed file integrity test of '%s'",
! 436: name, file);
! 437: return NULL;
! 438: }
! 439: }
! 440: if (lib->settings->get_bool(lib->settings, "%s.dlopen_use_rtld_now",
! 441: FALSE, lib->ns))
! 442: {
! 443: flag = RTLD_NOW;
! 444: }
! 445: #ifdef RTLD_NODELETE
! 446: /* If supported, do not unload the library when unloading a plugin. It
! 447: * really doesn't matter in productive systems, but causes many (dependency)
! 448: * library reloads during unit tests. Some libraries can't handle that, e.g.
! 449: * GnuTLS leaks file descriptors in its library load/unload functions. */
! 450: flag |= RTLD_NODELETE;
! 451: #endif
! 452: handle = dlopen(file, flag);
! 453: if (handle == NULL)
! 454: {
! 455: DBG1(DBG_LIB, "plugin '%s' failed to load: %s", name, dlerror());
! 456: return NULL;
! 457: }
! 458: if (create_plugin(this, handle, name, TRUE, critical, &entry) != SUCCESS)
! 459: {
! 460: dlclose(handle);
! 461: return NULL;
! 462: }
! 463: entry->handle = handle;
! 464: this->plugins->insert_last(this->plugins, entry);
! 465: return entry;
! 466: }
! 467:
! 468: CALLBACK(feature_filter, bool,
! 469: void *null, enumerator_t *orig, va_list args)
! 470: {
! 471: provided_feature_t *provided;
! 472: plugin_feature_t **feature;
! 473:
! 474: VA_ARGS_VGET(args, feature);
! 475:
! 476: while (orig->enumerate(orig, &provided))
! 477: {
! 478: if (provided->loaded)
! 479: {
! 480: *feature = provided->feature;
! 481: return TRUE;
! 482: }
! 483: }
! 484: return FALSE;
! 485: }
! 486:
! 487: CALLBACK(plugin_filter, bool,
! 488: void *null, enumerator_t *orig, va_list args)
! 489: {
! 490: plugin_entry_t *entry;
! 491: linked_list_t **list;
! 492: plugin_t **plugin;
! 493:
! 494: VA_ARGS_VGET(args, plugin, list);
! 495:
! 496: if (orig->enumerate(orig, &entry))
! 497: {
! 498: *plugin = entry->plugin;
! 499: if (list)
! 500: {
! 501: enumerator_t *features;
! 502: features = enumerator_create_filter(
! 503: entry->features->create_enumerator(entry->features),
! 504: feature_filter, NULL, NULL);
! 505: *list = linked_list_create_from_enumerator(features);
! 506: }
! 507: return TRUE;
! 508: }
! 509: return FALSE;
! 510: }
! 511:
! 512: METHOD(plugin_loader_t, create_plugin_enumerator, enumerator_t*,
! 513: private_plugin_loader_t *this)
! 514: {
! 515: return enumerator_create_filter(
! 516: this->plugins->create_enumerator(this->plugins),
! 517: plugin_filter, NULL, NULL);
! 518: }
! 519:
! 520: METHOD(plugin_loader_t, has_feature, bool,
! 521: private_plugin_loader_t *this, plugin_feature_t feature)
! 522: {
! 523: enumerator_t *plugins, *features;
! 524: plugin_t *plugin;
! 525: linked_list_t *list;
! 526: plugin_feature_t *current;
! 527: bool found = FALSE;
! 528:
! 529: plugins = create_plugin_enumerator(this);
! 530: while (plugins->enumerate(plugins, &plugin, &list))
! 531: {
! 532: features = list->create_enumerator(list);
! 533: while (features->enumerate(features, ¤t))
! 534: {
! 535: if (plugin_feature_matches(&feature, current))
! 536: {
! 537: found = TRUE;
! 538: break;
! 539: }
! 540: }
! 541: features->destroy(features);
! 542: list->destroy(list);
! 543: }
! 544: plugins->destroy(plugins);
! 545:
! 546: return found;
! 547: }
! 548:
! 549: /**
! 550: * Create a list of the names of all loaded plugins
! 551: */
! 552: static char* loaded_plugins_list(private_plugin_loader_t *this)
! 553: {
! 554: int buf_len = 128, len = 0;
! 555: char *buf, *name;
! 556: enumerator_t *enumerator;
! 557: plugin_t *plugin;
! 558:
! 559: buf = malloc(buf_len);
! 560: buf[0] = '\0';
! 561: enumerator = create_plugin_enumerator(this);
! 562: while (enumerator->enumerate(enumerator, &plugin, NULL))
! 563: {
! 564: name = plugin->get_name(plugin);
! 565: if (len + (strlen(name) + 1) >= buf_len)
! 566: {
! 567: buf_len <<= 1;
! 568: buf = realloc(buf, buf_len);
! 569: }
! 570: len += snprintf(&buf[len], buf_len - len, "%s ", name);
! 571: }
! 572: enumerator->destroy(enumerator);
! 573: if (len > 0 && buf[len - 1] == ' ')
! 574: {
! 575: buf[len - 1] = '\0';
! 576: }
! 577: return buf;
! 578: }
! 579:
! 580: /**
! 581: * Check if a plugin is already loaded
! 582: */
! 583: static bool plugin_loaded(private_plugin_loader_t *this, char *name)
! 584: {
! 585: enumerator_t *enumerator;
! 586: bool found = FALSE;
! 587: plugin_t *plugin;
! 588:
! 589: enumerator = create_plugin_enumerator(this);
! 590: while (enumerator->enumerate(enumerator, &plugin, NULL))
! 591: {
! 592: if (streq(plugin->get_name(plugin), name))
! 593: {
! 594: found = TRUE;
! 595: break;
! 596: }
! 597: }
! 598: enumerator->destroy(enumerator);
! 599: return found;
! 600: }
! 601:
! 602: /**
! 603: * Forward declaration
! 604: */
! 605: static void load_provided(private_plugin_loader_t *this,
! 606: provided_feature_t *provided,
! 607: int level);
! 608:
! 609: CALLBACK(is_feature_loaded, bool,
! 610: provided_feature_t *item, va_list args)
! 611: {
! 612: return item->loaded;
! 613: }
! 614:
! 615: CALLBACK(is_feature_loadable, bool,
! 616: provided_feature_t *item, va_list args)
! 617: {
! 618: return !item->loading && !item->loaded && !item->failed;
! 619: }
! 620:
! 621: /**
! 622: * Find a loaded and matching feature
! 623: */
! 624: static bool loaded_feature_matches(registered_feature_t *a,
! 625: registered_feature_t *b)
! 626: {
! 627: if (plugin_feature_matches(a->feature, b->feature))
! 628: {
! 629: return b->plugins->find_first(b->plugins, is_feature_loaded, NULL);
! 630: }
! 631: return FALSE;
! 632: }
! 633:
! 634: /**
! 635: * Find a loadable module that equals the requested feature
! 636: */
! 637: static bool loadable_feature_equals(registered_feature_t *a,
! 638: registered_feature_t *b)
! 639: {
! 640: if (plugin_feature_equals(a->feature, b->feature))
! 641: {
! 642: return b->plugins->find_first(b->plugins, is_feature_loadable, NULL);
! 643: }
! 644: return FALSE;
! 645: }
! 646:
! 647: /**
! 648: * Find a loadable module that matches the requested feature
! 649: */
! 650: static bool loadable_feature_matches(registered_feature_t *a,
! 651: registered_feature_t *b)
! 652: {
! 653: if (plugin_feature_matches(a->feature, b->feature))
! 654: {
! 655: return b->plugins->find_first(b->plugins, is_feature_loadable, NULL);
! 656: }
! 657: return FALSE;
! 658: }
! 659:
! 660: /**
! 661: * Returns a compatible plugin feature for the given dependency
! 662: */
! 663: static bool find_compatible_feature(private_plugin_loader_t *this,
! 664: plugin_feature_t *dependency)
! 665: {
! 666: registered_feature_t *feature, lookup = {
! 667: .feature = dependency,
! 668: };
! 669:
! 670: feature = this->features->get_match(this->features, &lookup,
! 671: (void*)loaded_feature_matches);
! 672: return feature != NULL;
! 673: }
! 674:
! 675: /**
! 676: * Load a registered plugin feature
! 677: */
! 678: static void load_registered(private_plugin_loader_t *this,
! 679: registered_feature_t *registered,
! 680: int level)
! 681: {
! 682: enumerator_t *enumerator;
! 683: provided_feature_t *provided;
! 684:
! 685: enumerator = registered->plugins->create_enumerator(registered->plugins);
! 686: while (enumerator->enumerate(enumerator, &provided))
! 687: {
! 688: load_provided(this, provided, level);
! 689: }
! 690: enumerator->destroy(enumerator);
! 691: }
! 692:
! 693: /**
! 694: * Try to load dependencies of the given feature
! 695: */
! 696: static bool load_dependencies(private_plugin_loader_t *this,
! 697: provided_feature_t *provided,
! 698: int level)
! 699: {
! 700: registered_feature_t *registered, lookup;
! 701: int i;
! 702:
! 703: /* first entry is provided feature, followed by dependencies */
! 704: for (i = 1; i < provided->dependencies; i++)
! 705: {
! 706: if (provided->feature[i].kind != FEATURE_DEPENDS &&
! 707: provided->feature[i].kind != FEATURE_SDEPEND)
! 708: { /* end of dependencies */
! 709: break;
! 710: }
! 711:
! 712: /* we load the feature even if a compatible one is already loaded,
! 713: * otherwise e.g. a specific database implementation loaded before
! 714: * another might cause a plugin feature loaded in-between to fail */
! 715: lookup.feature = &provided->feature[i];
! 716: do
! 717: { /* prefer an exactly matching feature, could be omitted but
! 718: * results in a more predictable behavior */
! 719: registered = this->features->get_match(this->features,
! 720: &lookup,
! 721: (void*)loadable_feature_equals);
! 722: if (!registered)
! 723: { /* try fuzzy matching */
! 724: registered = this->features->get_match(this->features,
! 725: &lookup,
! 726: (void*)loadable_feature_matches);
! 727: }
! 728: if (registered)
! 729: {
! 730: load_registered(this, registered, level);
! 731: }
! 732: /* we could stop after finding one but for dependencies like
! 733: * DB_ANY it might be needed to load all matching features */
! 734: }
! 735: while (registered);
! 736:
! 737: if (!find_compatible_feature(this, &provided->feature[i]))
! 738: {
! 739: bool soft = provided->feature[i].kind == FEATURE_SDEPEND;
! 740:
! 741: #ifndef USE_FUZZING
! 742: char *name, *provide, *depend;
! 743: int indent = level * 2;
! 744:
! 745: name = provided->entry->plugin->get_name(provided->entry->plugin);
! 746: provide = plugin_feature_get_string(&provided->feature[0]);
! 747: depend = plugin_feature_get_string(&provided->feature[i]);
! 748: if (soft)
! 749: {
! 750: DBG3(DBG_LIB, "%*sfeature %s in plugin '%s' has unmet soft "
! 751: "dependency: %s", indent, "", provide, name, depend);
! 752: }
! 753: else if (provided->entry->critical)
! 754: {
! 755: DBG1(DBG_LIB, "feature %s in critical plugin '%s' has unmet "
! 756: "dependency: %s", provide, name, depend);
! 757: }
! 758: else
! 759: {
! 760: DBG2(DBG_LIB, "feature %s in plugin '%s' has unmet dependency: "
! 761: "%s", provide, name, depend);
! 762: }
! 763: free(provide);
! 764: free(depend);
! 765: #endif /* !USE_FUZZING */
! 766:
! 767: if (soft)
! 768: { /* it's ok if we can't resolve soft dependencies */
! 769: continue;
! 770: }
! 771: return FALSE;
! 772: }
! 773: }
! 774: return TRUE;
! 775: }
! 776:
! 777: /**
! 778: * Load registered plugin features
! 779: */
! 780: static void load_feature(private_plugin_loader_t *this,
! 781: provided_feature_t *provided,
! 782: int level)
! 783: {
! 784: if (load_dependencies(this, provided, level))
! 785: {
! 786: if (plugin_feature_load(provided->entry->plugin, provided->feature,
! 787: provided->reg))
! 788: {
! 789: provided->loaded = TRUE;
! 790: /* insert first so we can unload the features in reverse order */
! 791: this->loaded->insert_first(this->loaded, provided);
! 792: return;
! 793: }
! 794:
! 795: #ifndef USE_FUZZING
! 796: char *name, *provide;
! 797:
! 798: name = provided->entry->plugin->get_name(provided->entry->plugin);
! 799: provide = plugin_feature_get_string(&provided->feature[0]);
! 800: if (provided->entry->critical)
! 801: {
! 802: DBG1(DBG_LIB, "feature %s in critical plugin '%s' failed to load",
! 803: provide, name);
! 804: }
! 805: else
! 806: {
! 807: DBG2(DBG_LIB, "feature %s in plugin '%s' failed to load",
! 808: provide, name);
! 809: }
! 810: free(provide);
! 811: #endif /* !USE_FUZZING */
! 812: }
! 813: else
! 814: { /* TODO: we could check the current level and set a different flag when
! 815: * being loaded as dependency. If there are loops there is a chance the
! 816: * feature can be loaded later when loading the feature directly. */
! 817: this->stats.depends++;
! 818: }
! 819: provided->failed = TRUE;
! 820: this->stats.critical += provided->entry->critical ? 1 : 0;
! 821: this->stats.failed++;
! 822: }
! 823:
! 824: /**
! 825: * Load a provided feature
! 826: */
! 827: static void load_provided(private_plugin_loader_t *this,
! 828: provided_feature_t *provided,
! 829: int level)
! 830: {
! 831:
! 832: if (provided->loaded || provided->failed)
! 833: {
! 834: return;
! 835: }
! 836:
! 837: #ifndef USE_FUZZING
! 838: char *name, *provide;
! 839: int indent = level * 2;
! 840:
! 841: name = provided->entry->plugin->get_name(provided->entry->plugin);
! 842: provide = plugin_feature_get_string(provided->feature);
! 843: if (provided->loading)
! 844: { /* prevent loop */
! 845: DBG3(DBG_LIB, "%*sloop detected while loading %s in plugin '%s'",
! 846: indent, "", provide, name);
! 847: free(provide);
! 848: return;
! 849: }
! 850: DBG3(DBG_LIB, "%*sloading feature %s in plugin '%s'",
! 851: indent, "", provide, name);
! 852: free(provide);
! 853: #else
! 854: if (provided->loading)
! 855: {
! 856: return;
! 857: }
! 858: #endif /* USE_FUZZING */
! 859:
! 860: provided->loading = TRUE;
! 861: load_feature(this, provided, level + 1);
! 862: provided->loading = FALSE;
! 863: }
! 864:
! 865: /**
! 866: * Load registered plugin features
! 867: */
! 868: static void load_features(private_plugin_loader_t *this)
! 869: {
! 870: enumerator_t *enumerator, *inner;
! 871: plugin_entry_t *plugin;
! 872: provided_feature_t *provided;
! 873:
! 874: /* we do this in plugin order to allow implicit dependencies to be resolved
! 875: * by reordering plugins */
! 876: enumerator = this->plugins->create_enumerator(this->plugins);
! 877: while (enumerator->enumerate(enumerator, &plugin))
! 878: {
! 879: inner = plugin->features->create_enumerator(plugin->features);
! 880: while (inner->enumerate(inner, &provided))
! 881: {
! 882: load_provided(this, provided, 0);
! 883: }
! 884: inner->destroy(inner);
! 885: }
! 886: enumerator->destroy(enumerator);
! 887: }
! 888:
! 889: /**
! 890: * Register plugin features provided by the given plugin
! 891: */
! 892: static void register_features(private_plugin_loader_t *this,
! 893: plugin_entry_t *entry)
! 894: {
! 895: plugin_feature_t *feature, *reg;
! 896: registered_feature_t *registered, lookup;
! 897: provided_feature_t *provided;
! 898: int count, i;
! 899:
! 900: if (!entry->plugin->get_features)
! 901: { /* feature interface not supported */
! 902: DBG1(DBG_LIB, "plugin '%s' does not provide features, deprecated",
! 903: entry->plugin->get_name(entry->plugin));
! 904: return;
! 905: }
! 906: reg = NULL;
! 907: count = entry->plugin->get_features(entry->plugin, &feature);
! 908: for (i = 0; i < count; i++)
! 909: {
! 910: switch (feature->kind)
! 911: {
! 912: case FEATURE_PROVIDE:
! 913: lookup.feature = feature;
! 914: registered = this->features->get(this->features, &lookup);
! 915: if (!registered)
! 916: {
! 917: INIT(registered,
! 918: .feature = feature,
! 919: .plugins = linked_list_create(),
! 920: );
! 921: this->features->put(this->features, registered, registered);
! 922: }
! 923: INIT(provided,
! 924: .entry = entry,
! 925: .feature = feature,
! 926: .reg = reg,
! 927: .dependencies = count - i,
! 928: );
! 929: registered->plugins->insert_last(registered->plugins,
! 930: provided);
! 931: entry->features->insert_last(entry->features, provided);
! 932: break;
! 933: case FEATURE_REGISTER:
! 934: case FEATURE_CALLBACK:
! 935: reg = feature;
! 936: break;
! 937: default:
! 938: break;
! 939: }
! 940: feature++;
! 941: }
! 942: }
! 943:
! 944: /**
! 945: * Unregister a plugin feature
! 946: */
! 947: static void unregister_feature(private_plugin_loader_t *this,
! 948: provided_feature_t *provided)
! 949: {
! 950: registered_feature_t *registered, lookup;
! 951:
! 952: lookup.feature = provided->feature;
! 953: registered = this->features->get(this->features, &lookup);
! 954: if (registered)
! 955: {
! 956: registered->plugins->remove(registered->plugins, provided, NULL);
! 957: if (registered->plugins->get_count(registered->plugins) == 0)
! 958: {
! 959: this->features->remove(this->features, &lookup);
! 960: registered->plugins->destroy(registered->plugins);
! 961: free(registered);
! 962: }
! 963: else if (registered->feature == provided->feature)
! 964: { /* update feature in case the providing plugin gets unloaded */
! 965: provided_feature_t *first;
! 966:
! 967: registered->plugins->get_first(registered->plugins, (void**)&first);
! 968: registered->feature = first->feature;
! 969: }
! 970: }
! 971: free(provided);
! 972: }
! 973:
! 974: /**
! 975: * Unregister plugin features
! 976: */
! 977: static void unregister_features(private_plugin_loader_t *this,
! 978: plugin_entry_t *entry)
! 979: {
! 980: provided_feature_t *provided;
! 981: enumerator_t *enumerator;
! 982:
! 983: enumerator = entry->features->create_enumerator(entry->features);
! 984: while (enumerator->enumerate(enumerator, &provided))
! 985: {
! 986: entry->features->remove_at(entry->features, enumerator);
! 987: unregister_feature(this, provided);
! 988: }
! 989: enumerator->destroy(enumerator);
! 990: }
! 991:
! 992: /**
! 993: * Remove plugins we were not able to load any plugin features from.
! 994: */
! 995: static void purge_plugins(private_plugin_loader_t *this)
! 996: {
! 997: enumerator_t *enumerator;
! 998: plugin_entry_t *entry;
! 999:
! 1000: enumerator = this->plugins->create_enumerator(this->plugins);
! 1001: while (enumerator->enumerate(enumerator, &entry))
! 1002: {
! 1003: if (!entry->plugin->get_features)
! 1004: { /* feature interface not supported */
! 1005: continue;
! 1006: }
! 1007: if (!entry->features->find_first(entry->features, is_feature_loaded,
! 1008: NULL))
! 1009: {
! 1010: DBG2(DBG_LIB, "unloading plugin '%s' without loaded features",
! 1011: entry->plugin->get_name(entry->plugin));
! 1012: this->plugins->remove_at(this->plugins, enumerator);
! 1013: unregister_features(this, entry);
! 1014: plugin_entry_destroy(entry);
! 1015: }
! 1016: }
! 1017: enumerator->destroy(enumerator);
! 1018: }
! 1019:
! 1020: METHOD(plugin_loader_t, add_static_features, void,
! 1021: private_plugin_loader_t *this, const char *name,
! 1022: plugin_feature_t features[], int count, bool critical,
! 1023: bool (*reload)(void*), void *reload_data)
! 1024: {
! 1025: plugin_entry_t *entry;
! 1026: plugin_t *plugin;
! 1027:
! 1028: plugin = static_features_create(name, features, count, reload, reload_data);
! 1029:
! 1030: INIT(entry,
! 1031: .plugin = plugin,
! 1032: .critical = critical,
! 1033: .features = linked_list_create(),
! 1034: );
! 1035: this->plugins->insert_last(this->plugins, entry);
! 1036: register_features(this, entry);
! 1037: }
! 1038:
! 1039: /**
! 1040: * Tries to find the plugin with the given name in the given path.
! 1041: */
! 1042: static bool find_plugin(char *path, char *name, char *buf, char **file)
! 1043: {
! 1044: struct stat stb;
! 1045:
! 1046: if (path && snprintf(buf, PATH_MAX, "%s/libstrongswan-%s.so",
! 1047: path, name) < PATH_MAX)
! 1048: {
! 1049: if (stat(buf, &stb) == 0)
! 1050: {
! 1051: *file = buf;
! 1052: return TRUE;
! 1053: }
! 1054: }
! 1055: return FALSE;
! 1056: }
! 1057:
! 1058: CALLBACK(find_plugin_cb, bool,
! 1059: char *path, va_list args)
! 1060: {
! 1061: char *name, *buf, **file;
! 1062:
! 1063: VA_ARGS_VGET(args, name, buf, file);
! 1064: return find_plugin(path, name, buf, file);
! 1065: }
! 1066:
! 1067: /**
! 1068: * Used to sort plugins by priority
! 1069: */
! 1070: typedef struct {
! 1071: /* name of the plugin */
! 1072: char *name;
! 1073: /* the plugins priority */
! 1074: int prio;
! 1075: /* default priority */
! 1076: int def;
! 1077: } plugin_priority_t;
! 1078:
! 1079: static void plugin_priority_free(const plugin_priority_t *this, int idx,
! 1080: void *user)
! 1081: {
! 1082: free(this->name);
! 1083: }
! 1084:
! 1085: /**
! 1086: * Sort plugins and their priority by name
! 1087: */
! 1088: static int plugin_priority_cmp_name(const plugin_priority_t *a,
! 1089: const plugin_priority_t *b)
! 1090: {
! 1091: return strcmp(a->name, b->name);
! 1092: }
! 1093:
! 1094: /**
! 1095: * Sort plugins by decreasing priority or default priority then by name
! 1096: */
! 1097: static int plugin_priority_cmp(const plugin_priority_t *a,
! 1098: const plugin_priority_t *b, void *user)
! 1099: {
! 1100: int diff;
! 1101:
! 1102: diff = b->prio - a->prio;
! 1103: if (!diff)
! 1104: { /* the same priority, use default order */
! 1105: diff = b->def - a->def;
! 1106: if (!diff)
! 1107: { /* same default priority (i.e. both were not found in that list) */
! 1108: return strcmp(a->name, b->name);
! 1109: }
! 1110: }
! 1111: return diff;
! 1112: }
! 1113:
! 1114: CALLBACK(plugin_priority_filter, bool,
! 1115: void *null, enumerator_t *orig, va_list args)
! 1116: {
! 1117: plugin_priority_t *prio;
! 1118: char **name;
! 1119:
! 1120: VA_ARGS_VGET(args, name);
! 1121:
! 1122: if (orig->enumerate(orig, &prio))
! 1123: {
! 1124: *name = prio->name;
! 1125: return TRUE;
! 1126: }
! 1127: return FALSE;
! 1128: }
! 1129:
! 1130: /**
! 1131: * Determine the list of plugins to load via load option in each plugin's
! 1132: * config section.
! 1133: */
! 1134: static char *modular_pluginlist(char *list)
! 1135: {
! 1136: enumerator_t *enumerator;
! 1137: array_t *given, *final;
! 1138: plugin_priority_t item, *current, found;
! 1139: char *plugin, *plugins = NULL;
! 1140: int i = 0, max_prio;
! 1141: bool load_def = FALSE;
! 1142:
! 1143: given = array_create(sizeof(plugin_priority_t), 0);
! 1144: final = array_create(sizeof(plugin_priority_t), 0);
! 1145:
! 1146: enumerator = enumerator_create_token(list, " ", " ");
! 1147: while (enumerator->enumerate(enumerator, &plugin))
! 1148: {
! 1149: item.name = strdup(plugin);
! 1150: item.prio = i++;
! 1151: array_insert(given, ARRAY_TAIL, &item);
! 1152: }
! 1153: enumerator->destroy(enumerator);
! 1154: array_sort(given, (void*)plugin_priority_cmp_name, NULL);
! 1155: /* the maximum priority used for plugins not found in this list */
! 1156: max_prio = i + 1;
! 1157:
! 1158: if (lib->settings->get_bool(lib->settings, "%s.load_modular", FALSE,
! 1159: lib->ns))
! 1160: {
! 1161: enumerator = lib->settings->create_section_enumerator(lib->settings,
! 1162: "%s.plugins", lib->ns);
! 1163: }
! 1164: else
! 1165: {
! 1166: enumerator = enumerator_create_filter(array_create_enumerator(given),
! 1167: plugin_priority_filter, NULL, NULL);
! 1168: load_def = TRUE;
! 1169: }
! 1170: while (enumerator->enumerate(enumerator, &plugin))
! 1171: {
! 1172: item.prio = lib->settings->get_int(lib->settings,
! 1173: "%s.plugins.%s.load", 0, lib->ns, plugin);
! 1174: if (!item.prio)
! 1175: {
! 1176: if (!lib->settings->get_bool(lib->settings,
! 1177: "%s.plugins.%s.load", load_def, lib->ns, plugin))
! 1178: {
! 1179: continue;
! 1180: }
! 1181: item.prio = 1;
! 1182: }
! 1183: item.name = plugin;
! 1184: item.def = max_prio;
! 1185: if (array_bsearch(given, &item, (void*)plugin_priority_cmp_name,
! 1186: &found) != -1)
! 1187: {
! 1188: item.def = max_prio - found.prio;
! 1189: }
! 1190: array_insert(final, ARRAY_TAIL, &item);
! 1191: }
! 1192: enumerator->destroy(enumerator);
! 1193:
! 1194: array_sort(final, (void*)plugin_priority_cmp, NULL);
! 1195:
! 1196: plugins = strdup("");
! 1197: enumerator = array_create_enumerator(final);
! 1198: while (enumerator->enumerate(enumerator, ¤t))
! 1199: {
! 1200: char *prev = plugins;
! 1201: if (asprintf(&plugins, "%s %s", plugins ?: "", current->name) < 0)
! 1202: {
! 1203: plugins = prev;
! 1204: break;
! 1205: }
! 1206: free(prev);
! 1207: }
! 1208: enumerator->destroy(enumerator);
! 1209: array_destroy_function(given, (void*)plugin_priority_free, NULL);
! 1210: array_destroy(final);
! 1211: return plugins;
! 1212: }
! 1213:
! 1214: METHOD(plugin_loader_t, load_plugins, bool,
! 1215: private_plugin_loader_t *this, char *list)
! 1216: {
! 1217: enumerator_t *enumerator;
! 1218: char *default_path = NULL, *plugins, *token;
! 1219: bool critical_failed = FALSE;
! 1220:
! 1221: #ifdef PLUGINDIR
! 1222: default_path = PLUGINDIR;
! 1223: #endif /* PLUGINDIR */
! 1224:
! 1225: plugins = modular_pluginlist(list);
! 1226:
! 1227: enumerator = enumerator_create_token(plugins, " ", " ");
! 1228: while (!critical_failed && enumerator->enumerate(enumerator, &token))
! 1229: {
! 1230: plugin_entry_t *entry;
! 1231: bool critical = FALSE;
! 1232: char buf[PATH_MAX], *file = NULL;
! 1233: int len;
! 1234:
! 1235: token = strdup(token);
! 1236: len = strlen(token);
! 1237: if (token[len-1] == '!')
! 1238: {
! 1239: critical = TRUE;
! 1240: token[len-1] = '\0';
! 1241: }
! 1242: if (plugin_loaded(this, token))
! 1243: {
! 1244: free(token);
! 1245: continue;
! 1246: }
! 1247: if (this->paths)
! 1248: {
! 1249: this->paths->find_first(this->paths, find_plugin_cb, NULL, token,
! 1250: buf, &file);
! 1251: }
! 1252: if (!file)
! 1253: {
! 1254: find_plugin(default_path, token, buf, &file);
! 1255: }
! 1256: entry = load_plugin(this, token, file, critical);
! 1257: if (entry)
! 1258: {
! 1259: register_features(this, entry);
! 1260: }
! 1261: else if (critical)
! 1262: {
! 1263: critical_failed = TRUE;
! 1264: DBG1(DBG_LIB, "loading critical plugin '%s' failed", token);
! 1265: }
! 1266: free(token);
! 1267: }
! 1268: enumerator->destroy(enumerator);
! 1269: if (!critical_failed)
! 1270: {
! 1271: load_features(this);
! 1272: if (this->stats.critical > 0)
! 1273: {
! 1274: critical_failed = TRUE;
! 1275: DBG1(DBG_LIB, "failed to load %d critical plugin feature%s",
! 1276: this->stats.critical, this->stats.critical == 1 ? "" : "s");
! 1277: }
! 1278: /* unload plugins that we were not able to load any features for */
! 1279: purge_plugins(this);
! 1280: }
! 1281: if (!critical_failed)
! 1282: {
! 1283: free(this->loaded_plugins);
! 1284: this->loaded_plugins = loaded_plugins_list(this);
! 1285: }
! 1286: if (plugins != list)
! 1287: {
! 1288: free(plugins);
! 1289: }
! 1290: return !critical_failed;
! 1291: }
! 1292:
! 1293: /**
! 1294: * Unload plugin features, they are registered in reverse order
! 1295: */
! 1296: static void unload_features(private_plugin_loader_t *this)
! 1297: {
! 1298: enumerator_t *enumerator;
! 1299: provided_feature_t *provided;
! 1300: plugin_entry_t *entry;
! 1301:
! 1302: enumerator = this->loaded->create_enumerator(this->loaded);
! 1303: while (enumerator->enumerate(enumerator, &provided))
! 1304: {
! 1305: entry = provided->entry;
! 1306: plugin_feature_unload(entry->plugin, provided->feature, provided->reg);
! 1307: this->loaded->remove_at(this->loaded, enumerator);
! 1308: entry->features->remove(entry->features, provided, NULL);
! 1309: unregister_feature(this, provided);
! 1310: }
! 1311: enumerator->destroy(enumerator);
! 1312: }
! 1313:
! 1314: METHOD(plugin_loader_t, unload, void,
! 1315: private_plugin_loader_t *this)
! 1316: {
! 1317: plugin_entry_t *entry;
! 1318:
! 1319: /* unload features followed by plugins, in reverse order */
! 1320: unload_features(this);
! 1321: while (this->plugins->remove_last(this->plugins, (void**)&entry) == SUCCESS)
! 1322: {
! 1323: if (lib->leak_detective)
! 1324: { /* keep handle to report leaks properly */
! 1325: entry->handle = NULL;
! 1326: }
! 1327: unregister_features(this, entry);
! 1328: plugin_entry_destroy(entry);
! 1329: }
! 1330: free(this->loaded_plugins);
! 1331: this->loaded_plugins = NULL;
! 1332: memset(&this->stats, 0, sizeof(this->stats));
! 1333: }
! 1334:
! 1335: METHOD(plugin_loader_t, add_path, void,
! 1336: private_plugin_loader_t *this, char *path)
! 1337: {
! 1338: if (!this->paths)
! 1339: {
! 1340: this->paths = linked_list_create();
! 1341: }
! 1342: this->paths->insert_last(this->paths, strdupnull(path));
! 1343: }
! 1344:
! 1345: /**
! 1346: * Reload a plugin by name, NULL for all
! 1347: */
! 1348: static u_int reload_by_name(private_plugin_loader_t *this, char *name)
! 1349: {
! 1350: u_int reloaded = 0;
! 1351: enumerator_t *enumerator;
! 1352: plugin_t *plugin;
! 1353:
! 1354: enumerator = create_plugin_enumerator(this);
! 1355: while (enumerator->enumerate(enumerator, &plugin, NULL))
! 1356: {
! 1357: if (name == NULL || streq(name, plugin->get_name(plugin)))
! 1358: {
! 1359: if (plugin->reload && plugin->reload(plugin))
! 1360: {
! 1361: DBG2(DBG_LIB, "reloaded configuration of '%s' plugin",
! 1362: plugin->get_name(plugin));
! 1363: reloaded++;
! 1364: }
! 1365: }
! 1366: }
! 1367: enumerator->destroy(enumerator);
! 1368: return reloaded;
! 1369: }
! 1370:
! 1371: METHOD(plugin_loader_t, reload, u_int,
! 1372: private_plugin_loader_t *this, char *list)
! 1373: {
! 1374: u_int reloaded = 0;
! 1375: enumerator_t *enumerator;
! 1376: char *name;
! 1377:
! 1378: if (list == NULL)
! 1379: {
! 1380: return reload_by_name(this, NULL);
! 1381: }
! 1382: enumerator = enumerator_create_token(list, " ", "");
! 1383: while (enumerator->enumerate(enumerator, &name))
! 1384: {
! 1385: reloaded += reload_by_name(this, name);
! 1386: }
! 1387: enumerator->destroy(enumerator);
! 1388: return reloaded;
! 1389: }
! 1390:
! 1391: METHOD(plugin_loader_t, loaded_plugins, char*,
! 1392: private_plugin_loader_t *this)
! 1393: {
! 1394: return this->loaded_plugins ?: "";
! 1395: }
! 1396:
! 1397: METHOD(plugin_loader_t, status, void,
! 1398: private_plugin_loader_t *this, level_t level)
! 1399: {
! 1400: if (this->loaded_plugins)
! 1401: {
! 1402: dbg(DBG_LIB, level, "loaded plugins: %s", this->loaded_plugins);
! 1403:
! 1404: if (this->stats.failed)
! 1405: {
! 1406: DBG2(DBG_LIB, "unable to load %d plugin feature%s (%d due to unmet "
! 1407: "dependencies)", this->stats.failed,
! 1408: this->stats.failed == 1 ? "" : "s", this->stats.depends);
! 1409: }
! 1410: }
! 1411: }
! 1412:
! 1413: METHOD(plugin_loader_t, destroy, void,
! 1414: private_plugin_loader_t *this)
! 1415: {
! 1416: unload(this);
! 1417: this->features->destroy(this->features);
! 1418: this->loaded->destroy(this->loaded);
! 1419: this->plugins->destroy(this->plugins);
! 1420: DESTROY_FUNCTION_IF(this->paths, free);
! 1421: free(this->loaded_plugins);
! 1422: free(this);
! 1423: }
! 1424:
! 1425: /*
! 1426: * see header file
! 1427: */
! 1428: plugin_loader_t *plugin_loader_create()
! 1429: {
! 1430: private_plugin_loader_t *this;
! 1431:
! 1432: INIT(this,
! 1433: .public = {
! 1434: .add_static_features = _add_static_features,
! 1435: .load = _load_plugins,
! 1436: .add_path = _add_path,
! 1437: .reload = _reload,
! 1438: .unload = _unload,
! 1439: .create_plugin_enumerator = _create_plugin_enumerator,
! 1440: .has_feature = _has_feature,
! 1441: .loaded_plugins = _loaded_plugins,
! 1442: .status = _status,
! 1443: .destroy = _destroy,
! 1444: },
! 1445: .plugins = linked_list_create(),
! 1446: .loaded = linked_list_create(),
! 1447: .features = hashtable_create(
! 1448: (hashtable_hash_t)registered_feature_hash,
! 1449: (hashtable_equals_t)registered_feature_equals, 64),
! 1450: );
! 1451:
! 1452: return &this->public;
! 1453: }
! 1454:
! 1455: /*
! 1456: * See header
! 1457: */
! 1458: void plugin_loader_add_plugindirs(char *basedir, char *plugins)
! 1459: {
! 1460: enumerator_t *enumerator;
! 1461: char *name, path[PATH_MAX], dir[64];
! 1462:
! 1463: enumerator = enumerator_create_token(plugins, " ", "!");
! 1464: while (enumerator->enumerate(enumerator, &name))
! 1465: {
! 1466: snprintf(dir, sizeof(dir), "%s", name);
! 1467: translate(dir, "-", "_");
! 1468: snprintf(path, sizeof(path), "%s/%s/.libs", basedir, dir);
! 1469: lib->plugins->add_path(lib->plugins, path);
! 1470: }
! 1471: enumerator->destroy(enumerator);
! 1472: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to plugin_loader.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins