void Module::set_name(STATE, Symbol* name, Module* under) { if(!module_name()->nil_p()) return; if(under == G(object)) { module_name(state, name); } else { Symbol* under_name = under->module_name(); if(!under_name->nil_p()) { std::ostringstream path_name; path_name << under_name->cpp_str(state) << "::" << name->cpp_str(state); module_name(state, state->symbol(path_name.str())); LookupTable::iterator i(constants()); while(i.advance()) { if(Module* m = try_as<Module>(i.value())) { if(m->module_name()->nil_p()) { m->set_name(state, as<Symbol>(i.key()), this); } } } } } }
/* Replace all calls to to the target functions with calls to the * replacement-functions in the module. */ static void replace_calls_in_module(struct module* mod) { BUG_ON(mod == NULL); BUG_ON(mod->module_core == NULL); if (mod->module_init != NULL) { KEDR_MSG(COMPONENT_STRING "target module: \"%s\", processing \"init\" area\n", module_name(mod)); do_process_area(mod->module_init, mod->module_init + mod->init_text_size, repl_table.orig_addrs, repl_table.repl_addrs, repl_table.num_addrs); } KEDR_MSG(COMPONENT_STRING "target module: \"%s\", processing \"core\" area\n", module_name(mod)); do_process_area(mod->module_core, mod->module_core + mod->core_text_size, repl_table.orig_addrs, repl_table.repl_addrs, repl_table.num_addrs); return; }
String* Module::get_name(STATE) { if(module_name()->nil_p()) { if(LANGUAGE_18_ENABLED(state)) { return String::create(state, ""); } else { return nil<String>(); } } else { return module_name()->to_str(state); } }
static int verify_export_symbols(struct module *mod) { unsigned int i; struct module *owner; const struct kernel_symbol *s; struct { const struct kernel_symbol *sym; unsigned int num; } arr[] = { { mod->syms, mod->num_syms},}; for (i = 0; i < ARRAY_SIZE(arr); i++) { for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) { if (find_symbol(s->name, &owner, NULL, 0)) { kprintf("verify_export_symbols: " "%s: exports duplicate symbol %s" " (owned by %s)\n", mod->name, s->name, module_name(owner)); return -1; } } } return 0; }
int main(int arg_count, char *args[]) { generator gen; int first_non_flag_index = process_options(gen, arg_count, args); int num_non_flag_args = arg_count - first_non_flag_index; if(num_non_flag_args != 1 && num_non_flag_args != 2) { std::cerr << "Usage: cppclassgen --<flags> <class_name> <module_name(optional)>" << std::endl; std::exit(-1); } std::string class_name(args[first_non_flag_index]); gen.m_tokens.push_back(std::make_pair("%CLASS_NAME%", class_name)); auto class_name_upper = toupper(class_name); gen.m_tokens.push_back(std::make_pair("%CLASS_NAME_UPPER%", class_name_upper)); if(num_non_flag_args == 2) { std::string module_name(args[first_non_flag_index + 1]); gen.m_tokens.push_back(std::make_pair("%MODULE_NAME%", module_name)); toupper(module_name); auto module_name_upper = toupper(module_name); gen.m_tokens.push_back(std::make_pair("%MODULE_NAME_UPPER%", module_name_upper)); } read_tokens_from_config_file(gen); create_new_file_from_template(gen, class_name, ".h"); create_new_file_from_template(gen, class_name, ".cpp"); return 0; }
/* * on_module_unload() should do real work when the target module is about to * be unloaded. * * Note that this function is called with controller_mutex locked. * * [NB] This function is called even if initialization of the target module * fails. * */ static void on_module_unload(struct module *mod) { int ret = 0; unsigned long flags; KEDR_MSG(COMPONENT_STRING "target module \"%s\" is going to unload.\n", module_name(mod)); /* The replacement table may be used no longer. * The base will take care of releasing its contents when appropriate. * [NB] The access to repl_table is already synchronized as on_module_unload() * is called with controller_mutex locked. */ repl_table.num_addrs = 0; repl_table.orig_addrs = NULL; repl_table.repl_addrs = NULL; spin_lock_irqsave(&target_in_init_lock, flags); target_in_init = 0; spin_unlock_irqrestore(&target_in_init_lock, flags); /* Notify the base */ ret = kedr_impl_on_target_unload(target_module); if (ret != 0) { KEDR_MSG(COMPONENT_STRING "failed to handle unloading of the target module.\n"); return; } trace_target_session_ends(target_name); return; }
/* A callback function to catch loading and unloading of module. * Sets target_module pointer among other things. */ static int detector_notifier_call(struct notifier_block *nb, unsigned long mod_state, void *vmod) { struct module* mod = (struct module *)vmod; BUG_ON(mod == NULL); /* handle module state change */ switch(mod_state) { case MODULE_STATE_COMING: /* the module has just loaded */ if(mutex_lock_killable(&target_module_mutex)) { KEDR_MSG(COMPONENT_STRING "failed to lock target_module_mutex\n"); return 0; } if((target_name != NULL) && (strcmp(target_name, module_name(mod)) == 0)) { BUG_ON(target_module != NULL); if((notifier->mod == NULL) || try_module_get(notifier->mod)) { if(!notifier->on_target_load(notifier, mod)) { target_module = mod; } else { if(notifier->mod) module_put(notifier->mod); } } else { pr_err("Fail to fix module of notifier."); } } mutex_unlock(&target_module_mutex); break; case MODULE_STATE_GOING: /* the module is going to unload */ /* if the target module has already been unloaded, * target_module is NULL, so (mod != target_module) will * be true. */ mutex_lock(&target_module_mutex); if(mod == target_module) { notifier->on_target_unload(notifier, mod); target_module = NULL; if(notifier->mod != NULL) module_put(notifier->mod); } mutex_unlock(&target_module_mutex); break; } return 0; }
FrmTransportistas::FrmTransportistas(QWidget *parent) : MayaModule(module_zone(),module_name(),parent), ui(new Ui::FrmTransportistas), menuButton(QIcon(":/Icons/PNG/transport.png"),tr("Transportistas"),this) { ui->setupUi(this); transportistas oTransportista(this); anadiendo = false; ui->txtCodigo_proveedor->installEventFilter(this); //------------------ // Busqueda //------------------ ui->stackedWidget->setCurrentIndex(0); m = new QSqlQueryModel(this); m->setQuery("select codigo,transportista from transportista",Configuracion_global->groupDB); ui->tablaBusqueda->setModel(m); //--------------- // Cargo combos //--------------- QSqlQueryModel *paises = new QSqlQueryModel(this); paises->setQuery("select pais from paises order by pais",Configuracion_global->groupDB); ui->cbopais->setModel(paises); Bloquear_campos(true); setUpBusqueda(); }
/* * on_module_load() should do real work when the target module is loaded: * instrument it, etc. * * Note that this function is called with controller_mutex locked. */ static void on_module_load(struct module *mod) { int ret = 0; unsigned long flags; KEDR_MSG(COMPONENT_STRING "target module \"%s\" has just loaded.\n", module_name(mod)); spin_lock_irqsave(&target_in_init_lock, flags); target_in_init = 1; spin_unlock_irqrestore(&target_in_init_lock, flags); trace_target_session_begins(target_name); /* Until this function finishes, no replacement function will be called * because the target module has not completed loading yet. That means, * no tracepoint will be triggered in the target module before the * tracepoint above is triggered. The order of the messages in the trace * is still up to the tracing system. */ /* Notify the base and request the combined replacement table */ ret = kedr_impl_on_target_load(target_module, &repl_table); if (ret != 0) { KEDR_MSG(COMPONENT_STRING "failed to handle loading of the target module.\n"); return; } replace_calls_in_module(mod); return; }
Object* Class::allocate(STATE) { Object* obj = cNil; object_type obj_type = type_info()->type; if(obj_type == PackedObject::type) { obj = allocate_packed(state, this); } else if(!type_info()->allow_user_allocate || kind_of<SingletonClass>(this)) { std::ostringstream msg; msg << "direct allocation disabled for "; if(kind_of<SingletonClass>(this)) { msg << to_string(state); } else { msg << module_name()->debug_str(state); } Exception::raise_type_error(state, msg.str().c_str()); } else if(obj_type == Object::type) { auto_pack(state); obj = allocate_packed(state, this); } else { // type_info()->type is neither PackedObject nor Object, so use the // generic path. obj = state->memory()->new_object<Object>( state, this, type_info()->instance_size, obj_type); } #ifdef RBX_ALLOC_TRACKING if(unlikely(state->vm()->allocation_tracking())) { new_obj->setup_allocation_site(state); } #endif return obj; }
void be_util::gen_nesting_open (TAO_OutStream &os, AST_Decl *node) { AST_Decl::NodeType nt = node->node_type (); if (nt == AST_Decl::NT_root) { os << be_nl; return; } be_util::gen_nesting_open ( os, ScopeAsDecl (node->defined_in ())); if (nt == AST_Decl::NT_module) { ACE_CString module_name ( IdentifierHelper::try_escape (node->original_local_name ())); os << be_nl << "module " << module_name.c_str () << be_nl << "{" << be_idt; } }
void tLuaCOMEnumerator::push(lua_State* L) { LUASTACK_SET(L); tStringBuffer module_name(tUtil::RegistryGetString(L, module_name_key)); LUASTACK_DOCLEAN(L, 0); // creates table lua_newtable(L); luaCompat_pushTypeByName(L, module_name, tLuaCOMEnumerator::type_name); lua_setmetatable(L, -2); lua_pushstring(L, ENUMERATOR_FIELD); // pushes typed pointer luaCompat_pushTypeByName(L, module_name, tLuaCOMEnumerator::pointer_type_name); luaCompat_newTypedObject(L, this); // stores in the table lua_settable(L, -3); LUASTACK_CLEAN(L, 1); }
/* [NB] We do not check here if debugfs is supported because this is done * when creating the directory for these files ('dir_klc_main'). */ static int klc_create_debugfs_files(struct kedr_lc_output *output, struct module *target, struct kedr_leak_check *lc) { BUG_ON(output == NULL || target == NULL); BUG_ON(dir_klc_main == NULL); output->dir_klc = debugfs_create_dir(module_name(target), dir_klc_main); if (output->dir_klc == NULL) goto fail; output->file_leaks = debugfs_create_file("possible_leaks", S_IRUGO, output->dir_klc, &output->ob_leaks, &klc_fops); if (output->file_leaks == NULL) goto fail; output->file_bad_frees = debugfs_create_file("unallocated_frees", S_IRUGO, output->dir_klc, &output->ob_bad_frees, &klc_fops); if (output->file_bad_frees == NULL) goto fail; output->file_stats = debugfs_create_file("info", S_IRUGO, output->dir_klc, &output->ob_other, &klc_fops); if (output->file_stats == NULL) goto fail; output->file_flush = debugfs_create_file("flush", S_IWUSR | S_IWGRP, output->dir_klc, lc, &klc_flush_ops); if (output->file_flush == NULL) goto fail; output->file_clear = debugfs_create_file("clear", S_IWUSR | S_IWGRP, output->dir_klc, lc, &klc_clear_ops); if (output->file_clear == NULL) goto fail; return 0; fail: pr_warning(KEDR_LC_MSG_PREFIX "failed to create output files in debugfs for module \"%s\"\n", module_name(target)); klc_remove_debugfs_files(output); return -EINVAL; }
static int __init jprobe_sys_mount_init(void) { jprobe_sys_mount.kp.symbol_name = "sys_mount"; jprobe_sys_mount.entry = (kprobe_opcode_t *) jprobe_sys_mount_handler; register_jprobe(&jprobe_sys_mount); printk(KERN_INFO "Register %s module\n", module_name(THIS_MODULE)); return 0; }
RepDesignModule::RepDesignModule(QWidget *parent) : MayaModule(module_zone(),module_name(),parent), menuButton(QIcon(":/Icons/PNG/reports.png"),tr("Editar reportes"),this), _report(), _layout(this) { _layout.setMargin(0); _layout.addWidget(&_report); }
std::string Module::debug_str(STATE) { Symbol* name = module_name(); if(name->nil_p()) { return "<anonymous module>"; } else { return name->cpp_str(state); } }
Object* Class::allocate(STATE, GCToken gct, CallFrame* calling_environment) { object_type obj_type = type_info_->type; if(obj_type == PackedObject::type) { Object* new_obj = allocate_packed(state, gct, this, calling_environment); #ifdef RBX_ALLOC_TRACKING if(unlikely(state->vm()->allocation_tracking())) { new_obj->setup_allocation_site(state, calling_environment); } #endif #ifdef RBX_GC_STRESS state->shared().gc_soon(); #endif return new_obj; } else if(!type_info_->allow_user_allocate || kind_of<SingletonClass>(this)) { std::ostringstream msg; msg << "direct allocation disabled for "; if(kind_of<SingletonClass>(this)) { msg << to_string(state); } else { msg << module_name()->debug_str(state); } Exception::type_error(state, msg.str().c_str()); return cNil; } else if(obj_type == Object::type) { // transition all normal object classes to PackedObject Class* self = this; OnStack<1> os(state, self); auto_pack(state, gct, calling_environment); Object* new_obj = allocate_packed(state, gct, self, calling_environment); #ifdef RBX_ALLOC_TRACKING if(unlikely(state->vm()->allocation_tracking())) { new_obj->setup_allocation_site(state, calling_environment); } #endif #ifdef RBX_GC_STRESS state->shared().gc_soon(); #endif return new_obj; } else { // type_info_->type is neither PackedObject nor Object, so use the // generic path. Object* new_obj = state->vm()->new_object_typed(this, type_info_->instance_size, obj_type); #ifdef RBX_ALLOC_TRACKING if(unlikely(state->vm()->allocation_tracking())) { new_obj->setup_allocation_site(state, calling_environment); } #endif #ifdef RBX_GC_STRESS state->shared().gc_soon(); #endif return new_obj; } }
bool system_info_to_json(appender_fn append, void* append_data, hal_system_info_t& system) { AppendJson json(append, append_data); bool result = true; result &= json.write_value("p", system.platform_id) && json.write_key_values(system.key_value_count, system.key_values) && json.write_attribute("m") && json.write('['); char buf[65]; for (unsigned i=0; i<system.module_count; i++) { if (i) result &= json.write(','); const hal_module_t& module = system.modules[i]; const module_info_t* info = module.info; buf[64] = 0; bool output_uuid = module.suffix && module_function(info)==MODULE_FUNCTION_USER_PART; result &= json.write('{') && json.write_value("s", module.bounds.maximum_size) && json.write_string("l", module_store_string(module.bounds.store)) && json.write_value("vc",module.validity_checked) && json.write_value("vv", module.validity_result) && (!output_uuid || json.write_string("u", bytes2hexbuf(module.suffix->sha, 32, buf))) && (!info || (json.write_string("f", module_function_string(module_function(info))) && json.write_string("n", module_name(module_index(info), buf)) && json.write_value("v", info->module_version))) // on the photon we have just one dependency, this will need generalizing for other platforms && json.write_attribute("d") && json.write('['); for (unsigned int d=0; d<1 && info; d++) { const module_dependency_t& dependency = info->dependency; module_function_t function = module_function_t(dependency.module_function); if (function==MODULE_FUNCTION_NONE) // skip empty dependents continue; if (d) result &= json.write(','); result &= json.write('{') && json.write_string("f", module_function_string(function)) && json.write_string("n", module_name(dependency.module_index, buf)) && json.write_value("v", dependency.module_version) && json.end_list() && json.write('}'); } result &= json.write("]}"); } result &= json.write(']'); return result; }
void implement_port(SC_PORT< bool > &p, std::string name) { sc_module_name module_name((name + "_connector").c_str()); connector<1, bool > *c = new connector<1, bool >(module_name, &p); std::vector<sc_inout_resolved *> *map = ports[name]; for (int i=0;i<1;i++) { sc_inout_resolved *p = (*map)[i]; (*p).bind(c->io_sig[i]); } }
static int execdomains_proc_show(struct seq_file *m, void *v) { struct exec_domain *ep; read_lock(&exec_domains_lock); for (ep = exec_domains; ep; ep = ep->next) seq_printf(m, "%d-%d\t%-16s\t[%s]\n", ep->pers_low, ep->pers_high, ep->name, module_name(ep->module)); read_unlock(&exec_domains_lock); return 0; }
SEXP pycall__funname(SEXP Rmodule_name, SEXP Rfun_name, SEXP Rargv_list, SEXP Rargv_dict) { #ifdef REMBEDPY_DEBUG Rprintf("funname\n"); #endif std::string fun_name(Rcpp::as<std::string>(Rfun_name)), module_name(Rcpp::as<std::string>(Rmodule_name)); boost::python::object callable(RembedPy::extract_pyobj(fun_name, module_name)); boost::python::list argv_list(RembedPy::extract_argv_list(Rargv_list)); boost::python::dict argv_dict(RembedPy::extract_argv_dict(Rargv_dict)); return RembedPy::pycall(callable, argv_list, argv_dict); }
dsn_handle_t load_dynamic_library(const char* module, const std::vector<std::string>& search_dirs) { std::string module_name(module); # if defined(_WIN32) module_name += ".dll"; # elif defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__) module_name = "lib" + module_name + ".so"; # else # error not implemented yet # endif // search given dirs with priority std::vector<std::string> passes; for (auto & dr : search_dirs) { passes.push_back(utils::filesystem::path_combine(dr, module_name)); } // search OS given passes passes.push_back(module_name); // try dsn_handle_t hmod = nullptr; for (auto & m : passes) { # if defined(_WIN32) hmod = (dsn_handle_t)::LoadLibraryA(m.c_str()); if (hmod == nullptr) { // ddebug("load dynamic library '%s' failed, err = %d", m.c_str(), ::GetLastError()); } # else hmod = (dsn_handle_t)dlopen(m.c_str(), RTLD_LAZY | RTLD_GLOBAL); if (nullptr == hmod) { // ddebug("load dynamic library '%s' failed, err = %s", m.c_str(), dlerror()); } # endif else break; } if (hmod == nullptr) { derror("load dynamic library '%s' failed after trying all the following paths", module_name.c_str()); for (auto& m : passes) { derror("\t%s", m.c_str()); } } return hmod; }
void kedr_payload_unregister(struct kedr_payload *payload) { struct payload_elem *elem; BUG_ON(payload == NULL); if (mutex_lock_killable(&base_mutex)) { KEDR_MSG(COMPONENT_STRING "failed to lock base_mutex\n"); return; } elem = payload_elem_find(payload, &payload_list); if (elem == NULL) { KEDR_MSG(COMPONENT_STRING "module \"%s\" attempts to unregister the payload " "that was never registered\n", module_name(payload->mod)); goto out; } KEDR_MSG(COMPONENT_STRING "unregistering payload from module \"%s\"\n", module_name(payload->mod)); list_del(&elem->list); kfree(elem); payload_functions_unuse(payload); function_replacements_remove_payload(&replaced_functions_map, payload); out: mutex_unlock(&base_mutex); return; }
int get_exec_domain_list(char *page) { struct exec_domain *ep; int len = 0; read_lock(&exec_domains_lock); for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next) len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n", ep->pers_low, ep->pers_high, ep->name, module_name(ep->module)); read_unlock(&exec_domains_lock); return (len); }
gboolean blog_add (const GtkWidget *wid, const gchar *disname) { GKeyFile *gkf; GtkEntry *entry; gchar *content, *token; const gchar *entrytext; gsize size; renrenblog_t *blog; entry = g_object_get_data (G_OBJECT (wid), "token_entry"); entrytext = gtk_entry_get_text (entry); token = get_token_from_uri (entrytext); g_return_val_if_fail (token, FALSE); blog = g_malloc (sizeof (renrenblog_t)); g_return_val_if_fail (blog, FALSE); blog->core->name = g_strdup (disname); blog->core->plugin_name = g_strdup (module_name ()); blog->core->enable = TRUE; blog->token = token; #ifndef WIN32 blog_list = g_list_append (blog_list, blog); #else *blog_list_p = g_list_append (*blog_list_p, blog); #endif if (g_inifile == NULL) { g_inifile = am_realpath ("~/.amblog/renrenblog"); } g_return_val_if_fail (g_inifile, FALSE); gkf = g_key_file_new (); g_key_file_load_from_file (gkf, g_inifile, G_KEY_FILE_NONE, NULL); g_key_file_set_value (gkf, disname, "token", token); content = g_key_file_to_data (gkf, &size, NULL); g_file_set_contents (g_inifile, content, size, NULL); g_key_file_free (gkf); return TRUE; }
gboolean module_init () { GKeyFile *gkf; renrenblog_t *blog; gchar **v; gsize i; if (g_inifile == NULL) { g_inifile = am_realpath ("~/.amblog/renrenblog"); } g_return_val_if_fail (g_inifile, TRUE); gkf = g_key_file_new (); g_key_file_load_from_file (gkf, g_inifile, G_KEY_FILE_NONE, NULL); v = g_key_file_get_groups (gkf, NULL); if (v == NULL) { g_key_file_free (gkf); return TRUE; } for (i = 0; v[i]; ++ i ) { blog = g_malloc (sizeof (renrenblog_t)); blog->core->name = g_strdup (v[i]); blog->core->plugin_name = g_strdup (module_name ()); blog->core->enable = TRUE; blog->token = g_key_file_get_value (gkf, v[i], "token", NULL); #ifndef WIN32 blog_list = g_list_append (blog_list, blog); #else *blog_list_p = g_list_append (*blog_list_p, blog); #endif } g_strfreev (v); return TRUE; }
bool Plugin::isAlreadyLoaded(const wchar_t* filename) { const wchar_t *e = wcsrchr(filename, L'.'); if (!e) return false; tstring module_name(filename, e); tstring ext(e+1); if (isLoadedPlugin(module_name.c_str())) { swprintf(plugin_buffer(), L"Плагин %s не загружен, так как место _G['%s'] занято модулем или другим плагином.", filename, module_name.c_str()); pluginOut(plugin_buffer()); return true; } return false; }
void kedr_trace_marker_target(struct module* target_module, struct module* payload_module, bool is_begin) { const char* target_name, *payload_name; void* id; size_t size; void* data; target_name = module_name(target_module); payload_name = module_name(payload_module); size = sizeof(bool) + strlen(target_name) + strlen(payload_name) + 2; id = kedr_trace_lock(kedr_trace_marker_target_pp_function, size, &data); if(id == NULL) return; *(bool*)data = is_begin; strcpy(data + sizeof(bool), target_name); strcpy(data + sizeof(bool) + strlen(target_name) + 1, payload_name); kedr_trace_unlock_commit(id); }
void sword_logic_installmgr_list_remote_modules (string source_name, vector <string> & modules) { (void) source_name; (void) modules; #ifdef HAVE_SWORD sword::SWMgr *mgr = new sword::SWMgr(); sword::SWBuf baseDir = sword_logic_get_path ().c_str (); sword::InstallMgr *installMgr = new sword::InstallMgr (baseDir, NULL); installMgr->setUserDisclaimerConfirmed (true); sword::InstallSourceMap::iterator source = installMgr->sources.find(source_name.c_str ()); if (source == installMgr->sources.end()) { Database_Logs::log ("Could not find remote source " + source_name); } else { sword::SWMgr *otherMgr = source->second->getMgr(); sword::SWModule *module; if (!otherMgr) otherMgr = mgr; std::map<sword::SWModule *, int> mods = sword::InstallMgr::getModuleStatus(*mgr, *otherMgr); for (std::map<sword::SWModule *, int>::iterator it = mods.begin(); it != mods.end(); it++) { module = it->first; sword::SWBuf version = module->getConfigEntry("Version"); sword::SWBuf status = " "; if (it->second & sword::InstallMgr::MODSTAT_NEW) status = "*"; if (it->second & sword::InstallMgr::MODSTAT_OLDER) status = "-"; if (it->second & sword::InstallMgr::MODSTAT_UPDATED) status = "+"; string module_name (status); module_name.append ("["); module_name.append (module->getName()); module_name.append ("] \t("); module_name.append (version); module_name.append (") \t- "); module_name.append (module->getDescription()); // Check if the module is a verse-based Bible or commentary. bool verse_based = false; string module_type = module->getType (); if (module_type == "Biblical Texts") verse_based = true; if (module_type == "Commentaries") verse_based = true; if (verse_based) modules.push_back (module_name); } } delete installMgr; delete mgr; #endif }
void module_init(module_t *handle) { dsme_log(LOG_DEBUG, "DSME %s starting up", STRINGIFY(PRG_VERSION)); char * modulename; char * path; char name[1024]; /* TODO more dynamic length */ const char **names; FILE *conffile = fopen(MODULES_CONF, "r"); modulename = strdup(module_name(handle)); if (!modulename) { dsme_log(LOG_CRIT, "strdup failed"); exit(EXIT_FAILURE); } path = dirname(modulename); if (!conffile) { dsme_log(LOG_DEBUG, "Unable to read conffile (%s), using compiled-in startup list", MODULES_CONF); for (names = modules ; *names ; names++) { snprintf(name, sizeof(name), "%s/%s", path, *names); if(load_module(name, 0) == NULL) { dsme_log(LOG_ERR, "error loading module %s", name); } } } else { size_t len = 0; char * line = NULL; dsme_log(LOG_DEBUG, "Conf file exists, reading modulenames from %s", MODULES_CONF); while (getline(&line, &len, conffile) > 0) { snprintf(name, sizeof(name), "%s/%s", path, line); name[strlen(name) - 1] = '\0'; /* Remove newline */ if (load_module(name, 0) == NULL) { dsme_log(LOG_ERR, "error loading module %s", name); } } if (line) free(line); fclose(conffile); } free(modulename); dsme_log(LOG_DEBUG, "Module loading finished."); }