ModHandle CModules::OpenModule(const CString& sModule, const CString& sModPath, bool &bVersionMismatch, bool &bIsGlobal, CString& sDesc, CString& sRetMsg) { // Some sane defaults in case anything errors out below bVersionMismatch = false; bIsGlobal = false; sDesc.clear(); sRetMsg.clear(); for (unsigned int a = 0; a < sModule.length(); a++) { if (((sModule[a] < '0') || (sModule[a] > '9')) && ((sModule[a] < 'a') || (sModule[a] > 'z')) && ((sModule[a] < 'A') || (sModule[a] > 'Z')) && (sModule[a] != '_')) { sRetMsg = "Module names can only contain letters, numbers and underscores, [" + sModule + "] is invalid."; return NULL; } } #ifndef _WIN32 // The second argument to dlopen() has a long history. It seems clear // that (despite what the man page says) we must include either of // RTLD_NOW and RTLD_LAZY and either of RTLD_GLOBAL and RTLD_LOCAL. // // RTLD_NOW vs. RTLD_LAZY: We use RTLD_NOW to avoid znc dying due to // failed symbol lookups later on. Doesn't really seem to have much of a // performance impact. // // RTLD_GLOBAL vs. RTLD_LOCAL: If perl is loaded with RTLD_LOCAL and later on // loads own modules (which it apparently does with RTLD_LAZY), we will die in a // name lookup since one of perl's symbols isn't found. That's worse // than any theoretical issue with RTLD_GLOBAL. ModHandle p = dlopen((sModPath).c_str(), RTLD_NOW | RTLD_GLOBAL); #else ModHandle p = dlopen((sModPath).c_str(), RTLD_NOW | RTLD_LOCAL); #endif if (!p) { sRetMsg = "Unable to open module [" + sModule + "] [" + dlerror() + "]"; return NULL; } typedef double (*dFP)(); dFP Version = (dFP) dlsym(p, "ZNCModVersion"); if (!Version) { dlclose(p); sRetMsg = "Could not find ZNCModVersion() in module [" + sModule + "]"; return NULL; } typedef bool (*bFP)(); bFP IsGlobal = (bFP) dlsym(p, "ZNCModGlobal"); if (!IsGlobal) { dlclose(p); sRetMsg = "Could not find ZNCModGlobal() in module [" + sModule + "]"; return NULL; } typedef const char *(*sFP)(); sFP GetDesc = (sFP) dlsym(p, "ZNCModDescription"); if (!GetDesc) { dlclose(p); sRetMsg = "Could not find ZNCModDescription() in module [" + sModule + "]"; return NULL; } if (CModule::GetCoreVersion() != Version()) { bVersionMismatch = true; #ifndef _WIN32 sRetMsg = "Version mismatch, recompile this module."; #else sRetMsg = "Module version is '" + CString(Version(), 3) + "', but core expects '" + CString(CModule::GetCoreVersion(), 3) + "'. Please re-download/re-install/re-compile the module."; #endif } else { sRetMsg = ""; bVersionMismatch = false; bIsGlobal = IsGlobal(); sDesc = GetDesc(); } return p; }
CMMBDataSource::CMMBDataSource(int fd) { const char* dlerr; //do null pVideoFrame = NULL; FrameOffset = 0; libcmmbsp_handle = dlopen("/data/data/com.mediatek.cmmb.app/lib/libcmmbsp.so",RTLD_NOW); // dlopen ´ò¿ªso dlerr = dlerror(); if (dlerr != NULL) LOGE("CMMBDataSource: dlopen() error: %s\n", dlerr); if(!libcmmbsp_handle) { LOGE("CMMBDataSource dlopen /data/data/com.mediatek.cmmb.app/lib/libcmmbsp fail,then open /system/lib/so"); libcmmbsp_handle = dlopen("libcmmbsp.so",RTLD_NOW); if(!libcmmbsp_handle) { LOGE("CMMBDataSource dlopen /system/lib/so fail"); } } if(libcmmbsp_handle){ LOGI("dlopen success,then dlsym"); // get CmmbFreeVideoFrame function point F_CmmbFreeVideoFrame = (CmmbFreeVideoFrame_T)dlsym(libcmmbsp_handle,"CmmbFreeVideoFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbFreeVideoFrame dlsym() error: %s\n", dlerr); F_CmmbFreeVideoFrame=NULL; } // get CmmbReadVideoFrame function point F_CmmbReadVideoFrame = (CmmbReadVideoFrame_T)dlsym(libcmmbsp_handle,"CmmbReadVideoFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbReadVideoFrame dlsym() error: %s\n", dlerr); F_CmmbReadVideoFrame = NULL; } // get CmmbReadAudioFrame function point F_CmmbReadAudioFrame=(CmmbReadAudioFrame_T)dlsym(libcmmbsp_handle,"CmmbReadAudioFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbReadAudioFrame dlsym() error: %s\n", dlerr); F_CmmbReadAudioFrame=NULL; } // get CmmbFreeAudioFrame function point F_CmmbFreeAudioFrame = (CmmbFreeAudioFrame_T)dlsym(libcmmbsp_handle,"CmmbFreeAudioFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbFreeAudioFrame dlsym() error: %s\n", dlerr); F_CmmbFreeAudioFrame=NULL; } // get CmmbFlushAVFrame function point F_CmmbFlushAVFrame = (CmmbFlushAVFrame_T)dlsym(libcmmbsp_handle,"CmmbFlushAVFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbFlushAVFrame dlsym() error: %s\n", dlerr); F_CmmbFlushAVFrame =NULL; } // get CmmbGetMetadata function point F_CmmbGetMetadata = (CmmbGetMetadata_T)dlsym(libcmmbsp_handle,"CmmbGetMetadata"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbGetMetadata dlsym() error: %s\n", dlerr); F_CmmbGetMetadata = NULL; } // get CmmbFlushOldestFrame function point F_CmmbFlushOldestFrame = (CmmbFlushOldestFrame_T)dlsym(libcmmbsp_handle,"CmmbFlushOldestFrame"); dlerr = dlerror(); if (dlerr != NULL){ LOGE( "CMMBDataSource::CMMBDataSource CmmbFlushOldestFrame dlsym() error: %s\n", dlerr); F_CmmbFlushOldestFrame = NULL; } } /*release redundancy frame to push forward playback*/ if(F_CmmbFlushOldestFrame) { F_CmmbFlushOldestFrame(); } else { LOGE("Error F_CmmbFlushOldestFrame=NULL"); } //test #if 0 filesource = new CMMBFileSource; #endif }
static int load_dll(ClipMachine * mp, const char *name, struct Coll *names, ClipVar * resp) { void *hp; char buf[256], *s, *e; char uname[128]; const char **spp; ClipModule *entry; ClipFunction **fpp; ClipNameEntry *np; ClipFile **cpp; struct DBFuncTable **dpp; unsigned l, i; int ret = 0; s = strrchr(name, '/'); if (s) snprintf(buf, sizeof(buf), "%s", name); else snprintf(buf, sizeof(buf), "%s/lib/%s", CLIPROOT, name); if (!loaded_dlls) { loaded_dlls = new_Coll(free, strcmp); } else { if (search_Coll(loaded_dlls, buf, 0)) return 0; } hp = dlopen(buf, RTLD_NOW); if (!hp) { _clip_trap_printf(mp, __FILE__, __LINE__, "shared loading problem: %s: file %s", dlerror(), buf); return _clip_call_errblock(mp, 1); } insert_Coll(loaded_dlls, strdup(buf)); /* path/name.ext -> name_module entry symbol */ s = strrchr(name, '/'); if (!s) s = (char *) name; else s = s + 1; e = strchr(s, '.'); if (e) l = e - s; else l = strlen(s); if (l > sizeof(uname)) l = sizeof(uname); for (i = 0; i < l; i++, s++) { if (*s == '-') uname[i] = '_'; else uname[i] = toupper(*s); } uname[l] = 0; snprintf(buf, sizeof(buf), "clip__MODULE_%s", uname); entry = (ClipModule *) dlsym(hp, buf); if (!entry) { _clip_trap_printf(mp, __FILE__, __LINE__, "shared '%s' fetch name '%s' problem: %s", name, buf, dlerror()); return _clip_call_errblock(mp, 1); } for (np = entry->cfunctions; np && np->f; ++np) _clip_register_hash(mp, np->f, np->hash); for (fpp = entry->inits; fpp && *fpp; ++fpp) _clip_main_func(mp, *fpp, _clip_argc, _clip_argv, _clip_envp); for (fpp = entry->exits; fpp && *fpp; ++fpp) { mp->cexits = realloc(mp->cexits, (mp->ncexits + 1) * sizeof(ClipFunction *)); mp->cexits[mp->ncexits] = *fpp; ++mp->ncexits; } for (spp = entry->pfunctions; spp && *spp; ++spp) if (_clip_load(mp, *spp, 0, 0)) ++ret; /* if (entry->cpfile && _clip_register_file(mp, entry->cpfile)) ++ret; */ for (cpp = entry->cpfiles; cpp && *cpp; ++cpp) if (_clip_register_file(mp, *cpp)) ++ret; for (dpp = entry->dbdrivers; dpp && *dpp; ++dpp) if (_clip_register_driver(mp, *dpp)) ++ret; add_ClipVect(&mp->dlls, hp); return ret; }
/* ============== VID_LoadRefresh ============== */ qboolean VID_LoadRefresh( char *name ) { refimport_t ri; GetRefAPI_t GetRefAPI; char fn[MAX_OSPATH]; struct stat st; extern uid_t saved_euid; FILE *fp; if ( reflib_active ) { if (KBD_Close_fp) KBD_Close_fp(); if (RW_IN_Shutdown_fp) RW_IN_Shutdown_fp(); KBD_Close_fp = NULL; RW_IN_Shutdown_fp = NULL; re.Shutdown(); VID_FreeReflib (); } Com_Printf( "------- Loading %s -------\n", name ); //regain root seteuid(saved_euid); if ((fp = fopen(so_file, "r")) == NULL) { Com_Printf( "LoadLibrary(\"%s\") failed: can't open %s (required for location of ref libraries)\n", name, so_file); return false; } fgets(fn, sizeof(fn), fp); fclose(fp); while (*fn && isspace(fn[strlen(fn) - 1])) fn[strlen(fn) - 1] = 0; strcat(fn, "/"); strcat(fn, name); // permission checking if (strstr(fn, "softx") == NULL) { // softx doesn't require root if (stat(fn, &st) == -1) { Com_Printf( "LoadLibrary(\"%s\") failed: %s\n", name, strerror(errno)); return false; } #if 0 if (st.st_uid != 0) { Com_Printf( "LoadLibrary(\"%s\") failed: ref is not owned by root\n", name); return false; } if ((st.st_mode & 0777) & ~0700) { Com_Printf( "LoadLibrary(\"%s\") failed: invalid permissions, must be 700 for security considerations\n", name); return false; } #endif } else { // softx requires we give up root now setreuid(getuid(), getuid()); setegid(getgid()); } if ( ( reflib_library = dlopen( fn, RTLD_LAZY | RTLD_GLOBAL ) ) == 0 ) { Com_Printf( "LoadLibrary(\"%s\") failed: %s\n", name , dlerror()); return false; } Com_Printf( "LoadLibrary(\"%s\")\n", fn ); ri.Cmd_AddCommand = Cmd_AddCommand; ri.Cmd_RemoveCommand = Cmd_RemoveCommand; ri.Cmd_Argc = Cmd_Argc; ri.Cmd_Argv = Cmd_Argv; ri.Cmd_ExecuteText = Cbuf_ExecuteText; ri.Con_Printf = VID_Printf; ri.Sys_Error = VID_Error; ri.FS_LoadFile = FS_LoadFile; ri.FS_FreeFile = FS_FreeFile; ri.FS_Gamedir = FS_Gamedir; ri.Cvar_Get = Cvar_Get; ri.Cvar_Set = Cvar_Set; ri.Cvar_SetValue = Cvar_SetValue; ri.Vid_GetModeInfo = VID_GetModeInfo; ri.Vid_MenuInit = VID_MenuInit; ri.Vid_NewWindow = VID_NewWindow; if ( ( GetRefAPI = (void *) dlsym( reflib_library, "GetRefAPI" ) ) == 0 ) Com_Error( ERR_FATAL, "dlsym failed on %s", name ); re = GetRefAPI( ri ); if (re.api_version != API_VERSION) { VID_FreeReflib (); Com_Error (ERR_FATAL, "%s has incompatible api_version", name); } /* Init IN (Mouse) */ in_state.IN_CenterView_fp = IN_CenterView; in_state.Key_Event_fp = Do_Key_Event; in_state.viewangles = cl.viewangles; in_state.in_strafe_state = &in_strafe.state; if ((RW_IN_Init_fp = dlsym(reflib_library, "RW_IN_Init")) == NULL || (RW_IN_Shutdown_fp = dlsym(reflib_library, "RW_IN_Shutdown")) == NULL || (RW_IN_Activate_fp = dlsym(reflib_library, "RW_IN_Activate")) == NULL || (RW_IN_Commands_fp = dlsym(reflib_library, "RW_IN_Commands")) == NULL || (RW_IN_Move_fp = dlsym(reflib_library, "RW_IN_Move")) == NULL || (RW_IN_Frame_fp = dlsym(reflib_library, "RW_IN_Frame")) == NULL) Sys_Error("No RW_IN functions in REF.\n"); Real_IN_Init(); if ( re.Init( 0, 0 ) == -1 ) { re.Shutdown(); VID_FreeReflib (); return false; } /* Init KBD */ #if 1 if ((KBD_Init_fp = dlsym(reflib_library, "KBD_Init")) == NULL || (KBD_Update_fp = dlsym(reflib_library, "KBD_Update")) == NULL || (KBD_Close_fp = dlsym(reflib_library, "KBD_Close")) == NULL) Sys_Error("No KBD functions in REF.\n"); #else { void KBD_Init(void); void KBD_Update(void); void KBD_Close(void); KBD_Init_fp = KBD_Init; KBD_Update_fp = KBD_Update; KBD_Close_fp = KBD_Close; } #endif KBD_Init_fp(Do_Key_Event); // give up root now setreuid(getuid(), getuid()); setegid(getgid()); Com_Printf( "------------------------------------\n"); reflib_active = true; return true; }
OMX_ERRORTYPE RKOMXPlugin::AddCore(const char* coreName) { bool isRKCore = false; if (!strcmp(coreName, "libOMX_Core.so")) { isRKCore = true; } void* libHandle = dlopen(coreName, RTLD_NOW); if (libHandle != NULL) { RKOMXCore* core = (RKOMXCore*)calloc(1,sizeof(RKOMXCore)); if (!core) { dlclose(libHandle); return OMX_ErrorUndefined; } // set plugin lib handle and methods core->mLibHandle = libHandle; if (isRKCore) { core->mInit = (RKOMXCore::InitFunc)dlsym(libHandle, "RKOMX_Init"); core->mDeinit = (RKOMXCore::DeinitFunc)dlsym(libHandle, "RKOMX_DeInit"); core->mComponentNameEnum = (RKOMXCore::ComponentNameEnumFunc)dlsym(libHandle, "RKOMX_ComponentNameEnum"); core->mGetHandle = (RKOMXCore::GetHandleFunc)dlsym(libHandle, "RKOMX_GetHandle"); core->mFreeHandle = (RKOMXCore::FreeHandleFunc)dlsym(libHandle, "RKOMX_FreeHandle"); core->mGetRolesOfComponentHandle = (RKOMXCore::GetRolesOfComponentFunc)dlsym( libHandle, "RKOMX_GetRolesOfComponent"); } else { core->mInit = (RKOMXCore::InitFunc)dlsym(libHandle, "OMX_Init"); core->mDeinit = (RKOMXCore::DeinitFunc)dlsym(libHandle, "OMX_Deinit"); core->mComponentNameEnum = (RKOMXCore::ComponentNameEnumFunc)dlsym(libHandle, "OMX_ComponentNameEnum"); core->mGetHandle = (RKOMXCore::GetHandleFunc)dlsym(libHandle, "OMX_GetHandle"); core->mFreeHandle = (RKOMXCore::FreeHandleFunc)dlsym(libHandle, "OMX_FreeHandle"); core->mGetRolesOfComponentHandle = (RKOMXCore::GetRolesOfComponentFunc)dlsym( libHandle, "OMX_GetRolesOfComponent"); } if (core->mInit != NULL) { (*(core->mInit))(); } if (core->mComponentNameEnum != NULL) { // calculating number of components registered inside given OMX core char tmpComponentName[OMX_MAX_STRINGNAME_SIZE] = { 0 }; OMX_U32 tmpIndex = 0; while (OMX_ErrorNone == ((*(core->mComponentNameEnum))(tmpComponentName, OMX_MAX_STRINGNAME_SIZE, tmpIndex))) { tmpIndex++; ALOGI("OMX IL core %s: declares component %s", coreName, tmpComponentName); } core->mNumComponents = tmpIndex; ALOGI("OMX IL core %s: contains %ld components", coreName, core->mNumComponents); } // add plugin to the vector mCores.push_back(core); } else { ALOGW("OMX IL core %s not found", coreName); return OMX_ErrorUndefined; // Do we need to return error message } return OMX_ErrorNone; }
s32 ifm_process_unregister_notify(const s8 * ifname, s32 ifindex) { void *handle; s32 (* subif_del_handle)(const s8 *); s8 *error; s32 ret = ERROR_SUCCESS; struct if_stat *ifstat=NULL; ifstat=if_stat_list; sqlite3 *db= NULL; sqlite3_res res=NULL; s8 sqlite_sql_buf[SQLITE_SQL_BUF_SIZE]; s32 count=0; while(ifstat!=NULL) { if((strcmp(ifstat->name,ifname) == 0)&&(ifstat->use_flag==IFMD_INFO_USE)) { ifstat->use_flag=IFMD_INFO_UN_USE; syslogex_syslog_send("ifmd",LOG_NOTICE|LOG_DAEMON,"Interface %s is unregister\n",ifstat->name); break; } else { ifstat = ifstat->next; } } if((strncmp(ifname,"eth",3)==0)&&(strchr(ifname,'.') != NULL)) { handle = dlopen("/usr/lib/liblogicinterface.so", RTLD_LAZY); if(handle) { return ERROR_SUCCESS; } dlerror(); subif_del_handle = dlsym(handle, "subInterface_db_delete"); if ((error = dlerror()) != NULL) { return ERROR_SYSTEM; } if(ERROR_SUCCESS != if_get_index_by_name(ifname, &ifindex)) { return ERROR_SYSTEM; } db = sqlite3_open_ex(1,IFMODE_DB); if(NULL == db) { dlclose(handle); return ERROR_SYSTEM; } snprintf(sqlite_sql_buf, SQLITE_SQL_BUF_SIZE, "select count(ifindex) as count from (select l3.ifindex from tb_port_l3 as l3 where l3.ifindex = '%d' union all select l2.ifindex from tb_port_l2 as l2 where l2.ifindex = '%d');", ifindex, ifindex); ret = sqlite3_exec_query_ex (db, sqlite_sql_buf, &res); if (SQLITE_OK != ret) { sqlite3_close_ex(db); dlclose(handle); return VLAN_DB_OPT_UNSUCCESS; } ret = sqlite3_get_u32_ex (res, 0, "count", (u32*) &count); if (SQLITE_OK != ret) { count = VLAN_DB_OPT_UNSUCCESS; } sqlite3_res_free_ex(res); res = NULL; sqlite3_close_ex(db); if(count>0) { ret = subif_del_handle(ifname); if(ret!=ERROR_SUCCESS) { dlclose(handle); return ret; } } else { dlclose(handle); return ret; } } return ret; }
std::string unity_global::load_toolkit(std::string soname, std::string module_subpath) { // rewrite "local" protocol std::string protocol = fileio::get_protocol(soname); if (protocol == "local") { soname = fileio::remove_protocol(soname); } so_registration_list regentry; regentry.original_soname = soname; logstream(LOG_INFO) << "Attempt loading of " << sanitize_url(soname) << std::endl; // see if the file exists and whether we need to donwnload it if (fileio::try_to_open_file(soname) == false) { return "Unable to open file " + sanitize_url(soname); } if (protocol != "") { // there is a protocol associated. We need to copy this file to local // issue a copy to copy it to the local temp directory std::string tempname = get_temp_name(); fileio::copy(soname, tempname); soname = tempname; } if (!file_contains_substring(soname, "get_toolkit_function_registration") && !file_contains_substring(soname, "get_toolkit_class_registration")) { return soname + " is not a valid extension"; } // get the base name of the shared library (without the .so) std::string modulename = fileio::get_filename(regentry.original_soname); std::vector<std::string> split_names; boost::algorithm::split(split_names, modulename, boost::is_any_of(".")); if (split_names.size() == 0) return "Invalid filename"; if (module_subpath.empty()) { regentry.modulename = split_names[0]; } else if (module_subpath == "..") { regentry.modulename = ""; } else { regentry.modulename = module_subpath + "." + split_names[0]; } // goody. now for the dl loading #ifndef _WIN32 void* dl = dlopen(soname.c_str(), RTLD_NOW | RTLD_LOCAL); #else void *dl = (void *)LoadLibrary(soname.c_str()); #endif logstream(LOG_INFO) << "Library load of " << sanitize_url(soname) << std::endl; regentry.effective_soname = soname; regentry.dl = dl; // check for failure if (dl == NULL) { #ifndef _WIN32 char* err = dlerror(); // I think we need to copy this out early std::string ret = err; logstream(LOG_ERROR) << "Unable to load " << sanitize_url(soname) << ": " << ret << std::endl; if (err) return ret; else return "dlopen failed due to an unknown error"; #else std::string ret = get_last_err_str(GetLastError()); logstream(LOG_ERROR) << "Unable to load " << sanitize_url(soname) << ": " << ret << std::endl; if (!ret.empty()) return ret; else return "LoadLibrary failed due to an unknown error"; #endif } /**************************************************************************/ /* */ /* Function Registration */ /* */ /**************************************************************************/ // get the registration symbols std::vector<std::string> toolkit_function_reg_names {"get_toolkit_function_registration", "_Z33get_toolkit_function_registrationv", "__Z33get_toolkit_function_registrationv"}; get_toolkit_function_registration_type get_toolkit_function_registration = nullptr; for (auto reg_name : toolkit_function_reg_names) { get_toolkit_function_registration = reinterpret_cast<get_toolkit_function_registration_type> ( #ifndef _WIN32 dlsym(dl, reg_name.c_str()) #else (void *)GetProcAddress((HMODULE)dl, reg_name.c_str()) #endif ); if (get_toolkit_function_registration != nullptr) break; } // register functions if (get_toolkit_function_registration) { auto functions = (*get_toolkit_function_registration)(); for (auto& fn: functions) { if (!regentry.modulename.empty()) { fn.name = regentry.modulename + "." + fn.name; } fn.description["file"] = regentry.original_soname; logstream(LOG_INFO) << "Adding function: " << fn.name << std::endl; regentry.functions.push_back(fn.name); } toolkit_functions->register_toolkit_function(functions); } /**************************************************************************/ /* */ /* Class Registration */ /* */ /**************************************************************************/ std::vector<std::string> toolkit_class_reg_names {"get_toolkit_class_registration", "_Z30get_toolkit_class_registrationv", "__Z30get_toolkit_class_registrationv"}; get_toolkit_class_registration_type get_toolkit_class_registration = nullptr; for (auto reg_name : toolkit_class_reg_names) { get_toolkit_class_registration = reinterpret_cast<get_toolkit_class_registration_type> ( #ifndef _WIN32 dlsym(dl, reg_name.c_str()) #else (void *)GetProcAddress((HMODULE)dl, reg_name.c_str()) #endif ); if (get_toolkit_class_registration != nullptr) break; } // register classes if (get_toolkit_class_registration) { auto class_reg = (*get_toolkit_class_registration)(); for (auto& cl: class_reg) { if (!regentry.modulename.empty()) { cl.name = regentry.modulename + "." + cl.name; } cl.description["file"] = regentry.original_soname; logstream(LOG_INFO) << "Adding class : " << cl.name << std::endl; regentry.functions.push_back(cl.name); } classes->register_toolkit_class(class_reg); } if (regentry.functions.empty() && regentry.classes.empty()) { // nothing has been registered! unload the dl #ifndef _WIN32 dlclose(dl); #else FreeLibrary((HMODULE)dl); #endif return "No functions or classes registered by " + sanitize_url(soname); } // note that it is possible to load a toolkit multiple times. // It is not safe to unload previously loaded toolkits since I may have // a reference to it (for instance a class). We just keep loading over // and hope for the best. // store and remember the dlhandle and what was registered; dynamic_loaded_toolkits[regentry.original_soname] = regentry; return std::string(); }
int uv__set_process_title(const char* title) { #if TARGET_OS_IPHONE return uv__pthread_setname_np(title); #else CFStringRef (*pCFStringCreateWithCString)(CFAllocatorRef, const char*, CFStringEncoding); CFBundleRef (*pCFBundleGetBundleWithIdentifier)(CFStringRef); void *(*pCFBundleGetDataPointerForName)(CFBundleRef, CFStringRef); void *(*pCFBundleGetFunctionPointerForName)(CFBundleRef, CFStringRef); CFTypeRef (*pLSGetCurrentApplicationASN)(void); OSStatus (*pLSSetApplicationInformationItem)(int, CFTypeRef, CFStringRef, CFStringRef, CFDictionaryRef*); void* application_services_handle; void* core_foundation_handle; CFBundleRef launch_services_bundle; CFStringRef* display_name_key; CFDictionaryRef (*pCFBundleGetInfoDictionary)(CFBundleRef); CFBundleRef (*pCFBundleGetMainBundle)(void); CFBundleRef hi_services_bundle; OSStatus (*pSetApplicationIsDaemon)(int); CFDictionaryRef (*pLSApplicationCheckIn)(int, CFDictionaryRef); void (*pLSSetApplicationLaunchServicesServerConnectionStatus)(uint64_t, void*); CFTypeRef asn; int err; err = UV_ENOENT; application_services_handle = dlopen("/System/Library/Frameworks/" "ApplicationServices.framework/" "Versions/A/ApplicationServices", RTLD_LAZY | RTLD_LOCAL); core_foundation_handle = dlopen("/System/Library/Frameworks/" "CoreFoundation.framework/" "Versions/A/CoreFoundation", RTLD_LAZY | RTLD_LOCAL); if (application_services_handle == NULL || core_foundation_handle == NULL) goto out; *(void **)(&pCFStringCreateWithCString) = dlsym(core_foundation_handle, "CFStringCreateWithCString"); *(void **)(&pCFBundleGetBundleWithIdentifier) = dlsym(core_foundation_handle, "CFBundleGetBundleWithIdentifier"); *(void **)(&pCFBundleGetDataPointerForName) = dlsym(core_foundation_handle, "CFBundleGetDataPointerForName"); *(void **)(&pCFBundleGetFunctionPointerForName) = dlsym(core_foundation_handle, "CFBundleGetFunctionPointerForName"); if (pCFStringCreateWithCString == NULL || pCFBundleGetBundleWithIdentifier == NULL || pCFBundleGetDataPointerForName == NULL || pCFBundleGetFunctionPointerForName == NULL) { goto out; } #define S(s) pCFStringCreateWithCString(NULL, (s), kCFStringEncodingUTF8) launch_services_bundle = pCFBundleGetBundleWithIdentifier(S("com.apple.LaunchServices")); if (launch_services_bundle == NULL) goto out; *(void **)(&pLSGetCurrentApplicationASN) = pCFBundleGetFunctionPointerForName(launch_services_bundle, S("_LSGetCurrentApplicationASN")); if (pLSGetCurrentApplicationASN == NULL) goto out; *(void **)(&pLSSetApplicationInformationItem) = pCFBundleGetFunctionPointerForName(launch_services_bundle, S("_LSSetApplicationInformationItem")); if (pLSSetApplicationInformationItem == NULL) goto out; display_name_key = pCFBundleGetDataPointerForName(launch_services_bundle, S("_kLSDisplayNameKey")); if (display_name_key == NULL || *display_name_key == NULL) goto out; *(void **)(&pCFBundleGetInfoDictionary) = dlsym(core_foundation_handle, "CFBundleGetInfoDictionary"); *(void **)(&pCFBundleGetMainBundle) = dlsym(core_foundation_handle, "CFBundleGetMainBundle"); if (pCFBundleGetInfoDictionary == NULL || pCFBundleGetMainBundle == NULL) goto out; /* Black 10.9 magic, to remove (Not responding) mark in Activity Monitor */ hi_services_bundle = pCFBundleGetBundleWithIdentifier(S("com.apple.HIServices")); err = UV_ENOENT; if (hi_services_bundle == NULL) goto out; *(void **)(&pSetApplicationIsDaemon) = pCFBundleGetFunctionPointerForName( hi_services_bundle, S("SetApplicationIsDaemon")); *(void **)(&pLSApplicationCheckIn) = pCFBundleGetFunctionPointerForName( launch_services_bundle, S("_LSApplicationCheckIn")); *(void **)(&pLSSetApplicationLaunchServicesServerConnectionStatus) = pCFBundleGetFunctionPointerForName( launch_services_bundle, S("_LSSetApplicationLaunchServicesServerConnectionStatus")); if (pSetApplicationIsDaemon == NULL || pLSApplicationCheckIn == NULL || pLSSetApplicationLaunchServicesServerConnectionStatus == NULL) { goto out; } if (pSetApplicationIsDaemon(1) != noErr) goto out; pLSSetApplicationLaunchServicesServerConnectionStatus(0, NULL); /* Check into process manager?! */ pLSApplicationCheckIn(-2, pCFBundleGetInfoDictionary(pCFBundleGetMainBundle())); asn = pLSGetCurrentApplicationASN(); err = UV_EINVAL; if (pLSSetApplicationInformationItem(-2, /* Magic value. */ asn, *display_name_key, S(title), NULL) != noErr) { goto out; } uv__pthread_setname_np(title); /* Don't care if it fails. */ err = 0; out: if (core_foundation_handle != NULL) dlclose(core_foundation_handle); if (application_services_handle != NULL) dlclose(application_services_handle); return err; #endif /* !TARGET_OS_IPHONE */ }
/* * Class: sun_awt_X11SurfaceData * Method: initIDs * Signature: ()V */ JNIEXPORT void JNICALL Java_sun_awt_X11SurfaceData_initIDs(JNIEnv *env, jclass xsd, jclass XORComp) { #ifndef HEADLESS void *lib = 0; union { char c[4]; int i; } endian; endian.i = 0xff000000; nativeByteOrder = (endian.c[0]) ? MSBFirst : LSBFirst; cachedXImage = NULL; if (sizeof(X11RIPrivate) > SD_RASINFO_PRIVATE_SIZE) { JNU_ThrowInternalError(env, "Private RasInfo structure too large!"); return; } xorCompClass = (*env)->NewGlobalRef(env, XORComp); if (getenv("NO_J2D_DGA") == NULL) { /* we use RTLD_NOW because of bug 4032715 */ #ifdef DEBUG lib = dlopen("libsunwjdga_g.so", RTLD_NOW); #else lib = dlopen("libsunwjdga.so", RTLD_NOW); #endif } dgaAvailable = JNI_FALSE; if (lib != NULL) { JDgaStatus ret = JDGA_FAILED; void *sym = dlsym(lib, "JDgaLibInit"); if (sym != NULL) { theJDgaInfo.display = awt_display; AWT_LOCK(); ret = (*(JDgaLibInitFunc *)sym)(env, &theJDgaInfo); AWT_UNLOCK(); } if (ret == JDGA_SUCCESS) { pJDgaInfo = &theJDgaInfo; dgaAvailable = JNI_TRUE; useDGAWithPixmaps = (getenv("USE_DGA_PIXMAPS") != NULL); } else { dlclose(lib); lib = NULL; } } #ifdef MITSHM if (getenv("NO_AWT_MITSHM") == NULL && getenv("NO_J2D_MITSHM") == NULL) { char * force; TryInitMITShm(env, &useMitShmExt, &useMitShmPixmaps); useMitShmPixmaps = (useMitShmPixmaps == CAN_USE_MITSHM); force = getenv("J2D_PIXMAPS"); if (force != NULL) { if (strcmp(force, "shared") == 0) { forceSharedPixmaps = JNI_TRUE; } else if (strcmp(force, "server") == 0) { useMitShmPixmaps = JNI_FALSE; } } } #endif /* MITSHM */ #endif /* !HEADLESS */ }
plugin_err_t plugin_load_from_file(plugin_handle_t *p, const char *fq_path) { plugin_handle_t plug; int (*init)(void); uint32_t *version; char *type = NULL; *p = PLUGIN_INVALID_HANDLE; /* * Check for file existence and access permissions */ if (access(fq_path, R_OK) < 0) { if (errno == ENOENT) return EPLUGIN_NOTFOUND; else return EPLUGIN_ACCESS_ERROR; } /* * Try to open the shared object. * * Use RTLD_LAZY to allow plugins to use symbols that may be * defined in only one slurm entity (e.g. srun and not slurmd), * when the use of that symbol is restricted to within the * entity from which it is available. (i.e. srun symbols are only * used in the context of srun, not slurmd.) * */ plug = dlopen(fq_path, RTLD_LAZY); if (plug == NULL) { error("plugin_load_from_file: dlopen(%s): %s", fq_path, _dlerror()); return EPLUGIN_DLOPEN_FAILED; } /* Now see if our required symbols are defined. */ if ((dlsym(plug, PLUGIN_NAME) == NULL) || ((type = dlsym(plug, PLUGIN_TYPE)) == NULL)) { dlclose(plug); return EPLUGIN_MISSING_NAME; } version = (uint32_t *) dlsym(plug, PLUGIN_VERSION); if (!version) { verbose("%s: plugin_version symbol not defined", fq_path); } else if ((*version != SLURM_VERSION_NUMBER) && xstrcmp(type,"spank")){ /* NOTE: We could alternatly test just the MAJOR.MINOR values */ int plugin_major, plugin_minor, plugin_micro; plugin_major = SLURM_VERSION_MAJOR(*version); plugin_minor = SLURM_VERSION_MINOR(*version); plugin_micro = SLURM_VERSION_MICRO(*version); dlclose(plug); info("%s: Incompatible Slurm plugin version (%d.%d.%d)", fq_path, plugin_major, plugin_minor, plugin_micro); return EPLUGIN_BAD_VERSION; } /* * Now call its init() function, if present. If the function * returns nonzero, unload the plugin and signal an error. */ if ((init = dlsym(plug, "init")) != NULL) { if ((*init)() != 0) { dlclose(plug); return EPLUGIN_INIT_FAILED; } } *p = plug; return EPLUGIN_SUCCESS; }
/* * Function * linuxModInfoDir * * Description * Retrieve info about the modules whose shared library files are contained in a given directory * (for each shared library, load it, retrieve info about the module (tModInfo struct), * and finally unload the library). * * Parameters * dir (in) directory to search (relative) * level (in) if 1, load any shared library contained in the subdirs of dir * and whose name is the same as the containing subdir (ex: bt/bt.so) * if 0, load any shared library contained in dir (ignore subdirs) * modlist (in/out) list of module description structure (may begin empty) * * Return * >=0 number of modules loaded * -1 error * * Remarks * The loaded module info structures are added in the list according to each module's priority * (NOT at the head of the list). * */ static int linuxModInfoDir(unsigned int /* gfid */, const char *dir, int level, tModList **modlist) { char sopath[256]; /* path of the lib[x].so */ tSOHandle handle; DIR *dp; struct dirent *ep; int modnb; /* number on loaded modules */ tModList *curMod; modnb = 0; /* open the current directory */ dp = opendir(dir); if (dp) { /* some files in it */ while ((ep = readdir (dp)) != 0) { if (((strlen(ep->d_name) > 4) && (strcmp(".so", ep->d_name+strlen(ep->d_name)-3) == 0)) /* xxxx.so */ || ((level == 1) && (ep->d_name[0] != '.'))) { if (level == 1) sprintf(sopath, "%s/%s/%s.so", dir, ep->d_name, ep->d_name); else sprintf(sopath, "%s/%s", dir, ep->d_name); /* Try and avoid loading the same module twice (WARNING: Only checks sopath equality !) */ if (!GfModIsInList(sopath, *modlist)) { /* Load the shared library */ GfLogTrace("Querying module %s\n", sopath); handle = dlopen(sopath, RTLD_LAZY); if (handle) { /* Initialize the module */ if (GfModInitialize(handle, sopath, GfIdAny, &curMod) == 0) { if (curMod) /* Retained against gfid */ { /* Get associated info */ modnb++; GfModAddInList(curMod, modlist, /* priosort */ 1); } /* Terminate the module */ GfModTerminate(handle, sopath); } /* Close the shared library */ dlclose(handle); } else { GfLogError("linuxModInfoDir: ... %s\n", dlerror()); } } } } (void)closedir(dp); } else { GfLogError("linuxModInfoDir: ... Couldn't open the directory %s.\n", dir); return -1; } return modnb; }
/* build NULL-terminated table of name + init-function */ typedef struct { const char* name; int (*plugin_init)(plugin *p); } plugin_load_functions; static const plugin_load_functions load_functions[] = { #define PLUGIN_INIT(x) \ { #x, &x ## _plugin_init }, #include "plugin-static.h" { NULL, NULL } #undef PLUGIN_INIT }; int plugins_load(server *srv) { plugin *p; size_t i, j; for (i = 0; i < srv->srvconf.modules->used; i++) { data_string *d = (data_string *)srv->srvconf.modules->data[i]; char *module = d->value->ptr; for (j = 0; j < i; j++) { if (buffer_is_equal(d->value, ((data_string *) srv->srvconf.modules->data[j])->value)) { log_error_write(srv, __FILE__, __LINE__, "sbs", "Cannot load plugin", d->value, "more than once, please fix your config (lighttpd may not accept such configs in future releases)"); continue; } } for (j = 0; load_functions[j].name; ++j) { if (0 == strcmp(load_functions[j].name, module)) { p = plugin_init(); if ((*load_functions[j].plugin_init)(p)) { log_error_write(srv, __FILE__, __LINE__, "ss", module, "plugin init failed" ); plugin_free(p); return -1; } plugins_register(srv, p); break; } } if (!load_functions[j].name) { log_error_write(srv, __FILE__, __LINE__, "ss", module, " plugin not found" ); return -1; } } return 0; } #else /* defined(LIGHTTPD_STATIC) */ int plugins_load(server *srv) { plugin *p; int (*init)(plugin *pl); size_t i, j; for (i = 0; i < srv->srvconf.modules->used; i++) { data_string *d = (data_string *)srv->srvconf.modules->data[i]; char *module = d->value->ptr; for (j = 0; j < i; j++) { if (buffer_is_equal(d->value, ((data_string *) srv->srvconf.modules->data[j])->value)) { log_error_write(srv, __FILE__, __LINE__, "sbs", "Cannot load plugin", d->value, "more than once, please fix your config (lighttpd may not accept such configs in future releases)"); continue; } } buffer_copy_buffer(srv->tmp_buf, srv->srvconf.modules_dir); buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("/")); buffer_append_string(srv->tmp_buf, module); #if defined(__WIN32) || defined(__CYGWIN__) buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN(".dll")); #else buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN(".so")); #endif p = plugin_init(); #ifdef __WIN32 if (NULL == (p->lib = LoadLibrary(srv->tmp_buf->ptr))) { LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); log_error_write(srv, __FILE__, __LINE__, "ssb", "LoadLibrary() failed", lpMsgBuf, srv->tmp_buf); plugin_free(p); return -1; } #else if (NULL == (p->lib = dlopen(srv->tmp_buf->ptr, RTLD_NOW|RTLD_GLOBAL))) { log_error_write(srv, __FILE__, __LINE__, "sbs", "dlopen() failed for:", srv->tmp_buf, dlerror()); plugin_free(p); return -1; } #endif buffer_reset(srv->tmp_buf); buffer_copy_string(srv->tmp_buf, module); buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("_plugin_init")); #ifdef __WIN32 init = GetProcAddress(p->lib, srv->tmp_buf->ptr); if (init == NULL) { LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); log_error_write(srv, __FILE__, __LINE__, "sbs", "getprocaddress failed:", srv->tmp_buf, lpMsgBuf); plugin_free(p); return -1; } #else #if 1 init = (int (*)(plugin *))(intptr_t)dlsym(p->lib, srv->tmp_buf->ptr); #else *(void **)(&init) = dlsym(p->lib, srv->tmp_buf->ptr); #endif if (NULL == init) { const char *error = dlerror(); if (error != NULL) { log_error_write(srv, __FILE__, __LINE__, "ss", "dlsym:", error); } else { log_error_write(srv, __FILE__, __LINE__, "ss", "dlsym symbol not found:", srv->tmp_buf->ptr); } plugin_free(p); return -1; } #endif if ((*init)(p)) { log_error_write(srv, __FILE__, __LINE__, "ss", module, "plugin init failed" ); plugin_free(p); return -1; } #if 0 log_error_write(srv, __FILE__, __LINE__, "ss", module, "plugin loaded" ); #endif plugins_register(srv, p); } return 0; }
/************************************************************************** * Name: LoadSharedLibrary * * Description: Load the library * * Inputs: library name * * Outputs: pointer to library loaded * * Returns: SUUCESS/FAILURE ************************************************************************* */ int LoadSharedLibrary(const char* libName, void** libPointer, char* errstr) { char fullLibName[50]; char errormessage[200]; int flags; int ret; ret = SUCCESS; fullLibName[0] = '\0'; #if defined(WIN32) sprintf(fullLibName, "%s.dll", libName); #else sprintf(fullLibName, "lib%s", libName); #endif #ifndef WIN32 #if defined(SOLARIS) || defined(OSF1) || defined(_AIX) || defined(LINUX) strcat(fullLibName, ".so"); #elif defined(HPUX) strcat(fullLibName, ".sl"); #endif #endif strcpy(errormessage, "Loading "); strcat(errormessage, fullLibName); strcat(errormessage, " library FAILED ..."); /* Load the library */ #if defined(WIN32) *libPointer = LoadLibrary(fullLibName); if (NULL == *libPointer) { strcpy(errstr, errormessage); /* emit(SHLIB_ERRLOC, MPS_GENERIC_DEBUG, errormessage); */ return FAILURE; } #elif defined(SOLARIS) || defined(OSF1) || defined(HPUX_64) || defined(_AIX) || defined(LINUX) *libPointer = dlopen( fullLibName, OPEN_MODE); if (NULL == *libPointer) { strcpy(errstr, errormessage); /* emit(SHLIB_ERRLOC, MPS_GENERIC_DEBUG, errormessage); */ return FAILURE; } #elif defined(HPUX) flags = OPEN_MODE; flags |= BIND_DEFERRED; *libPointer = shl_load( fullLibName, flags, 0L); if (NULL == *libPointer) { strcpy(errstr, errormessage); /* emit(SHLIB_ERRLOC, MPS_GENERIC_DEBUG, errormessage); */ return FAILURE; } #else #error SendToTHSlibLoader not defined for this platform you must define it now Load #endif return ret; }
//============================================================================== void scanForDevices() { hasScanned = true; inputNames.clear(); inputIds.clear(); outputNames.clear(); outputIds.clear(); if (juce_libjackHandle == nullptr) { juce_libjackHandle = dlopen ("libjack.so", RTLD_LAZY); if (juce_libjackHandle == nullptr) return; } // open a dummy client jack_status_t status; jack_client_t* client = juce::jack_client_open ("JuceJackDummy", JackNoStartServer, &status); if (client == nullptr) { dumpJackErrorMessage (status); } else { // scan for output devices const char** ports = juce::jack_get_ports (client, 0, 0, /* JackPortIsPhysical | */ JackPortIsOutput); if (ports != nullptr) { int j = 0; while (ports[j] != 0) { String clientName (ports[j]); clientName = clientName.upToFirstOccurrenceOf (":", false, false); if (clientName != String (JUCE_JACK_CLIENT_NAME) && ! inputNames.contains (clientName)) { inputNames.add (clientName); inputIds.add (ports [j]); } ++j; } free (ports); } // scan for input devices ports = juce::jack_get_ports (client, 0, 0, /* JackPortIsPhysical | */ JackPortIsInput); if (ports != nullptr) { int j = 0; while (ports[j] != 0) { String clientName (ports[j]); clientName = clientName.upToFirstOccurrenceOf (":", false, false); if (clientName != String (JUCE_JACK_CLIENT_NAME) && ! outputNames.contains (clientName)) { outputNames.add (clientName); outputIds.add (ports [j]); } ++j; } free (ports); } juce::jack_client_close (client); } }
int load_opus(char *name){ void *lib; const char *msg; int *num=NULL; struct coreInfo_t **core; SPICEdev **devs; Evt_Udn_Info_t **udns; funptr_t fetch; lib = dlopen(name,RTLD_NOW); if(!lib){ msg = dlerror(); printf("%s\n", msg); return 1; } fetch = dlsym(lib,"CMdevNum"); if(fetch){ num = ((int * (*)(void)) fetch) (); #ifdef TRACE printf("Got %u devices.\n",*num); #endif }else{ msg = dlerror(); printf("%s\n", msg); return 1; } fetch = dlsym(lib,"CMdevs"); if(fetch){ devs = ((SPICEdev ** (*)(void)) fetch) (); }else{ msg = dlerror(); printf("%s\n", msg); return 1; } fetch = dlsym(lib,"CMgetCoreItfPtr"); if(fetch){ core = ((struct coreInfo_t ** (*)(void)) fetch) (); *core = &coreInfo; }else{ msg = dlerror(); printf("%s\n", msg); return 1; } add_device(*num,devs,1); fetch = dlsym(lib,"CMudnNum"); if(fetch){ num = ((int * (*)(void)) fetch) (); #ifdef TRACE printf("Got %u udns.\n",*num); #endif }else{ msg = dlerror(); printf("%s\n", msg); return 1; } fetch = dlsym(lib,"CMudns"); if(fetch){ udns = ((Evt_Udn_Info_t ** (*)(void)) fetch) (); }else{ msg = dlerror(); printf("%s\n", msg); return 1; } add_udn(*num,udns); return 0; }
void UdfHandler::openUdfLibrary(const std::string & s) { this->M_lib_handle=dlopen(s.c_str(),RTLD_LAZY); if (!this->M_lib_handle) throw std::invalid_argument("Udf library " + s + " not found"); }
static void *ll_load (lua_State *L, const char *path) { void *lib = dlopen(path, RTLD_NOW); if (lib == NULL) lua_pushstring(L, dlerror()); return lib; }
void context::load_module(v8::FunctionCallbackInfo<v8::Value> const& args) { v8::Isolate* isolate = args.GetIsolate(); v8::EscapableHandleScope scope(isolate); v8::Local<v8::Value> result; try { std::string const name = from_v8<std::string>(isolate, args[0], ""); if (name.empty()) { throw std::runtime_error("load_module: require module name string argument"); } context* ctx = detail::get_external_data<context*>(args.Data()); context::dynamic_modules::iterator it = ctx->modules_.find(name); // check if module is already loaded if (it != ctx->modules_.end()) { result = v8::Local<v8::Value>::New(isolate, it->second.exports); } else { std::string filename = name; if (!ctx->lib_path_.empty()) { filename = ctx->lib_path_ + path_sep + name; } std::string const suffix = V8PP_PLUGIN_SUFFIX; if (filename.size() >= suffix.size() && filename.compare(filename.size() - suffix.size(), suffix.size(), suffix) != 0) { filename += suffix; } dynamic_module module; #if defined(WIN32) UINT const prev_error_mode = SetErrorMode(SEM_NOOPENFILEERRORBOX); module.handle = LoadLibraryA(filename.c_str()); ::SetErrorMode(prev_error_mode); #else module.handle = dlopen(filename.c_str(), RTLD_LAZY); #endif if (!module.handle) { throw std::runtime_error("load_module(" + name + "): could not load shared library " + filename); } #if defined(WIN32) void *sym = ::GetProcAddress((HMODULE)module.handle, STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME)); #else void *sym = dlsym(module.handle, STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME)); #endif if (!sym) { throw std::runtime_error("load_module(" + name + "): initialization function " STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME) " not found in " + filename); } using module_init_proc = v8::Handle<v8::Value>(*)(v8::Isolate*); module_init_proc init_proc = reinterpret_cast<module_init_proc>(sym); result = init_proc(isolate); module.exports.Reset(isolate, result); ctx->modules_.emplace(name, std::move(module)); } } catch (std::exception const& ex) { result = throw_ex(isolate, ex.what()); } args.GetReturnValue().Set(scope.Escape(result)); }
static void* mydlopen(const char *filename, int flag) { char *buf; const char *end, *start, *ladspapath; int endsinso, needslash; size_t filenamelen; void *result = NULL; #if defined(__MINGW32__) || defined(__CYGWIN__) /* For Windows there's only absolute path support. * If you have a Windows machine, feel free to fix this. * (path separator, shared objects extension, et cetera). */ mp_msg(MSGT_AFILTER, MSGL_V, "\ton windows, only absolute pathnames " "are supported\n"); mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", filename); return dlopen(filename, flag); #endif filenamelen = strlen(filename); endsinso = 0; if (filenamelen > 3) endsinso = (strcmp(filename+filenamelen-3, ".so") == 0); if (!endsinso) { buf=malloc(filenamelen+4); strcpy(buf, filename); strcat(buf, ".so"); result=mydlopen(buf, flag); free(buf); } if (result) return result; ladspapath=getenv("LADSPA_PATH"); if (ladspapath) { start=ladspapath; while (*start != '\0') { end=start; while ( (*end != ':') && (*end != '\0') ) end++; buf=malloc(filenamelen + 2 + (end-start) ); if (end > start) strncpy(buf, start, end-start); needslash=0; if (end > start) if (*(end-1) != '/') { needslash = 1; buf[end-start] = '/'; } strcpy(buf+needslash+(end-start), filename); mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", buf); result=dlopen(buf, flag); free(buf); if (result) return result; start = end; if (*start == ':') start++; } /* end while there's still more in the path */ } /* end if there's a ladspapath */ /* last resort, just open it again, so the dlerror() message is correct */ mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", filename); return dlopen(filename,flag); }
static int loadpng() { /* Oops someone might have libpng without libz. If we try to load libpng */ /* first we crash and burn horribly, so... */ if ( dlopen("libz" SO_EXT,RTLD_GLOBAL|RTLD_LAZY)==NULL #ifdef SO_1_EXT && dlopen("libz" SO_1_EXT,RTLD_LAZY)==NULL #endif ) { fprintf(stderr,"%s\n", dlerror()); return( 0 ); } # if !defined(PNG_LIBPNG_VER_MAJOR) || (PNG_LIBPNG_VER_MAJOR==1 && PNG_LIBPNG_VER_MINOR<2) /* Early versions are called libpng. Later libpng10/libpng12/libpng14... */ libpng = dlopen("libpng" SO_EXT,RTLD_LAZY); # ifdef SO_2_EXT if ( libpng==NULL ) libpng = dlopen("libpng" SO_2_EXT,RTLD_LAZY); # endif # else /* After version 1.2.1 (I think) dynamic libpng is called libpng12/libpng14... */ # define xstr(s) str(s) # define str(s) #s # define PNGLIBNAME "libpng" xstr(PNG_LIBPNG_VER_MAJOR) xstr(PNG_LIBPNG_VER_MINOR) libpng = dlopen(PNGLIBNAME SO_EXT,RTLD_LAZY); # ifdef SO_0_EXT if ( libpng==NULL ) libpng = dlopen(PNGLIBNAME SO_0_EXT,RTLD_LAZY); # endif if ( libpng==NULL ) { libpng = dlopen("libpng" SO_EXT,RTLD_LAZY); # ifdef SO_2_EXT if ( libpng==NULL ) libpng = dlopen("libpng" SO_2_EXT,RTLD_LAZY); # endif } # endif if ( libpng==NULL ) { fprintf(stderr,"%s", dlerror()); return( 0 ); } _png_create_write_struct = (png_structp (*)(char *, png_voidp, png_error_ptr, png_error_ptr)) dlsym(libpng,"png_create_write_struct"); _png_create_info_struct = (png_infop (*)(png_structp)) dlsym(libpng,"png_create_info_struct"); _png_destroy_write_struct = (void (*)(png_structpp, png_infopp)) dlsym(libpng,"png_destroy_write_struct"); _png_init_io = (void (*)(png_structp, FILE *)) dlsym(libpng,"png_init_io"); _png_write_info = (void (*)(png_structp, png_infop)) dlsym(libpng,"png_write_info"); _png_set_packing = (void (*)(png_structp)) dlsym(libpng,"png_set_packing"); _png_set_filler = (void (*)(png_structp,png_uint_32,int)) dlsym(libpng,"png_set_filler"); _png_write_image = (void (*)(png_structp,png_bytep*)) dlsym(libpng,"png_write_image"); _png_write_end = (void (*)(png_structp,png_infop)) dlsym(libpng,"png_write_end"); #if (PNG_LIBPNG_VER >= 10500) _png_longjmp = (void (*)(png_structp, int)) dlsym(libpng,"png_longjmp"); _png_set_longjmp_fn = (jmp_buf* (*)(png_structp,png_longjmp_ptr,size_t)) dlsym(libpng,"png_set_longjmp_fn"); #endif _png_set_IHDR = (void (*)(png_structp,png_infop,png_uint_32,png_uint_32,int,int,int,int,int)) dlsym(libpng,"png_set_IHDR"); _png_set_PLTE = (void (*)(png_structp,png_infop,png_colorp,int)) dlsym(libpng,"png_set_PLTE"); _png_set_tRNS = (void (*)(png_structp,png_infop,png_bytep,int,png_color_16p)) dlsym(libpng,"png_set_tRNS"); if ( _png_create_write_struct && _png_create_info_struct && _png_destroy_write_struct && _png_init_io && _png_set_filler && _png_write_info && _png_set_packing && _png_write_image && _png_write_end) return( 1 ); dlclose(libpng); fprintf(stderr,"%s", dlerror()); return( 0 ); }
int dl_dcli_init(boot_flag) { void (*dcli_init_func)(int); /*dcli_main*/ /***************sem*************/ void (*dcli_sem_init_func)(void); void (*dcli_fpga_init_func)(void); /***************npd*************/ void (*dcli_diag_init_func)(void); void (*dcli_vlan_init_func)(void); void (*dcli_trunk_init_func)(void); void (*dcli_dynamic_trunk_init_func)(void); void (*dcli_fdb_init_func)(void); void (*dcli_qos_init_func)(void); void (*dcli_acl_init_func)(void); void (*dcli_stp_element_init_func)(void); void (*dcli_drv_routesyn_init_func)(void); void (*dcli_tunnel_init_func)(void); void (*dcli_pvlan_init_func)(void); void (*dcli_prot_vlan_element_init_func)(void); void (*dcli_igmp_snp_element_init_func)(void); void (*dcli_mld_snp_element_init_func)(void); void (*dcli_mirror_init_func)(void); /*************asd****************/ void (*dcli_sta_init_func)(void); void (*dcli_security_init_func)(void); /************wid******************/ void (*dcli_wtp_init_func)(void); void (*dcli_radio_init_func)(void); void (*dcli_ac_init_func)(void); void (*dcli_wlan_init_func)(void); void (*dcli_ebr_init_func)(void); void (*dcli_aciplist_init_func)(void); void (*dcli_ac_group_init_func)(void); void (*dcli_ap_group_init_func)(void); void (*dcli_bsd_init_func)(void); void (*dcli_license_init_func)(void); void (*dcli_wbridge_init_func)(void); void (*dcli_scanlocate_init_func)(void); char *error; int temp=boot_flag; /***********************dcli_main********************/ dcli_dl_handle = dlopen("libdcli.so.0",RTLD_NOW); if (!dcli_dl_handle) { fputs (dlerror(),stderr); printf(" Run without /opt/lib/libdcli.so.0\n"); EXIT(1); } dcli_init_func = dlsym(dcli_dl_handle,"dcli_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_init be called.\n"); fputs(error,stderr); EXIT(1); } (*dcli_init_func)(temp); /***********************dcli_sem**********************/ if (dcli_dl_handle_sem = dlopen("libdcli_sem.so",RTLD_NOW)){ dcli_sem_init_func = dlsym(dcli_dl_handle_sem,"dcli_sem_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_sem_init be called.\n"); fputs(error,stderr); //EXIT(1); } else { (*dcli_sem_init_func)(); } dcli_fpga_init_func = dlsym(dcli_dl_handle_sem,"dcli_fpga_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_fpga_init be called.\n"); fputs(error,stderr); //EXIT(1); } else { (*dcli_fpga_init_func)(); } } else { fputs (dlerror(),stderr); printf(" Run without /opt/lib/libdcli_sem.so\n"); } #ifndef _D_NANOCELL_ /*******************dcli_npd****************************/ if (dcli_dl_handle_npd = dlopen("libdcli_npd.so",RTLD_NOW)){ dcli_diag_init_func = dlsym(dcli_dl_handle_npd,"dcli_diag_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_diag_init be called.\n"); fputs(error,stderr); } else { (*dcli_diag_init_func)(); } dcli_vlan_init_func = dlsym(dcli_dl_handle_npd,"dcli_vlan_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_vlan_init be called.\n"); fputs(error,stderr); } else { (*dcli_vlan_init_func)(); } dcli_trunk_init_func = dlsym(dcli_dl_handle_npd,"dcli_trunk_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_trunk_init be called.\n"); fputs(error,stderr); } else { (*dcli_trunk_init_func)(); } dcli_dynamic_trunk_init_func = dlsym(dcli_dl_handle_npd,"dcli_dynamic_trunk_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_dynamic_trunk_init be called.\n"); fputs(error,stderr); } else { (*dcli_dynamic_trunk_init_func)(); } dcli_fdb_init_func = dlsym(dcli_dl_handle_npd,"dcli_fdb_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_fdb_init be called.\n"); fputs(error,stderr); } else { (*dcli_fdb_init_func)(); } dcli_qos_init_func = dlsym(dcli_dl_handle_npd,"dcli_qos_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_qos_init be called.\n"); fputs(error,stderr); } else { (*dcli_qos_init_func)(); } dcli_acl_init_func = dlsym(dcli_dl_handle_npd,"dcli_acl_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_acl_init be called.\n"); fputs(error,stderr); } else { (*dcli_acl_init_func)(); } dcli_stp_element_init_func = dlsym(dcli_dl_handle_npd,"dcli_stp_element_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_stp_element_init be called.\n"); fputs(error,stderr); } else { (*dcli_stp_element_init_func)(); } dcli_drv_routesyn_init_func = dlsym(dcli_dl_handle_npd,"dcli_drv_routesyn_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_drv_routesyn_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_drv_routesyn_init_func)(); } dcli_tunnel_init_func = dlsym(dcli_dl_handle_npd,"dcli_tunnel_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_tunnel_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_tunnel_init_func)(); } dcli_pvlan_init_func = dlsym(dcli_dl_handle_npd,"dcli_pvlan_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_pvlan_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_pvlan_init_func)(); } dcli_prot_vlan_element_init_func = dlsym(dcli_dl_handle_npd,"dcli_prot_vlan_element_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_prot_vlan_element_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_prot_vlan_element_init_func)(); } dcli_igmp_snp_element_init_func = dlsym(dcli_dl_handle_npd,"dcli_igmp_snp_element_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_igmp_snp_element_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_igmp_snp_element_init_func)(); } dcli_mld_snp_element_init_func = dlsym(dcli_dl_handle_npd,"dcli_mld_snp_element_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_mld_snp_element_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_mld_snp_element_init_func)(); } dcli_mirror_init_func = dlsym(dcli_dl_handle_npd,"dcli_mirror_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_mirror_init_func be called.\n"); fputs(error,stderr); } else { (*dcli_mirror_init_func)(); } } else { fputs (dlerror(),stderr); printf(" Run without /opt/lib/libdcli_npd.so\n"); } #endif /*******************dcli_asd****************************/ if (dcli_dl_handle_asd = dlopen("libdcli_asd.so",RTLD_NOW)){ dcli_sta_init_func = dlsym(dcli_dl_handle_asd,"dcli_sta_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_sta_init be called.\n"); fputs(error,stderr); //EXIT(1); } else { (*dcli_sta_init_func)(); } dcli_security_init_func = dlsym(dcli_dl_handle_asd,"dcli_security_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_security_init be called.\n"); fputs(error,stderr); //EXIT(1); } else { (*dcli_security_init_func)(); } } else { fputs (dlerror(),stderr); printf(" Run without /opt/lib/libdcli_sta.so\n"); } /*******************dcli_wid************************************/ if (dcli_dl_handle_wid = dlopen("libdcli_wid.so",RTLD_NOW)){ dcli_wtp_init_func = dlsym(dcli_dl_handle_wid,"dcli_wtp_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_wtp_init be called.\n"); fputs(error,stderr); } else { (*dcli_wtp_init_func)(); } dcli_radio_init_func = dlsym(dcli_dl_handle_wid,"dcli_radio_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_radio_init be called.\n"); fputs(error,stderr); } else { (*dcli_radio_init_func)(); } dcli_ac_init_func = dlsym(dcli_dl_handle_wid,"dcli_ac_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_ac_init be called.\n"); fputs(error,stderr); } else { (*dcli_ac_init_func)(); } dcli_wlan_init_func = dlsym(dcli_dl_handle_wid,"dcli_wlan_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_wlan_init be called.\n"); fputs(error,stderr); } else { (*dcli_wlan_init_func)(); } dcli_ebr_init_func = dlsym(dcli_dl_handle_wid,"dcli_ebr_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_ebr_init be called.\n"); fputs(error,stderr); } else { (*dcli_ebr_init_func)(); } dcli_aciplist_init_func = dlsym(dcli_dl_handle_wid,"dcli_aciplist_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_aciplist_init be called.\n"); fputs(error,stderr); } else { (*dcli_aciplist_init_func)(); } dcli_ac_group_init_func = dlsym(dcli_dl_handle_wid,"dcli_ac_group_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_ac_group_init be called.\n"); fputs(error,stderr); } else { (*dcli_ac_group_init_func)(); } dcli_ap_group_init_func = dlsym(dcli_dl_handle_wid,"dcli_ap_group_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_ap_group_init be called.\n"); fputs(error,stderr); } else { (*dcli_ap_group_init_func)(); } dcli_bsd_init_func = dlsym(dcli_dl_handle_wid,"dcli_bsd_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_bsd_init be called.\n"); fputs(error,stderr); } else { (*dcli_bsd_init_func)(); } dcli_license_init_func = dlsym(dcli_dl_handle_wid,"dcli_license_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_license_init be called.\n"); fputs(error,stderr); } else { (*dcli_license_init_func)(); } dcli_wbridge_init_func = dlsym(dcli_dl_handle_wid,"dcli_wbridge_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_wbridge_init be called.\n"); fputs(error,stderr); } else { (*dcli_wbridge_init_func)(); } #if 1 dcli_scanlocate_init_func = dlsym(dcli_dl_handle_wid, "dcli_scanlocate_init"); if ((error = dlerror()) != NULL) { printf(" Run without dcli_wbridge_init be called.\n"); fputs(error,stderr); } else { (*dcli_scanlocate_init_func)(); } #endif } else { fputs (dlerror(),stderr); printf(" Run without /opt/lib/libdcli_wid.so\n"); } vtysh_send_dbus_signal_init(); vtysh_sync_file_init(); vtysh_get_rpa_broadcast_mask_init(); /* * The handle should not be closed before we do not use libdcli any more. */ return 1; }
int CMainCtrl::Initialize(char* pProName,char* pConfigFile) { //读配置 strcpy(m_stConfig.m_szSvrName,pProName); int iRet = ReadCfgFile(pConfigFile); if( 0 != iRet ) { return iRet; } //连接资源限制,root用户下有效 rlimit rlim; rlim.rlim_cur = m_stConfig.MAX_SOCKET_NUM+10240; rlim.rlim_max = m_stConfig.MAX_SOCKET_NUM+10240; setrlimit(RLIMIT_NOFILE, &rlim); //bind cpu if(m_stConfig.m_iBindCpu >= 0) { cpu_set_t mask; int iCpuId = m_stConfig.m_iBindCpu; printf("set cpu affinity %d.\n",iCpuId); CPU_ZERO(&mask); CPU_SET(iCpuId, &mask); sched_setaffinity(0, sizeof(mask), &mask); } //读so void* pHandle = dlopen(m_stConfig.m_szNetCompleteSo, RTLD_LAZY); if (!pHandle) { printf("open %s failed!\n",m_stConfig.m_szNetCompleteSo); printf("use ccs/src/make -f makefile.complete to make these so,and choose the one you want.\n"); return -1; } dlerror(); //Clear any existing error net_complete_func = (check_complete)dlsym(pHandle, "net_complete_func"); if (dlerror() != NULL) { printf("get net_complete_func from %s failed!\n",m_stConfig.m_szNetCompleteSo); return -1; } msg_header_len_func = (msg_header_len)dlsym(pHandle, "msg_header_len"); if (dlerror() != NULL) { printf("get msg_header_len from %s failed!\n",m_stConfig.m_szNetCompleteSo); return -1; } m_iMsgHeaderLen = msg_header_len_func(); //初始化epoll端口 if(m_stEPollFlow.Create(m_stConfig.MAX_SOCKET_NUM)) { printf("epoll create error!"); return -1; } //创建管道 if(CCodeQueue::CreateMQByFile(m_stConfig.m_szMeToSvrMQ,&m_Me2SvrPipe)) { printf("CreateCodeMQ %s failed!\n",m_stConfig.m_szMeToSvrMQ); return -1; } if(CCodeQueue::CreateMQByFile(m_stConfig.m_szSvrToMeMQ,&m_Svr2MePipe)) { printf("CreateCodeMQ %s failed!\n",m_stConfig.m_szSvrToMeMQ); return -1; } long long ullMemCost = 0; //创建CS消息缓冲区 int iMemSize = TIdxObjMng::CountMemSize(m_stConfig.RCV_BLOCK_SIZE,m_stConfig.RCV_BLOCK_NUM,1); char* pMem = new char[iMemSize]; m_stIdxObjMngRecv.AttachMem(pMem,iMemSize,m_stConfig.RCV_BLOCK_SIZE,m_stConfig.RCV_BLOCK_NUM,emInit,1); ullMemCost += (long long)iMemSize; iMemSize = CBuffMng::CountMemSize(m_stConfig.MAX_SOCKET_NUM); pMem = new char[iMemSize]; m_stBuffMngRecv.AttachMem(pMem,iMemSize,m_stConfig.MAX_SOCKET_NUM); ullMemCost += (long long)iMemSize; m_stBuffMngRecv.AttachIdxObjMng(&m_stIdxObjMngRecv); //创建SC消息缓冲区 iMemSize = TIdxObjMng::CountMemSize(m_stConfig.SND_BLOCK_SIZE,m_stConfig.SND_BLOCK_NUM,1); pMem = new char[iMemSize]; m_stIdxObjMngSend.AttachMem(pMem,iMemSize,m_stConfig.SND_BLOCK_SIZE,m_stConfig.SND_BLOCK_NUM,emInit,1); ullMemCost += (long long)iMemSize; iMemSize = CBuffMng::CountMemSize(m_stConfig.MAX_SOCKET_NUM); pMem = new char[iMemSize]; m_stBuffMngSend.AttachMem(pMem,iMemSize,m_stConfig.MAX_SOCKET_NUM); ullMemCost += (long long)iMemSize; m_stBuffMngSend.AttachIdxObjMng(&m_stIdxObjMngSend); //创建socket管理区 iMemSize = TIdxObjMng::CountMemSize(sizeof(TSocketNode),m_stConfig.MAX_SOCKET_NUM,1); pMem = new char[iMemSize]; m_stSocketNodeMng.AttachMem(pMem,iMemSize,sizeof(TSocketNode),m_stConfig.MAX_SOCKET_NUM,emInit,1); ullMemCost += (long long)iMemSize; iMemSize = CHashTab::CountMemSize(m_stConfig.MAX_SOCKET_NUM); pMem = new char[iMemSize]; m_stSocketNodeHash.AttachMem(pMem, iMemSize,m_stConfig.MAX_SOCKET_NUM); ullMemCost += (long long)iMemSize; m_stSocketNodeHash.AttachIdxObjMng(&m_stSocketNodeMng,SetSocketNodeKey,GetSocketNodeKey); //内存管道监听 if (m_Svr2MePipe.GetReadNotifyFD() >= 0) { iRet = CreateSocketNode(m_Svr2MePipe.GetReadNotifyFD(),TSocketNode::STATUS_OK, 0,0,"_PIPE_",TSocketNode::PIPE_SOCKET); if(iRet < 0) { printf("CreateSocketNode Failed!iRet=%d\n",iRet); return iRet; } } //管理端口 if(m_stConfig.m_iAdminPort > 0) { unsigned short usListenPort = (unsigned short)m_stConfig.m_iAdminPort; unsigned int unListenIP = inet_addr(m_stConfig.m_szAdminIp); int iListenSocket = CreateListenSocket(unListenIP,usListenPort, m_stConfig.SOCKET_RCVBUF,m_stConfig.SOCKET_SNDBUF); if (iListenSocket < 0) { printf("CreateListenSocket %u:%u failed!\n",unListenIP,usListenPort); TLib_Log_LogMsg("CreateListenSocket %u:%u failed!\n",unListenIP,usListenPort); return -2; } //加入监听数组 int iNewSuffix = CreateSocketNode(iListenSocket,TSocketNode::STATUS_OK, unListenIP,usListenPort,"_ADMIN_",TSocketNode::ADMIN_LISTEN_SOCKET); if (iNewSuffix < 0) { close(iListenSocket); printf("add to socket array failed!\n"); TLib_Log_LogMsg("add to socket array failed!\n"); return -3; } printf("Admin Listen on %s:%u Success!\n", m_stConfig.m_szAdminIp, m_stConfig.m_iAdminPort); } printf("%s Cost Mem %llu bytes.\n",SVR_NAME,ullMemCost); TLib_Log_LogMsg("Cost Mem %llu bytes.\n",ullMemCost); printf("Server Init Success!\n"); TLib_Log_LogMsg("Server Init Success!\n"); return 0; }
void vt_plugin_cntr_init() { char ** plugins; int nr_selected_plugins = 0; char * plugin_read_start; int read_plugin; char * current_plugin; char * env_vt_plugin_metrics; char current_plugin_metric[255]; char * next_plugin_metric; char * env_vt_callback_buffer; char buffer[512]; char * dl_lib_error; void * handle; vt_plugin_cntr_info info; /* used union to get rid of compiler warning */ union { void * vp; vt_plugin_cntr_info (* function)(void); } get_info; int index; int i; int found = 0; struct vt_plugin * current; /* set some internal variables to zero */ vt_plugin_handles = calloc(VT_PLUGIN_CNTR_SYNCH_TYPE_MAX, sizeof(struct vt_plugin *)); nr_plugins = calloc(VT_PLUGIN_CNTR_SYNCH_TYPE_MAX, sizeof(uint32_t)); /* check whether plugins are activated */ env_vt_plugin_metrics = getenv("VT_PLUGIN_CNTR_METRICS"); if (env_vt_plugin_metrics == NULL) return; env_vt_callback_buffer = getenv("VT_PLUGIN_CNTR_CALLBACK_BUFFER"); /* default: 1 M elements (16 MiB memory) per thread and callback counter */ if (env_vt_callback_buffer == NULL) max_values_callback = 1024 * 1024; else max_values_callback = atoi(env_vt_callback_buffer); /* extract the plugin names */ plugin_read_start = env_vt_plugin_metrics; read_plugin = 1; current_plugin = plugin_read_start; plugins = NULL; /* go through the plugin env. variable */ for (; *current_plugin != '\0'; current_plugin++) { if (read_plugin) { if (*current_plugin == '_') { /* do not use the same plugin twice! */ memcpy(buffer, plugin_read_start, ((current_plugin - plugin_read_start)) * sizeof(char)); buffer[(current_plugin - plugin_read_start)] = '\0'; found = 0; for (i = 0; i < nr_selected_plugins; i++) { if (strcmp(buffer, plugins[i]) == 0) found = 1; } if (found) { read_plugin = 0; continue; } else { nr_selected_plugins++; /* allocate the plugin name buffer */ plugins = realloc(plugins, nr_selected_plugins * sizeof(char*)); plugins[nr_selected_plugins - 1] = malloc( (current_plugin - plugin_read_start + 1) * sizeof(char)); /* copy the content to the buffer */ memcpy(plugins[nr_selected_plugins - 1], plugin_read_start, ((current_plugin - plugin_read_start)) * sizeof(char)); /* finish with null */ plugins[nr_selected_plugins - 1] [(current_plugin - plugin_read_start)] = '\0'; read_plugin = 0; } } } else { /* a new plugin/counter starts after the ':' */ if (*current_plugin == ':') { read_plugin = 1; plugin_read_start = current_plugin + 1; } } } /*go through all plugins:*/ for (i = 0; i < nr_selected_plugins; i++) { uint32_t group = 0; current_plugin = plugins[i]; vt_cntl_msg(2, "Loading plugin counter library: lib%s.so", current_plugin); /* next one is stored in next_plugin, / * current is stored in current_plugin_buffer */ /* load it from LD_LIBRARY_PATH*/ sprintf(buffer, "lib%s.so", current_plugin); /* now dlopen it */ handle = dlopen(buffer, RTLD_NOW); /* if it is not valid */ if ((dl_lib_error = dlerror()) != NULL) { vt_error_msg("Error loading plugin: %s\n", dl_lib_error); /* try loading next */ continue; } /* now get the info */ get_info.vp = dlsym(handle, "get_info"); if ((dl_lib_error = dlerror()) != NULL) { vt_error_msg("Error getting info from plugin: %s\n", dl_lib_error); dlclose(handle); /* try loading next */ continue; } /* now store it */ /* get the info */ info = get_info.function(); /* check the run per type */ if (info.run_per == VT_PLUGIN_CNTR_PER_PROCESS) { if (thread_group == INVALID_GROUP_NUMBER){ vt_cntl_msg(3, "No process group defined, using master thread for %s", current_plugin); } else{ # if (defined(VT_MT) || defined(VT_HYB)) /* only called per process */ group = vt_get_curid(); thread_group = group; # else /* not multithreaded -> keep information on local process */ #endif } } if (info.run_per == VT_PLUGIN_CNTR_PER_HOST) { if (!vt_my_trace_is_master) continue; else if (host_group == INVALID_GROUP_NUMBER){ host_group = vt_node_pgid; vt_def_procgrp_attributes(VT_MY_THREAD ,vt_node_pgid, VT_PROCGRP_HASCOUNTERS); } group = host_group; } if (info.run_per == VT_PLUGIN_CNTR_ONCE) { if (vt_my_trace != 0) continue; else if (all_group == INVALID_GROUP_NUMBER){ all_group = vt_all_pgid; vt_def_procgrp_attributes(VT_MY_THREAD ,vt_all_pgid, VT_PROCGRP_HASCOUNTERS); } group = all_group; } if (info.init == NULL) { vt_error_msg( "Init not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } if (info.add_counter == NULL) { vt_error_msg( "Add counter not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } if (info.get_event_info == NULL) { vt_error_msg("Get event info not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } /* check the type of plugin */ switch (info.synch) { case VT_PLUGIN_CNTR_SYNCH: nr_plugins[VT_PLUGIN_CNTR_SYNCH]++; vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH] = realloc( vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH], nr_plugins[VT_PLUGIN_CNTR_SYNCH] * sizeof(struct vt_plugin)); current = &vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH] [nr_plugins[VT_PLUGIN_CNTR_SYNCH] - 1]; if (info.get_current_value == NULL) { nr_plugins[VT_PLUGIN_CNTR_SYNCH]--; vt_error_msg("Get current results not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } break; case VT_PLUGIN_CNTR_ASYNCH_CALLBACK: nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]++; vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK] = realloc( vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK], nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK] * sizeof(struct vt_plugin)); current = &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK] [nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK] - 1]; if (info.set_callback_function == NULL) { nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]--; vt_error_msg("set callback not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } if (info.set_pform_wtime_function == NULL) { nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]--; vt_error_msg( "set wtime not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } break; case VT_PLUGIN_CNTR_ASYNCH_EVENT: nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]++; vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT] = realloc( vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT], nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT] * sizeof(struct vt_plugin)); current = &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT] [nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT] - 1]; if (info.get_all_values == NULL) { nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]--; vt_error_msg("get all values not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } if (info.set_pform_wtime_function == NULL) { nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]--; vt_error_msg( "set wtime not implemented in plugin %s\n", current_plugin); /* try loading next */ continue; } break; case VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM: nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]++; vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] = realloc( vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM], nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] * sizeof(struct vt_plugin)); current = &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] [nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] - 1]; if (info.get_all_values == NULL) { vt_error_msg("get all values not implemented in plugin %s\n", current_plugin); nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]--; /* try loading next */ continue; } if (info.set_pform_wtime_function == NULL) { vt_error_msg( "set wtime not implemented in plugin %s\n", current_plugin); nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]--; /* try loading next */ continue; } break; default: vt_error_msg( "Error getting synch type from plugin (invalid synch type)\n"); continue; } /* clear out current plugin */ memset(current, 0, sizeof(struct vt_plugin)); /* add handle (should be closed in the end) */ current->dlfcn_handle = handle; /* store the info object of the plugin */ current->info = info; /* store the name of the plugin */ current->name = current_plugin; /* give plugin the wtime function to make it possible to convert times */ if (current->info.set_pform_wtime_function != NULL) { current->info.set_pform_wtime_function(vt_pform_wtime); } vt_cntl_msg(3, "Initializing plugin counter library: lib%s.so", current_plugin); /* initialize plugin */ if (current->info.init()) { vt_error_msg("Error initializing plugin %s, init returned != 0\n", current_plugin); continue; } /* define a counter group for every plugin*/ current->counter_group = vt_def_counter_group(VT_MY_THREAD, current_plugin); /* now search for all available events on that plugin */ next_plugin_metric = env_vt_plugin_metrics; while (next_plugin_metric[0] != 0) { /* shall contain current index in environment VT_PLUGIN_METRICS */ index = 0; /* copy metric to current_plugin_metric char by char */ while ((next_plugin_metric[index] != ':') && (next_plugin_metric[index] != '\0')) { current_plugin_metric[index] = next_plugin_metric[index]; index++; } current_plugin_metric[index] = 0; if (next_plugin_metric[index] == ':') next_plugin_metric = &next_plugin_metric[index + 1]; else next_plugin_metric = &next_plugin_metric[index]; /* If the plugin metric belongs to the current plugin */ if (strstr(current_plugin_metric, current_plugin) == current_plugin_metric) { /* some meta data*/ char * unit = NULL; uint32_t otf_prop = 0; /* This will be needed to iterate over the infos */ vt_plugin_cntr_metric_info * current_event_info; /* check the event name from plugin */ /* it could contain wildcards and other stuff */ vt_plugin_cntr_metric_info * event_infos = info.get_event_info( ¤t_plugin_metric[strlen(current_plugin) + 1]); vt_cntl_msg(3, "Adding metric %s for plugin counter library: lib%s.so", current_plugin_metric, current_plugin); /* check the event name from plugin */ /* it could contain wildcards and other stuff */ if (event_infos == NULL) { vt_error_msg( "Error initializing plugin metric %s, no info returned\n", current_plugin_metric); continue; } /* now for all events which are present in the struct */ current_event_info = event_infos; for (current_event_info = event_infos; current_event_info->name != NULL; current_event_info++) { vt_cntl_msg(3, "Retrieved metric %s for plugin counter library: lib%s.so." " Initializing data structures", current_event_info->name, current_plugin); /* event is part of this plugin */ current->num_selected_events++; /* allocate space for events */ current->selected_events = realloc(current->selected_events, current->num_selected_events * sizeof(char*)); /*the metric is everything after "plugin_"*/ current->selected_events[current->num_selected_events - 1] = current_event_info->name; current->vt_counter_ids = realloc(current->vt_counter_ids, current->num_selected_events * sizeof(uint32_t)); current->vt_asynch_keys = realloc(current->vt_asynch_keys, current->num_selected_events * sizeof(uint32_t)); /* if a unit is provided, use it */ unit = current_event_info->unit == NULL ? "#" : current_event_info->unit; /* if otf properties are provided, use them */ otf_prop = current_event_info->cntr_property; /* define new counter */ current->vt_counter_ids[current->num_selected_events - 1] = vt_def_counter(VT_MY_THREAD, current->selected_events[current->num_selected_events - 1], unit, otf_prop, current->counter_group, group); if (current->info.synch != VT_PLUGIN_CNTR_SYNCH) { char buffer[512]; sprintf(buffer, "%s_%s", current_plugin, current_event_info->name); current->vt_asynch_keys[current->num_selected_events - 1] = vt_def_async_source(VT_MY_THREAD, buffer); } /* enable plugin counters */ vt_plugin_cntr_used = 1; } /* end of: for all metrics related to the metric string */ if (event_infos != NULL) free(event_infos); } /* end of if metric belongs to this plugin */ } /* end of: for all plugin metrics */ } /* end of: for all plugins */ /* free temporary variables */ if (plugins != NULL) free(plugins); }
int main (int argc, char **argv) { int expect = 0; int error_fail = 0; int verbose = 0; char const * glibmm = "libglibmm-2.4.so"; const struct option long_options[] = { { "fail", no_argument, 0, 'f' }, { "help", no_argument, 0, 'h' }, { "gcc4", no_argument, 0, '4' }, { "gcc5", no_argument, 0, '5' }, { "glibmm", required_argument, 0, 'g' }, { "verbose", no_argument, 0, 'v' }, { "version", no_argument, 0, 'V' }, }; const char *optstring = "fh45g:vV"; int c; while ((c = getopt_long (argc, argv, optstring, long_options, NULL)) != -1) { switch (c) { case 'f': error_fail = 1; break; case 'h': print_usage (); return 0; break; case '4': expect |= 1; break; case '5': expect |= 2; break; case 'g': glibmm = optarg; break; case 'v': verbose = 1; break; case 'V': print_version (); return 0; break; default: fprintf (stderr, "invalid argument.\n"); print_usage (); return -1; break; } } int gcc5 = 0; int gcc4 = 0; dlerror (); // reset error void *h = dlopen (glibmm, RTLD_LAZY); if (!h) { if (verbose) { fprintf (stderr, "Cannot open '%s': %s.\n", glibmm, dlerror ()); } return error_fail ? 3 : 0; } // Glib::ustring::ustring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) if (dlsym (h, "_ZN4Glib7ustringC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE")) { gcc5 |= 1; } // Glib::ustring::ustring(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) if (dlsym (h, "_ZN4Glib7ustringC1ERKSs")) { gcc4 |= 1; } // Glib::Module::Module(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, Glib::ModuleFlags) if (dlsym (h, "_ZN4Glib6ModuleC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_11ModuleFlagsE")) { gcc5 |= 2; } // Glib::Module::Module(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, Glib::ModuleFlags) if (dlsym (h, "_ZN4Glib6ModuleC1ERKSsNS_11ModuleFlagsE")) { gcc4 |= 2; } // Glib::ustring::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) if (dlsym (h, "_ZN4Glib7ustringaSERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE")) { gcc5 |= 4; } // Glib::ustring::operator=(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) if (dlsym (h, "_ZN4Glib7ustringaSERKSs")) { gcc4 |= 4; } dlclose (h); if (7 != (gcc4 ^ gcc5)) { if (verbose) { fprintf (stderr, "Inconsistent result: gcc4=%x gcc5=%x\n", gcc4, gcc5); } } else if (gcc4 == 7) { if (verbose) { printf ("System uses gcc4 c++ ABI\n"); } if (expect != 0) { return (expect & 1) ? 0 : 1; } } else if (gcc5 == 7) { if (verbose) { printf ("System uses gcc5 c++11 ABI\n"); } if (expect != 0) { return (expect & 2) ? 0 : 1; } } else if (verbose) { fprintf (stderr, "Incomplete result: gcc4=%x gcc5=%x\n", gcc4, gcc5); } return error_fail ? 2 : 0; }
static Eina_Bool _ecore_drm2_link(void) { int i, fail; const char *drm_libs[] = { "libdrm.so.2", "libdrm.so.1", "libdrm.so.0", "libdrm.so", NULL, }; #define SYM(lib, xx) \ do { \ sym_ ## xx = dlsym(lib, #xx); \ if (!(sym_ ## xx)) { \ fail = 1; \ } \ } while (0) if (drm_lib) return EINA_TRUE; for (i = 0; drm_libs[i]; i++) { drm_lib = dlopen(drm_libs[i], RTLD_LOCAL | RTLD_LAZY); if (!drm_lib) continue; fail = 0; SYM(drm_lib, drmIoctl); /* SYM(drm_lib, drmClose); */ /* SYM(drm_lib, drmWaitVBlank); */ SYM(drm_lib, drmHandleEvent); SYM(drm_lib, drmGetVersion); SYM(drm_lib, drmFreeVersion); SYM(drm_lib, drmModeGetProperty); SYM(drm_lib, drmModeFreeProperty); SYM(drm_lib, drmModeGetPropertyBlob); SYM(drm_lib, drmModeFreePropertyBlob); SYM(drm_lib, drmModeDestroyPropertyBlob); SYM(drm_lib, drmModeObjectGetProperties); SYM(drm_lib, drmModeFreeObjectProperties); SYM(drm_lib, drmModeCreatePropertyBlob); #ifdef HAVE_ATOMIC_DRM SYM(drm_lib, drmModeAtomicAlloc); SYM(drm_lib, drmModeAtomicFree); SYM(drm_lib, drmModeAtomicAddProperty); SYM(drm_lib, drmModeAtomicCommit); SYM(drm_lib, drmModeAtomicSetCursor); SYM(drm_lib, drmModeAtomicMerge); #endif SYM(drm_lib, drmModeGetEncoder); SYM(drm_lib, drmModeFreeEncoder); SYM(drm_lib, drmModeGetCrtc); SYM(drm_lib, drmModeFreeCrtc); SYM(drm_lib, drmModeSetCrtc); SYM(drm_lib, drmModeGetResources); SYM(drm_lib, drmModeFreeResources); SYM(drm_lib, drmModeGetConnector); SYM(drm_lib, drmModeFreeConnector); SYM(drm_lib, drmModeConnectorSetProperty); SYM(drm_lib, drmGetCap); SYM(drm_lib, drmSetClientCap); SYM(drm_lib, drmModeGetPlaneResources); SYM(drm_lib, drmModeFreePlaneResources); SYM(drm_lib, drmModeGetPlane); SYM(drm_lib, drmModeFreePlane); SYM(drm_lib, drmModeAddFB); SYM(drm_lib, drmModeAddFB2); SYM(drm_lib, drmModeRmFB); SYM(drm_lib, drmModePageFlip); SYM(drm_lib, drmModeDirtyFB); SYM(drm_lib, drmModeCrtcSetGamma); SYM(drm_lib, drmPrimeFDToHandle); if (fail) { dlclose(drm_lib); drm_lib = NULL; } else break; } if (!drm_lib) return EINA_FALSE; return EINA_TRUE; }
int main() {dlopen("a",RTLD_LAZY); return 0;}
static void startup_desktop() { #if 0 char error[1024]; void *libwine_handle; //char *args[]={"wineloader","c:\\gcc.exe","/c","/FAs","c:\\myfile.c",NULL}; //For VC++6.0 cl char *args[]={"wineloader","c:\\gcc.exe","c:\\myfile.c",NULL}; //For notepad //char *args[]={"wineloader","c:\\AngryBirds\\AngryBirds.exe",NULL}; //For angrybirds //char *args[]={"wineloader","c:\\mplayer.exe","c:\\a.flv","-vo", "none",NULL}; //For notepad //char *args[]={"wineloader","c:\\gcc.exe","/DLL","c:\\windows\\myfile.obj"}; //For VC++6.0 linker //char *args[]={"wineloader","c:\\gcc.exe","-s","myfile","-l","language\\chinese.oic"}; //For Olanguage void (*wine_init)(int argc, char *argv[], char *error, int error_size ); char *pWineBaseDir = "/0:/wine/"; FASetCurrentThreadNameA("winapp 主线程."); FAVfsInitTTY(); //必须将客户端的0,1,2 FD 对应的位置预留起来,WINE内部是固定用这几个来作为CONSOLE处理的,它要将0,1,2发送给server,导致发送失败 setenv("WINEDLLPATH","dlls",TRUE); //WINE dll目录; setenv("WINEPREFIX",pWineBaseDir,TRUE); //Server Connect需要得到当前工作目录; //setenv("WINEDEBUG","+all,trace-heap",TRUE); //OPen all messages setenv("WINEDEBUG","+trace-heap",TRUE); //OPen all messages setenv("PWD","0:",TRUE); setenv("DISPLAY","unix:0.0",TRUE); /* X defualt display name */ dprintf("\n正在启动 wine server..."); FAStartupServiceA("WINESERVER",TRUE); dprintf("\n正在启动 wine ..."); #ifdef __i386__ __asm("mov $0,%ax\n\t " "mov %ax,%fs\n\t"); #endif /* 切换当前工作路径 */ if(FAChangeDirByStringA(pWineBaseDir)!=FASTATUS_SUCCESS) { dprintf("\n系统没有安装Wine."); return 0; } /* 打开第一个动态库 */ libwine_handle = dlopen(ELF_FILE_NAME,NULL); if(libwine_handle==NULL) { dprintf("\nWINLOADER:无法找到%s.",ELF_FILE_NAME); return 0; } FASleepThreadMs(5000); //waiting the wineserver is ready. wine_init = dlsym(libwine_handle,"wine_init");/*Call wine Init*/ if(wine_init) wine_init( sizeof(args)/(sizeof(char*))-1/*MUST escape the null*/, args, error, sizeof(error) ); else { dprintf("\nWINLOADER:无法找到入口wine_init."); return 0; } /*Load the libwine,因为wine_init这个入口函数在libwine.a中,根据loader\main.c中的流程,在运行wine_init之前还要运行preloader,和pthread,不知道是干什么的*/ return 0; #endif }
static void load_module(const char *name) { void *handle, *cast; autofree(char) *path = NULL; char *error = NULL; cve_plugin_init init_func; CvePlugin *plugin = NULL; #ifdef TEST_SUITE_BUILD if (!asprintf(&path, TOP_BUILD_DIR"/tests/dummy_install/%s", name)) { #else if (!asprintf(&path, "%s/%s", MODULE_DIR, name)) { #endif fprintf(stderr, "No memory\n"); return; } handle = dlopen(path, RTLD_LAZY); if (!handle) { fprintf(stderr, "Unable to load module: %s\n", dlerror()); return; } dlerror(); cast = dlsym(handle, "cve_plugin_module_init"); if (!cast || (error = dlerror()) != NULL) { fprintf(stderr, "Cannot load module: %s\n", error); abort(); } dlerror(); memcpy(&init_func, &cast, sizeof(init_func)); plugin = calloc(1, sizeof(struct CvePlugin)); if (!plugin) { fprintf(stderr, "Unable to allocate memory\n"); abort(); } if (!init_func(plugin)) { fprintf(stderr, "Plugin initialisation failed\n"); abort(); } if (!plugin->name) { fprintf(stderr, "Plugin %s does not set a name - aborting\n", name); abort(); } plugin->handle = handle; cve_hashmap_put(_plugins, (char*)plugin->name, plugin); } static void destroy_plugin(CvePlugin *plugin) { if (plugin->destroy) { plugin->destroy(plugin); } if (plugin->handle) { dlclose(plugin->handle); } free(plugin); } void cve_plugin_manager_init() { DIR *dir = NULL; struct dirent *ent = NULL; if (_plugins) { return; } _plugins = cve_hashmap_new_full(string_hash, string_compare, NULL, (hash_free_func)destroy_plugin); #ifdef TEST_SUITE_BUILD if (!(dir = opendir(TOP_BUILD_DIR "/tests/dummy_install"))) { #else if (!(dir = opendir(MODULE_DIR))) { #endif fprintf(stderr, "Unable to list modules: %s\n", strerror(errno)); return; } while ((ent = readdir(dir))) { if (g_str_has_suffix(ent->d_name, ".so")) { load_module(ent->d_name); } } if (dir) { closedir(dir); } } void cve_plugin_manager_destroy() { if (!_plugins) { return; } cve_hashmap_free(_plugins); _plugins = NULL; } CvePlugin *cve_plugin_get_by_name(const char *name) { CvePlugin *ret = NULL; if (!_plugins) { return NULL; } ret = cve_hashmap_get(_plugins, name); return ret; }
/* Load a plugin from disk and put the function table into a driver_list struct. */ static driver_list *_get_plugin(char *plugin_file) { ao_device *device = ao_global_dummy; driver_list *dt; void *handle; char *prompt=""; handle = dlopen(plugin_file, DLOPEN_FLAG /* See ao_private.h */); if (handle) { prompt="calloc() failed"; dt = (driver_list *)calloc(1,sizeof(driver_list)); if (!dt) return NULL; dt->handle = handle; dt->functions = (ao_functions *)calloc(1,sizeof(ao_functions)); if (!(dt->functions)) { free(dt); return NULL; } prompt="ao_plugin_test() missing"; dt->functions->test = dlsym(dt->handle, "ao_plugin_test"); if (!(dt->functions->test)) goto failed; prompt="ao_plugin_driver_info() missing"; dt->functions->driver_info = dlsym(dt->handle, "ao_plugin_driver_info"); if (!(dt->functions->driver_info)) goto failed; prompt="ao_plugin_device_list() missing"; dt->functions->device_init = dlsym(dt->handle, "ao_plugin_device_init"); if (!(dt->functions->device_init )) goto failed; prompt="ao_plugin_set_option() missing"; dt->functions->set_option = dlsym(dt->handle, "ao_plugin_set_option"); if (!(dt->functions->set_option)) goto failed; prompt="ao_plugin_open() missing"; dt->functions->open = dlsym(dt->handle, "ao_plugin_open"); if (!(dt->functions->open)) goto failed; prompt="ao_plugin_play() missing"; dt->functions->play = dlsym(dt->handle, "ao_plugin_play"); if (!(dt->functions->play)) goto failed; prompt="ao_plugin_close() missing"; dt->functions->close = dlsym(dt->handle, "ao_plugin_close"); if (!(dt->functions->close)) goto failed; prompt="ao_plugin_clear() missing"; dt->functions->device_clear = dlsym(dt->handle, "ao_plugin_device_clear"); if (!(dt->functions->device_clear)) goto failed; } else { aerror("Failed to load plugin %s => dlopen() failed\n",plugin_file); return NULL; } adebug("Loaded driver %s\n",dt->functions->driver_info()->short_name); return dt; failed: aerror("Failed to load plugin %s => %s\n",plugin_file,prompt); free(dt->functions); free(dt); return NULL; }
/* Create (if necessary), find, lock, fill in, and return our globals. Return NULL on error, in which case the globals will not be locked. The caller should call keymgr_set_and_unlock. */ static struct keymgr_atexit_list * get_globals (void) { struct keymgr_atexit_list * r; #ifdef __ppc__ /* 10.3.9 doesn't have _keymgr_get_and_lock_processwide_ptr_2 so the PPC side can't use it. On 10.4 this just means the error gets reported a little later when _keymgr_set_and_unlock_processwide_ptr finds that the key was never locked. */ r = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST); #else void * rr; if (_keymgr_get_and_lock_processwide_ptr_2 (KEYMGR_ATEXIT_LIST, &rr)) return NULL; r = rr; #endif if (r == NULL) { r = calloc (sizeof (struct keymgr_atexit_list), 1); if (! r) return NULL; } if (r->atexit_status == atexit_status_unknown) { void *handle; handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD); if (!handle) { #ifdef __ppc__ r->atexit_status = atexit_status_missing; r->atexit_f = find_atexit_10_3 (); if (! r->atexit_f) goto error; if (r->atexit_f (our_atexit)) goto error; #else goto error; #endif } else { int chk_result; r->cxa_atexit_f = (cxa_atexit_p)dlsym (handle, "__cxa_atexit"); r->cxa_finalize_f = (cxa_finalize_p)dlsym (handle, "__cxa_finalize"); if (! r->cxa_atexit_f || ! r->cxa_finalize_f) goto error; chk_result = check_cxa_atexit (r->cxa_atexit_f, r->cxa_finalize_f); if (chk_result == -1) goto error; else if (chk_result == 0) r->atexit_status = atexit_status_broken; else { r->atexit_f = (atexit_p)dlsym (handle, "atexit"); if (! r->atexit_f) goto error; r->atexit_status = atexit_status_working; } } } return r; error: _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, r); return NULL; }