/* A function called through the vtable to open a module with this loader. Returns an opaque representation of the newly opened module for processing with this loader's other vtable functions. */ static lt_module vm_open (lt_user_data LT__UNUSED loader_data, const char *filename, lt_dladvise LT__UNUSED advise) { image_id image = 0; if (filename) { image = load_add_on (filename); } else { image_info info; int32 cookie = 0; if (get_next_image_info (0, &cookie, &info) == B_OK) image = load_add_on (info.name); } if (image <= 0) { LT__SETERROR (CANNOT_OPEN); image = 0; } return (lt_module) image; }
status_t PrintTransport::Open(BNode* printerFolder) { // already opened? if (fDataIO != NULL) { return B_ERROR; } // retrieve transport add-on name from printer folder attribute BString transportName; if (printerFolder->ReadAttrString("transport", &transportName) != B_OK) { return B_ERROR; } // try first in user add-ons directory BPath path; find_directory(B_USER_ADDONS_DIRECTORY, &path); path.Append("Print/transport"); path.Append(transportName.String()); fAddOnID = load_add_on(path.Path()); if (fAddOnID < 0) { // on failure try in system add-ons directory find_directory(B_BEOS_ADDONS_DIRECTORY, &path); path.Append("Print/transport"); path.Append(transportName.String()); fAddOnID = load_add_on(path.Path()); } if (fAddOnID < 0) { // failed to load transport add-on return B_ERROR; } // get init & exit proc BDataIO* (*initProc)(BMessage*); get_image_symbol(fAddOnID, "init_transport", B_SYMBOL_TYPE_TEXT, (void **) &initProc); get_image_symbol(fAddOnID, "exit_transport", B_SYMBOL_TYPE_TEXT, (void **) &fExitProc); if (initProc == NULL || fExitProc == NULL) { // transport add-on has not the proper interface return B_ERROR; } // now, initialize the transport add-on node_ref ref; BDirectory dir; printerFolder->GetNodeRef(&ref); dir.SetTo(&ref); if (path.SetTo(&dir, NULL) != B_OK) { return B_ERROR; } // request BDataIO object from transport add-on BMessage input('TRIN'); input.AddString("printer_file", path.Path()); fDataIO = (*initProc)(&input); return B_OK; }
void *ILDynLibraryOpen(const char *name) { image_id handle; const char *error; handle = load_add_on(name); if(!handle) { /* If the name does not start with "lib" and does not contain a path, then prepend "lib" and try again */ if(strncmp(name, "lib", 3) != 0) { error = name; while(*error != '\0' && *error != '/' && *error != '\\') { ++error; } if(*error == '\0') { /* Try adding "lib" to the start */ char *temp = (char *)ILMalloc(strlen(name) + 4); if(temp) { strcpy(temp, "lib"); strcat(temp, name); handle = load_add_on(temp); ILFree(temp); if(handle >= B_NO_ERROR) /* errors are < B_NO_ERROR */ { return handle; } } /* Reload the original error state */ handle = load_add_on(name); } } /* Report the error */ #ifdef IL_DYNLIB_DEBUG error = strerror(handle); fprintf(stderr, "%s: \n", name, (error ? error : "could not load dynamic library")); #endif return 0; } else { return handle; } }
status_t TEncoderAddonManager::LoadAddons(const char *addondDir) { fp_text_convert_t fp_text_convert; image_id id; BDirectory dir(addondDir); BEntry entry; // load encoders add-on while (dir.GetNextEntry(&entry) == B_OK) { BPath addonPath(&entry); if ((id = load_add_on(addonPath.Path())) < 0) continue; if (get_image_symbol(id, "fp_text_convert", B_SYMBOL_TYPE_TEXT, (void **)&fp_text_convert)) { unload_add_on(id); continue; } encoder_addon_t *addon = (encoder_addon_t *)malloc(sizeof(encoder_addon_t)); if (!addon) { fprintf(stderr, "%s\n", strerror(ENOMEM)); unload_add_on(id); return ENOMEM; } addon->id = id; addon->fp_text_convert = fp_text_convert; strncpy(addon->name, addonPath.Leaf(), sizeof(addon->name)); fEncoderAddonList.AddItem(addon); fprintf(stderr, "load: %s\n", addon->name); } return B_OK; }
bool BTranslatorRoster::IsTranslator(entry_ref* ref) { if (ref == NULL) return false; BPath path(ref); image_id image = load_add_on(path.Path()); if (image < B_OK) return false; // Function pointer used to create post R4.5 style translators BTranslator* (*makeNthTranslator)(int32 n, image_id you, uint32 flags, ...); status_t status = get_image_symbol(image, "make_nth_translator", B_SYMBOL_TYPE_TEXT, (void**)&makeNthTranslator); if (status < B_OK) { // If this is a translator add-on, it is in the C format translator_data translatorData; status = fPrivate->GetTranslatorData(image, translatorData); } unload_add_on(image); return status == B_OK; }
static int beos_load (DSO * dso) { image_id id; /* See applicable comments from dso_dl.c */ char *filename = DSO_convert_filename (dso, NULL); if (filename == NULL) { DSOerr (DSO_F_BEOS_LOAD, DSO_R_NO_FILENAME); goto err; } id = load_add_on (filename); if (id < 1) { DSOerr (DSO_F_BEOS_LOAD, DSO_R_LOAD_FAILED); ERR_add_error_data (3, "filename(", filename, ")"); goto err; } if (!sk_push (dso->meth_data, (char *) id)) { DSOerr (DSO_F_BEOS_LOAD, DSO_R_STACK_ERROR); goto err; } /* Success */ dso->loaded_filename = filename; return (1); err: /* Cleanup ! */ if (filename != NULL) OPENSSL_free (filename); if (id > 0) unload_add_on (id); return (0); }
bool BeHappy::CheckAddOn(const char *path,bool alert,BString *pName) { image_id addOnImage = load_add_on(path); void *instFunc; const char **projName; const uint16 *BHVersion,*BHVLastCompatible; bool ok = false; BPath aoPath(path); BString alTxt(aoPath.Leaf()); // chaîne utilisée pour générer des alertes d'erreur if ((addOnImage>=0) && (get_image_symbol(addOnImage,"InstantiateProject",B_SYMBOL_TYPE_ANY,&instFunc) == B_OK) && (get_image_symbol(addOnImage,"projectName",B_SYMBOL_TYPE_ANY,(void**)&projName) == B_OK) && (get_image_symbol(addOnImage,"BHVersion",B_SYMBOL_TYPE_ANY,(void**)&BHVersion) == B_OK) && (get_image_symbol(addOnImage,"BHVLastCompatible",B_SYMBOL_TYPE_ANY,(void**)&BHVLastCompatible) == B_OK)) { if ((*BHVLastCompatible) > bhv_application) { if (alert) { alTxt << " " << T("isn't compatible with this (old) version of BeHappy. Please download a more recent version of BeHappy."); BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK", NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT); myAlert->Go(); } } else if ((*BHVersion) < bhv_last_addon) { if (alert) { alTxt << " " << T("is too old, and isn't compatible with this version of BeHappy. Please find a more recent version of the add-on."); BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK", NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT); myAlert->Go(); } } else { ok = true; if (pName != NULL) *pName=*projName; } } else { if (alert) { alTxt << " " << T("is an invalid BeHappy add-on."); BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK", NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT); myAlert->Go(); } } if (addOnImage>=0) unload_add_on(addOnImage); return ok; }
image_id ArpAddonManager::BasicAddon::Open(void) { if( image < 0 ) { image = load_add_on(Path().Path()); } if( image >= 0 ) ref_count++; return image; }
int main(int argc, char **argv) { // Parse command line arguments bool ignorePunctuation = false; char *addon = NULL; BCollator *collator = NULL; while ((++argv)[0]) { if (argv[0][0] == '-') { if (!strcmp(argv[0], "-i")) ignorePunctuation = true; else if (!strcmp(argv[0], "--help")) usage(); } else { // this will be the add-on to be loaded addon = argv[0]; } } // load the collator add-on if necessary if (addon != NULL) { image_id image = load_add_on(addon); if (image < B_OK) fprintf(stderr, "could not load add-on at \"%s\": %s.\n", addon, strerror(image)); BCollatorAddOn *(*instantiate)(void); if (get_image_symbol(image, "instantiate_collator", B_SYMBOL_TYPE_TEXT, (void **)&instantiate) == B_OK) { BCollatorAddOn *collatorAddOn = instantiate(); if (collatorAddOn != NULL) collator = new BCollator(collatorAddOn, B_COLLATE_PRIMARY, true); } else if (image >= B_OK) { fprintf(stderr, "could not find instantiate_collator() function in add-on!\n"); unload_add_on(image); } } if (collator == NULL) { collator = be_locale->Collator(); addon = (char*)"default"; } // test key creation speed collator->SetIgnorePunctuation(ignorePunctuation); printf("%s:\n", addon); test(collator, "primary: ", B_COLLATE_PRIMARY); test(collator, "secondary: ", B_COLLATE_SECONDARY); test(collator, "tertiary: ", B_COLLATE_TERTIARY); test(collator, "quaternary:", B_COLLATE_QUATERNARY); test(collator, "identical: ", B_COLLATE_IDENTICAL); return 0; }
static SDL_INLINE void *get_sdlapi_entry(const char *fname, const char *sym) { image_id lib = load_add_on(fname); void *retval = NULL; if ((lib < 0) || (get_image_symbol(lib, sym, B_SYMBOL_TYPE_TEXT, &retval) != B_NO_ERROR)) { retval = NULL; } return retval; }
image_id BPrinter::_LoadDriver() const { BPath driverPath(_DriverPath()); if (driverPath.InitCheck() != B_OK) return -1; return load_add_on(driverPath.Path()); }
void* CC_CALL cc_load_object(const tchar_t *sofile) { image_id library_id = load_add_on(sofile); if (library_id < 0) { CC_ERROR_LOG(_T("Failed loading %s : %s"),sofile,strerror((int) library_id)); return NULL; } return (void *) (library_id); }
void * SDL_LoadObject(const char *sofile) { void *handle = NULL; image_id library_id = load_add_on(sofile); if (library_id < 0) { SDL_SetError(strerror((int) library_id)); } else { handle = (void *) (library_id); } return (handle); }
// Load status_t AddOnImage::Load(const char* path) { Unload(); status_t error = (path ? B_OK : B_BAD_VALUE); if (error == B_OK) { image_id id = load_add_on(path); if (id >= 0) fID = id; else error = id; } return error; }
void DecorManager::RescanDecorators() { BDirectory dir(DECORATORS_DIR); if (dir.InitCheck() != B_OK) return; entry_ref ref; while (dir.GetNextRef(&ref) == B_OK) { BPath path; path.SetTo(DECORATORS_DIR); path.Append(ref.name); // Because this function is used for both initialization and for keeping // the list up to date, check for existence in the list. Note that we // do not check to see if a decorator has been removed. This is for // stability. If there is a decorator in memory already whose file has // been deleted, it is still available until the next boot, at which point // it will obviously not be loaded. if (_FindDecor(ref.name)) continue; image_id image = load_add_on(path.Path()); if (image < 0) continue; // As of now, we do nothing with decorator versions, but the possibility // exists that the API will change even though I cannot forsee any reason // to do so. If we *did* do anything with decorator versions, the // assignment would go here. create_decorator* createFunc; // Get the instantiation function status_t status = get_image_symbol(image, "instantiate_decorator", B_SYMBOL_TYPE_TEXT, (void**)&createFunc); if (status != B_OK) { unload_add_on(image); continue; } // TODO: unload images until they are actually used! fDecorList.AddItem(new DecorInfo(image, ref.name, createFunc)); } }
void BF_GUI_FilesPanel::Action_Tracker_Addons_Run(const char *pc_AddOn) { ASSERT(pc_AddOn); image_id uImage; uImage = load_add_on(pc_AddOn); if(0==uImage) return; BEntry oEntry(oPath.Path()); entry_ref uEntryRef; if(B_OK!=oEntry.GetRef(&uEntryRef)) return; void (*Func_AddOn)(entry_ref dir_ref, BMessage *msg, void *); if(B_OK!=get_image_symbol(uImage, "process_refs", B_SYMBOL_TYPE_TEXT, (void**)&Func_AddOn)) return; BMessage *poMessage = new BMessage(); BF_NodeCollection loSelNode; loNode.GetSelecting(loSelNode); if(loSelNode.CountItems()==0) loSelNode.AddItem(Nodes_Focus()); if(loSelNode.CountItems()==0) return; ASSERT(poMessage); BF_Node *poNode=NULL; entry_ref uNodeRef; BL_String s; for(int iNode=0;iNode<loSelNode.CountItems();iNode++){ poNode = loSelNode.NodeAt(iNode); s=oPath.Path(); s<<"/"; s<<poNode->sName; if(B_OK!=oEntry.SetTo(s.String()) || B_OK!=oEntry.GetRef(&uNodeRef)) continue; poMessage->AddRef("refs",&uNodeRef); } poMessage->AddRef("folder_ref",&uEntryRef); poMessage->AddPointer("func",(void*)Func_AddOn); // run thread // thread_id idThread = spawn_thread(BF_GUI_FilesPanel_Action_Tracker_Addons_Run_Thread,"tracker_addon_thread",B_THREAD_SUSPENDED,(void*)poMessage); ASSERT(idThread>0,"can`t start thread\n"); ASSERT(B_OK==resume_thread(idThread)); set_thread_priority(idThread,1); }
status_t AddOnManager::_RegisterAddOn(BEntry& entry) { BPath path(&entry); entry_ref ref; status_t status = entry.GetRef(&ref); if (status < B_OK) return status; TRACE("AddOnManager::RegisterAddOn(): trying to load \"%s\"\n", path.Path()); image_id image = load_add_on(path.Path()); if (image < B_OK) { ERROR("load addon %s failed\n", path.Path()); return image; } status = B_ERROR; if (_IsDevice(path.Path())) { BInputServerDevice* device = instantiate_add_on<BInputServerDevice>( image, path.Path(), "device"); if (device != NULL) status = _RegisterDevice(device, ref, image); } else if (_IsFilter(path.Path())) { BInputServerFilter* filter = instantiate_add_on<BInputServerFilter>( image, path.Path(), "filter"); if (filter != NULL) status = _RegisterFilter(filter, ref, image); } else if (_IsMethod(path.Path())) { BInputServerMethod* method = instantiate_add_on<BInputServerMethod>( image, path.Path(), "method"); if (method != NULL) status = _RegisterMethod(method, ref, image); } else { ERROR("AddOnManager::_RegisterAddOn(): addon type not found for " "\"%s\" \n", path.Path()); } if (status != B_OK) unload_add_on(image); return status; }
//------------------------------------------------------------------------------ void TInstantiateObjectTester::LoadAddon() { if (fAddonId > 0) return; // We're not testing the roster, so I'm going to just // find the add-on manually. std::string libPath = std::string(BTestShell::GlobalTestDir()) + gRemoteLib; cout << "dir == '" << libPath << "'" << endl; fAddonId = load_add_on(libPath.c_str()); RES(fAddonId); if (fAddonId <= 0) { FORMAT_AND_THROW(" failed to load addon: ", fAddonId); } }
status_t DormantNodeManager::_LoadAddOn(const char* path, media_addon_id id, BMediaAddOn** _newAddOn, image_id* _newImage) { image_id image = load_add_on(path); if (image < 0) { ERROR("DormantNodeManager::LoadAddon: loading \"%s\" failed: %s\n", path, strerror(image)); return image; } BMediaAddOn* (*makeAddOn)(image_id); status_t status = get_image_symbol(image, "make_media_addon", B_SYMBOL_TYPE_TEXT, (void**)&makeAddOn); if (status != B_OK) { ERROR("DormantNodeManager::LoadAddon: loading failed, function not " "found: %s\n", strerror(status)); unload_add_on(image); return status; } BMediaAddOn* addOn = makeAddOn(image); if (addOn == NULL) { ERROR("DormantNodeManager::LoadAddon: creating BMediaAddOn failed\n"); unload_add_on(image); return B_ERROR; } ASSERT(addOn->ImageID() == image); // this should be true for a well behaving add-ons // We are a friend class of BMediaAddOn and initialize these member // variables addOn->fAddon = id; addOn->fImage = image; // everything ok *_newAddOn = addOn; *_newImage = image; return B_OK; }
BView* CreateConfigView(entry_ref addon, MailAddonSettings& settings, BMailAccountSettings& accountSettings, image_id* image) { BView* (*instantiate_config)(MailAddonSettings& settings, BMailAccountSettings& accountSettings); BPath path(&addon); *image = load_add_on(path.Path()); if (image < 0) return NULL; if (get_image_symbol(*image, "instantiate_config_panel", B_SYMBOL_TYPE_TEXT, (void **)&instantiate_config) != B_OK) { unload_add_on(*image); *image = -1; return NULL; } BView* view = (*instantiate_config)(settings, accountSettings); return view; }
/* --- functions --- */ static gpointer _g_module_open (const gchar *file_name, gboolean bind_lazy) { image_id handle; handle = load_add_on (file_name); if (handle < B_OK) { gchar *msg = g_strdup_printf ("failed to load_add_on(%s): %s", file_name, strerror (handle)); g_module_set_error (msg); g_free (msg); return NULL; } return (gpointer) handle; }
DecorAddOn* DecorManager::_LoadDecor(BString _path, status_t& error ) { if (_path == "Default") { error = B_OK; return &fDefaultDecor; } BEntry entry(_path.String(), true); if (!entry.Exists()) { error = B_ENTRY_NOT_FOUND; return NULL; } BPath path(&entry); image_id image = load_add_on(path.Path()); if (image < 0) { error = B_BAD_IMAGE_ID; return NULL; } create_decor_addon* createFunc; if (get_image_symbol(image, "instantiate_decor_addon", B_SYMBOL_TYPE_TEXT, (void**)&createFunc) != B_OK) { unload_add_on(image); error = B_MISSING_SYMBOL; return NULL; } char name[B_FILE_NAME_LENGTH]; entry.GetName(name); DecorAddOn* newDecor = createFunc(image, name); if (newDecor == NULL || newDecor->InitCheck() != B_OK) { unload_add_on(image); error = B_ERROR; return NULL; } return newDecor; }
void IndexServer::RegisterAddOn(entry_ref ref) { STRACE("RegisterAddOn %s\n", ref.name); BPath path(&ref); image_id image = load_add_on(path.Path()); if (image < 0) return; create_index_server_addon* createFunc; // Get the instantiation function status_t status = get_image_symbol(image, "instantiate_index_server_addon", B_SYMBOL_TYPE_TEXT, (void**)&createFunc); if (status != B_OK) { unload_add_on(image); return; } IndexServerAddOn* addon = createFunc(image, ref.name); if (!addon) { unload_add_on(image); return; } if (!fAddOnList.AddItem(addon)) { unload_add_on(image); return; } for (int i = 0; i < fVolumeWatcherList.CountItems(); i++) { VolumeWatcher* watcher = fVolumeWatcherList.ItemAt(i); FileAnalyser* analyser = _SetupFileAnalyser(addon, watcher->Volume()); if (!analyser) continue; if (!watcher->AddAnalyser(analyser)) delete analyser; } }
status_t PluginManager::_LoadPlugin(const entry_ref& ref, MediaPlugin** plugin, image_id* image) { BPath p(&ref); TRACE("PluginManager: _LoadPlugin trying to load %s\n", p.Path()); image_id id; id = load_add_on(p.Path()); if (id < 0) { printf("PluginManager: Error, load_add_on(): %s\n", strerror(id)); return B_ERROR; } MediaPlugin* (*instantiate_plugin_func)(); if (get_image_symbol(id, "instantiate_plugin", B_SYMBOL_TYPE_TEXT, (void**)&instantiate_plugin_func) < B_OK) { printf("PluginManager: Error, _LoadPlugin can't find " "instantiate_plugin in %s\n", p.Path()); unload_add_on(id); return B_ERROR; } MediaPlugin *pl; pl = (*instantiate_plugin_func)(); if (pl == NULL) { printf("PluginManager: Error, _LoadPlugin instantiate_plugin in %s " "returned NULL\n", p.Path()); unload_add_on(id); return B_ERROR; } *plugin = pl; *image = id; return B_OK; }
main(int argc, char **argv) { char *path, *symname; image_id img; int32 n = 0; volatile int32 symnamelen, symtype; void *symloc; if (argc != 2) { printf("more args, bozo\n"); exit(1); } path = (void *) malloc((size_t) 2048); symname = (void *) malloc((size_t) 2048); if (!getcwd(path, 2048)) { printf("aiee!\n"); exit(1); } if (!strcat(path, "/")) {printf("naah.\n"); exit (1); } /*printf("%s\n",path);*/ if ('/' != argv[1][0]) { if (!strcat(path, argv[1])) { printf("feh1\n"); exit(1); } } else { if (!strcpy(path, argv[1])) { printf("gah!\n"); exit(1); } } /*printf("%s\n",path);*/ img = load_add_on(path); if (B_ERROR == img) {printf("Couldn't load_add_on() %s.\n", path); exit(2); } symnamelen=2047; while (B_BAD_INDEX != get_nth_image_symbol(img, n++, symname, &symnamelen, &symtype, &symloc)) { printf("%s |%s |GLOB %Lx | \n", symname, ((B_SYMBOL_TYPE_ANY == symtype) || (B_SYMBOL_TYPE_TEXT == symtype)) ? "FUNC" : "VAR ", symloc); symnamelen=2047; } printf("number of symbols: %d\n", n); if (B_ERROR == unload_add_on(img)) {printf("err while closing.\n"); exit(3); } free(path); return(0); }
status_t GLRendererRoster::CreateRenderer(const entry_ref& ref) { BEntry entry(&ref, true); node_ref nodeRef; status_t status = entry.GetNodeRef(&nodeRef); if (status < B_OK) return status; BPath path(&ref); image_id image = load_add_on(path.Path()); if (image < B_OK) return image; BGLRenderer* (*instantiate_renderer) (BGLView* view, ulong options, BGLDispatcher* dispatcher); status = get_image_symbol(image, "instantiate_gl_renderer", B_SYMBOL_TYPE_TEXT, (void**)&instantiate_renderer); if (status == B_OK) { BGLRenderer* renderer = instantiate_renderer(fView, fOptions, new BGLDispatcher()); if (!renderer) { unload_add_on(image); return B_UNSUPPORTED; } if (AddRenderer(renderer, image, &ref, nodeRef.node) != B_OK) { renderer->Release(); // this will delete the renderer unload_add_on(image); } return B_OK; } unload_add_on(image); return status; }
bool CatalogAddOnInfo::MakeSureItsLoaded() { if (!fIsEmbedded && fAddOnImage < B_OK) { // add-on has not been loaded yet, so we try to load it: BString fullAddOnPath(fPath); fullAddOnPath << "/" << fName; fAddOnImage = load_add_on(fullAddOnPath.String()); if (fAddOnImage >= B_OK) { get_image_symbol(fAddOnImage, "instantiate_catalog", B_SYMBOL_TYPE_TEXT, (void**)&fInstantiateFunc); get_image_symbol(fAddOnImage, "create_catalog", B_SYMBOL_TYPE_TEXT, (void**)&fCreateFunc); get_image_symbol(fAddOnImage, "get_available_languages", B_SYMBOL_TYPE_TEXT, (void**)&fLanguagesFunc); } else return false; } else if (fIsEmbedded) { // The built-in catalog still has to provide this function fLanguagesFunc = default_catalog_get_available_languages; } return true; }
static void * xmlModulePlatformOpen(const char *name) { return (void *) load_add_on(name); }
/* iterate over add-on-folders and collect information about each catalog-add-ons (types of catalogs) into fCatalogAddOnInfos. */ status_t LocaleRosterData::_InitializeCatalogAddOns() { BAutolock lock(fLock); if (!lock.IsLocked()) return B_ERROR; // add info about embedded default catalog: CatalogAddOnInfo* defaultCatalogAddOnInfo = new(std::nothrow) CatalogAddOnInfo("Default", "", DefaultCatalog::kDefaultCatalogAddOnPriority); if (!defaultCatalogAddOnInfo) return B_NO_MEMORY; defaultCatalogAddOnInfo->fInstantiateFunc = DefaultCatalog::Instantiate; defaultCatalogAddOnInfo->fCreateFunc = DefaultCatalog::Create; fCatalogAddOnInfos.AddItem((void*)defaultCatalogAddOnInfo); directory_which folders[] = { B_USER_ADDONS_DIRECTORY, B_COMMON_ADDONS_DIRECTORY, B_SYSTEM_ADDONS_DIRECTORY, }; BPath addOnPath; BDirectory addOnFolder; char buf[4096]; status_t err; for (uint32 f = 0; f < sizeof(folders) / sizeof(directory_which); ++f) { find_directory(folders[f], &addOnPath); BString addOnFolderName(addOnPath.Path()); addOnFolderName << "/locale/catalogs"; system_info info; if (get_system_info(&info) == B_OK && (info.abi & B_HAIKU_ABI_MAJOR) != (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR)) { switch (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR) { case B_HAIKU_ABI_GCC_2: addOnFolderName << "/gcc2"; break; case B_HAIKU_ABI_GCC_4: addOnFolderName << "/gcc4"; break; } } err = addOnFolder.SetTo(addOnFolderName.String()); if (err != B_OK) continue; // scan through all the folder's entries for catalog add-ons: int32 count; int8 priority; entry_ref eref; BNode node; BEntry entry; dirent* dent; while ((count = addOnFolder.GetNextDirents((dirent*)buf, 4096)) > 0) { dent = (dirent*)buf; while (count-- > 0) { if (strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") && strcmp(dent->d_name, "gcc2") && strcmp(dent->d_name, "gcc4")) { // we have found (what should be) a catalog-add-on: eref.device = dent->d_pdev; eref.directory = dent->d_pino; eref.set_name(dent->d_name); entry.SetTo(&eref, true); // traverse through any links to get to the real thang! node.SetTo(&entry); priority = -1; if (node.ReadAttr(kPriorityAttr, B_INT8_TYPE, 0, &priority, sizeof(int8)) <= 0) { // add-on has no priority-attribute yet, so we load it // to fetch the priority from the corresponding // symbol... BString fullAddOnPath(addOnFolderName); fullAddOnPath << "/" << dent->d_name; image_id image = load_add_on(fullAddOnPath.String()); if (image >= B_OK) { uint8* prioPtr; if (get_image_symbol(image, "gCatalogAddOnPriority", B_SYMBOL_TYPE_DATA, (void**)&prioPtr) == B_OK) { priority = *prioPtr; node.WriteAttr(kPriorityAttr, B_INT8_TYPE, 0, &priority, sizeof(int8)); } unload_add_on(image); } } if (priority >= 0) { // add-ons with priority < 0 will be ignored CatalogAddOnInfo* addOnInfo = new(std::nothrow) CatalogAddOnInfo(dent->d_name, addOnFolderName, priority); if (addOnInfo) fCatalogAddOnInfos.AddItem((void*)addOnInfo); } } // Bump the dirent-pointer by length of the dirent just handled: dent = (dirent*)((char*)dent + dent->d_reclen); } } } fCatalogAddOnInfos.SortItems(CompareInfos); return B_OK; }
/** * Load a dynamically linked library using a system dependent method. * * \param p_this vlc object * \param psz_file library file * \param p_handle the module handle returned * \return 0 on success as well as the module handle. */ int module_Load( vlc_object_t *p_this, const char *psz_file, module_handle_t *p_handle ) { module_handle_t handle; #if defined(HAVE_DL_BEOS) handle = load_add_on( psz_file ); if( handle < 0 ) { msg_Warn( p_this, "cannot load module `%s'", psz_file ); return -1; } #elif defined(HAVE_DL_WINDOWS) wchar_t psz_wfile[MAX_PATH]; MultiByteToWideChar( CP_UTF8, 0, psz_file, -1, psz_wfile, MAX_PATH ); #ifndef UNDER_CE /* FIXME: this is not thread-safe -- Courmisch */ UINT mode = SetErrorMode (SEM_FAILCRITICALERRORS); SetErrorMode (mode|SEM_FAILCRITICALERRORS); #endif handle = LoadLibraryW( psz_wfile ); #ifndef UNDER_CE SetErrorMode (mode); #endif if( handle == NULL ) { char *psz_err = GetWindowsError(); msg_Warn( p_this, "cannot load module `%s' (%s)", psz_file, psz_err ); free( psz_err ); return -1; } #elif defined(HAVE_DL_DLOPEN) # if defined (RTLD_NOW) const int flags = RTLD_NOW; # elif defined (DL_LAZY) const int flags = DL_LAZY; # else const int flags = 0; # endif char *path = ToLocale( psz_file ); handle = dlopen( path, flags ); if( handle == NULL ) { msg_Warn( p_this, "cannot load module `%s' (%s)", path, dlerror() ); LocaleFree( path ); return -1; } LocaleFree( path ); #elif defined(HAVE_DL_SHL_LOAD) handle = shl_load( psz_file, BIND_IMMEDIATE | BIND_NONFATAL, NULL ); if( handle == NULL ) { msg_Warn( p_this, "cannot load module `%s' (%m)", psz_file ); return -1; } #else # error "Something is wrong in modules.c" #endif *p_handle = handle; return 0; }