int do_addnick(User * u)
{
NickAlias *na, *target;
NickCore *nc;
char *nick = strtok(NULL, " ");
char *pass = strtok(NULL, " ");
int i;
char tsbuf[16];
char modes[512];
int len;
if (NSEmailReg && (findrequestnick(u->nick))) {
notice_lang(s_NickServ, u, NS_REQUESTED);
return MOD_CONT;
}
if (readonly) {
notice_lang(s_NickServ, u, NS_ADDNICK_DISABLED);
return MOD_CONT;
}
if (checkDefCon(DEFCON_NO_NEW_NICKS)) {
notice_lang(s_NickServ, u, OPER_DEFCON_DENIED);
return MOD_CONT;
}
if (RestrictOperNicks) {
for (i = 0; i < RootNumber; i++) {
if (stristr(u->nick, ServicesRoots[i]) && !is_oper(u)) {
notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
u->nick);
return MOD_CONT;
}
}
for (i = 0; i < servadmins.count && (nc = servadmins.list[i]); i++) {
if (stristr(u->nick, nc->display) && !is_oper(u)) {
notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
u->nick);
return MOD_CONT;
}
}
for (i = 0; i < servopers.count && (nc = servopers.list[i]); i++) {
if (stristr(u->nick, nc->display) && !is_oper(u)) {
notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
u->nick);
return MOD_CONT;
}
}
}
if (!nick || !pass) {
syntax_error(s_NickServ, u, "ADDNICK", NS_ADDNICK_SYNTAX);
} else if (!(target = findnick(nick))) {
notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
} else if (time(NULL) < u->lastnickreg + NSRegDelay) {
notice_lang(s_NickServ, u, NS_ADDNICK_PLEASE_WAIT, NSRegDelay);
} else if (u->na && (u->na->status & NS_VERBOTEN)) {
alog("%s: %s@%s tried to use ADDNICK from forbidden nick %s.",
s_NickServ, u->username, u->host, u->nick);
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, u->nick);
} else if (u->na && (u->na->nc->flags & NI_SUSPENDED)) {
alog("%s: %s!%s@%s tried to use ADDNICK from suspended nick %s.",
s_NickServ, u->nick, u->username, u->host, target->nick);
notice_lang(s_NickServ, u, NICK_X_SUSPENDED, u->nick);
} else if (u->na && NSNoGroupChange) {
notice_lang(s_NickServ, u, NS_ADDNICK_CHANGE_DISABLED, s_NickServ);
} else if (u->na && !nick_identified(u)) {
notice_lang(s_NickServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
} else if (target && (target->nc->flags & NI_SUSPENDED)) {
alog("%s: %s!%s@%s tried to use GROUP from SUSPENDED nick %s",
s_NickServ, u->nick, u->username, u->host, target->nick);
notice_lang(s_NickServ, u, NICK_X_SUSPENDED, target->nick);
} else if (target->status & NS_VERBOTEN) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
} else if (u->na && target->nc == u->na->nc) {
notice_lang(s_NickServ, u, NS_ADDNICK_SAME, target->nick);
} else if (NSMaxAliases && (target->nc->aliases.count >= NSMaxAliases)
&& !nick_is_services_admin(target->nc)) {
notice_lang(s_NickServ, u, NS_ADDNICK_TOO_MANY, target->nick,
s_NickServ, s_NickServ);
} else if (enc_check_password(pass, target->nc->pass) != 1) {
alog("%s: Failed ADDNICK for %s!%s@%s (invalid password).",
s_NickServ, u->nick, u->username, u->host);
notice_lang(s_NickServ, u, PASSWORD_INCORRECT);
bad_password(u);
} else {
/* If the nick is already registered, drop it.
* If not, check that it is valid.
*/
if (u->na) {
delnick(u->na);
} else {
int prefixlen = strlen(NSGuestNickPrefix);
int nicklen = strlen(u->nick);
if (nicklen <= prefixlen + 7 && nicklen >= prefixlen + 1
&& stristr(u->nick, NSGuestNickPrefix) == u->nick
&& strspn(u->nick + prefixlen,
"1234567890") == nicklen - prefixlen) {
notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
u->nick);
return MOD_CONT;
}
}
na = makealias(u->nick, target->nc);
if (na) {
na->last_usermask =
scalloc(strlen(common_get_vident(u)) +
strlen(common_get_vhost(u)) + 2, 1);
sprintf(na->last_usermask, "%s@%s", common_get_vident(u),
common_get_vhost(u));
na->last_realname = sstrdup(u->realname);
na->time_registered = na->last_seen = time(NULL);
na->status = (int16) (NS_IDENTIFIED | NS_RECOGNIZED);
if (!(na->nc->flags & NI_SERVICES_ROOT)) {
for (i = 0; i < RootNumber; i++) {
if (!stricmp(ServicesRoots[i], u->nick)) {
na->nc->flags |= NI_SERVICES_ROOT;
break;
}
}
}
u->na = na;
na->u = u;
#ifdef USE_RDB
/* Is this really needed? Since this is a new alias it will get
* its unique id on the next update, since it was previously
* deleted by delnick. Must observe...
*/
if (rdb_open()) {
rdb_save_ns_alias(na);
rdb_close();
}
#endif
send_event(EVENT_GROUP, 1, u->nick);
alog("%s: %s!%s@%s makes %s join group of %s (%s) (e-mail: %s)", s_NickServ, u->nick, u->username, u->host, u->nick, target->nick, target->nc->display, (target->nc->email ? target->nc->email : "none"));
notice_lang(s_NickServ, u, NS_ADDNICK_SUCCESS, target->nick);
u->lastnickreg = time(NULL);
snprintf(tsbuf, sizeof(tsbuf), "%lu",
(unsigned long int) u->timestamp);
if (ircd->modeonreg) {
len = strlen(ircd->modeonreg);
strncpy(modes,ircd->modeonreg,512);
if(ircd->rootmodeonid && is_services_root(u)) {
strncat(modes,ircd->rootmodeonid,512-len);
} else if(ircd->adminmodeonid && is_services_admin(u)) {
strncat(modes,ircd->adminmodeonid,512-len);
} else if(ircd->opermodeonid && is_services_oper(u)) {
strncat(modes,ircd->opermodeonid,512-len);
}
if (ircd->tsonmode) {
common_svsmode(u, modes, tsbuf);
} else {
common_svsmode(u, modes, NULL);
}
}
check_memos(u);
} else {
alog("%s: makealias(%s) failed", s_NickServ, u->nick);
notice_lang(s_NickServ, u, NS_ADDNICK_FAILED);
}
}
return MOD_CONT;
}
/**
* The /hs set command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int myDoSet(User * u)
{
char *nick = strtok(NULL, " ");
char *rawhostmask = strtok(NULL, " ");
char *hostmask = smalloc(HOSTMAX);
NickAlias *na;
int32 tmp_time;
char *s;
char *vIdent = NULL;
if (!nick || !rawhostmask) {
syntax_error(s_HostServ, u, "SET", HOST_SET_SYNTAX);
free(hostmask);
return MOD_CONT;
}
vIdent = myStrGetOnlyToken(rawhostmask, '@', 0); /* Get the first substring, @ as delimiter */
if (vIdent) {
rawhostmask = myStrGetTokenRemainder(rawhostmask, '@', 1); /* get the remaining string */
if (!rawhostmask) {
syntax_error(s_HostServ, u, "SET", HOST_SET_SYNTAX);
free(vIdent);
free(hostmask);
return MOD_CONT;
}
if (strlen(vIdent) > USERMAX - 1) {
notice_lang(s_HostServ, u, HOST_SET_IDENTTOOLONG, USERMAX);
free(vIdent);
free(rawhostmask);
free(hostmask);
return MOD_CONT;
} else {
for (s = vIdent; *s; s++) {
if (!isvalidchar(*s)) {
notice_lang(s_HostServ, u, HOST_SET_IDENT_ERROR);
free(vIdent);
free(rawhostmask);
free(hostmask);
return MOD_CONT;
}
}
}
if (!ircd->vident) {
notice_lang(s_HostServ, u, HOST_NO_VIDENT);
free(vIdent);
free(rawhostmask);
free(hostmask);
return MOD_CONT;
}
}
if (strlen(rawhostmask) < HOSTMAX)
snprintf(hostmask, HOSTMAX, "%s", rawhostmask);
else {
notice_lang(s_HostServ, u, HOST_SET_TOOLONG, HOSTMAX);
if (vIdent) {
free(vIdent);
free(rawhostmask);
}
free(hostmask);
return MOD_CONT;
}
if (!isValidHost(hostmask, 3)) {
notice_lang(s_HostServ, u, HOST_SET_ERROR);
if (vIdent) {
free(vIdent);
free(rawhostmask);
}
free(hostmask);
return MOD_CONT;
}
tmp_time = time(NULL);
if ((na = findnick(nick))) {
if (na->status & NS_VERBOTEN) {
notice_lang(s_HostServ, u, NICK_X_FORBIDDEN, nick);
if (vIdent) {
free(vIdent);
free(rawhostmask);
}
free(hostmask);
return MOD_CONT;
}
if (vIdent && ircd->vident) {
alog("vHost for user \002%s\002 set to \002%s@%s\002 by oper \002%s\002", nick, vIdent, hostmask, u->nick);
} else {
alog("vHost for user \002%s\002 set to \002%s\002 by oper \002%s\002", nick, hostmask, u->nick);
}
addHostCore(nick, vIdent, hostmask, u->nick, tmp_time);
if (vIdent) {
notice_lang(s_HostServ, u, HOST_IDENT_SET, nick, vIdent,
hostmask);
} else {
notice_lang(s_HostServ, u, HOST_SET, nick, hostmask);
}
} else {
notice_lang(s_HostServ, u, HOST_NOREG, nick);
}
free(hostmask);
if (vIdent) {
free(vIdent);
free(rawhostmask);
}
return MOD_CONT;
}
int do_resetpass(User * u)
{
char *buffer = NULL;
char *nick = NULL;
char *email = NULL;
char passcode[PASSCODELEN];
char *callBackinfo[1];
NickAlias *na = NULL;
if ((RestrictReset == 1) && !(is_oper(u))) {
notice_lang(s_NickServ, u, ACCESS_DENIED);
return MOD_CONT;
}
buffer = moduleGetLastBuffer();
nick = myStrGetToken(buffer, ' ', 0);
email = myStrGetToken(buffer, ' ', 1);
if (!nick) {
moduleNoticeLang(s_NickServ, u, RESETPASS_SYNTAX);
} else if (!anope_valid_nick(nick)) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
} else if (!(na = findnick(nick))) {
notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
} else if (na->status & NS_VERBOTEN) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, na->nick);
} else if (na->nc->flags & NI_SUSPENDED) {
notice_lang(s_NickServ, u, NICK_X_SUSPENDED, na->nick);
} else if (!na->nc->email) {
notice_user(s_NickServ, u, "%s has no email associated with their account.", na->nick);
} else if (moduleGetData(&na->nc->moduleData, MODULEDATAKEY)) {
moduleNoticeLang(s_NickServ, u, RESETPASS_ALREADY_REQUESTED1,
na->nick);
moduleNoticeLang(s_NickServ, u, RESETPASS_ALREADY_REQUESTED2);
} else if (!email && !is_oper(u) && !is_helpop(u)) {
notice(s_NickServ, u->nick, "You need to provide the e-mail address associated with the account you are trying to reset the password on.");
notice(s_NickServ, u->nick, "Syntax: /ns resetpass <nickname> <e-mail>");
} else if (!is_oper(u) && !is_helpop(u) && strcasecmp(email, na->nc->email)) {
notice(s_NickServ, u->nick, "The e-mail address %s does not match the one associated with account %s.", email, na->nc->display);
} else {
generatePassCode(passcode);
moduleAddData(&na->nc->moduleData, MODULEDATAKEY, passcode);
if (do_sendmail(u, na) != 0) {
alog(LOG_COULDNT_SENDMAIL, MYNAME, na->nick);
moduleDelData(&na->nc->moduleData, MODULEDATAKEY);
} else {
callBackinfo[0] = na->nick;
moduleAddCallback(MYNAME, time(NULL) + ExpirePassCode, expirePassCode, 1, callBackinfo);
alog(LOG_RESETPASS_REQUESTED, MYNAME, u->nick, na->nick);
moduleNoticeLang(s_NickServ, u, RESETPASS_SUCCESS, na->nick);
moduleNoticeLang(s_NickServ, u, RESETPASS_INSTRUC);
}
}
if (nick)
free(nick);
if (email)
free(email);
return MOD_CONT;
}
MemoResult Send(const Anope::string &source, const Anope::string &target, const Anope::string &message, bool force)
{
bool ischan;
MemoInfo *mi = this->GetMemoInfo(target, ischan);
if (mi == NULL)
return MEMO_INVALID_TARGET;
User *sender = finduser(source);
if (sender != NULL && !sender->HasPriv("memoserv/no-limit") && !force)
{
if (Config->MSSendDelay > 0 && sender->lastmemosend + Config->MSSendDelay > Anope::CurTime)
return MEMO_TOO_FAST;
else if (!mi->memomax)
return MEMO_TARGET_FULL;
else if (mi->memomax > 0 && mi->memos.size() >= mi->memomax)
return MEMO_TARGET_FULL;
else if (mi->HasIgnore(sender))
return MEMO_SUCCESS;
}
if (sender != NULL)
sender->lastmemosend = Anope::CurTime;
Memo *m = new Memo();
mi->memos.push_back(m);
m->owner = target;
m->sender = source;
m->time = Anope::CurTime;
m->text = message;
m->SetFlag(MF_UNREAD);
FOREACH_MOD(I_OnMemoSend, OnMemoSend(source, target, mi, m));
if (ischan)
{
ChannelInfo *ci = cs_findchan(target);
if (ci->c)
{
for (CUserList::iterator it = ci->c->users.begin(), it_end = ci->c->users.end(); it != it_end; ++it)
{
UserContainer *cu = *it;
if (ci->AccessFor(cu->user).HasPriv("MEMO"))
{
if (cu->user->Account() && cu->user->Account()->HasFlag(NI_MEMO_RECEIVE))
cu->user->SendMessage(MemoServ, MEMO_NEW_X_MEMO_ARRIVED, ci->name.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), mi->memos.size());
}
}
}
}
else
{
NickCore *nc = findnick(target)->nc;
if (nc->HasFlag(NI_MEMO_RECEIVE))
{
for (std::list<NickAlias *>::iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end; ++it)
{
NickAlias *na = *it;
User *user = finduser(na->nick);
if (user && user->IsIdentified())
user->SendMessage(MemoServ, MEMO_NEW_MEMO_ARRIVED, source.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), mi->memos.size());
}
}
/* let's get out the mail if set in the nickcore - certus */
if (nc->HasFlag(NI_MEMO_MAIL))
SendMemoMail(nc, mi, m);
}
return MEMO_SUCCESS;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string &subcommand = params[0];
if (subcommand.equals_ci("ADD") && params.size() > 2)
{
const Anope::string &oper = params[1];
const Anope::string &otype = params[2];
NickAlias *na = findnick(oper);
if (na == NULL)
source.Reply(NICK_X_NOT_REGISTERED, oper.c_str());
else if (na->nc->o)
source.Reply(_("Nick \2%s\2 is already an operator."), na->nick.c_str());
else
{
OperType *ot = OperType::Find(otype);
if (ot == NULL)
source.Reply(_("Oper type \2%s\2 has not been configured."), otype.c_str());
else
{
na->nc->o = new MyOper(na->nc->display, ot);
Log(LOG_ADMIN, source.u, this) << "ADD " << na->nick << " as type " << ot->GetName();
source.Reply("%s (%s) added to the \2%s\2 list.", na->nick.c_str(), na->nc->display.c_str(), ot->GetName().c_str());
}
}
}
else if (subcommand.equals_ci("DEL") && params.size() > 1)
{
const Anope::string &oper = params[1];
NickAlias *na = findnick(oper);
if (na == NULL)
source.Reply(NICK_X_NOT_REGISTERED, oper.c_str());
else if (!na->nc || !na->nc->o)
source.Reply(_("Nick \2%s\2 is not a services operator."), oper.c_str());
else
{
delete na->nc->o;
na->nc->o = NULL;
Log(LOG_ADMIN, source.u, this) << "DEL " << na->nick;
source.Reply(_("Oper privileges removed from %s (%s)."), na->nick.c_str(), na->nc->display.c_str());
}
}
else if (subcommand.equals_ci("LIST"))
{
source.Reply(_("Name Type"));
for (nickcore_map::const_iterator it = NickCoreList.begin(), it_end = NickCoreList.end(); it != it_end; ++it)
{
NickCore *nc = it->second;
if (!nc->o)
continue;
source.Reply(_("%-8s %s"), nc->o->name.c_str(), nc->o->ot->GetName().c_str());
if (nc->o->config)
source.Reply(_(" This oper is configured in the configuration file."));
for (std::list<User *>::iterator uit = nc->Users.begin(); uit != nc->Users.end(); ++uit)
{
User *u = *uit;
source.Reply(_(" %s is online using this oper block."), u->nick.c_str());
}
}
}
else if (subcommand.equals_ci("INFO") && params.size() > 1)
{
Anope::string fulltype = params[1];
if (params.size() > 2)
fulltype += " " + params[2];
OperType *ot = OperType::Find(fulltype);
if (ot == NULL)
source.Reply(_("Oper type \2%s\2 has not been configured."), fulltype.c_str());
else
{
if (ot->GetCommands().empty())
source.Reply(_("Opertype \2%s\2 has no allowed commands."), ot->GetName().c_str());
else
{
source.Reply(_("Available commands for \2%s\2:"), ot->GetName().c_str());
Anope::string buf;
std::list<Anope::string> cmds = ot->GetCommands();
for (std::list<Anope::string>::const_iterator it = cmds.begin(), it_end = cmds.end(); it != it_end; ++it)
{
buf += *it + " ";
if (buf.length() > 400)
{
source.Reply("%s", buf.c_str());
buf.clear();
}
}
if (!buf.empty())
{
source.Reply("%s", buf.c_str());
buf.clear();
}
}
if (ot->GetPrivs().empty())
source.Reply(_("Opertype \2%s\2 has no allowed privileges."), ot->GetName().c_str());
else
{
source.Reply(_("Available privileges for \2%s\2:"), ot->GetName().c_str());
Anope::string buf;
std::list<Anope::string> privs = ot->GetPrivs();
for (std::list<Anope::string>::const_iterator it = privs.begin(), it_end = privs.end(); it != it_end; ++it)
{
buf += *it + " ";
if (buf.length() > 400)
{
source.Reply("%s", buf.c_str());
buf.clear();
}
}
if (!buf.empty())
{
source.Reply("%s", buf.c_str());
buf.clear();
}
}
if (!ot->modes.empty())
source.Reply(_("Opertype \2%s\2 receives modes \2%s\2 once identifying."), ot->GetName().c_str(), ot->modes.c_str());
}
}
else
this->OnSyntaxError(source, subcommand);
return;
}
int do_akick(User * u, Channel *c, char *cmd, char *mask, char *reason) {
ChannelInfo *ci = c->ci;
AutoKick *akick;
int i;
struct c_userlist *cu = NULL, *next = NULL;
User *u2;
char *argv[3];
int count = 0;
if (!cmd || (!mask && (!stricmp(cmd, "ADD") || !stricmp(cmd, "STICK")
|| !stricmp(cmd, "UNSTICK") || !stricmp(cmd, "DEL")))) {
noticeLang(ci->bi->nick, u, LANG_AKICK_SYNTAX);
} else if (!check_access(u, ci, CA_AKICK) && !is_services_admin(u)) {
notice_lang(ci->bi->nick, u, ACCESS_DENIED);
} else if (stricmp(cmd, "ADD") == 0) {
NickAlias *na = findnick(mask), *na2;
User *target = finduser(mask);
NickCore *nc = NULL;
char *nick, *user, *host;
int freemask = 0;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (!na) {
if (target) {
char tmp[BUFSIZE];
mask = NULL;
freemask = 1;
get_idealban(ci, target, tmp, BUFSIZE);
mask = sstrdup(tmp);
} else {
split_usermask(mask, &nick, &user, &host);
mask = scalloc(strlen(nick) + strlen(user) + strlen(host) + 3, 1);
freemask = 1;
sprintf(mask, "%s!%s@%s", nick, user, host);
free(nick);
free(user);
free(host);
}
} else {
if (na->status & NS_VERBOTEN) {
notice_lang(ci->bi->nick, u, NICK_X_FORBIDDEN, mask);
return MOD_CONT;
}
nc = na->nc;
}
/* Check excepts BEFORE we get this far */
if (ircd->except) {
if (is_excepted_mask(ci, mask) == 1) {
notice_lang(ci->bi->nick, u, CHAN_EXCEPTED, mask, c->name);
if (freemask) free(mask);
return MOD_CONT;
}
}
/* Check whether target nick has equal/higher access
* or whether the mask matches a user with higher/equal access ~ Viper */
if ((ci->flags & CI_PEACE) && nc) {
if ((nc == ci->founder) || (get_access_nc(nc, ci) >= get_access(u, ci))) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
if (freemask)
free(mask);
return MOD_CONT;
}
} else if ((ci->flags & CI_PEACE)) {
char buf[BUFSIZE];
/* Match against all currently online users with equal or
* higher access. - Viper */
for (i = 0; i < 1024; i++) {
for (u2 = userlist[i]; u2; u2 = u2->next) {
if (is_founder(u2, ci) || (get_access(u2, ci) >= get_access(u, ci))) {
if (match_usermask(mask, u2)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
free(mask);
return MOD_CONT;
}
}
}
}
/* Match against the lastusermask of all nickalias's with equal
* or higher access. ~ Viper */
for (i = 0; i < 1024; i++) {
for (na2 = nalists[i]; na2; na2 = na2->next) {
if (na2->status & NS_VERBOTEN)
continue;
if (na2->nc && ((na2->nc == ci->founder) || (get_access_nc(na2->nc, ci)
>= get_access(u, ci)))) {
snprintf(buf, BUFSIZE, "%s!%s", na2->nick, na2->last_usermask);
if (match_wild_nocase(mask, buf)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
free(mask);
return MOD_CONT;
}
}
}
}
}
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if ((akick->flags & AK_ISNICK) ? akick->u.nc == nc : stricmp(akick->u.mask, mask) == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_ALREADY_EXISTS, (akick->flags & AK_ISNICK) ? akick->u.nc->
display : akick->u.mask, c->name);
if (freemask) free(mask);
return MOD_CONT;
}
}
/* All entries should be in use so we don't have to go over
* the entire list. We simply add new entries at the end. */
if (ci->akickcount >= CSAutokickMax) {
notice_lang(s_ChanServ, u, CHAN_AKICK_REACHED_LIMIT, CSAutokickMax);
if (freemask) free(mask);
return MOD_CONT;
}
ci->akickcount++;
ci->akick = srealloc(ci->akick, sizeof(AutoKick) * ci->akickcount);
akick = &ci->akick[i];
akick->flags = AK_USED;
if (nc) {
akick->flags |= AK_ISNICK;
akick->u.nc = nc;
} else {
akick->u.mask = sstrdup(mask);
}
akick->creator = sstrdup(u->nick);
akick->addtime = time(NULL);
if (reason) {
if (strlen(reason) > 200)
reason[200] = '\0';
akick->reason = sstrdup(reason);
} else {
akick->reason = NULL;
}
/* Auto ENFORCE #63 */
cu = c->users;
while (cu) {
next = cu->next;
if (check_kick(cu->user, c->name, c->creation_time)) {
argv[0] = sstrdup(c->name);
argv[1] = sstrdup(cu->user->nick);
if (akick->reason)
argv[2] = sstrdup(akick->reason);
else
argv[2] = sstrdup("none");
do_kick(ci->bi->nick, 3, argv);
free(argv[2]);
free(argv[1]);
free(argv[0]);
count++;
}
cu = next;
}
alog("%s: %s!%s@%s added akick for %s to %s",
ci->bi->nick, u->nick, u->username, u->host, mask, c->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_ADDED, mask, c->name);
if (count)
notice_lang(ci->bi->nick, u, CHAN_AKICK_ENFORCE_DONE, c->name, count);
if (freemask) free(mask);
} else if (stricmp(cmd, "STICK") == 0) {
NickAlias *na;
NickCore *nc;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, ci->name);
return MOD_CONT;
}
na = findnick(mask);
nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED) || (akick->flags & AK_ISNICK))
continue;
if (!stricmp(akick->u.mask, mask))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, ci->name);
return MOD_CONT;
}
akick->flags |= AK_STUCK;
alog("%s: %s!%s@%s set STICK on akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, akick->u.mask, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_STUCK, akick->u.mask, ci->name);
if (ci->c)
stick_mask(ci, akick);
} else if (stricmp(cmd, "UNSTICK") == 0) {
NickAlias *na;
NickCore *nc;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, ci->name);
return MOD_CONT;
}
na = findnick(mask);
nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED) || (akick->flags & AK_ISNICK))
continue;
if (!stricmp(akick->u.mask, mask))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, ci->name);
return MOD_CONT;
}
akick->flags &= ~AK_STUCK;
alog("%s: %s!%s@%s unset STICK on akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, akick->u.mask, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_UNSTUCK, akick->u.mask, ci->name);
} else if (stricmp(cmd, "DEL") == 0) {
int deleted, a, b;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
/* Special case: is it a number/list? Only do search if it isn't. */
if (isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
int count, last = -1;
deleted = process_numlist(mask, &count, akick_del_callback, u, ci, &last);
if (!deleted) {
if (count == 1) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_SUCH_ENTRY, last, ci->name);
} else {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, ci->name);
}
} else if (deleted == 1) {
alog("%s: %s!%s@%s deleted 1 akick on %s",
ci->bi->nick, u->nick, u->username, u->host, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED_ONE, ci->name);
} else {
alog("%s: %s!%s@%s deleted %d akicks on %s",
ci->bi->nick, u->nick, u->username, u->host, deleted, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED_SEVERAL, deleted, ci->name);
}
} else {
NickAlias *na = findnick(mask);
NickCore *nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (((akick->flags & AK_ISNICK) && akick->u.nc == nc) || (!(akick->flags & AK_ISNICK)
&& stricmp(akick->u.mask, mask) == 0))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, c->name);
return MOD_CONT;
}
alog("%s: %s!%s@%s deleted akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, mask, c->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED, mask, c->name);
akick_del(u, akick);
deleted = 1;
}
if (deleted) {
/* Reordering - DrStein */
for (b = 0; b < ci->akickcount; b++) {
if (ci->akick[b].flags & AK_USED) {
for (a = 0; a < ci->akickcount; a++) {
if (a > b)
break;
if (!(ci->akick[a].flags & AK_USED)) {
ci->akick[a].flags = ci->akick[b].flags;
if (ci->akick[b].flags & AK_ISNICK) {
ci->akick[a].u.nc = ci->akick[b].u.nc;
} else {
ci->akick[a].u.mask = sstrdup(ci->akick[b].u.mask);
}
/* maybe we should first check whether there
is a reason before we sstdrup it -Certus */
if (ci->akick[b].reason)
ci->akick[a].reason = sstrdup(ci->akick[b].reason);
else
ci->akick[a].reason = NULL;
ci->akick[a].creator = sstrdup(ci->akick[b].creator);
ci->akick[a].addtime = ci->akick[b].addtime;
akick_del(u, &ci->akick[b]);
break;
}
}
}
}
/* After reordering only the entries at the end could still be empty.
* We ll free the places no longer in use... - Viper */
for (i = ci->akickcount - 1; i >= 0; i--) {
if (ci->akick[i].flags & AK_USED)
break;
ci->akickcount--;
}
ci->akick = srealloc(ci->akick,sizeof(AutoKick) * ci->akickcount);
}
} else if (stricmp(cmd, "LIST") == 0) {
int sent_header = 0;
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
if (mask && isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
process_numlist(mask, NULL, akick_list_callback, u, ci, &sent_header);
} else {
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (mask) {
if (!(akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.mask))
continue;
if ((akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.nc->display))
continue;
}
akick_list(u, i, ci, &sent_header);
}
}
if (!sent_header)
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, c->name);
} else if (stricmp(cmd, "VIEW") == 0) {
int sent_header = 0;
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
if (mask && isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
process_numlist(mask, NULL, akick_view_callback, u, ci, &sent_header);
} else {
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (mask) {
if (!(akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.mask))
continue;
if ((akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.nc->display))
continue;
}
akick_view(u, i, ci, &sent_header);
}
}
if (!sent_header)
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, c->name);
} else if (stricmp(cmd, "ENFORCE") == 0) {
struct c_userlist *cu = NULL, *next = NULL;
char *argv[3];
int count = 0;
if (!c) {
notice_lang(ci->bi->nick, u, CHAN_X_NOT_IN_USE, ci->name);
return MOD_CONT;
}
cu = c->users;
while (cu) {
next = cu->next;
if (check_kick(cu->user, c->name, c->creation_time)) {
argv[0] = sstrdup(c->name);
argv[1] = sstrdup(cu->user->nick);
argv[2] = sstrdup(CSAutokickReason);
do_kick(ci->bi->nick, 3, argv);
free(argv[2]);
free(argv[1]);
free(argv[0]);
count++;
}
cu = next;
}
notice_lang(ci->bi->nick, u, CHAN_AKICK_ENFORCE_DONE, ci->name, count);
} else if (stricmp(cmd, "CLEAR") == 0) {
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
akick_del(u, akick);
}
free(ci->akick);
ci->akick = NULL;
ci->akickcount = 0;
alog("%s: %s!%s@%s cleared akicks on %s",
ci->bi->nick, u->nick, u->username, u->host, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_CLEAR, ci->name);
} else {
noticeLang(ci->bi->nick, u, LANG_AKICK_SYNTAX);
}
return MOD_CONT;
}
void load_os_dbase(void)
{
dbFILE *f;
int16 i, ver;
uint16 tmp16, n;
uint32 tmp32;
char *s;
int failed = 0;
if (!(f = open_db(s_OperServ, OperDBName, "r", OPER_VERSION)))
return;
ver = get_file_version(f);
if (ver <= 9) {
NickAlias *na;
SAFE(read_int16(&n, f));
for (i = 0; i < n && !failed; i++) {
SAFE(read_string(&s, f));
if (s) {
na = findnick(s);
if (na) {
na->nc->flags |= NI_SERVICES_ADMIN;
if (slist_indexof(&servadmins, na) == -1)
slist_add(&servadmins, na);
}
free(s);
}
}
if (!failed)
SAFE(read_int16(&n, f));
for (i = 0; i < n && !failed; i++) {
SAFE(read_string(&s, f));
if (s) {
na = findnick(s);
if (na) {
na->nc->flags |= NI_SERVICES_OPER;
if (slist_indexof(&servopers, na) == -1)
slist_add(&servopers, na);
}
free(s);
}
}
}
if (ver >= 7) {
uint32 tmp32;
SAFE(read_int32(&maxusercnt, f));
SAFE(read_int32(&tmp32, f));
maxusertime = tmp32;
}
if (ver <= 10)
load_old_akill();
else {
Akill *ak;
read_int16(&tmp16, f);
slist_setcapacity(&akills, tmp16);
for (i = 0; i < akills.capacity; i++) {
ak = scalloc(sizeof(Akill), 1);
SAFE(read_string(&ak->user, f));
SAFE(read_string(&ak->host, f));
SAFE(read_string(&ak->by, f));
SAFE(read_string(&ak->reason, f));
SAFE(read_int32(&tmp32, f));
ak->seton = tmp32;
SAFE(read_int32(&tmp32, f));
ak->expires = tmp32;
slist_add(&akills, ak);
}
}
if (ver >= 11) {
SXLine *sx;
read_int16(&tmp16, f);
slist_setcapacity(&sglines, tmp16);
for (i = 0; i < sglines.capacity; i++) {
sx = scalloc(sizeof(SXLine), 1);
SAFE(read_string(&sx->mask, f));
SAFE(read_string(&sx->by, f));
SAFE(read_string(&sx->reason, f));
SAFE(read_int32(&tmp32, f));
sx->seton = tmp32;
SAFE(read_int32(&tmp32, f));
sx->expires = tmp32;
slist_add(&sglines, sx);
}
if (ver >= 13) {
read_int16(&tmp16, f);
slist_setcapacity(&sqlines, tmp16);
for (i = 0; i < sqlines.capacity; i++) {
sx = scalloc(sizeof(SXLine), 1);
SAFE(read_string(&sx->mask, f));
SAFE(read_string(&sx->by, f));
SAFE(read_string(&sx->reason, f));
SAFE(read_int32(&tmp32, f));
sx->seton = tmp32;
SAFE(read_int32(&tmp32, f));
sx->expires = tmp32;
slist_add(&sqlines, sx);
}
}
read_int16(&tmp16, f);
slist_setcapacity(&szlines, tmp16);
for (i = 0; i < szlines.capacity; i++) {
sx = scalloc(sizeof(SXLine), 1);
SAFE(read_string(&sx->mask, f));
SAFE(read_string(&sx->by, f));
SAFE(read_string(&sx->reason, f));
SAFE(read_int32(&tmp32, f));
sx->seton = tmp32;
SAFE(read_int32(&tmp32, f));
sx->expires = tmp32;
slist_add(&szlines, sx);
}
}
close_db(f);
}
/**
* The /ns saset command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int do_saset(User * u)
{
char *nick = strtok(NULL, " ");
char *cmd = strtok(NULL, " ");
char *param = strtok(NULL, " ");
NickAlias *na;
if (readonly) {
notice_lang(s_NickServ, u, NICK_SASET_DISABLED);
return MOD_CONT;
}
if (!nick) {
syntax_error(s_NickServ, u, "SASET", NICK_SASET_SYNTAX);
return MOD_CONT;
}
if (!(na = findnick(nick))) {
notice_lang(s_NickServ, u, NICK_SASET_BAD_NICK, nick);
return MOD_CONT;
}
if (!param
&& (!cmd
|| (stricmp(cmd, "URL") != 0 && stricmp(cmd, "EMAIL") != 0
&& stricmp(cmd, "GREET") != 0
&& stricmp(cmd, "ICQ") != 0))) {
syntax_error(s_NickServ, u, "SASET", NICK_SASET_SYNTAX);
} else if (!na) {
notice_lang(s_NickServ, u, NICK_NOT_REGISTERED, nick);
} else if (na->status & NS_VERBOTEN) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, na->nick);
} else if (na->nc->flags & NI_SUSPENDED) {
notice_lang(s_NickServ, u, NICK_X_SUSPENDED, na->nick);
} else if (stricmp(cmd, "DISPLAY") == 0) {
do_saset_display(u, na->nc, param);
} else if (stricmp(cmd, "PASSWORD") == 0) {
do_saset_password(u, na->nc, param);
} else if (stricmp(cmd, "URL") == 0) {
do_saset_url(u, na->nc, param);
} else if (stricmp(cmd, "EMAIL") == 0) {
do_saset_email(u, na->nc, param);
} else if (stricmp(cmd, "ICQ") == 0) {
do_saset_icq(u, na->nc, param);
} else if (stricmp(cmd, "GREET") == 0) {
do_saset_greet(u, na->nc, param);
} else if (stricmp(cmd, "KILL") == 0) {
do_saset_kill(u, na->nc, param);
} else if (stricmp(cmd, "SECURE") == 0) {
do_saset_secure(u, na->nc, param);
} else if (stricmp(cmd, "PRIVATE") == 0) {
do_saset_private(u, na->nc, param);
} else if (stricmp(cmd, "MSG") == 0) {
do_saset_msg(u, na->nc, param);
} else if (stricmp(cmd, "HIDE") == 0) {
do_saset_hide(u, na->nc, param);
} else if (stricmp(cmd, "NOEXPIRE") == 0) {
do_saset_noexpire(u, na, param);
} else if (stricmp(cmd, "AUTOOP") == 0) {
do_saset_autoop(u, na->nc, param);
} else if (stricmp(cmd, "LANGUAGE") == 0) {
do_saset_language(u, na->nc, param);
} else {
notice_lang(s_NickServ, u, NICK_SASET_UNKNOWN_OPTION, cmd);
}
return MOD_CONT;
}
static int hs_do_request(User * u)
{
char *cur_buffer;
char *nick;
char *rawhostmask;
char hostmask[HOSTMAX];
NickAlias *na;
int32 tmp_time;
char *s;
char *vIdent = NULL;
time_t now = time(NULL);
cur_buffer = moduleGetLastBuffer();
nick = u->nick;
rawhostmask = myStrGetToken(cur_buffer, ' ', 0);
if (!nick || !rawhostmask) {
if (rawhostmask)
free(rawhostmask);
moduleNoticeLang(s_HostServ, u, LNG_REQUEST_SYNTAX);
return MOD_CONT;
}
vIdent = myStrGetOnlyToken(rawhostmask, '@', 0); /* Get the first substring, @ as delimiter */
if (vIdent) {
rawhostmask = myStrGetTokenRemainder(rawhostmask, '@', 1); /* get the remaining string */
if (!rawhostmask) {
moduleNoticeLang(s_HostServ, u, LNG_REQUEST_SYNTAX);
free(vIdent);
return MOD_CONT;
}
if (strlen(vIdent) > USERMAX - 1) {
notice_lang(s_HostServ, u, HOST_SET_IDENTTOOLONG, USERMAX);
free(vIdent);
free(rawhostmask);
return MOD_CONT;
} else {
for (s = vIdent; *s; s++) {
if (!my_isvalidchar(*s)) {
notice_lang(s_HostServ, u, HOST_SET_IDENT_ERROR);
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
}
}
if (!ircd->vident) {
notice_lang(s_HostServ, u, HOST_NO_VIDENT);
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
}
if (strlen(rawhostmask) < HOSTMAX) {
snprintf(hostmask, HOSTMAX, "%s", rawhostmask);
} else {
notice_lang(s_HostServ, u, HOST_SET_TOOLONG, HOSTMAX);
if (vIdent)
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
if (!isValidHost(hostmask, 3)) {
notice_lang(s_HostServ, u, HOST_SET_ERROR);
if (vIdent)
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
tmp_time = time(NULL);
if ((na = findnick(nick))) {
if (HSRequestMemoOper || HSRequestMemoSetters) {
if (MSSendDelay > 0 && u
&& u->lastmemosend + MSSendDelay > now) {
moduleNoticeLang(s_HostServ, u, LNG_REQUEST_WAIT,
MSSendDelay);
u->lastmemosend = now;
if (vIdent)
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
}
my_add_host_request(nick, vIdent, hostmask, u->nick, tmp_time);
moduleNoticeLang(s_HostServ, u, LNG_REQUESTED);
req_send_memos(u, hostmask);
alog("New vHost Requested by %s", nick);
} else {
notice_lang(s_HostServ, u, HOST_NOREG, nick);
}
if (vIdent)
free(vIdent);
free(rawhostmask);
return MOD_CONT;
}
/**
* The /ms info command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int do_info(User * u)
{
MemoInfo *mi;
NickAlias *na = NULL;
ChannelInfo *ci = NULL;
char *name = strtok(NULL, " ");
int is_servadmin = is_services_admin(u);
int hardmax = 0;
if (is_servadmin && name && *name != '#') {
na = findnick(name);
if (!na) {
notice_lang(s_MemoServ, u, NICK_X_NOT_REGISTERED, name);
return MOD_CONT;
} else if (na->status & NS_VERBOTEN) {
notice_lang(s_MemoServ, u, NICK_X_FORBIDDEN, name);
return MOD_CONT;
}
mi = &na->nc->memos;
hardmax = na->nc->flags & NI_MEMO_HARDMAX ? 1 : 0;
} else if (name && *name == '#') {
ci = cs_findchan(name);
if (!ci) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, name);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, name);
return MOD_CONT;
} else if (!check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
hardmax = ci->flags & CI_MEMO_HARDMAX ? 1 : 0;
} else if (name) { /* It's not a chan and we aren't services admin */
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
} else { /* !name */
if (!nick_identified(u)) {
notice_lang(s_MemoServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
return MOD_CONT;
}
mi = &u->na->nc->memos;
hardmax = u->na->nc->flags & NI_MEMO_HARDMAX ? 1 : 0;
}
if (name && (ci || na->nc != u->na->nc)) {
if (!mi->memocount) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NO_MEMOS, name);
} else if (mi->memocount == 1) {
if (mi->memos[0].flags & MF_UNREAD)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMO_UNREAD, name);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMO, name);
} else {
int count = 0, i;
for (i = 0; i < mi->memocount; i++) {
if (mi->memos[i].flags & MF_UNREAD)
count++;
}
if (count == mi->memocount)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_ALL_UNREAD,
name, count);
else if (count == 0)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS, name,
mi->memocount);
else if (count == 1)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_ONE_UNREAD,
name, mi->memocount);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_SOME_UNREAD,
name, mi->memocount, count);
}
if (mi->memomax == 0) {
if (hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_X_HARD_LIMIT, name,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_LIMIT, name,
mi->memomax);
} else if (mi->memomax > 0) {
if (hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_X_HARD_LIMIT, name,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_LIMIT, name,
mi->memomax);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NO_LIMIT, name);
}
/* I ripped this code out of ircservices 4.4.5, since I didn't want
to rewrite the whole thing (it pisses me off). */
if (na) {
if ((na->nc->flags & NI_MEMO_RECEIVE)
&& (na->nc->flags & NI_MEMO_SIGNON)) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_ON, name);
} else if (na->nc->flags & NI_MEMO_RECEIVE) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_RECEIVE,
name);
} else if (na->nc->flags & NI_MEMO_SIGNON) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_SIGNON,
name);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_OFF, name);
}
}
} else { /* !name || (!ci || na->nc == u->na->nc) */
if (!mi->memocount) {
notice_lang(s_MemoServ, u, MEMO_INFO_NO_MEMOS);
} else if (mi->memocount == 1) {
if (mi->memos[0].flags & MF_UNREAD)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMO_UNREAD);
else
notice_lang(s_MemoServ, u, MEMO_INFO_MEMO);
} else {
int count = 0, i;
for (i = 0; i < mi->memocount; i++) {
if (mi->memos[i].flags & MF_UNREAD)
count++;
}
if (count == mi->memocount)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_ALL_UNREAD,
count);
else if (count == 0)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS, mi->memocount);
else if (count == 1)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_ONE_UNREAD,
mi->memocount);
else
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_SOME_UNREAD,
mi->memocount, count);
}
if (mi->memomax == 0) {
if (!is_servadmin && hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_HARD_LIMIT_ZERO);
else
notice_lang(s_MemoServ, u, MEMO_INFO_LIMIT_ZERO);
} else if (mi->memomax > 0) {
if (!is_servadmin && hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_HARD_LIMIT,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_LIMIT, mi->memomax);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_NO_LIMIT);
}
/* Ripped too. But differently because of a seg fault (loughs) */
if ((u->na->nc->flags & NI_MEMO_RECEIVE)
&& (u->na->nc->flags & NI_MEMO_SIGNON)) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_ON);
} else if (u->na->nc->flags & NI_MEMO_RECEIVE) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_RECEIVE);
} else if (u->na->nc->flags & NI_MEMO_SIGNON) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_SIGNON);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_OFF);
}
}
return MOD_CONT; /* if (name && (ci || na->nc != u->na->nc)) */
}
/**
* The /os admin command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_admin(User * u)
{
char *cmd = strtok(NULL, " ");
char *nick = strtok(NULL, " ");
NickAlias *na;
int res = 0;
if (skeleton) {
notice_lang(s_OperServ, u, OPER_ADMIN_SKELETON);
return MOD_CONT;
}
if (!cmd || (!nick && stricmp(cmd, "LIST") && stricmp(cmd, "CLEAR"))) {
syntax_error(s_OperServ, u, "ADMIN", OPER_ADMIN_SYNTAX);
} else if (!stricmp(cmd, "ADD")) {
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return MOD_CONT;
}
if (!(na = findnick(nick))) {
notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick);
return MOD_CONT;
}
if (na->status & NS_VERBOTEN) {
notice_lang(s_OperServ, u, NICK_X_FORBIDDEN, nick);
return MOD_CONT;
}
if (na->nc->flags & NI_SERVICES_ADMIN
|| slist_indexof(&servadmins, na->nc) != -1) {
notice_lang(s_OperServ, u, OPER_ADMIN_EXISTS, nick);
return MOD_CONT;
}
res = slist_add(&servadmins, na->nc);
if (res == -2) {
notice_lang(s_OperServ, u, OPER_ADMIN_REACHED_LIMIT, nick);
return MOD_CONT;
} else {
if (na->nc->flags & NI_SERVICES_OPER
&& (res = slist_indexof(&servopers, na->nc)) != -1) {
slist_delete(&servopers, res);
na->nc->flags |= NI_SERVICES_ADMIN;
notice_lang(s_OperServ, u, OPER_ADMIN_MOVED, nick);
} else if (na->nc->flags & NI_SERVICES_HELPOP && (res = slist_indexof(&servhelpops, na->nc)) != -1) {
slist_delete(&servhelpops, res);
na->nc->flags |= NI_SERVICES_ADMIN;
notice_lang(s_OperServ, u, OPER_ADMIN_MOVED, nick);
} else {
na->nc->flags |= NI_SERVICES_ADMIN;
notice_lang(s_OperServ, u, OPER_ADMIN_ADDED, nick);
}
LogStaffAction(STAFFLOG_CHANNEL | STAFFLOG_OPERGLOBAL, "OperServ",
"%s!%s@%s added %s to the services admin list",
u->nick, u->username, u->host, nick);
}
if (readonly)
notice_lang(s_OperServ, u, READ_ONLY_MODE);
} else if (!stricmp(cmd, "DEL")) {
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return MOD_CONT;
}
if (servadmins.count == 0) {
notice_lang(s_OperServ, u, OPER_ADMIN_LIST_EMPTY);
return MOD_CONT;
}
if (isdigit(*nick) && strspn(nick, "1234567890,-") == strlen(nick)) {
/* Deleting a range */
res = slist_delete_range(&servadmins, nick, NULL);
if (res == 0) {
notice_lang(s_OperServ, u, OPER_ADMIN_NO_MATCH);
return MOD_CONT;
} else if (res == 1) {
notice_lang(s_OperServ, u, OPER_ADMIN_DELETED_ONE);
} else {
notice_lang(s_OperServ, u, OPER_ADMIN_DELETED_SEVERAL,
res);
}
} else {
if (!(na = findnick(nick))) {
notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick);
return MOD_CONT;
}
if (na->status & NS_VERBOTEN) {
notice_lang(s_OperServ, u, NICK_X_FORBIDDEN, nick);
return MOD_CONT;
}
if (!(na->nc->flags & NI_SERVICES_ADMIN)
|| (res = slist_indexof(&servadmins, na->nc)) == -1) {
notice_lang(s_OperServ, u, OPER_ADMIN_NOT_FOUND, nick);
return MOD_CONT;
}
slist_delete(&servadmins, res);
notice_lang(s_OperServ, u, OPER_ADMIN_DELETED, nick);
}
if (readonly)
notice_lang(s_OperServ, u, READ_ONLY_MODE);
} else if (!stricmp(cmd, "LIST")) {
int sent_header = 0;
if (servadmins.count == 0) {
notice_lang(s_OperServ, u, OPER_ADMIN_LIST_EMPTY);
return MOD_CONT;
}
if (!nick || (isdigit(*nick)
&& strspn(nick, "1234567890,-") == strlen(nick))) {
res =
slist_enum(&servadmins, nick, &admin_list_callback, u,
&sent_header);
if (res == 0) {
notice_lang(s_OperServ, u, OPER_ADMIN_NO_MATCH);
return MOD_CONT;
} else {
notice_lang(s_OperServ, u, END_OF_ANY_LIST, "Admin");
}
} else {
int i;
for (i = 0; i < servadmins.count; i++)
if (!stricmp
(nick, ((NickCore *) servadmins.list[i])->display)
|| match_wild_nocase(nick,
((NickCore *) servadmins.
list[i])->display))
admin_list(i + 1, servadmins.list[i], u, &sent_header);
if (!sent_header)
notice_lang(s_OperServ, u, OPER_ADMIN_NO_MATCH);
else {
notice_lang(s_OperServ, u, END_OF_ANY_LIST, "Admin");
}
}
} else if (!stricmp(cmd, "CLEAR")) {
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return MOD_CONT;
}
if (servadmins.count == 0) {
notice_lang(s_OperServ, u, OPER_ADMIN_LIST_EMPTY);
return MOD_CONT;
}
slist_clear(&servadmins, 1);
notice_lang(s_OperServ, u, OPER_ADMIN_CLEAR);
} else {
syntax_error(s_OperServ, u, "ADMIN", OPER_ADMIN_SYNTAX);
}
return MOD_CONT;
}
/**
* Split from do_send, this way we can easily send a memo from any point.
*
* @param u User Struct
* @param name Target of the memo
* @param text Memo Text
* @param z type see info
* @param source Nickname of the alias the memo originates from.
* 0 - reply to user
* 1 - silent
* 2 - silent with no delay timer
* 3 - reply to user and request read receipt
* @return void
*/
void memo_send_from(User * u, char *name, char *text, int z, char *source)
{
int ischan;
int isforbid;
Memo *m;
MemoInfo *mi;
time_t now = time(NULL);
int is_servoper = is_services_oper(u);
if (readonly) {
notice_lang(s_MemoServ, u, MEMO_SEND_DISABLED);
} else if (checkDefCon(DEFCON_NO_NEW_MEMOS)) {
notice_lang(s_MemoServ, u, OPER_DEFCON_DENIED);
return;
} else if (!text) {
if (z == 0)
syntax_error(s_MemoServ, u, "SEND", MEMO_SEND_SYNTAX);
if (z == 3)
syntax_error(s_MemoServ, u, "RSEND", MEMO_RSEND_SYNTAX);
} else if (!nick_recognized(u)) {
if (z == 0 || z == 3)
notice_lang(s_MemoServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
} else if (!(mi = getmemoinfo(name, &ischan, &isforbid))) {
if (z == 0 || z == 3) {
if (isforbid) {
notice_lang(s_MemoServ, u,
ischan ? CHAN_X_FORBIDDEN :
NICK_X_FORBIDDEN, name);
} else {
notice_lang(s_MemoServ, u,
ischan ? CHAN_X_NOT_REGISTERED :
NICK_X_NOT_REGISTERED, name);
}
}
} else if (z != 2 && MSSendDelay > 0 &&
u && u->lastmemosend + MSSendDelay > now && !is_servoper) {
u->lastmemosend = now;
if (z == 0)
notice_lang(s_MemoServ, u, MEMO_SEND_PLEASE_WAIT, MSSendDelay);
if (z == 3)
notice_lang(s_MemoServ, u, MEMO_RSEND_PLEASE_WAIT,
MSSendDelay);
} else if (mi->memomax == 0 && !is_servoper) {
if (z == 0 || z == 3)
notice_lang(s_MemoServ, u, MEMO_X_GETS_NO_MEMOS, name);
} else if (mi->memocount >= 32767 || (mi->memomax > 0 && mi->memocount >= mi->memomax
&& !is_servoper)) {
if (z == 0 || z == 3)
notice_lang(s_MemoServ, u, MEMO_X_HAS_TOO_MANY_MEMOS, name);
} else {
u->lastmemosend = now;
mi->memocount++;
mi->memos = srealloc(mi->memos, sizeof(Memo) * mi->memocount);
m = &mi->memos[mi->memocount - 1];
strscpy(m->sender, source, NICKMAX);
m->moduleData = NULL;
if (mi->memocount > 1) {
m->number = m[-1].number + 1;
if (m->number < 1) {
int i;
for (i = 0; i < mi->memocount; i++) {
mi->memos[i].number = i + 1;
}
}
} else {
m->number = 1;
}
m->time = time(NULL);
m->text = sstrdup(text);
m->flags = MF_UNREAD;
#ifdef USE_MYSQL
m->id = 0;
#endif
/* Set notify sent flag - DrStein */
if (z == 2) {
m->flags |= MF_NOTIFYS;
}
/* Set receipt request flag */
if (z == 3)
m->flags |= MF_RECEIPT;
if (z == 0 || z == 3)
notice_lang(s_MemoServ, u, MEMO_SENT, name);
if (!ischan) {
NickAlias *na;
NickCore *nc = (findnick(name))->nc;
if (MSNotifyAll) {
if ((nc->flags & NI_MEMO_RECEIVE)
&& get_ignore(name) == NULL) {
int i;
for (i = 0; i < nc->aliases.count; i++) {
na = nc->aliases.list[i];
if (na->u && nick_identified(na->u))
notice_lang(s_MemoServ, na->u,
MEMO_NEW_MEMO_ARRIVED, source,
s_MemoServ, m->number);
}
} else {
if ((u = finduser(name)) && nick_identified(u)
&& (nc->flags & NI_MEMO_RECEIVE))
notice_lang(s_MemoServ, u, MEMO_NEW_MEMO_ARRIVED,
source, s_MemoServ, m->number);
} /* if (flags & MEMO_RECEIVE) */
}
/* if (MSNotifyAll) */
/* let's get out the mail if set in the nickcore - certus */
if (nc->flags & NI_MEMO_MAIL)
new_memo_mail(nc, m);
} else {
struct c_userlist *cu, *next;
Channel *c;
if (MSNotifyAll && (c = findchan(name))) {
for (cu = c->users; cu; cu = next) {
next = cu->next;
if (check_access(cu->user, c->ci, CA_MEMO)) {
if (cu->user->na
&& (cu->user->na->nc->flags & NI_MEMO_RECEIVE)
&& get_ignore(cu->user->nick) == NULL) {
notice_lang(s_MemoServ, cu->user,
MEMO_NEW_X_MEMO_ARRIVED,
c->ci->name, s_MemoServ,
c->ci->name, m->number);
}
}
}
} /* MSNotifyAll */
} /* if (!ischan) */
} /* if command is valid */
}
void load_ns_dbase(void)
{
dbFILE *f;
int ver, i, c;
NickInfo *ni;
int failed = 0;
if (!(f = open_db(s_NickServ, NickDBName, "r")))
return;
switch (ver = get_file_version(f)) {
case 13:
case 12:
case 11:
case 10:
case 9:
case 8:
case 7:
case 6:
case 5:
for (i = 0; i < 256 && !failed; i++) {
while ((c = getc_db(f)) != 0) {
if (c != 1)
fatal("Invalid format in %s", NickDBName);
ni = load_nick(f, ver);
if (ni) {
alpha_insert_nick(ni);
} else {
failed = 1;
break;
}
}
}
/* Now resolve links */
for (ni = firstnick(); ni; ni = nextnick()) {
if (ni->link) {
char *s = (char *)ni->link;
ni->link = findnick(s);
free(s);
if (ni->link)
ni->link->linkcount++;
}
}
break;
case 4:
case 3:
case 2:
case 1:
load_old_ns_dbase(f, ver);
break;
case -1:
fatal("Unable to read version number from %s", NickDBName);
default:
fatal("Unsupported version number (%d) on %s", ver, NickDBName);
} /* switch (version) */
close_db(f);
}
/**
* The /ms set limit command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int do_set_limit(User * u, MemoInfo * mi, char *param)
{
char *p1 = strtok(param, " ");
char *p2 = strtok(NULL, " ");
char *p3 = strtok(NULL, " ");
char *user = NULL, *chan = NULL;
int32 limit;
NickAlias *na = u->na;
ChannelInfo *ci = NULL;
int is_servadmin = is_services_admin(u);
if (p1 && *p1 == '#') {
chan = p1;
p1 = p2;
p2 = p3;
p3 = strtok(NULL, " ");
if (!(ci = cs_findchan(chan))) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, chan);
return MOD_CONT;
} else if (!is_servadmin && !check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
}
if (is_servadmin) {
if (p2 && stricmp(p2, "HARD") != 0 && !chan) {
if (!(na = findnick(p1))) {
notice_lang(s_MemoServ, u, NICK_X_NOT_REGISTERED, p1);
return MOD_CONT;
}
user = p1;
mi = &na->nc->memos;
p1 = p2;
p2 = p3;
} else if (!p1) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SERVADMIN_SYNTAX);
return MOD_CONT;
}
if ((!isdigit(*p1) && stricmp(p1, "NONE") != 0) ||
(p2 && stricmp(p2, "HARD") != 0)) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SERVADMIN_SYNTAX);
return MOD_CONT;
}
if (chan) {
if (p2)
ci->flags |= CI_MEMO_HARDMAX;
else
ci->flags &= ~CI_MEMO_HARDMAX;
} else {
if (p2)
na->nc->flags |= NI_MEMO_HARDMAX;
else
na->nc->flags &= ~NI_MEMO_HARDMAX;
}
limit = atoi(p1);
if (limit < 0 || limit > 32767) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_OVERFLOW, 32767);
limit = 32767;
}
if (stricmp(p1, "NONE") == 0)
limit = -1;
} else {
if (!p1 || p2 || !isdigit(*p1)) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SYNTAX);
return MOD_CONT;
}
if (chan && (ci->flags & CI_MEMO_HARDMAX)) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_FORBIDDEN, chan);
return MOD_CONT;
} else if (!chan && (na->nc->flags & NI_MEMO_HARDMAX)) {
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_FORBIDDEN);
return MOD_CONT;
}
limit = atoi(p1);
/* The first character is a digit, but we could still go negative
* from overflow... watch out! */
if (limit < 0 || (MSMaxMemos > 0 && limit > MSMaxMemos)) {
if (chan) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_TOO_HIGH,
chan, MSMaxMemos);
} else {
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_TOO_HIGH,
MSMaxMemos);
}
return MOD_CONT;
} else if (limit > 32767) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_OVERFLOW, 32767);
limit = 32767;
}
}
mi->memomax = limit;
if (limit > 0) {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s set their memo limit to %d",
s_MemoServ, u->nick, u->username, u->host, limit);
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT, limit);
} else {
alog("%s: %s!%s@%s set the memo limit for %s to %d",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user, limit);
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT,
chan ? chan : user, limit);
}
} else if (limit == 0) {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s set their memo limit to 0",
s_MemoServ, u->nick, u->username, u->host);
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_ZERO);
} else {
alog("%s: %s!%s@%s set the memo limit for %s to 0",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user);
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_ZERO,
chan ? chan : user);
}
} else {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s unset their memo limit",
s_MemoServ, u->nick, u->username, u->host);
notice_lang(s_MemoServ, u, MEMO_UNSET_YOUR_LIMIT);
} else {
alog("%s: %s!%s@%s unset the memo limit for %s",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user);
notice_lang(s_MemoServ, u, MEMO_UNSET_LIMIT,
chan ? chan : user);
}
}
return MOD_CONT;
}
int do_root(User *u)
{
char *buf = moduleGetLastBuffer();
char *cmd = myStrGetToken(buf, ' ', 0);
char *nick = myStrGetToken(buf, ' ', 1);
if (!cmd)
{
do_syntax_err(u);
}
else
{
if (!stricmp(cmd, "LIST"))
{
notice_user(s_OperServ, u, "Current services roots:");
int i;
for (i = 0; i < RootNumber; ++i)
{
notice_user(s_OperServ, u, "%d. %s", i + 1, ServicesRoots[i]);
}
notice_user(s_OperServ, u, "End of services root list.");
}
else if (!nick)
do_syntax_err(u);
else
{
NickAlias *na = findnick(nick);
if (!na)
notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick);
else if (!stricmp(cmd, "ADD"))
{
if (na->nc->flags & NI_SERVICES_ROOT)
{
notice_user(s_OperServ, u, "\2%s\2 is already a services root", na->nick);
}
else
{
++RootNumber;
ServicesRoots = srealloc(ServicesRoots, sizeof(char *) * RootNumber);
ServicesRoots[RootNumber - 1] = sstrdup(na->nick);
na->nc->flags |= NI_SERVICES_ROOT;
anope_cmd_global(s_OperServ, "\2%s\2 made \2%s\2 (\2%s\2) a services root administrator", u->nick, na->nick, na->nc->display);
alog("%s: %s!%s@%s made %s (%s) a services root administrator", s_OperServ, u->nick, u->username, u->host, na->nick, na->nc->display);
notice_user(s_OperServ, u, "\2%s\2 added to the services root administrator list.", na->nick);
}
}
else if (!stricmp(cmd, "DEL"))
{
if (!(na->nc->flags & NI_SERVICES_ROOT))
{
notice_user(s_OperServ, u, "\2%s\2 isn't already a services root", na->nick);
}
else
{
na->nc->flags &= ~NI_SERVICES_ROOT;
int i, j, removed = 0;
NickAlias *na2;
for (i = 0; i < RootNumber; ++i)
{
for (j = 0; j < na->nc->aliases.count; ++j)
{
na2 = na->nc->aliases.list[j];
if (ServicesRoots[i] && !stricmp(ServicesRoots[i], na2->nick))
{
free(ServicesRoots[i]);
ServicesRoots[i] = NULL;
++removed;
break;
}
}
}
int RealRootNum = RootNumber - removed;;
char **RealRoots = scalloc(RealRootNum, sizeof(char *));
j = 0;
for (i = 0; i < RootNumber; ++i)
{
if (ServicesRoots[i])
{
RealRoots[j] = sstrdup(ServicesRoots[i]);
++j;
}
}
free(ServicesRoots);
ServicesRoots = RealRoots;
RootNumber = RealRootNum;
anope_cmd_global(s_OperServ, "\2%s\2 removed \2%s\2 (\2%s\2) from being a services root administrator", u->nick, na->nick, na->nc->display);
alog("%s: %s!%s@%s made %s (%s) a services root administrator", s_OperServ, u->nick, u->username, u->host, na->nick, na->nc->display);
notice_user(s_OperServ, u, "\2%s\2 removed from the services root administrator list.", na->nick);
}
}
else
do_syntax_err(u);
}
}
if (cmd)
free(cmd);
if (nick)
free(nick);
return MOD_CONT;
}
XMLRPCUser(const Anope::string &nnick) : User(nnick, Config->NSEnforcerUser, Config->NSEnforcerHost, ""), na(findnick(nick))
{
this->realname = "XMLRPC User";
this->server = Me;
}
