/** Find an existing module instance and verify it implements the specified method * * Extracts the method from the module name where the format is @verbatim <module>.<method> @endverbatim * and ensures the module implements the specified method. * * @param[out] method the method component we found associated with the module. May be NULL. * @param[in] modules section in the main config. * @param[in] name The name of the module we're attempting to find, concatenated with * the method. * @return * - The module instance on success. * - NULL on error (or not found). */ module_instance_t *module_find_with_method(rlm_components_t *method, CONF_SECTION *modules, char const *name) { char *p; rlm_components_t i; module_instance_t *mi; /* * Module names are allowed to contain '.' * so we search for the bare module name first. */ mi = module_find(modules, name); if (mi) return mi; /* * Find out if the instance name contains * a method, if it doesn't, then the module * doesn't exist. */ p = strrchr(name, '.'); if (!p) return NULL; /* * Find the component. */ for (i = MOD_AUTHENTICATE; i < MOD_COUNT; i++) { if (strcmp(p + 1, section_type_value[i].section) == 0) { char *inst_name; inst_name = talloc_bstrndup(NULL, name, p - name); mi = module_find(modules, inst_name); talloc_free(inst_name); if (!mi) return NULL; /* * Verify the module actually implements * the specified method. */ if (!mi->module->methods[i]) { cf_log_debug(modules, "%s does not implement method \"%s\"", mi->module->name, p + 1); return NULL; } if (method) *method = i; return mi; } } return mi; }
/* Completely removes a channel. * * This includes the removal of all channel-bans, -exempts and -invites, as * well as all user flags related to the channel. */ static void remove_channel(struct chanset_t *chan) { int i; module_entry *me; /* Remove the channel from the list, so that noone can pull it * away from under our feet during the check_tcl_part() call. */ (void) chanset_unlink(chan); if ((me = module_find("irc", 1, 3)) != NULL) (me->funcs[IRC_DO_CHANNEL_PART]) (chan); clear_channel(chan, 0); noshare = 1; /* Remove channel-bans */ while (chan->bans) u_delban(chan, chan->bans->mask, 1); /* Remove channel-exempts */ while (chan->exempts) u_delexempt(chan, chan->exempts->mask, 1); /* Remove channel-invites */ while (chan->invites) u_delinvite(chan, chan->invites->mask, 1); /* Remove channel specific user flags */ user_del_chan(chan->dname); noshare = 0; nfree(chan->channel.key); for (i = 0; i < MODES_PER_LINE_MAX && chan->cmode[i].op; i++) nfree(chan->cmode[i].op); if (chan->key) nfree(chan->key); if (chan->rmkey) nfree(chan->rmkey); nfree(chan); }
int module_init (int ver, struct module *mod, struct session *sess) { /* This check *MUST* be done first */ if (ver != MODULE_IFACE_VER) return 1; if (module_find (name) != NULL) { /* We are already loaded */ PrintText(sess, "Module xchat-autogb already loaded\n"); return 1; } PrintText(sess, "Loaded module xchat-autogb\n"); mod->name = name; mod->desc = desc; chanmsg_sig.signal = XP_CHANMSG; chanmsg_sig.callback = XP_CALLBACK(autogb_chanmsg); chanmsg_sig.naddr = &chanmsg_next; chanmsg_sig.mod = mod; privmsg_sig.signal = XP_PRIVMSG; privmsg_sig.callback = XP_CALLBACK(autogb_privmsg); privmsg_sig.naddr = &privmsg_next; privmsg_sig.mod = mod; hook_signal(&chanmsg_sig); hook_signal(&privmsg_sig); big2gb_init(); return 0; }
int send_uptime(void) { struct sockaddr_in sai; struct stat st; PackUp *mem; int len, servidx; char servhost[UHOSTLEN] = "none"; module_entry *me; if (uptimeip == -1) { uptimeip = get_ip(); if (uptimeip == -1) return -2; } uptimecount++; upPack.packets_sent = htonl(uptimecount); /* Tell the server how many uptime packets we've sent. */ upPack.now2 = htonl(time(NULL)); upPack.ontime = 0; if ((me = module_find("server", 1, 0))) { Function *server_funcs = me->funcs; if (server_online) { servidx = findanyidx(serv); strncpyz(servhost, dcc[servidx].host, sizeof servhost); upPack.ontime = htonl(server_online); } } if (!upPack.pid) upPack.pid = htonl(getpid()); if (!upPack.uptime) upPack.uptime = htonl(online_since); if (stat("/proc", &st) < 0) upPack.sysup = 0; else upPack.sysup = htonl(st.st_ctime); len = sizeof(upPack) + strlen(botnetnick) + strlen(servhost) + strlen(uptime_version); mem = (PackUp *) nmalloc(len); egg_bzero(mem, len); /* mem *should* be completely filled before it's * sent to the server. But belt-and-suspenders * is always good. */ my_memcpy(mem, &upPack, sizeof(upPack)); sprintf(mem->string, "%s %s %s", botnetnick, servhost, uptime_version); egg_bzero(&sai, sizeof(sai)); sai.sin_family = AF_INET; sai.sin_addr.s_addr = uptimeip; sai.sin_port = htons(uptime_port); len = sendto(uptimesock, (void *) mem, len, 0, (struct sockaddr *) &sai, sizeof(sai)); nfree(mem); return len; }
/* filereq <sock:nick@bot> <bot:file> */ static void bot_filereq(int idx, char *tobot) { char *from, *path; int i; from = newsplit(&tobot); if ((path = strchr(tobot, ':'))) { *path++ = 0; if (!egg_strcasecmp(tobot, botnetnick)) { /* For me! */ /* Process this */ module_entry *fs = module_find("filesys", 0, 0); if (fs == NULL) botnet_send_priv(idx, botnetnick, from, NULL, MOD_NOFILESYSMOD); else { Function f = fs->funcs[FILESYS_REMOTE_REQ]; f(idx, from, path); } } else { /* Pass it on */ i = nextbot(tobot); if (i >= 0) botnet_send_filereq(i, from, tobot, path); } } }
/* Got 442: not on channel */ static int got442(char *from, char *msg) { char *chname, *key; struct chanset_t *chan; if (!realservername || egg_strcasecmp(from, realservername)) return 0; newsplit(&msg); chname = newsplit(&msg); chan = findchan(chname); if (chan && !channel_inactive(chan)) { module_entry *me = module_find("channels", 0, 0); putlog(LOG_MISC, chname, IRC_SERVNOTONCHAN, chname); if (me && me->funcs) (me->funcs[CHANNEL_CLEAR]) (chan, 1); chan->status &= ~CHAN_ACTIVE; key = chan->channel.key[0] ? chan->channel.key : chan->key_prot; if (key[0]) dprintf(DP_SERVER, "JOIN %s %s\n", chan->name, key); else dprintf(DP_SERVER, "JOIN %s\n", chan->name); } return 0; }
/* SYNTAX: UNLOAD <module> [<submodule>] */ static void cmd_unload(const char *data) { MODULE_REC *module; MODULE_FILE_REC *file; char *rootmodule, *submodule; void *free_arg; g_return_if_fail(data != NULL); if (!cmd_get_params(data, &free_arg, 2 , &rootmodule, &submodule)) return; if (*rootmodule == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS); module = module_find(rootmodule); if (module != NULL) { if (*submodule == '\0') module_unload(module); else { file = module_file_find(module, submodule); if (file != NULL) module_file_unload(file); else module = NULL; } } if (module == NULL) { printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_MODULE_NOT_LOADED, rootmodule, submodule); } cmd_params_free(free_arg); }
static int module_load_full(const char *path, const char *rootmodule, const char *submodule, int start, int end, char **prefixes) { MODULE_REC *module; int status, try_prefixes; if (!g_module_supported()) return FALSE; module = module_find(rootmodule); if (module != NULL && (strcmp(submodule, rootmodule) == 0 || module_file_find(module, submodule) != NULL)) { /* module is already loaded */ module_error(MODULE_ERROR_ALREADY_LOADED, NULL, rootmodule, submodule); return FALSE; } /* check if the given module exists.. */ try_prefixes = strcmp(rootmodule, submodule) == 0; status = module_load_name(path, rootmodule, submodule, try_prefixes); if (status == -1 && try_prefixes) { /* nope, try loading the module_core, fe_module, etc. */ status = module_load_prefixes(path, rootmodule, start, end, prefixes); } return status > 0; }
static int tcl_echo(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { int i; module_entry *me; BADARGS(2, 3, " idx ?status?"); i = findidx(atoi(argv[1])); if (i < 0 || dcc[i].type != &DCC_CHAT) { Tcl_AppendResult(irp, "invalid idx", NULL); return TCL_ERROR; } if (argc == 3) { if (atoi(argv[2])) dcc[i].status |= STAT_ECHO; else dcc[i].status &= ~STAT_ECHO; } if (dcc[i].status & STAT_ECHO) Tcl_AppendResult(irp, "1", NULL); else Tcl_AppendResult(irp, "0", NULL); /* Console autosave. */ if (argc > 2 && (me = module_find("console", 1, 1))) { Function *func = me->funcs; (func[CONSOLE_DOSTORE]) (i); } return TCL_OK; }
int engine_register(struct engine *engine, const char *name, const char *precedence, const char* ref) { if (engine == NULL || name == NULL) { return kr_error(EINVAL); } /* Make sure module is unloaded */ (void) engine_unregister(engine, name); /* Find the index of referenced module. */ module_array_t *mod_list = &engine->modules; size_t ref_pos = mod_list->len; if (precedence && ref) { ref_pos = module_find(mod_list, ref); if (ref_pos >= mod_list->len) { return kr_error(EIDRM); } } /* Attempt to load binary module */ struct kr_module *module = malloc(sizeof(*module)); if (!module) { return kr_error(ENOMEM); } module->data = engine; int ret = kr_module_load(module, name, NULL); /* Load Lua module if not a binary */ if (ret == kr_error(ENOENT)) { ret = ffimodule_register_lua(engine, module, name); } if (ret != 0) { free(module); return ret; } if (array_push(engine->modules, module) < 0) { engine_unload(engine, module); return kr_error(ENOMEM); } /* Evaluate precedence operator */ if (precedence) { struct kr_module **arr = mod_list->at; size_t emplacement = mod_list->len; if (strcasecmp(precedence, ">") == 0) { if (ref_pos + 1 < mod_list->len) emplacement = ref_pos + 1; /* Insert after target */ } if (strcasecmp(precedence, "<") == 0) { emplacement = ref_pos; /* Insert at target */ } /* Move the tail if it has some elements. */ if (emplacement + 1 < mod_list->len) { memmove(&arr[emplacement + 1], &arr[emplacement], sizeof(*arr) * (mod_list->len - (emplacement + 1))); arr[emplacement] = module; } } /* Register properties */ if (module->props || module->config) { return register_properties(engine, module); } return kr_ok(); }
static int tcl_console(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { int i, j, pls, arg; module_entry *me; BADARGS(2, 4, " idx ?channel? ?console-modes?"); i = findidx(atoi(argv[1])); if (i < 0 || dcc[i].type != &DCC_CHAT) { Tcl_AppendResult(irp, "invalid idx", NULL); return TCL_ERROR; } pls = 1; for (arg = 2; arg < argc; arg++) { if (argv[arg][0] && ((strchr(CHANMETA, argv[arg][0]) != NULL) || (argv[arg][0] == '*'))) { if ((argv[arg][0] != '*') && (!findchan_by_dname(argv[arg]))) { /* If we dont find the channel, and it starts with a +, assume it * should be the console flags to set. */ if (argv[arg][0] == '+') goto do_console_flags; Tcl_AppendResult(irp, "invalid channel", NULL); return TCL_ERROR; } strncpyz(dcc[i].u.chat->con_chan, argv[arg], 81); } else { if ((argv[arg][0] != '+') && (argv[arg][0] != '-')) dcc[i].u.chat->con_flags = 0; do_console_flags: for (j = 0; j < strlen(argv[arg]); j++) { if (argv[arg][j] == '+') pls = 1; else if (argv[arg][j] == '-') pls = -1; else { char s[2]; s[0] = argv[arg][j]; s[1] = 0; if (pls == 1) dcc[i].u.chat->con_flags |= logmodes(s); else dcc[i].u.chat->con_flags &= ~logmodes(s); } } } } Tcl_AppendElement(irp, dcc[i].u.chat->con_chan); Tcl_AppendElement(irp, masktype(dcc[i].u.chat->con_flags)); /* Console autosave. */ if (argc > 2 && (me = module_find("console", 1, 1))) { Function *func = me->funcs; (func[CONSOLE_DOSTORE]) (i); } return TCL_OK; }
int main(int argc, char **argv) { const struct pppoat_module *m; const struct pppoat_if_module *im; void *m_data; void *im_data; int rd[2]; int wr[2]; int rc; pppoat_log_init(PPPOAT_DEBUG); if (argc > 1 && strcmp(argv[1], "--help") == 0) { help_print(stdout, argv[0]); exit(0); } if (argc > 1 && strcmp(argv[1], "--list") == 0) { module_list_print(stdout); exit(0); } im = if_module_tbl[0]; PPPOAT_ASSERT(im != NULL); m = module_find("udp"); PPPOAT_ASSERT(m != NULL); /* init modules */ rc = im->im_init(argc, argv, &im_data); PPPOAT_ASSERT_INFO(rc == 0, "rc=%d", rc); rc = m->m_init(argc, argv, &m_data); PPPOAT_ASSERT_INFO(rc == 0, "rc=%d", rc); /* create pipes for communication with pppd */ rc = pipe(rd); PPPOAT_ASSERT(rc == 0); rc = pipe(wr); PPPOAT_ASSERT(rc == 0); /* exec pppd */ rc = im->im_run(wr[0], rd[1], im_data); PPPOAT_ASSERT_INFO(rc == 0, "rc=%d", rc); close(rd[1]); close(wr[0]); /* run appropriate module's function */ rc = m->m_run(rd[0], wr[1], 0 /* XXX */, m_data); pppoat_error("main", "rc=%d", rc); /* finalisation */ im->im_stop(im_data); im->im_fini(im_data); m->m_fini(m_data); close(rd[0]); close(wr[1]); pppoat_log_fini(); return 0; }
int module_deregister(const char *filename) { ModuleList *p; p = module_find(filename); return module_delete(p); }
static int tcl_setchan(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { int idx, chan; module_entry *me; BADARGS(3, 3, " idx channel"); idx = findidx(atoi(argv[1])); if (idx < 0 || (dcc[idx].type != &DCC_CHAT && dcc[idx].type != &DCC_SCRIPT)) { Tcl_AppendResult(irp, "invalid idx", NULL); return TCL_ERROR; } if (argv[2][0] < '0' || argv[2][0] > '9') { if (!strcmp(argv[2], "-1") || !egg_strcasecmp(argv[2], "off")) chan = -1; else { Tcl_SetVar(irp, "chan", argv[2], 0); if (Tcl_VarEval(irp, "assoc ", "$chan", NULL) != TCL_OK || !interp->result[0]) { Tcl_AppendResult(irp, "channel name is invalid", NULL); return TCL_ERROR; } chan = atoi(interp->result); } } else chan = atoi(argv[2]); if ((chan < -1) || (chan > 199999)) { Tcl_AppendResult(irp, "channel out of range; must be -1 through 199999", NULL); return TCL_ERROR; } if (dcc[idx].type == &DCC_SCRIPT) dcc[idx].u.script->u.chat->channel = chan; else { int oldchan = dcc[idx].u.chat->channel; if (dcc[idx].u.chat->channel >= 0) { if ((chan >= GLOBAL_CHANS) && (oldchan < GLOBAL_CHANS)) botnet_send_part_idx(idx, "*script*"); check_tcl_chpt(botnetnick, dcc[idx].nick, dcc[idx].sock, dcc[idx].u.chat->channel); } dcc[idx].u.chat->channel = chan; if (chan < GLOBAL_CHANS) botnet_send_join_idx(idx, oldchan); check_tcl_chjn(botnetnick, dcc[idx].nick, chan, geticon(idx), dcc[idx].sock, dcc[idx].host); } /* Console autosave. */ if ((me = module_find("console", 1, 1))) { Function *func = me->funcs; (func[CONSOLE_DOSTORE]) (idx); } return TCL_OK; }
/* 001: welcome to IRC (use it to fix the server name) */ static int got001(char *from, char *msg) { int i; char *key; struct chanset_t *chan; struct server_list *x = serverlist; /* FIXME - x should never be NULL anywhere in this function, but * apparently it sometimes is. */ if (x) { for (i = curserv; i > 0 && x; i--) x = x->next; if (!x) { putlog(LOG_MISC, "*", "Invalid server list!"); } else { if (x->realname) nfree(x->realname); x->realname = nmalloc(strlen(from) + 1); strcpy(x->realname, from); } if (realservername) nfree(realservername); realservername = nmalloc(strlen(from) + 1); strcpy(realservername, from); } else putlog(LOG_MISC, "*", "No server list!"); server_online = now; fixcolon(msg); strncpyz(botname, msg, NICKLEN); altnick_char = 0; dprintf(DP_SERVER, "WHOIS %s\n", botname); /* get user@host */ if (initserver[0]) do_tcl("init-server", initserver); /* Call Tcl init-server */ check_tcl_event("init-server"); if (!x) return 0; if (module_find("irc", 0, 0)) { /* Only join if the IRC module is loaded. */ for (chan = chanset; chan; chan = chan->next) { chan->status &= ~(CHAN_ACTIVE | CHAN_PEND); if (!channel_inactive(chan)) { key = chan->channel.key[0] ? chan->channel.key : chan->key_prot; if (key[0]) dprintf(DP_SERVER, "JOIN %s %s\n", chan->name[0] ? chan->name : chan->dname, key); else dprintf(DP_SERVER, "JOIN %s\n", chan->name[0] ? chan->name : chan->dname); } } } return 0; }
// Unload module by name void module_unload(const char* name) { // Get full path to module file, and hash of path char path[60]; unsigned int hash = get_module_path(path, name); // Find loaded module, and unload it module_unload_idx(module_find(hash)); }
HMODULE module_lookup(const char *filename) { ModuleList *p; if ((p = module_find(filename)) == NULL) return NULL; return p->module; }
/* info? <from@bot> -> send priv */ static void bot_infoq(int idx, char *par) { char s[200], s2[32], *realnick; struct chanset_t *chan; time_t now2; int hr, min; /* Strip the idx from user@bot */ realnick = strchr(par, ':'); if (realnick) realnick++; else realnick = par; putlog(LOG_BOTS, "*", "#%s# botinfo", realnick); now2 = now - online_since; s2[0] = 0; if (now2 > 86400) { int days = now2 / 86400; /* Days */ sprintf(s2, "%d day", days); if (days >= 2) strcat(s2, "s"); strcat(s2, ", "); now2 -= days * 86400; } hr = (time_t) ((int) now2 / 3600); now2 -= (hr * 3600); min = (time_t) ((int) now2 / 60); sprintf(&s2[strlen(s2)], "%02d:%02d", (int) hr, (int) min); if (module_find("server", 0, 0)) { s[0] = 0; for (chan = chanset; chan; chan = chan->next) { if (!channel_secret(chan)) { if ((strlen(s) + strlen(chan->dname) + strlen(network) + strlen(botnetnick) + strlen(ver) + 1) >= 200) { strcat(s, "++ "); break; /* Yegads..! */ } strcat(s, chan->dname); strcat(s, ", "); } } if (s[0]) { s[strlen(s) - 2] = 0; botnet_send_priv(idx, botnetnick, par, NULL, "%s <%s> (%s) [UP %s]", ver, network, s, s2); } else botnet_send_priv(idx, botnetnick, par, NULL, "%s <%s> (%s) [UP %s]", ver, network, BOT_NOCHANNELS, s2); } else botnet_send_priv(idx, botnetnick, par, NULL, "%s <NO_IRC> [UP %s]", ver, s2); botnet_send_infoq(idx, par); }
int engine_unregister(struct engine *engine, const char *name) { module_array_t *mod_list = &engine->modules; size_t found = module_find(mod_list, name); if (found < mod_list->len) { engine_unload(engine, mod_list->at[found]); array_del(*mod_list, found); return kr_ok(); } return kr_error(ENOENT); }
void *dlopen(const char *path, int flag) { module_t *m; m = module_find(runtime_env, path); if (m == NULL) { m = module_load(runtime_env, path, mlf_local); module_load_deps(m, mlf_local); /* Now relocate. */ module_process_relocs(m); } return (void *) m; }
static void kill_server(int idx, void *x) { module_entry *me; disconnect_server(idx); if ((me = module_find("channels", 0, 0)) && me->funcs) { struct chanset_t *chan; for (chan = chanset; chan; chan = chan->next) (me->funcs[CHANNEL_CLEAR]) (chan, 1); } /* A new server connection will be automatically initiated in * about 2 seconds. */ }
static int script_newsomething(void *type, char *chan_name, char *mask, char *creator, char *comment, char *lifetime, char *options) { time_t expire_time; struct chanset_t *chan = NULL; int sticky = 0; int r; module_entry *me; if (chan_name[0]) { chan = findchan_by_dname(chan_name); if (!chan) return(-1); } if (lifetime) { expire_time = atoi(lifetime); if (expire_time) expire_time = expire_time * 60 + now; } expire_time = now + (60 * (((int) type == 'b') ? ((chan->ban_time == 0) ? 0L : chan->ban_time) : (((int) type == 'e') ? ((chan->exempt_time == 0) ? 0L : chan->exempt_time) : ((chan->invite_time == 0) ? 0L : chan->invite_time)))); if (options && !strcasecmp(options, "sticky")) sticky = 1; r = u_addmask((int) type, chan, mask, creator, comment, expire_time, sticky); if (chan && !r) return(-1); if ((int) type == 'b') { me = module_find("irc", 0, 0); if (me) { if (chan) (me->funcs[IRC_CHECK_THIS_BAN])(chan, mask, sticky); else for (chan = chanset; chan; chan = chan->next) { (me->funcs[IRC_CHECK_THIS_BAN])(chan, mask, sticky); } } return(0); } if (chan) add_mode(chan, '+', (int) type, mask); else { for (chan = chanset; chan; chan = chan->next) { add_mode(chan, '+', (int) type, mask); } } return(0); }
static int _module_load(module_handler_t* hMod) { int idx; // Check if module loaded idx = module_find(hMod->name); if ( idx>=0 ) return idx; // Find empty slot for ( idx=0; idx<MAX_NUM_LOADED_MODULES && modules[idx].hdr; idx++ ); if ( idx == MAX_NUM_LOADED_MODULES ) { moduleload_error("%d already loaded",MAX_NUM_LOADED_MODULES); return -1; } if (module_preload(hMod->name, hMod->version) != 0) { // Module is valid. Finalize binding modules[idx].hdr = flat_buf; // store runtime params flat_module_name_make(modules[idx].modulename, module_filename); modules[idx].hMod = hMod; int bind_err = bind_module( hMod, flat_buf->_module_info->lib ); if ( flat_buf->_module_info->lib->loader ) { uint32_t x = flat_buf->_module_info->lib->loader(); bind_err = bind_err || x; } if ( bind_err ) { module_unload(module_filename); moduleload_error("chdk mismatch",0); return -1; } return idx; } return -1; }
static int tcl_strip(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { int i, j, pls, arg; module_entry *me; BADARGS(2, 4, " idx ?strip-flags?"); i = findidx(atoi(argv[1])); if (i < 0 || dcc[i].type != &DCC_CHAT) { Tcl_AppendResult(irp, "invalid idx", NULL); return TCL_ERROR; } pls = 1; for (arg = 2; arg < argc; arg++) { if ((argv[arg][0] != '+') && (argv[arg][0] != '-')) dcc[i].u.chat->strip_flags = 0; for (j = 0; j < strlen(argv[arg]); j++) { if (argv[arg][j] == '+') pls = 1; else if (argv[arg][j] == '-') pls = -1; else { char s[2]; s[0] = argv[arg][j]; s[1] = 0; if (pls == 1) dcc[i].u.chat->strip_flags |= stripmodes(s); else dcc[i].u.chat->strip_flags &= ~stripmodes(s); } } } Tcl_AppendElement(irp, stripmasktype(dcc[i].u.chat->strip_flags)); /* Console autosave. */ if (argc > 2 && (me = module_find("console", 1, 1))) { Function *func = me->funcs; (func[CONSOLE_DOSTORE]) (i); } return TCL_OK; }
int __char_device_register(unsigned int major, const char *name, struct file_operations *fops, unsigned int this_module) { struct device *dev; struct kernel_module *mod; if (new(dev)) return -ENOMEM; dev->fops = fops; dev->owner = 0; strcpy(dev->name, name); if ((mod = module_find(this_module))) dev->owner = mod; char_devices[major] = dev; return 0; }
/* SYNTAX: UNLOAD <module> [<submodule>] */ static void cmd_unload(const char *data) { MODULE_REC *module; MODULE_FILE_REC *file; char *rootmodule, *submodule; void *free_arg; GSList *tmp; int all_dynamic; g_return_if_fail(data != NULL); if (!cmd_get_params(data, &free_arg, 2 , &rootmodule, &submodule)) return; if (*rootmodule == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS); module = module_find(rootmodule); if (module != NULL) { if (*submodule == '\0') { all_dynamic = 1; for (tmp = module->files; tmp != NULL; tmp = tmp->next) all_dynamic &= !MODULE_IS_STATIC((MODULE_FILE_REC*) tmp->data); if (all_dynamic) module_unload(module); } else { file = module_file_find(module, submodule); if (file != NULL) { if (!MODULE_IS_STATIC(file)) module_file_unload(file); } else module = NULL; } } if (module == NULL) { printformat(NULL, NULL, MSGLEVEL_CLIENTERROR, TXT_MODULE_NOT_LOADED, rootmodule, submodule); } cmd_params_free(free_arg); }
int module_init (int ver, struct module *mod, struct session *sess) { /* This check *MUST* be done first */ if (ver != MODULE_IFACE_VER) return 1; if (module_find (name) != NULL) { /* We are already loaded */ PrintText(sess, "Module sample already loaded\n"); return 1; } PrintText(sess, "Loaded module sample\n"); mod->name = name; mod->desc = desc; privmsg_sig.signal = XP_PRIVMSG; privmsg_sig.callback = XP_CALLBACK(sample_privmsg); privmsg_sig.naddr = &privmsg_next; privmsg_sig.mod = mod; test_sig.signal = XP_USERCOMMAND; test_sig.callback = XP_CALLBACK(sample_test); test_sig.naddr = &test_next; test_sig.mod = mod; test2_sig.signal = XP_USERCOMMAND; test2_sig.callback = XP_CALLBACK(sample_test2); test2_sig.naddr = &test2_next; test2_sig.mod = mod; hook_signal(&test_sig); hook_signal(&test2_sig); hook_signal(&privmsg_sig); sample_cmd_set.mod = mod; sample_cmd_set.cmds = sample_cmds; module_add_cmds (&sample_cmd_set); return 0; }
int module_register(const char *filename, HMODULE module) { if (mod_list == NULL) { mod_list = malloc(sizeof(ModuleList)); mod_list->next = mod_list->prev = NULL; } else { if (module_find(filename)) return 1; mod_list->next = malloc(sizeof(ModuleList)); mod_list->next->prev = mod_list; mod_list->next->next = NULL; mod_list = mod_list->next; } mod_list->filename = filename ? strdup(filename) : NULL; mod_list->module = module; return 1; }
static void irc_proc_cmd_privmsg_user_cmd (struct irc_t * irc) { struct mod_c_t * mod_c; char token[MAX_IRC_MSG]; char str[MAX_IRC_MSG]; char * t; strncpy(str, irc->request, MAX_IRC_MSG); if ( !(t = strtok(str, " \r\n")) ) return; strncpy(token, t, MAX_IRC_MSG); if ( (mod_c = module_find(token+1)) ) { char reply_msg[MAX_IRC_MSG]; reply_msg[0] = '\0'; mod_c->func(irc, reply_msg); if (reply_msg[0]) snprintf(irc->response, MAX_IRC_MSG, "PRIVMSG %s :%s\r\n", irc->from, reply_msg); } #ifdef USE_PYTHON_MODULES else { char * ret; struct py_module_t * mod = py_find_loaded_name (token); if (mod) { ret = py_call_module ( mod, irc ); snprintf( irc->response, MAX_IRC_MSG , "PRIVMSG %s :%s\r\n", irc->from, ret ); free(ret); } } #endif if ( !strncmp (irc->session->admin, irc->nick_to_msg, strlen(irc->session->admin)) ) irc_proc_cmd_privmsg_user_cmd_admin (irc); }
static int tcl_page(ClientData cd, Tcl_Interp *irp, int argc, char *argv[]) { int i; char x[20]; module_entry *me; BADARGS(2, 3, " idx ?status?"); i = findidx(atoi(argv[1])); if (i < 0 || dcc[i].type != &DCC_CHAT) { Tcl_AppendResult(irp, "invalid idx", NULL); return TCL_ERROR; } if (argc == 3) { int l = atoi(argv[2]); if (!l) dcc[i].status &= ~STAT_PAGE; else { dcc[i].status |= STAT_PAGE; dcc[i].u.chat->max_line = l; } } if (dcc[i].status & STAT_PAGE) { egg_snprintf(x, sizeof x, "%d", dcc[i].u.chat->max_line); Tcl_AppendResult(irp, x, NULL); } else Tcl_AppendResult(irp, "0", NULL); /* Console autosave. */ if ((argc > 2) && (me = module_find("console", 1, 1))) { Function *func = me->funcs; (func[CONSOLE_DOSTORE]) (i); } return TCL_OK; }