static int mech_step_accname(sasl_session_t *p, char *message, int len, char **out, int *out_len) { ecdsa_session_t *s = p->mechdata; myuser_t *mu; char *username; unsigned char pubkey_raw[BUFSIZE]; const unsigned char *pubkey_raw_p; metadata_t *md; int ret; memset(pubkey_raw, '\0', sizeof pubkey_raw); username = mowgli_alloc(len + 5); memcpy(username, message, len); username[len] = '\0'; p->username = sstrdup(username); mowgli_free(username); mu = myuser_find_by_nick(p->username); if (mu == NULL) return ASASL_FAIL; md = metadata_find(mu, "pubkey"); if (md == NULL) return ASASL_FAIL; ret = base64_decode(md->value, (char *)pubkey_raw, BUFSIZE); if (ret == -1) return ASASL_FAIL; pubkey_raw_p = pubkey_raw; o2i_ECPublicKey(&s->pubkey, &pubkey_raw_p, ret); #ifndef DEBUG_STATIC_CHALLENGE_VECTOR RAND_pseudo_bytes(s->challenge, CHALLENGE_LENGTH); #else memset(s->challenge, 'A', CHALLENGE_LENGTH); #endif *out = malloc(400); memcpy(*out, s->challenge, CHALLENGE_LENGTH); *out_len = CHALLENGE_LENGTH; s->step = ECDSA_ST_RESPONSE; return ASASL_MORE; }
static void gs_cmd_invite(sourceinfo_t *si, int parc, char *parv[]) { mygroup_t *mg; myuser_t *mu; groupacs_t *ga; char *group = parv[0]; char *user = parv[1]; char buf[BUFSIZE]; service_t *svs; if (!group || !user) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "INVITE"); command_fail(si, fault_needmoreparams, _("Syntax: INVITE <!group> <user>")); return; } if ((mg = mygroup_find(group)) == NULL) { command_fail(si, fault_nosuch_target, _("The group \2%s\2 does not exist."), group); return; } if (!groupacs_sourceinfo_has_flag(mg, si, GA_INVITE)) { command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED); return; } if ((mu = myuser_find_ext(user)) == NULL) { command_fail(si, fault_nosuch_target, _("\2%s\2 is not a registered account."), user); return; } if ((ga = groupacs_find(mg, entity(mu), 0, false)) != NULL) { command_fail(si, fault_badparams, _("\2%s\2 is already a member of \2%s\2."), user, group); return; } if (metadata_find(mu, "private:groupinvite")) { command_fail(si, fault_badparams, _("\2%s\2 can not be invited to a group currently because they already \ have another invitation pending."), user); return; }
static void cs_cmd_getkey(sourceinfo_t *si, int parc, char *parv[]) { char *chan = parv[0]; mychan_t *mc; if (!chan) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "GETKEY"); command_fail(si, fault_needmoreparams, _("Syntax: GETKEY <#channel>")); return; } mc = mychan_find(chan); if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan); return; } if (metadata_find(mc, "private:close:closer")) { command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan); return; } if (!chanacs_source_has_flag(mc, si, CA_INVITE)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (!mc->chan) { command_fail(si, fault_nosuch_target, _("\2%s\2 is currently empty."), mc->name); return; } if (!mc->chan->key) { command_fail(si, fault_nosuch_key, _("\2%s\2 is not keyed."), mc->name); return; } logcommand(si, CMDLOG_GET, "GETKEY: \2%s\2", mc->name); command_success_string(si, mc->chan->key, _("Channel \2%s\2 key is: %s"), mc->name, mc->chan->key); }
static void gs_cmd_set_channel(sourceinfo_t *si, int parc, char *parv[]) { mygroup_t *mg; char *chan = parv[1]; if (!(mg = mygroup_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Group \2%s\2 does not exist."), parv[0]); return; } if (si->smu == NULL) { command_fail(si, fault_noprivs, _("You are not logged in.")); return; } if (!groupacs_sourceinfo_has_flag(mg, si, GA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to execute this command.")); return; } if (!chan || !strcasecmp("OFF", chan) || !strcasecmp("NONE", chan)) { /* not in a namespace to allow more natural use of SET PROPERTY. * they may be able to introduce spaces, though. c'est la vie. */ if (metadata_find(mg, "channel")) { metadata_delete(mg, "channel"); logcommand(si, CMDLOG_SET, "SET:CHANNEL:NONE: \2%s\2", entity(mg)->name); command_success_nodata(si, _("The official channel for \2%s\2 has been cleared."), parv[0]); return; } command_fail(si, fault_nochange, _("A official channel for \2%s\2 was not set."), parv[0]); return; } /* we'll overwrite any existing metadata */ metadata_add(mg, "channel", chan); logcommand(si, CMDLOG_SET, "SET:CHANNEL: \2%s\2 \2%s\2", entity(mg)->name, chan); command_success_nodata(si, _("The official channel of \2%s\2 has been set to \2%s\2."), parv[0], chan); }
static void cs_cmd_set_email(struct sourceinfo *si, int parc, char *parv[]) { struct mychan *mc; char *mail = parv[1]; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to execute this command.")); return; } if (!mail || !strcasecmp(mail, "NONE") || !strcasecmp(mail, "OFF")) { if (metadata_find(mc, "email")) { metadata_delete(mc, "email"); command_success_nodata(si, _("The e-mail address for channel \2%s\2 was deleted."), mc->name); logcommand(si, CMDLOG_SET, "SET:EMAIL:NONE: \2%s\2", mc->name); return; } command_fail(si, fault_nochange, _("The e-mail address for channel \2%s\2 was not set."), mc->name); return; } if (!validemail(mail)) { command_fail(si, fault_badparams, _("\2%s\2 is not a valid e-mail address."), mail); return; } // we'll overwrite any existing metadata metadata_add(mc, "email", mail); logcommand(si, CMDLOG_SET, "SET:EMAIL: \2%s\2 \2%s\2", mc->name, mail); verbose(mc, _("\2%s\2 set the e-mail address for the channel to \2%s\2"), get_source_name(si), mail); command_success_nodata(si, _("The e-mail address for channel \2%s\2 has been set to \2%s\2."), parv[0], mail); }
static void cs_cmd_set_entrymsg(sourceinfo_t *si, int parc, char *parv[]) { mychan_t *mc; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to execute this command.")); return; } if (!parv[1] || !strcasecmp("OFF", parv[1]) || !strcasecmp("NONE", parv[1])) { /* entrymsg is private because users won't see it if they're AKICKED, * if the channel is +i, or if the channel is RESTRICTED */ if (metadata_find(mc, "private:entrymsg")) { metadata_delete(mc, "private:entrymsg"); logcommand(si, CMDLOG_SET, "SET:ENTRYMSG:NONE: \2%s\2", mc->name); verbose(mc, _("\2%s\2 cleared the entry message"), get_source_name(si)); command_success_nodata(si, _("The entry message for \2%s\2 has been cleared."), parv[0]); return; } command_fail(si, fault_nochange, _("The entry message for \2%s\2 was not set."), parv[0]); return; } /* we'll overwrite any existing metadata. * Why is/was this even private? There are no size/content sanity checks * and even users with no channel access can see it. --jdhore */ metadata_add(mc, "private:entrymsg", parv[1]); logcommand(si, CMDLOG_SET, "SET:ENTRYMSG: \2%s\2 \2%s\2", mc->name, parv[1]); verbose(mc, _("\2%s\2 set the entry message for the channel to \2%s\2"), get_source_name(si), parv[1]); command_success_nodata(si, _("The entry message for \2%s\2 has been set to \2%s\2"), parv[0], parv[1]); }
/* * atheme.login * * XML Inputs: * account name, password, source ip (optional) * * XML Outputs: * fault 1 - insufficient parameters * fault 3 - account is not registered * fault 5 - invalid username and password * fault 6 - account is frozen * default - success (authcookie) * * Side Effects: * an authcookie ticket is created for the myuser_t. * the user's lastlogin is updated */ static int xmlrpcmethod_login(void *conn, int parc, char *parv[]) { myuser_t *mu; authcookie_t *ac; const char *sourceip; if (parc < 2) { xmlrpc_generic_error(fault_needmoreparams, "Insufficient parameters."); return 0; } sourceip = parc >= 3 && *parv[2] != '\0' ? parv[2] : NULL; if (!(mu = myuser_find(parv[0]))) { xmlrpc_generic_error(fault_nosuch_source, "The account is not registered."); return 0; } if (metadata_find(mu, "private:freeze:freezer") != NULL) { logcommand_external(nicksvs.me, "xmlrpc", conn, sourceip, NULL, CMDLOG_LOGIN, "failed LOGIN to %s (frozen)", mu->name); xmlrpc_generic_error(fault_noprivs, "The account has been frozen."); return 0; } if (!verify_password(mu, parv[1])) { logcommand_external(nicksvs.me, "xmlrpc", conn, sourceip, NULL, CMDLOG_LOGIN, "failed LOGIN to %s (bad password)", mu->name); xmlrpc_generic_error(fault_authfail, "The password is not valid for this account."); return 0; } mu->lastlogin = CURRTIME; ac = authcookie_create(mu); logcommand_external(nicksvs.me, "xmlrpc", conn, sourceip, mu, CMDLOG_LOGIN, "LOGIN"); xmlrpc_send_string(ac->ticket); return 0; }
static void gs_cmd_set_email(sourceinfo_t *si, int parc, char *parv[]) { mygroup_t *mg; char *mail = parv[1]; if (!(mg = mygroup_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Group \2%s\2 does not exist."), parv[0]); return; } if (!groupacs_sourceinfo_has_flag(mg, si, GA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to execute this command.")); return; } if (!mail || !strcasecmp(mail, "NONE") || !strcasecmp(mail, "OFF")) { if (metadata_find(mg, "email")) { metadata_delete(mg, "email"); command_success_nodata(si, _("The e-mail address for group \2%s\2 was deleted."), entity(mg)->name); logcommand(si, CMDLOG_SET, "SET:EMAIL:NONE: \2%s\2", entity(mg)->name); return; } command_fail(si, fault_nochange, _("The e-mail address for group \2%s\2 was not set."), entity(mg)->name); return; } if (!validemail(mail)) { command_fail(si, fault_badparams, _("\2%s\2 is not a valid e-mail address."), mail); return; } /* we'll overwrite any existing metadata */ metadata_add(mg, "email", mail); logcommand(si, CMDLOG_SET, "SET:EMAIL: \2%s\2 \2%s\2", entity(mg)->name, mail); command_success_nodata(si, _("The e-mail address for group \2%s\2 has been set to \2%s\2."), parv[0], mail); }
static void cs_cmd_set_url(struct sourceinfo *si, int parc, char *parv[]) { struct mychan *mc; char *url = parv[1]; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to execute this command.")); return; } if (!url || !strcasecmp("OFF", url) || !strcasecmp("NONE", url)) { /* not in a namespace to allow more natural use of SET PROPERTY. * they may be able to introduce spaces, though. c'est la vie. */ if (metadata_find(mc, "url")) { metadata_delete(mc, "url"); logcommand(si, CMDLOG_SET, "SET:URL:NONE: \2%s\2", mc->name); verbose(mc, _("\2%s\2 cleared the channel URL"), get_source_name(si)); command_success_nodata(si, _("The URL for \2%s\2 has been cleared."), parv[0]); return; } command_fail(si, fault_nochange, _("The URL for \2%s\2 was not set."), parv[0]); return; } // we'll overwrite any existing metadata metadata_add(mc, "url", url); logcommand(si, CMDLOG_SET, "SET:URL: \2%s\2 \2%s\2", mc->name, url); verbose(mc, _("\2%s\2 set the channel URL to \2%s\2"), get_source_name(si), url); command_success_nodata(si, _("The URL of \2%s\2 has been set to \2%s\2."), parv[0], url); }
static void helpserv_cmd_helpme(sourceinfo_t *si, int parc, char *parv[]) { char *topic = parv[0]; if ((unsigned int)(CURRTIME - ratelimit_firsttime) > config_options.ratelimit_period) ratelimit_count = 0, ratelimit_firsttime = CURRTIME; if (ratelimit_count > config_options.ratelimit_uses && !has_priv(si, PRIV_FLOOD)) { command_fail(si, fault_toomany, _("The system is currently too busy to process your help request, please try again later.")); slog(LG_INFO, "HELPME:THROTTLED: %s", si->su->nick); return; } if (si->smu != NULL && metadata_find(si->smu, "private:restrict:setter")) { command_fail(si, fault_noprivs, _("You have been restricted from requesting help by network staff.")); return; } command_add_flood(si, FLOOD_HEAVY); if (topic) { logcommand(si, CMDLOG_ADMIN, "HELPME: \2%s\2", topic); wallops("\2%s\2 has requested help about \2%s\2", get_source_name(si), topic); } else { logcommand(si, CMDLOG_ADMIN, "HELPME"); wallops("\2%s\2 has requested help.", get_source_name(si)); } command_success_nodata(si, "The network staff has been notified that you need help and will be with you shortly."); if (config_options.ratelimit_uses && config_options.ratelimit_period) ratelimit_count++; return; }
chd_error chd_file::read_metadata(chd_metadata_tag searchtag, UINT32 searchindex, dynamic_buffer &output) { // wrap this for clean reporting try { // if we didn't find it, just return metadata_entry metaentry; if (!metadata_find(searchtag, searchindex, metaentry)) throw CHDERR_METADATA_NOT_FOUND; // read the metadata output.resize(metaentry.length); file_read(metaentry.offset + METADATA_HEADER_SIZE, output, metaentry.length); return CHDERR_NONE; } // just return errors catch (chd_error &err) { return err; } }
chd_error chd_file::read_metadata(chd_metadata_tag searchtag, UINT32 searchindex, void *output, UINT32 outputlen, UINT32 &resultlen) { // wrap this for clean reporting try { // if we didn't find it, just return metadata_entry metaentry; if (!metadata_find(searchtag, searchindex, metaentry)) throw CHDERR_METADATA_NOT_FOUND; // read the metadata resultlen = metaentry.length; file_read(metaentry.offset + METADATA_HEADER_SIZE, output, MIN(outputlen, resultlen)); return CHDERR_NONE; } // just return errors catch (chd_error &err) { return err; } }
uint32_t get_template_flags(mychan_t *mc, char *name) { metadata_t *md; char *d; if (*name != '\0' && !strcasecmp(name + 1, "op")) { switch (*name) { case 's': case 'S': return chansvs.ca_sop; case 'a': case 'A': return chansvs.ca_aop; case 'h': case 'H': return chansvs.ca_hop; case 'v': case 'V': return chansvs.ca_vop; } } md = metadata_find(mc, METADATA_CHANNEL, "private:templates"); if (md != NULL) { d = getitem(md->value, name); if (d != NULL) return flags_to_bitmask(d, chanacs_flags, 0); } return 0; }
static void ns_cmd_sendpass(sourceinfo_t *si, int parc, char *parv[]) { myuser_t *mu; char *name = parv[0]; char *newpass = NULL; char *key; metadata_t *md; enum specialoperation op = op_none; bool ismarked = false; char cmdtext[NICKLEN + 20]; hook_user_needforce_t needforce_hdata; if (!name) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SENDPASS"); command_fail(si, fault_needmoreparams, _("Syntax: SENDPASS <account>")); return; } if (parc > 1) { if (!strcasecmp(parv[1], "FORCE")) op = op_force; else if (!strcasecmp(parv[1], "CLEAR")) op = op_clear; else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "SENDPASS"); command_fail(si, fault_badparams, _("Syntax: SENDPASS <account> [FORCE|CLEAR]")); return; } } if (!(mu = myuser_find_by_nick(name))) { command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), name); return; } if (is_soper(mu) && !has_priv(si, PRIV_ADMIN)) { logcommand(si, CMDLOG_ADMIN, "failed SENDPASS \2%s\2 (is SOPER)", name); command_fail(si, fault_badparams, _("\2%s\2 belongs to a services operator; you need %s privilege to send the password."), name, PRIV_ADMIN); return; } if (mu->flags & MU_WAITAUTH) { command_fail(si, fault_badparams, _("\2%s\2 is not verified."), entity(mu)->name); return; } if ((md = metadata_find(mu, "private:mark:setter"))) { ismarked = true; if (op == op_none) { logcommand(si, CMDLOG_ADMIN, "failed SENDPASS \2%s\2 (marked by \2%s\2)", entity(mu)->name, md->value); command_fail(si, fault_badparams, _("This operation cannot be performed on %s, because the account has been marked by %s."), entity(mu)->name, md->value); if (has_priv(si, PRIV_MARK)) { snprintf(cmdtext, sizeof cmdtext, "SENDPASS %s FORCE", entity(mu)->name); command_fail(si, fault_badparams, _("Use %s to override this restriction."), cmdtext); } return; } else if (!has_priv(si, PRIV_MARK)) { logcommand(si, CMDLOG_ADMIN, "failed SENDPASS \2%s\2 (marked by \2%s\2)", entity(mu)->name, md->value); command_fail(si, fault_noprivs, STR_NO_PRIVILEGE, PRIV_MARK); return; } } needforce_hdata.si = si; needforce_hdata.mu = mu; needforce_hdata.allowed = 1; hook_call_user_needforce(&needforce_hdata); if (!needforce_hdata.allowed) { ismarked = true; if (op == op_none) { logcommand(si, CMDLOG_ADMIN, "failed SENDPASS \2%s\2 (marked)", entity(mu)->name); command_fail(si, fault_badparams, _("This operation cannot be performed on %s, because the account has been marked."), entity(mu)->name); if (has_priv(si, PRIV_MARK)) { snprintf(cmdtext, sizeof cmdtext, "SENDPASS %s FORCE", entity(mu)->name); command_fail(si, fault_badparams, _("Use %s to override this restriction."), cmdtext); } return; } else if (!has_priv(si, PRIV_MARK)) { logcommand(si, CMDLOG_ADMIN, "failed SENDPASS \2%s\2 (marked)", entity(mu)->name); command_fail(si, fault_noprivs, STR_NO_PRIVILEGE, PRIV_MARK); return; } } if (op == op_clear) { if (metadata_find(mu, "private:setpass:key")) { metadata_delete(mu, "private:setpass:key"); metadata_delete(mu, "private:sendpass:sender"); metadata_delete(mu, "private:sendpass:timestamp"); logcommand(si, CMDLOG_ADMIN, "SENDPASS:CLEAR: \2%s\2", entity(mu)->name); command_success_nodata(si, _("The password change key for \2%s\2 has been cleared."), entity(mu)->name); } else command_fail(si, fault_nochange, _("\2%s\2 did not have a password change key outstanding."), entity(mu)->name); return; } if (MOWGLI_LIST_LENGTH(&mu->logins) > 0) { command_fail(si, fault_noprivs, _("This operation cannot be performed on %s, because someone is logged in to it."), entity(mu)->name); return; } if (metadata_find(mu, "private:freeze:freezer")) { command_fail(si, fault_noprivs, _("%s has been frozen by the %s administration."), entity(mu)->name, me.netname); return; } if (command_find(si->service->commands, "SETPASS")) { if (metadata_find(mu, "private:setpass:key")) { command_fail(si, fault_alreadyexists, _("\2%s\2 already has a password change key outstanding."), entity(mu)->name); command_fail(si, fault_alreadyexists, _("Use SENDPASS %s CLEAR to clear it so that a new one can be sent."), entity(mu)->name); return; } if (ismarked) { wallops("%s sent the password for the \2MARKED\2 account %s.", get_oper_name(si), entity(mu)->name); if (md) command_success_nodata(si, _("Overriding MARK placed by %s on the account %s."), md->value, entity(mu)->name); else command_success_nodata(si, _("Overriding MARK on the account %s."), entity(mu)->name); } logcommand(si, CMDLOG_ADMIN, "SENDPASS: \2%s\2 (change key)", name); key = random_string(12); metadata_add(mu, "private:sendpass:sender", get_oper_name(si)); metadata_add(mu, "private:sendpass:timestamp", number_to_string(time(NULL))); if (!sendemail(si->su != NULL ? si->su : si->service->me, mu, EMAIL_SETPASS, mu->email, key)) { command_fail(si, fault_emailfail, _("Email send failed.")); free(key); return; } metadata_add(mu, "private:setpass:key", crypt_string(key, gen_salt())); free(key); command_success_nodata(si, _("The password change key for \2%s\2 has been sent to \2%s\2."), entity(mu)->name, mu->email); } else { if (ismarked) { wallops("%s sent the password for the \2MARKED\2 account %s.", get_oper_name(si), entity(mu)->name); if (md) command_success_nodata(si, _("Overriding MARK placed by %s on the account %s."), md->value, entity(mu)->name); else command_success_nodata(si, _("Overriding MARK on the account %s."), entity(mu)->name); } logcommand(si, CMDLOG_ADMIN, "SENDPASS: \2%s\2", name); newpass = random_string(12); metadata_add(mu, "private:sendpass:sender", get_oper_name(si)); metadata_add(mu, "private:sendpass:timestamp", number_to_string(time(NULL))); if (!sendemail(si->su != NULL ? si->su : si->service->me, mu, EMAIL_SENDPASS, mu->email, newpass)) { command_fail(si, fault_emailfail, _("Email send failed.")); free(newpass); return; } set_password(mu, newpass); free(newpass); command_success_nodata(si, _("The password for \2%s\2 has been sent to \2%s\2."), entity(mu)->name, mu->email); if (mu->flags & MU_NOPASSWORD) { mu->flags &= ~MU_NOPASSWORD; command_success_nodata(si, _("The \2%s\2 flag has been removed for account \2%s\2."), "NOPASSWORD", entity(mu)->name); } } }
static void cs_cmd_ban(sourceinfo_t *si, int parc, char *parv[]) { char *channel = parv[0]; char *target = parv[1]; char *newtarget; channel_t *c = channel_find(channel); mychan_t *mc = mychan_find(channel); user_t *tu; if (!channel || !target) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "BAN"); command_fail(si, fault_needmoreparams, _("Syntax: BAN <#channel> <nickname|hostmask>")); return; } if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), channel); return; } if (!c) { command_fail(si, fault_nosuch_target, _("\2%s\2 is currently empty."), channel); return; } if (!chanacs_source_has_flag(mc, si, CA_REMOVE)) { command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED); return; } if (metadata_find(mc, "private:close:closer")) { command_fail(si, fault_noprivs, _("\2%s\2 is closed."), channel); return; } if ((tu = user_find_named(target))) { char hostbuf[BUFSIZE]; hostbuf[0] = '\0'; mowgli_strlcat(hostbuf, "*!*@", BUFSIZE); mowgli_strlcat(hostbuf, tu->vhost, BUFSIZE); modestack_mode_param(chansvs.nick, c, MTYPE_ADD, 'b', hostbuf); chanban_add(c, hostbuf, 'b'); logcommand(si, CMDLOG_DO, "BAN: \2%s\2 on \2%s\2 (for user \2%s!%s@%s\2)", hostbuf, mc->name, tu->nick, tu->user, tu->vhost); if (si->su == NULL || !chanuser_find(mc->chan, si->su)) command_success_nodata(si, _("Banned \2%s\2 on \2%s\2."), target, channel); return; } else if ((is_extban(target) && (newtarget = target)) || ((newtarget = pretty_mask(target)) && validhostmask(newtarget))) { modestack_mode_param(chansvs.nick, c, MTYPE_ADD, 'b', newtarget); chanban_add(c, newtarget, 'b'); logcommand(si, CMDLOG_DO, "BAN: \2%s\2 on \2%s\2", newtarget, mc->name); if (si->su == NULL || !chanuser_find(mc->chan, si->su)) command_success_nodata(si, _("Banned \2%s\2 on \2%s\2."), newtarget, channel); return; } else { command_fail(si, fault_badparams, _("Invalid nickname/hostmask provided: \2%s\2"), target); command_fail(si, fault_badparams, _("Syntax: BAN <#channel> <nickname|hostmask>")); return; } }
static void ns_cmd_sendpass(struct sourceinfo *si, int parc, char *parv[]) { struct myuser *mu; char *name = parv[0]; char *key; enum specialoperation op = op_none; bool ismarked = false; if (!name) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SENDPASS"); command_fail(si, fault_needmoreparams, _("Syntax: SENDPASS <account>")); return; } if (parc > 1) { if (!has_priv(si, PRIV_USER_SENDPASS)) { command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED); return; } else if (!strcasecmp(parv[1], "FORCE")) op = op_force; else if (!strcasecmp(parv[1], "CLEAR")) op = op_clear; else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "SENDPASS"); command_fail(si, fault_badparams, _("Syntax: SENDPASS <account> [FORCE|CLEAR]")); return; } } if (!(mu = myuser_find_by_nick(name))) { command_fail(si, fault_nosuch_target, STR_IS_NOT_REGISTERED, name); return; } if (mu->flags & MU_WAITAUTH) { command_fail(si, fault_badparams, _("\2%s\2 is not verified."), entity(mu)->name); return; } if (metadata_find(mu, "private:mark:setter")) { ismarked = true; // don't want to disclose this, so just go ahead... } if (op == op_clear) { if (metadata_find(mu, "private:setpass:key")) { logcommand(si, CMDLOG_ADMIN, "SENDPASS:CLEAR: \2%s\2", entity(mu)->name); metadata_delete(mu, "private:setpass:key"); metadata_delete(mu, "private:sendpass:sender"); metadata_delete(mu, "private:sendpass:timestamp"); command_success_nodata(si, _("The password change key for \2%s\2 has been cleared."), entity(mu)->name); } else command_fail(si, fault_nochange, _("\2%s\2 did not have a password change key outstanding."), entity(mu)->name); return; } if (MOWGLI_LIST_LENGTH(&mu->logins) > 0) { if (si->smu == mu) command_fail(si, fault_already_authed, _("You are logged in and can change your password using the SET PASSWORD command.")); else command_fail(si, fault_noprivs, _("This operation cannot be performed on %s, because someone is logged in to it."), entity(mu)->name); return; } if (metadata_find(mu, "private:freeze:freezer")) { command_fail(si, fault_noprivs, _("%s has been frozen by the %s administration."), entity(mu)->name, me.netname); return; } if (metadata_find(mu, "private:setpass:key")) { command_fail(si, fault_alreadyexists, _("\2%s\2 already has a password change key outstanding."), entity(mu)->name); if (has_priv(si, PRIV_USER_SENDPASS)) command_fail(si, fault_alreadyexists, _("Use SENDPASS %s CLEAR to clear it so that a new one can be sent."), entity(mu)->name); return; } key = random_string(12); const char *const hash = crypt_password(key); if (!hash) { command_fail(si, fault_internalerror, _("Hash generation for password change key failed.")); sfree(key); return; } if (sendemail(si->su != NULL ? si->su : si->service->me, mu, EMAIL_SETPASS, mu->email, key)) { if (ismarked) wallops("%s sent the password for the \2MARKED\2 account %s.", get_oper_name(si), entity(mu)->name); logcommand(si, CMDLOG_ADMIN, "SENDPASS: \2%s\2 (change key)", name); metadata_add(mu, "private:sendpass:sender", get_oper_name(si)); metadata_add(mu, "private:sendpass:timestamp", number_to_string(time(NULL))); metadata_add(mu, "private:setpass:key", hash); command_success_nodata(si, _("The password change key for \2%s\2 has been sent to the corresponding email address."), entity(mu)->name); } else command_fail(si, fault_emailfail, _("Email send failed.")); sfree(key); }
static void cs_cmd_topic(sourceinfo_t *si, int parc, char *parv[]) { char *chan = parv[0]; char *topic = parv[1]; mychan_t *mc; channel_t *c; const char *topicsetter; time_t prevtopicts; if (!chan || !topic) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "TOPIC"); command_fail(si, fault_needmoreparams, _("Syntax: TOPIC <#channel> <topic>")); return; } mc = mychan_find(chan); if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan); return; } c = channel_find(chan); if (!c) { command_fail(si, fault_nosuch_target, _("\2%s\2 is currently empty."), chan); return; } if (metadata_find(mc, "private:close:closer")) { command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan); return; } if (!(chanacs_source_has_flag(mc, si, CA_TOPIC) || chanacs_source_has_flag(mc, si, CA_FOUNDER))) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (!validtopic(topic)) { command_fail(si, fault_badparams, _("The new topic is invalid or too long.")); return; } if (si->su != NULL) topicsetter = si->su->nick; else if (si->smu != NULL) topicsetter = entity(si->smu)->name; else topicsetter = "unknown"; prevtopicts = c->topicts; handle_topic(c, topicsetter, CURRTIME, topic); topic_sts(c, si->service->me, topicsetter, CURRTIME, prevtopicts, topic); logcommand(si, CMDLOG_DO, "TOPIC: \2%s\2", mc->name); if (si->su == NULL || !chanuser_find(c, si->su)) command_success_nodata(si, _("Topic set to \2%s\2 on \2%s\2."), topic, chan); }
static void cs_cmd_topicswap(sourceinfo_t *si, int parc, char *parv[]) { char *chan = parv[0]; char *topic = parv[1]; mychan_t *mc; channel_t *c; const char *topicsetter; time_t prevtopicts; char topicbuf[BUFSIZE]; char commbuf[BUFSIZE]; char *pos = NULL; char *search = NULL; char *replace = NULL; size_t search_size = 0; size_t replace_size = 0; size_t copylen = 0; if (parc < 2) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "TOPICSWAP"); command_fail(si, fault_needmoreparams, _("Syntax: TOPICSWAP <#channel> <search>:[<replace>]")); return; } mowgli_strlcpy(commbuf, parv[1], BUFSIZE); search = commbuf; pos = strrchr(commbuf, ':'); if (!pos || pos == commbuf) { command_fail(si, fault_badparams, STR_INSUFFICIENT_PARAMS, "TOPICSWAP"); command_fail(si, fault_badparams, _("Syntax: TOPICSWAP <#channel> <search>:[<replace>]")); return; } mc = mychan_find(chan); if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan); return; } c = channel_find(chan); if (!c) { command_fail(si, fault_nosuch_target, _("\2%s\2 is currently empty."), chan); return; } if (!chanacs_source_has_flag(mc, si, CA_TOPIC)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (metadata_find(mc, "private:close:closer")) { command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan); return; } if (!c->topic) topicbuf[0] = '\0'; else mowgli_strlcpy(topicbuf, c->topic, BUFSIZE); *pos = '\0'; replace = pos + 1; search_size = strlen(search); replace_size = strlen(replace); pos = strstr(topicbuf, search); if (!pos) { command_fail(si, fault_badparams, _("Channel \2%s\2 does not have \2%s\2 in its topic."), chan, search); return; } copylen = strlen(pos + search_size) + 1; if (pos - topicbuf + replace_size + copylen > BUFSIZE) goto invalid_error; memmove(pos + search_size + (replace_size - search_size), pos + search_size, copylen); memcpy(pos, replace, replace_size); if (!validtopic(topicbuf)) { invalid_error: command_fail(si, fault_badparams, _("The new topic is invalid or too long.")); return; } if (si->su != NULL) topicsetter = si->su->nick; else if (si->smu != NULL) topicsetter = entity(si->smu)->name; else topicsetter = "unknown"; prevtopicts = c->topicts; handle_topic(c, topicsetter, CURRTIME, topicbuf); topic_sts(c, si->service->me, topicsetter, CURRTIME, prevtopicts, topicbuf); logcommand(si, CMDLOG_DO, "TOPICSWAP: \2%s\2", mc->name); if (si->su == NULL || !chanuser_find(c, si->su)) command_success_nodata(si, _("Topic set to \2%s\2 on \2%s\2."), c->topic, chan); }
/* SET EMAIL <new address> */ static void ns_cmd_set_email(sourceinfo_t *si, int parc, char *parv[]) { char *email = parv[0]; metadata_t *md; if (!email) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "EMAIL"); command_fail(si, fault_needmoreparams, _("Syntax: SET EMAIL <new e-mail>")); return; } if (si->smu->flags & MU_WAITAUTH) { command_fail(si, fault_noprivs, _("Please verify your original registration before changing your e-mail address.")); return; } if (!strcasecmp(si->smu->email, email)) { md = metadata_find(si->smu, "private:verify:emailchg:newemail"); if (md != NULL) { command_success_nodata(si, _("The email address change to \2%s\2 has been cancelled."), md->value); metadata_delete(si->smu, "private:verify:emailchg:key"); metadata_delete(si->smu, "private:verify:emailchg:newemail"); metadata_delete(si->smu, "private:verify:emailchg:timestamp"); } else command_fail(si, fault_nochange, _("The email address for account \2%s\2 is already set to \2%s\2."), entity(si->smu)->name, si->smu->email); return; } if (!validemail(email)) { command_fail(si, fault_badparams, _("\2%s\2 is not a valid email address."), email); return; } if (me.auth == AUTH_EMAIL) { unsigned long key = makekey(); metadata_add(si->smu, "private:verify:emailchg:key", number_to_string(key)); metadata_add(si->smu, "private:verify:emailchg:newemail", email); metadata_add(si->smu, "private:verify:emailchg:timestamp", number_to_string(CURRTIME)); if (!sendemail(si->su != NULL ? si->su : si->service->me, EMAIL_SETEMAIL, si->smu, number_to_string(key))) { command_fail(si, fault_emailfail, _("Sending email failed, sorry! Your email address is unchanged.")); metadata_delete(si->smu, "private:verify:emailchg:key"); metadata_delete(si->smu, "private:verify:emailchg:newemail"); metadata_delete(si->smu, "private:verify:emailchg:timestamp"); return; } logcommand(si, CMDLOG_SET, "SET:EMAIL: \2%s\2 (\2%s\2 -> \2%s\2) (awaiting verification)", entity(si->smu)->name, si->smu->email, email); command_success_nodata(si, _("An email containing email changing instructions has been sent to \2%s\2."), email); command_success_nodata(si, _("Your email address will not be changed until you follow these instructions.")); return; } myuser_set_email(si->smu, email); logcommand(si, CMDLOG_SET, "SET:EMAIL: \2%s\2 (\2%s\2 -> \2%s\2)", entity(si->smu)->name, si->smu->email, email); command_success_nodata(si, _("The email address for account \2%s\2 has been changed to \2%s\2."), entity(si->smu)->name, si->smu->email); }
static void ns_cmd_freeze(char *origin) { myuser_t *mu; user_t *source = user_find_named(origin); char *target = strtok(NULL, " "); char *action = strtok(NULL, " "); char *reason = strtok(NULL, ""); if (source == NULL) return; if (!target || !action) { notice(nicksvs.nick, origin, STR_INSUFFICIENT_PARAMS, "FREEZE"); notice(nicksvs.nick, origin, "Usage: FREEZE <username> <ON|OFF> [reason]"); return; } mu = myuser_find_ext(target); if (!mu) { notice(nicksvs.nick, origin, "\2%s\2 is not a registered nickname.", target); return; } if (!strcasecmp(action, "ON")) { if (!reason) { notice(nicksvs.nick, origin, STR_INSUFFICIENT_PARAMS, "FREEZE"); notice(nicksvs.nick, origin, "Usage: FREEZE <username> ON <reason>"); return; } if (is_soper(mu)) { notice(nicksvs.nick, origin, "The nickname \2%s\2 belongs to a services operator; it cannot be frozen.", target); return; } if (metadata_find(mu, METADATA_USER, "private:freeze:freezer")) { notice(nicksvs.nick, origin, "\2%s\2 is already frozen.", target); return; } metadata_add(mu, METADATA_USER, "private:freeze:freezer", origin); metadata_add(mu, METADATA_USER, "private:freeze:reason", reason); metadata_add(mu, METADATA_USER, "private:freeze:timestamp", itoa(CURRTIME)); wallops("%s froze the nickname \2%s\2 (%s).", origin, target, reason); logcommand(nicksvs.me, source, CMDLOG_ADMIN, "FREEZE %s ON", target); notice(nicksvs.nick, origin, "\2%s\2 is now frozen.", target); } else if (!strcasecmp(action, "OFF")) { if (!metadata_find(mu, METADATA_USER, "private:freeze:freezer")) { notice(nicksvs.nick, origin, "\2%s\2 is not frozen.", target); return; } metadata_delete(mu, METADATA_USER, "private:freeze:freezer"); metadata_delete(mu, METADATA_USER, "private:freeze:reason"); metadata_delete(mu, METADATA_USER, "private:freeze:timestamp"); wallops("%s thawed the nickname \2%s\2.", origin, target); logcommand(nicksvs.me, source, CMDLOG_ADMIN, "FREEZE %s OFF", target); notice(nicksvs.nick, origin, "\2%s\2 has been thawed", target); } else { notice(nicksvs.nick, origin, STR_INSUFFICIENT_PARAMS, "FREEZE"); notice(nicksvs.nick, origin, "Usage: FREEZE <account> <ON|OFF> [reason]"); } }
static void bs_cmd_set_nobot(sourceinfo_t *si, int parc, char *parv[]) { char *channel = parv[0]; char *option = parv[1]; mychan_t *mc; metadata_t *md; if (parc < 2 || !channel || !option) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET NOBOT"); command_fail(si, fault_needmoreparams, _("Syntax: SET <#channel> NOBOT {ON|OFF}")); return; } mc = mychan_find(channel); if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), channel); return; } if (metadata_find(mc, "private:frozen:freezer")) { command_fail(si, fault_noprivs, _("\2%s\2 is frozen."), mc->name); return; } if (!si->smu) { command_fail(si, fault_noprivs, _("You are not logged in.")); return; } if (!has_priv(si, PRIV_CHAN_ADMIN)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (!irccasecmp(option, "ON")) { metadata_add(mc, "private:botserv:no-bot", "ON"); if ((md = metadata_find(mc, "private:botserv:bot-assigned")) != NULL) { if (mc->flags & MC_GUARD && (!config_options.leave_chans || (mc->chan != NULL && MOWGLI_LIST_LENGTH(&mc->chan->members) > 1))) join(mc->name, chansvs.nick); part(mc->name, md->value); metadata_delete(mc, "private:botserv:bot-assigned"); metadata_delete(mc, "private:botserv:bot-handle-fantasy"); } logcommand(si, CMDLOG_SET, "SET:NOBOT:ON: \2%s\2", mc->name); command_success_nodata(si, _("No Bot mode is now \2ON\2 on channel %s."), mc->name); } else if(!irccasecmp(option, "OFF")) { metadata_delete(mc, "private:botserv:no-bot"); logcommand(si, CMDLOG_SET, "SET:NOBOT:OFF: \2%s\2", mc->name); command_success_nodata(si, _("No Bot mode is now \2OFF\2 on channel %s."), mc->name); } else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "SET NOBOT"); command_fail(si, fault_badparams, _("Syntax: SET <#channel> NOBOT {ON|OFF}")); } }
static bool is_marked(const mynick_t *mn, const void *arg) { myuser_t *mu = mn->owner; return !!metadata_find(mu, "private:mark:setter"); }
static void cs_cmd_kick(sourceinfo_t *si, int parc, char *parv[]) { char *chan = parv[0]; char *nick = parv[1]; char *reason = parv[2]; mychan_t *mc; user_t *tu; chanuser_t *cu; char reasonbuf[BUFSIZE]; if (!chan || !nick) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "KICK"); command_fail(si, fault_needmoreparams, _("Syntax: KICK <#channel> <nickname> [reason]")); return; } mc = mychan_find(chan); if (!mc) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan); return; } if (!chanacs_source_has_flag(mc, si, CA_REMOVE)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (metadata_find(mc, "private:close:closer")) { command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan); return; } /* figure out who we're going to kick */ if (!(tu = user_find_named(nick))) { command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick); return; } /* if target is a service, bail. --nenolod */ if (is_internal_client(tu)) return; cu = chanuser_find(mc->chan, tu); if (!cu) { command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name); return; } if (cu->modes & CSTATUS_OWNER || cu->modes & CSTATUS_PROTECT) { command_fail(si, fault_noprivs, _("\2%s\2 is protected from kicks; you cannot kick them."), tu->nick); return; } snprintf(reasonbuf, BUFSIZE, "(%s) %s", get_source_name(si), reason ? reason : "No reason given"); try_kick(chansvs.me->me, mc->chan, tu, reasonbuf); logcommand(si, CMDLOG_DO, "KICK: \2%s!%s@%s\2 from \2%s\2", tu->nick, tu->user, tu->vhost, mc->name); if (si->su != tu && !chanuser_find(mc->chan, si->su)) command_success_nodata(si, _("\2%s\2 has been kicked from \2%s\2."), tu->nick, mc->name); }
static void cs_cmd_set_guard(sourceinfo_t *si, int parc, char *parv[]) { mychan_t *mc; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (!parv[1]) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET GUARD"); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this command.")); return; } if (!strcasecmp("ON", parv[1])) { if (MC_GUARD & mc->flags) { command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "GUARD", mc->name); return; } if (metadata_find(mc, "private:botserv:bot-assigned") && module_find_published("botserv/main")) { command_fail(si, fault_noprivs, _("Channel \2%s\2 already has a BotServ bot assigned to it. You need to unassign it first."), mc->name); return; } logcommand(si, CMDLOG_SET, "SET:GUARD:ON: \2%s\2", mc->name); mc->flags |= MC_GUARD; if (!(mc->flags & MC_INHABIT)) join(mc->name, chansvs.nick); command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "GUARD", mc->name); return; } else if (!strcasecmp("OFF", parv[1])) { if (!(MC_GUARD & mc->flags)) { command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "GUARD", mc->name); return; } logcommand(si, CMDLOG_SET, "SET:GUARD:OFF: \2%s\2", mc->name); mc->flags &= ~MC_GUARD; if (mc->chan != NULL && !(mc->flags & MC_INHABIT) && !(mc->chan->flags & CHAN_LOG)) part(mc->name, chansvs.nick); command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "GUARD", mc->name); return; } else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "GUARD"); return; } }
static void cs_cmd_set_fantasy(sourceinfo_t *si, int parc, char *parv[]) { mychan_t *mc; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (!parv[1]) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET FANTASY"); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this command.")); return; } if (!strcasecmp("ON", parv[1])) { metadata_t *md = metadata_find(mc, "disable_fantasy"); if (!md) { command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "FANTASY", mc->name); return; } metadata_delete(mc, "disable_fantasy"); logcommand(si, CMDLOG_SET, "SET:FANTASY:ON: \2%s\2", mc->name); verbose(mc, _("\2%s\2 enabled the FANTASY flag"), get_source_name(si)); command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "FANTASY", mc->name); return; } else if (!strcasecmp("OFF", parv[1])) { metadata_t *md = metadata_find(mc, "disable_fantasy"); if (md) { command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "FANTASY", mc->name); return; } metadata_add(mc, "disable_fantasy", "on"); logcommand(si, CMDLOG_SET, "SET:FANTASY:OFF: \2%s\2", mc->name); verbose(mc, _("\2%s\2 disabled the FANTASY flag"), get_source_name(si)); command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "FANTASY", mc->name); return; } else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "FANTASY"); return; } }
static void cs_cmd_drop(sourceinfo_t *si, int parc, char *parv[]) { mychan_t *mc; char *name = parv[0]; char *key = parv[1]; char fullcmd[512]; char key0[80], key1[80]; if (!name) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DROP"); command_fail(si, fault_needmoreparams, _("Syntax: DROP <#channel>")); return; } if (*name != '#') { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "DROP"); command_fail(si, fault_badparams, _("Syntax: DROP <#channel>")); return; } if (!(mc = mychan_find(name))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), name); return; } if (si->c != NULL) { command_fail(si, fault_noprivs, _("For security reasons, you may not drop a channel registration with a fantasy command.")); return; } if (!is_founder(mc, entity(si->smu))) { command_fail(si, fault_noprivs, _("You are not authorized to perform this operation.")); return; } if (metadata_find(mc, "private:close:closer")) { logcommand(si, CMDLOG_REGISTER, "DROP: \2%s\2 failed to drop (closed)", mc->name); command_fail(si, fault_noprivs, _("The channel \2%s\2 is closed; it cannot be dropped."), mc->name); return; } if (mc->flags & MC_HOLD) { command_fail(si, fault_noprivs, _("The channel \2%s\2 is held; it cannot be dropped."), mc->name); return; } if (si->su != NULL) { if (!key) { create_challenge(si, mc->name, 0, key0); snprintf(fullcmd, sizeof fullcmd, "/%s%s DROP %s %s", (ircd->uses_rcommand == false) ? "msg " : "", chansvs.me->disp, mc->name, key0); command_success_nodata(si, _("To avoid accidental use of this command, this operation has to be confirmed. Please confirm by replying with \2%s\2"), fullcmd); return; } /* accept current and previous key */ create_challenge(si, mc->name, 0, key0); create_challenge(si, mc->name, 1, key1); if (strcmp(key, key0) && strcmp(key, key1)) { command_fail(si, fault_badparams, _("Invalid key for %s."), "DROP"); return; } } logcommand(si, CMDLOG_REGISTER, "DROP: \2%s\2", mc->name); hook_call_channel_drop(mc); if (mc->chan != NULL && !(mc->chan->flags & CHAN_LOG)) part(mc->name, chansvs.nick); object_unref(mc); command_success_nodata(si, _("The channel \2%s\2 has been dropped."), name); return; }
static void ns_cmd_restrict(sourceinfo_t *si, int parc, char *parv[]) { char *target = parv[0]; char *action = parv[1]; char *info = parv[2]; myuser_t *mu; myuser_name_t *mun; if (!target || !action) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "RESTRICT"); command_fail(si, fault_needmoreparams, _("Usage: RESTRICT <target> <ON|OFF> [note]")); return; } if (!(mu = myuser_find_ext(target))) { mun = myuser_name_find(target); if (mun != NULL && !strcasecmp(action, "OFF")) { object_unref(mun); wallops("%s unrestricted the name \2%s\2.", get_oper_name(si), target); logcommand(si, CMDLOG_ADMIN, "RESTRICT:OFF: \2%s\2", target); command_success_nodata(si, _("\2%s\2 is now unrestricted."), target); return; } command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), target); return; } if (!strcasecmp(action, "ON")) { if (!info) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "RESTRICT"); command_fail(si, fault_needmoreparams, _("Usage: RESTRICT <target> ON <note>")); return; } if (metadata_find(mu, "private:restrict:setter")) { command_fail(si, fault_badparams, _("\2%s\2 is already restricted."), entity(mu)->name); return; } metadata_add(mu, "private:restrict:setter", get_oper_name(si)); metadata_add(mu, "private:restrict:reason", info); metadata_add(mu, "private:restrict:timestamp", number_to_string(time(NULL))); wallops("%s restricted the account \2%s\2.", get_oper_name(si), entity(mu)->name); logcommand(si, CMDLOG_ADMIN, "RESTRICT:ON: \2%s\2 (reason: \2%s\2)", entity(mu)->name, info); command_success_nodata(si, _("\2%s\2 is now restricted."), entity(mu)->name); } else if (!strcasecmp(action, "OFF")) { if (!metadata_find(mu, "private:restrict:setter")) { command_fail(si, fault_badparams, _("\2%s\2 is not restricted."), entity(mu)->name); return; } metadata_delete(mu, "private:restrict:setter"); metadata_delete(mu, "private:restrict:reason"); metadata_delete(mu, "private:restrict:timestamp"); wallops("%s unrestricted the account \2%s\2.", get_oper_name(si), entity(mu)->name); logcommand(si, CMDLOG_ADMIN, "RESTRICT:OFF: \2%s\2", entity(mu)->name); command_success_nodata(si, _("\2%s\2 is now unrestricted."), entity(mu)->name); } else { command_fail(si, fault_needmoreparams, STR_INVALID_PARAMS, "RESTRICT"); command_fail(si, fault_needmoreparams, _("Usage: RESTRICT <target> <ON|OFF> [note]")); } }
static void cs_cmd_register(struct sourceinfo *si, int parc, char *parv[]) { struct channel *c; struct chanuser *cu; struct mychan *mc; char *name = parv[0]; char str[21]; hook_channel_register_check_t hdatac; hook_channel_req_t hdata; unsigned int fl; /* This command is not useful on registered channels, ignore it if * it is a fantasy command so users can program bots to react on * it without interference from ChanServ. */ if (si->c != NULL) return; if (!name) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "REGISTER"); command_fail(si, fault_needmoreparams, _("To register a channel: REGISTER <#channel>")); return; } if (*name != '#') { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "REGISTER"); command_fail(si, fault_badparams, _("Syntax: REGISTER <#channel>")); return; } if (si->smu->flags & MU_WAITAUTH) { command_fail(si, fault_notverified, _("You need to verify your email address before you may register channels.")); return; } // make sure it isn't already registered if ((mc = mychan_find(name))) { if (! (mc->flags & MC_PRIVATE)) command_fail(si, fault_alreadyexists, _("\2%s\2 is already registered to \2%s\2."), mc->name, mychan_founder_names(mc)); else command_fail(si, fault_alreadyexists, _("\2%s\2 is already registered."), mc->name); return; } // make sure the channel exists if (!(c = channel_find(name))) { command_fail(si, fault_nosuch_target, _("The channel \2%s\2 must exist in order to register it."), name); return; } // make sure they're in it if (!(cu = chanuser_find(c, si->su))) { command_fail(si, fault_noprivs, _("You must be in \2%s\2 in order to register it."), name); return; } // make sure they're opped (or protected/owner on unreal/inspircd) if (!((CSTATUS_OP | CSTATUS_PROTECT | CSTATUS_OWNER) & cu->modes)) { command_fail(si, fault_noprivs, _("You must be a channel operator in \2%s\2 in order to register it."), name); return; } if (metadata_find(si->smu, "private:restrict:setter")) { command_fail(si, fault_noprivs, _("You have been restricted from registering channels by network staff.")); return; } if ((unsigned int)(CURRTIME - ratelimit_firsttime) > config_options.ratelimit_period) { ratelimit_count = 0; ratelimit_firsttime = CURRTIME; } if (ratelimit_count > config_options.ratelimit_uses && !has_priv(si, PRIV_FLOOD)) { command_fail(si, fault_toomany, _("The system is currently too busy to process your registration, please try again later.")); slog(LG_INFO, "CHANSERV:REGISTER:THROTTLED: \2%s\2 by \2%s\2", name, entity(si->smu)->name); return; } hdatac.si = si; hdatac.name = name; hdatac.chan = c; hdatac.approved = 0; hook_call_channel_can_register(&hdatac); if (hdatac.approved != 0) return; if (!myentity_can_register_channel(entity(si->smu))) { command_fail(si, fault_toomany, _("You have too many channels registered.")); return; } if (config_options.ratelimit_uses && config_options.ratelimit_period) ratelimit_count++; logcommand(si, CMDLOG_REGISTER, "REGISTER: \2%s\2", name); mc = mychan_add(name); mc->registered = CURRTIME; mc->used = CURRTIME; mc->mlock_on |= (CMODE_NOEXT | CMODE_TOPIC); if (c->limit == 0) mc->mlock_off |= CMODE_LIMIT; if (c->key == NULL) mc->mlock_off |= CMODE_KEY; mc->flags |= config_options.defcflags; chanacs_add(mc, entity(si->smu), custom_founder_check(), CURRTIME, entity(si->smu)); if (c->ts > 0) { snprintf(str, sizeof str, "%lu", (unsigned long)c->ts); metadata_add(mc, "private:channelts", str); } if (chansvs.deftemplates != NULL && *chansvs.deftemplates != '\0') metadata_add(mc, "private:templates", chansvs.deftemplates); command_success_nodata(si, _("\2%s\2 is now registered to \2%s\2."), mc->name, entity(si->smu)->name); hdata.si = si; hdata.mc = mc; hook_call_channel_register(&hdata); // Allow the hook to override this. fl = chanacs_source_flags(mc, si); cu = chanuser_find(mc->chan, si->su); if (cu == NULL) ; else if (ircd->uses_owner && fl & CA_USEOWNER && fl & CA_AUTOOP && !(cu->modes & CSTATUS_OWNER)) { modestack_mode_param(si->service->nick, mc->chan, MTYPE_ADD, ircd->owner_mchar[1], CLIENT_NAME(si->su)); cu->modes |= CSTATUS_OWNER; } else if (ircd->uses_protect && fl & CA_USEPROTECT && fl & CA_AUTOOP && !(cu->modes & CSTATUS_PROTECT)) { modestack_mode_param(si->service->nick, mc->chan, MTYPE_ADD, ircd->protect_mchar[1], CLIENT_NAME(si->su)); cu->modes |= CSTATUS_PROTECT; } }
static void gs_cmd_info(sourceinfo_t *si, int parc, char *parv[]) { mygroup_t *mg; struct tm tm; char buf[BUFSIZE], strfbuf[BUFSIZE]; metadata_t *md; if (!parv[0]) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "INFO"); command_fail(si, fault_needmoreparams, _("Syntax: INFO <!groupname>")); return; } if (!(mg = mygroup_find(parv[0]))) { command_fail(si, fault_alreadyexists, _("Group \2%s\2 does not exist."), parv[0]); return; } tm = *localtime(&mg->regtime); strftime(strfbuf, sizeof strfbuf, TIME_FORMAT, &tm); command_success_nodata(si, _("Information for \2%s\2:"), parv[0]); command_success_nodata(si, _("Registered : %s (%s ago)"), strfbuf, time_ago(mg->regtime)); if (config_options.show_entity_id || has_priv(si, PRIV_GROUP_AUSPEX)) command_success_nodata(si, _("Entity ID : %s"), entity(mg)->id); if (mg->flags & MG_PUBLIC || (si->smu != NULL && groupacs_sourceinfo_has_flag(mg, si, 0) && !groupacs_sourceinfo_has_flag(mg, si, GA_BAN)) || has_priv(si, PRIV_GROUP_AUSPEX)) command_success_nodata(si, _("Founder : %s"), mygroup_founder_names(mg)); if ((md = metadata_find(mg, "description"))) command_success_nodata(si, _("Description : %s"), md->value); if ((md = metadata_find(mg, "channel"))) command_success_nodata(si, _("Channel : %s"), md->value); if ((md = metadata_find(mg, "url"))) command_success_nodata(si, _("URL : %s"), md->value); if ((md = metadata_find(mg, "email"))) command_success_nodata(si, _("Email : %s"), md->value); *buf = '\0'; if (mg->flags & MG_REGNOLIMIT) mowgli_strlcat(buf, "REGNOLIMIT", BUFSIZE); if (mg->flags & MG_ACSNOLIMIT) { if (*buf) mowgli_strlcat(buf, " ", BUFSIZE); mowgli_strlcat(buf, "ACSNOLIMIT", BUFSIZE); } if (mg->flags & MG_OPEN) { if (*buf) mowgli_strlcat(buf, " ", BUFSIZE); mowgli_strlcat(buf, "OPEN", BUFSIZE); } if (mg->flags & MG_PUBLIC) { if (*buf) mowgli_strlcat(buf, " ", BUFSIZE); mowgli_strlcat(buf, "PUBLIC", BUFSIZE); } if (*buf) command_success_nodata(si, _("Flags : %s"), buf); command_success_nodata(si, _("\2*** End of Info ***\2")); logcommand(si, CMDLOG_GET, "INFO: \2%s\2", parv[0]); }
static void cs_cmd_set_topiclock(sourceinfo_t *si, int parc, char *parv[]) { mychan_t *mc; if (!(mc = mychan_find(parv[0]))) { command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]); return; } if (metadata_find(mc, "private:frozen:freezer")) { command_fail(si, fault_noprivs, _("\2%s\2 is frozen."), parv[0]); return; } if (!parv[1]) { command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET TOPICLOCK"); return; } if (!chanacs_source_has_flag(mc, si, CA_SET)) { command_fail(si, fault_noprivs, _("You are not authorized to perform this command.")); return; } if (!strcasecmp("ON", parv[1])) { if (MC_TOPICLOCK & mc->flags) { command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "TOPICLOCK", mc->name); return; } logcommand(si, CMDLOG_SET, "SET:TOPICLOCK:ON: \2%s\2", mc->name); mc->flags |= MC_KEEPTOPIC | MC_TOPICLOCK; topiclock_sts(mc->chan); command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "TOPICLOCK", mc->name); return; } else if (!strcasecmp("OFF", parv[1])) { if (!(MC_TOPICLOCK & mc->flags)) { command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "TOPICLOCK", mc->name); return; } logcommand(si, CMDLOG_SET, "SET:TOPICLOCK:OFF: \2%s\2", mc->name); mc->flags &= ~MC_TOPICLOCK; topiclock_sts(mc->chan); command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "TOPICLOCK", mc->name); return; } else { command_fail(si, fault_badparams, STR_INVALID_PARAMS, "TOPICLOCK"); return; } }