static void ns_cmd_status(sourceinfo_t *si, int parc, char *parv[])
{
logcommand(si, CMDLOG_GET, "STATUS");
if (!si->smu)
command_success_nodata(si, _("You are not logged in."));
else
{
command_success_nodata(si, _("You are logged in as \2%s\2."), entity(si->smu)->name);
if (is_soper(si->smu))
{
soper_t *soper = si->smu->soper;
command_success_nodata(si, _("You are a services operator of class %s."), soper->operclass ? soper->operclass->name : soper->classname);
}
}
if (si->su != NULL)
{
mynick_t *mn;
mn = mynick_find(si->su->nick);
if (mn != NULL && mn->owner != si->smu &&
myuser_access_verify(si->su, mn->owner))
command_success_nodata(si, _("You are recognized as \2%s\2."), entity(mn->owner)->name);
}
if (si->su != NULL && is_admin(si->su))
command_success_nodata(si, _("You are a server administrator."));
if (si->su != NULL && is_ircop(si->su))
command_success_nodata(si, _("You are an IRC operator."));
}
static void ns_cmd_status(char *origin)
{
user_t *u = user_find_named(origin);
logcommand(nicksvs.me, u, CMDLOG_GET, "STATUS");
if (!u->myuser)
{
notice(nicksvs.nick, origin, "You are not logged in.");
return;
}
notice(nicksvs.nick, origin, "You are logged in as \2%s\2.", u->myuser->name);
if (is_soper(u->myuser))
{
operclass_t *operclass;
operclass = u->myuser->soper->operclass;
if (operclass == NULL)
notice(nicksvs.nick, origin, "You are a services root administrator.");
else
notice(nicksvs.nick, origin, "You are a services operator of class %s.", operclass->name);
}
if (is_admin(u))
notice(nicksvs.nick, origin, "You are a server administrator.");
if (is_ircop(u))
notice(nicksvs.nick, origin, "You are an IRC operator.");
}
static void os_cmd_identify(sourceinfo_t *si, int parc, char *parv[])
{
/* XXX use this with authcookie also */
if (si->su == NULL)
{
command_fail(si, fault_noprivs, _("\2%s\2 can only be executed via IRC."), "IDENTIFY");
return;
}
if (parc < 1)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "IDENTIFY");
command_fail(si, fault_needmoreparams, _("Syntax: IDENTIFY <password>"));
return;
}
if (si->smu == NULL)
{
command_fail(si, fault_noprivs, _("You are not logged in."));
return;
}
if (!is_soper(si->smu))
{
command_fail(si, fault_noprivs, _("You do not have a services operator account."));
return;
}
if (si->smu->soper->password == NULL)
{
command_fail(si, fault_nochange, _("Your services operator account does not have a password set."));
return;
}
if (si->su->flags & UF_SOPER_PASS)
{
command_fail(si, fault_nochange, _("You are already identified to %s."), si->service->nick);
return;
}
if (!verify_operserv_password(si->smu->soper, parv[0]))
{
command_fail(si, fault_authfail, _("Invalid password."));
logcommand(si, CMDLOG_ADMIN, "failed IDENTIFY (bad password)");
return;
}
si->su->flags |= UF_SOPER_PASS;
command_success_nodata(si, _("You are now identified to %s."),
si->service->nick);
logcommand(si, CMDLOG_ADMIN, "IDENTIFY");
}
static void ns_cmd_fdrop(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
mynick_t *mn;
char *acc = parv[0];
if (!acc)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "FDROP");
command_fail(si, fault_needmoreparams, _("Syntax: FDROP <account>"));
return;
}
if (!(mu = myuser_find(acc)))
{
if (!nicksvs.no_nick_ownership)
{
mn = mynick_find(acc);
if (mn != NULL && command_find(si->service->cmdtree, "FUNGROUP"))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is a grouped nick, use %s to remove it."), acc, "FUNGROUP");
return;
}
}
command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), acc);
return;
}
if (is_soper(mu))
{
command_fail(si, fault_noprivs, _("The nickname \2%s\2 belongs to a services operator; it cannot be dropped."), acc);
return;
}
if (mu->flags & MU_HOLD)
{
command_fail(si, fault_noprivs, _("The account \2%s\2 is held; it cannot be dropped."), acc);
return;
}
wallops("%s dropped the account \2%s\2", get_oper_name(si), mu->name);
snoop("FDROP: \2%s\2 by \2%s\2", mu->name, get_oper_name(si));
logcommand(si, CMDLOG_ADMIN | LG_REGISTER, "FDROP %s", mu->name);
hook_call_user_drop(mu);
command_success_nodata(si, _("The account \2%s\2 has been dropped."), mu->name);
object_unref(mu);
}
/*
* atheme.privset
*
* XML inputs:
* authcookie, account name, source ip
*
* XML outputs:
* depends on command
*
* Side Effects:
* command is executed
*/
static int xmlrpcmethod_privset(void *conn, int parc, char *parv[])
{
myuser_t *mu;
int i;
for (i = 0; i < parc; i++)
{
if (strchr(parv[i], '\r') || strchr(parv[i], '\n'))
{
xmlrpc_generic_error(fault_badparams, "Invalid parameters.");
return 0;
}
}
if (parc < 2)
{
xmlrpc_generic_error(fault_needmoreparams, "Insufficient parameters.");
return 0;
}
if (*parv[1] != '\0' && strlen(parv[0]) > 1)
{
if ((mu = myuser_find(parv[1])) == NULL)
{
xmlrpc_generic_error(fault_nosuch_source, "Unknown user.");
return 0;
}
if (authcookie_validate(parv[0], mu) == false)
{
xmlrpc_generic_error(fault_badauthcookie, "Invalid authcookie for this account.");
return 0;
}
}
else
mu = NULL;
if (mu == NULL || !is_soper(mu))
{
/* no privileges */
xmlrpc_send_string("");
return 0;
}
xmlrpc_send_string(mu->soper->operclass->privs);
return 0;
}
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 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 ns_cmd_register(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
mynick_t *mn = NULL;
mowgli_node_t *n;
const char *account;
const char *pass;
const char *email;
char lau[BUFSIZE], lao[BUFSIZE];
hook_user_register_check_t hdata;
hook_user_req_t req;
if (si->smu)
{
command_fail(si, fault_already_authed, _("You are already logged in as \2%s\2."), entity(si->smu)->name);
if (si->su != NULL && !mynick_find(si->su->nick) &&
command_find(si->service->commands, "GROUP"))
command_fail(si, fault_already_authed, _("Use %s to register %s to your account."), "GROUP", si->su->nick);
return;
}
if (nicksvs.no_nick_ownership || si->su == NULL)
account = parv[0], pass = parv[1], email = parv[2];
else
account = si->su->nick, pass = parv[0], email = parv[1];
if (!account || !pass || !email)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "REGISTER");
if (nicksvs.no_nick_ownership || si->su == NULL)
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <account> <password> <email>"));
else
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <password> <email>"));
return;
}
if (strlen(pass) >= PASSLEN)
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "REGISTER");
command_fail(si, fault_badparams, _("Registration passwords may not be longer than \2%d\2 characters."), PASSLEN - 1);
return;
}
if (!nicksvs.no_nick_ownership && si->su == NULL && user_find_named(account))
{
command_fail(si, fault_noprivs, _("A user matching this account is already on IRC."));
return;
}
if (!nicksvs.no_nick_ownership && IsDigit(*account))
{
command_fail(si, fault_badparams, _("For security reasons, you can't register your UID."));
command_fail(si, fault_badparams, _("Please change to a real nickname, and try again."));
return;
}
if (nicksvs.no_nick_ownership || si->su == NULL)
{
if (strchr(account, ' ') || strchr(account, '\n') || strchr(account, '\r') || account[0] == '=' || account[0] == '#' || account[0] == '@' || account[0] == '+' || account[0] == '%' || account[0] == '!' || strchr(account, ','))
{
command_fail(si, fault_badparams, _("The account name \2%s\2 is invalid."), account);
return;
}
}
if (strlen(account) >= NICKLEN)
{
command_fail(si, fault_badparams, _("The account name \2%s\2 is invalid."), account);
return;
}
if ((si->su != NULL && !strcasecmp(pass, si->su->nick)) || !strcasecmp(pass, account))
{
command_fail(si, fault_badparams, _("You cannot use your nickname as a password."));
if (nicksvs.no_nick_ownership || si->su == NULL)
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <account> <password> <email>"));
else
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <password> <email>"));
return;
}
/* make sure it isn't registered already */
if (nicksvs.no_nick_ownership ? myuser_find(account) != NULL : mynick_find(account) != NULL)
{
command_fail(si, fault_alreadyexists, _("\2%s\2 is already registered."), account);
return;
}
if ((unsigned int)(CURRTIME - ratelimit_firsttime) > config_options.ratelimit_period)
ratelimit_count = 0, ratelimit_firsttime = CURRTIME;
/* Still do flood priv checking because the user may be in the ircop operclass */
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, "NICKSERV:REGISTER:THROTTLED: \2%s\2 by \2%s\2", account, si->su != NULL ? si->su->nick : get_source_name(si));
return;
}
hdata.si = si;
hdata.account = account;
hdata.email = email;
hdata.password = pass;
hdata.approved = 0;
hook_call_user_can_register(&hdata);
if (hdata.approved != 0)
return;
if (!nicksvs.no_nick_ownership)
{
hook_call_nick_can_register(&hdata);
if (hdata.approved != 0)
return;
}
if (!validemail(email))
{
command_fail(si, fault_badparams, _("\2%s\2 is not a valid email address."), email);
return;
}
if (!email_within_limits(email))
{
command_fail(si, fault_toomany, _("\2%s\2 has too many accounts registered."), email);
return;
}
mu = myuser_add(account, auth_module_loaded ? "*" : pass, email, config_options.defuflags | MU_NOBURSTLOGIN | (auth_module_loaded ? MU_CRYPTPASS : 0));
mu->registered = CURRTIME;
mu->lastlogin = CURRTIME;
if (!nicksvs.no_nick_ownership)
{
mn = mynick_add(mu, entity(mu)->name);
mn->registered = CURRTIME;
mn->lastseen = CURRTIME;
}
if (config_options.ratelimit_uses && config_options.ratelimit_period)
ratelimit_count++;
if (auth_module_loaded)
{
if (!verify_password(mu, pass))
{
command_fail(si, fault_authfail, _("Invalid password for \2%s\2."), entity(mu)->name);
bad_password(si, mu);
object_unref(mu);
return;
}
}
if (me.auth == AUTH_EMAIL)
{
char *key = random_string(12);
mu->flags |= MU_WAITAUTH;
metadata_add(mu, "private:verify:register:key", key);
metadata_add(mu, "private:verify:register:timestamp", number_to_string(time(NULL)));
if (!sendemail(si->su != NULL ? si->su : si->service->me, mu, EMAIL_REGISTER, mu->email, key))
{
command_fail(si, fault_emailfail, _("Sending email failed, sorry! Registration aborted."));
object_unref(mu);
free(key);
return;
}
command_success_nodata(si, _("An email containing nickname activation instructions has been sent to \2%s\2."), mu->email);
command_success_nodata(si, _("If you do not complete registration within one day, your nickname will expire."));
free(key);
}
if (si->su != NULL)
{
si->su->myuser = mu;
n = mowgli_node_create();
mowgli_node_add(si->su, n, &mu->logins);
if (!(mu->flags & MU_WAITAUTH))
/* only grant ircd registered status if it's verified */
ircd_on_login(si->su, mu, NULL);
}
command_add_flood(si, FLOOD_MODERATE);
if (!nicksvs.no_nick_ownership && si->su != NULL)
logcommand(si, CMDLOG_REGISTER, "REGISTER: \2%s\2 to \2%s\2", account, email);
else
logcommand(si, CMDLOG_REGISTER, "REGISTER: \2%s\2 to \2%s\2 by \2%s\2", account, email, si->su != NULL ? si->su->nick : get_source_name(si));
if (is_soper(mu))
{
wallops("%s registered the nick \2%s\2 and gained services operator privileges.", get_oper_name(si), entity(mu)->name);
logcommand(si, CMDLOG_ADMIN, "SOPER: \2%s\2 as \2%s\2", get_oper_name(si), entity(mu)->name);
}
command_success_nodata(si, _("\2%s\2 is now registered to \2%s\2, with the password \2%s\2."), entity(mu)->name, mu->email, pass);
hook_call_user_register(mu);
if (si->su != NULL)
{
snprintf(lau, BUFSIZE, "%s@%s", si->su->user, si->su->vhost);
metadata_add(mu, "private:host:vhost", lau);
snprintf(lao, BUFSIZE, "%s@%s", si->su->user, si->su->host);
metadata_add(mu, "private:host:actual", lao);
}
if (!(mu->flags & MU_WAITAUTH))
{
req.si = si;
req.mu = mu;
req.mn = mn;
hook_call_user_verify_register(&req);
}
}
/* s = service the command was sent to
u = user the command was sent from */
void cs_info(IRC_User *s, IRC_User *u)
{
ChanRecord* cr;
char buf[64];
struct tm *tm;
char *target = strtok(NULL, " ");
IRC_Chan *chan;
u_int32_t source_snid = u->snid;
if(NeedsAuth && !IsAuthenticated(u))
send_lang(u, s, NEEDS_AUTH_NICK);
else
if(IsNull(target))
send_lang(u, s, CHAN_INFO_SYNTAX);
else
if((cr = OpenCR(target)) == NULL)
send_lang(u, s, CHAN_X_NOT_REGISTERED, target);
else /* everything is valid */
{
int sadmin = (is_soper(source_snid) != 0);
send_lang(u, s, CHAN_INFO_HEADER);
if(sadmin)
send_lang(u, s, CHAN_SCID, cr->scid);
send_lang(u, s, CHAN_NAME, target);
if(IsPrivateChan(cr) && !sadmin &&
((source_snid == 0) || (source_snid && source_snid != cr->founder)))
send_lang(u, s, CHAN_INFO_PRIVATE, target);
else
{
if(cr->cdesc)
send_lang(u, s, CHAN_DESC, cr->cdesc);
if(sql_singlequery("SELECT nick FROM nickserv WHERE snid=%d",
cr->founder))
send_lang(u, s, CHAN_FOUNDER_X, sql_field(0));
if(sql_singlequery("SELECT nick FROM nickserv WHERE snid=%d",
cr->successor))
send_lang(u, s, CHAN_SUCCESSOR_X, sql_field(0));
tm = localtime(&cr->t_reg);
strftime(buf, sizeof(buf), format_str(u, INFO_DATE_FORMAT), tm);
send_lang(u, s, CHAN_REGDATE_X_X, buf, ago_time(cr->t_reg, u ));
tm = localtime(&cr->t_last_use);
strftime(buf, sizeof(buf), format_str(u, INFO_DATE_FORMAT), tm);
send_lang(u, s, CHAN_LAST_USE_X_X, buf, ago_time(cr->t_last_use, u ));
if(!IsNull(cr->email))
send_lang(u, s, CHAN_EMAIL, cr->email);
if(!IsNull(cr->url))
send_lang(u, s, CHAN_URL, cr->url);
if(!IsNull(cr->entrymsg))
send_lang(u, s, CHAN_ENTRYMSG, cr->entrymsg);
if(!IsNull(cr->last_topic))
send_lang(u, s, CHAN_TOPIC_X, cr->last_topic);
if(!IsNull(cr->last_topic_setter))
send_lang(u, s, CHAN_TOPIC_SETTER_X, cr->last_topic_setter);
chan = irc_FindChan(target);
if(chan && chan->users_count)
send_lang(u, s, CHAN_CURRUSERS_X, chan ? chan->users_count : 0);
tm = localtime(&cr->t_maxusers);
strftime(buf, sizeof(buf), format_str(u, INFO_DATE_FORMAT), tm);
send_lang(u, s, CHAN_USERS_REC_X_X_X, cr->maxusers,
buf, ago_time(cr->t_maxusers, u));
if((sadmin || (source_snid == cr->founder))
&& cr->mlock && cr->mlock[0])
send_lang(u, s, CHAN_MLOCK_X, cr->mlock);
if(cr->flags && (sadmin || (source_snid == cr->founder)))
send_lang(u, s, CHAN_OPTIONS_X,
mask_string(options_mask, cr->flags));
if(cr->flags & NFL_SUSPENDED)
{
MYSQL_RES *res;
MYSQL_ROW row;
res = sql_query("SELECT t_when, duration, reason "
"FROM chanserv_suspensions WHERE scid=%d", cr->scid);
if(res && (row = sql_next_row(res)))
{
time_t t_when = atoi(row[0]);
int remaining = -1;
if(atoi(row[1]) != 0)
{
remaining = atoi(row[1]) - (irc_CurrentTime - t_when);
remaining /= 24*3600;
remaining++;
if(remaining < 0)
remaining = 0;
}
tm = localtime(&t_when);
strftime(buf, sizeof(buf), format_str(u, DATE_FORMAT), tm);
if(remaining == -1)
send_lang(u,s, CS_INFO_SUSPENDED_X_FOREVER, buf);
else
send_lang(u,s, CS_INFO_SUSPENDED_X_X, buf, remaining);
send_lang(u,s, CS_INFO_SUSPENDED_REASON, row[2]);
}
sql_free(res);
}
send_lang(u, s, CHAN_INFO_TAIL);
}
CloseCR(cr);
}
}
static void ns_cmd_drop(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
mynick_t *mn;
char *acc = parv[0];
char *pass = parv[1];
if (!acc || !pass)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DROP");
command_fail(si, fault_needmoreparams, _("Syntax: DROP <account> <password>"));
return;
}
if (!(mu = myuser_find(acc)))
{
if (!nicksvs.no_nick_ownership)
{
mn = mynick_find(acc);
if (mn != NULL && command_find(si->service->cmdtree, "UNGROUP"))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is a grouped nick, use %s to remove it."), acc, "UNGROUP");
return;
}
}
command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), acc);
return;
}
if (metadata_find(mu, "private:freeze:freezer"))
{
command_fail(si, fault_authfail, nicksvs.no_nick_ownership ? "You cannot login as \2%s\2 because the account has been frozen." : "You cannot identify to \2%s\2 because the nickname has been frozen.", mu->name);
return;
}
if (!verify_password(mu, pass))
{
command_fail(si, fault_authfail, _("Authentication failed. Invalid password for \2%s\2."), mu->name);
bad_password(si, mu);
return;
}
if (!nicksvs.no_nick_ownership &&
LIST_LENGTH(&mu->nicks) > 1 &&
command_find(si->service->cmdtree, "UNGROUP"))
{
command_fail(si, fault_noprivs, _("Account \2%s\2 has %d other nick(s) grouped to it, remove those first."),
mu->name, LIST_LENGTH(&mu->nicks) - 1);
return;
}
if (is_soper(mu))
{
command_fail(si, fault_noprivs, _("The nickname \2%s\2 belongs to a services operator; it cannot be dropped."), acc);
return;
}
if (mu->flags & MU_HOLD)
{
command_fail(si, fault_noprivs, _("The account \2%s\2 is held; it cannot be dropped."), acc);
return;
}
snoop("DROP: \2%s\2 by \2%s\2", mu->name, get_source_name(si));
command_add_flood(si, FLOOD_MODERATE);
logcommand(si, CMDLOG_REGISTER, "DROP %s", mu->name);
hook_call_user_drop(mu);
command_success_nodata(si, _("The account \2%s\2 has been dropped."), mu->name);
object_unref(mu);
}
static void cs_cmd_status(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
if (chan)
{
mychan_t *mc = mychan_find(chan);
unsigned int flags;
if (*chan != '#')
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "STATUS");
return;
}
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
logcommand(si, CMDLOG_GET, "STATUS: \2%s\2", mc->name);
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
flags = chanacs_source_flags(mc, si);
if (flags & CA_AKICK && !(flags & CA_EXEMPT))
command_success_nodata(si, _("You are banned from \2%s\2."), mc->name);
else if (flags != 0)
{
command_success_nodata(si, _("You have access flags \2%s\2 on \2%s\2."), bitmask_to_flags(flags), mc->name);
}
else
command_success_nodata(si, _("You have no special access to \2%s\2."), mc->name);
return;
}
logcommand(si, CMDLOG_GET, "STATUS");
if (!si->smu)
command_success_nodata(si, _("You are not logged in."));
else
{
command_success_nodata(si, _("You are logged in as \2%s\2."), entity(si->smu)->name);
if (is_soper(si->smu))
{
soper_t *soper = si->smu->soper;
command_success_nodata(si, _("You are a services operator of class %s."), soper->operclass ? soper->operclass->name : soper->classname);
}
}
if (si->su != NULL)
{
mynick_t *mn;
mn = mynick_find(si->su->nick);
if (mn != NULL && mn->owner != si->smu &&
myuser_access_verify(si->su, mn->owner))
command_success_nodata(si, _("You are recognized as \2%s\2."), entity(mn->owner)->name);
}
if (si->su != NULL && is_admin(si->su))
command_success_nodata(si, _("You are a server administrator."));
if (si->su != NULL && is_ircop(si->su))
command_success_nodata(si, _("You are an IRC operator."));
}
/** internal functions implementation starts here **/
void os_sline(IRC_User *s, IRC_User *u)
{
u_int32_t source_snid;
char *cmd;
/* status validation */
CHECK_IF_IDENTIFIED_NICK
if (!is_soper(u->snid))
{
send_lang(u, s, PERMISSION_DENIED);
return;
}
/* syntax validation */
cmd = strtok(NULL, " ");
if(IsNull(cmd))
send_lang(u, s, SLINE_SYNTAX);
/* sub-command */
else if(strcasecmp(cmd, "ADD") == 0)
{
u_int32_t id;
char* letter = strtok(NULL, " ");
char* mask = strtok(NULL, " ");
char* message = strtok(NULL, "");
if(letter)
letter[0] = toupper(letter[0]);
if(letter && strlen(letter)>1)
letter[1] = '\0';
if(mask && strlen(mask)>128)
letter[128] = '\0';
if(message && strlen(message)>128)
message[128] = '\0';
/* syntax validation */
if(IsNull(letter) || IsNull(mask) || IsNull(message))
send_lang(u, s, SLINE_SYNTAX);
/* avoid duplicates */
else if(find_sline(*letter, mask) > 0)
send_lang(u, s, SLINE_ALREADY_EXISTS_X_X, *letter, mask);
/* execute operation */
else if((id = insert_sline(u->nick ,*letter, mask, message)) != 0)
{
send_lang(u, s, ADDED_SLINE_X_X, *letter, id);
irc_SendRaw(NULL, "S%cLINE %s :%s", *letter, mask, message);
}
else
send_lang(u, s, UPDATE_FAIL);
}
/* sub-command */
else if(strcasecmp(cmd, "DEL") == 0)
{
u_int32_t id = 0;
char *strid;
strid = strtok(NULL, " ");
if(strid)
id = atoi(strid);
/* syntax validation */
if(IsNull(strid))
send_lang(u, s, SLINE_SYNTAX);
else if(sql_singlequery("SELECT id, letter, mask FROM os_sline WHERE id=%d", id) == 0)
send_lang(u, s, SLINE_X_NOT_FOUND, id);
/* execute operation */
else if(sql_execute("DELETE FROM os_sline WHERE id=%d", id) > 0)
{
send_lang(u, s, DELETED_SLINE_X, id);
irc_SendRaw(NULL, "UNS%cLINE %s", *sql_field(1), sql_field(2));
}
else
send_lang(u, s, UPDATE_FAIL);
}
/* sub-command */
else if(strcasecmp(cmd, "LIST") == 0)
{
MYSQL_RES* res;
MYSQL_ROW row;
int rowc = 0;
char* letter = strtok(NULL, " ");
if(letter)
res = sql_query("SELECT "
"id, letter, mask, message, who_nick, t_create FROM os_sline"
" WHERE letter=%s", sql_str(letter));
else
res = sql_query("SELECT id, letter, mask, message, who_nick, t_create FROM os_sline");
if(res)
rowc = mysql_num_rows(res);
send_lang(u, s, SLINE_LIST_HEADER_X, rowc);
while((row = sql_next_row(res)))
{
send_lang(u, s, SLINE_LIST_FORMAT,
atoi(row[0]), *row[1], row[2], row[3], row[4], row[5]);
}
send_lang(u, s, SLINE_LIST_TAIL);
sql_free(res);
}
else
send_lang(u, s, SLINE_SYNTAX);
}
static void ns_cmd_resetpass(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
metadata_t *md;
char *name = parv[0];
char *newpass;
if (!name)
{
command_fail(si, fault_needmoreparams, STR_INVALID_PARAMS, "RESETPASS");
command_fail(si, fault_needmoreparams, _("Syntax: RESETPASS <account>"));
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 RESETPASS \2%s\2 (is SOPER)", name);
command_fail(si, fault_badparams, _("\2%s\2 belongs to a services operator; you need %s privilege to reset the password."), name, PRIV_ADMIN);
return;
}
if ((md = metadata_find(mu, "private:mark:setter")))
{
if (has_priv(si, PRIV_MARK))
{
wallops("%s reset the password for the \2MARKED\2 account %s.", get_oper_name(si), entity(mu)->name);
logcommand(si, CMDLOG_ADMIN, "RESETPASS: \2%s\2 (overriding mark by \2%s\2)", entity(mu)->name, md->value);
command_success_nodata(si, _("Overriding MARK placed by %s on the account %s."), md->value, entity(mu)->name);
}
else
{
logcommand(si, CMDLOG_ADMIN, "failed RESETPASS \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);
return;
}
}
else
{
wallops("%s reset the password for the account %s", get_oper_name(si), entity(mu)->name);
logcommand(si, CMDLOG_ADMIN, "RESETPASS: \2%s\2", entity(mu)->name);
}
newpass = random_string(12);
metadata_delete(mu, "private:setpass:key");
metadata_add(mu, "private:sendpass:sender", get_oper_name(si));
metadata_add(mu, "private:sendpass:timestamp", number_to_string(time(NULL)));
set_password(mu, newpass);
free(newpass);
command_success_nodata(si, _("The password for \2%s\2 has been changed to \2%s\2."), entity(mu)->name, newpass);
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);
}
}
/** internal functions implementation starts here **/
void os_sendpass(IRC_User *s, IRC_User *u)
{
u_int32_t source_snid;
u_int32_t snid;
char *target;
char *email;
int lang;
/* status validation */
CHECK_IF_IDENTIFIED_NICK
/* syntax validation */
target = strtok(NULL, " ");
if (!is_soper(u->snid))
{
send_lang(u, s, PERMISSION_DENIED);
return;
}
if(!irc_IsUMode(u, UMODE_OPER)) /* extra security */
return;
else if(IsNull(target))
send_lang(u, s, SENDPASS_SYNTAX);
else if( (snid = nick2snid(target)) == 0 )
send_lang(u, s, NICK_X_NOT_REGISTERED, target);
/* sub-command */
else if(is_sadmin(snid) || is_sroot(snid))
{
log_log(os_log, mod_info.name, "Nick %s trying SENDPASS on sadmin/soper %s",
s->nick, target);
irc_SendSanotice(s, "Nick %s trying SENDPASS on sadmin/soper %s",
s->nick, target);
}
else if((sql_singlequery("SELECT email, lang FROM nickserv WHERE snid=%d",
snid) < 1) || ((email = sql_field(0)) == NULL))
send_lang(u, s, OS_SENDPASS_NO_EMAIL_X, target);
else
{
char buf[512];
char pbuf[PASSLEN+1];
lang = sql_field_i(1);
rand_string(pbuf, PASSLEN, PASSLEN);
pbuf[2] = '0'+ (random() % 10);
sql_execute("UPDATE nickserv_security SET pass=%s WHERE snid=%d",
sql_str(hex_str(encrypted_password(pbuf), 16)), snid);
snprintf(buf, sizeof(buf),
"From: \"%%from_name%%\" <%%from%%>\r\nTo:\"%s\" <%s>\r\nSubject:%s\r\n\r\n%s",
target, email,
"Nick Password",
lang_str_l(lang, SENDPASS_X_X, target, pbuf)
);
email_init_symbols();
email_add_symbol("email", email);
email_send(buf);
memset(pbuf, 0, PASSLEN);
send_lang(u, s, SENDPASS_X_SENT_X, target, email);
log_log(os_log, mod_info.name, "SENDPASS for %s requested by %s",
target, u->nick);
irc_SendSanotice(s, "SENDPASS for %s requested by %s",
target, u->nick);
}
}
