users.cpp

Go to the documentation of this file.

/* Routines to maintain a list of online users.
 *
 * (C) 2003-2014 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */


#include "services.h"
#include "modules.h"
#include "users.h"
#include "account.h"
#include "protocol.h"
#include "servers.h"
#include "channels.h"
#include "bots.h"
#include "config.h"
#include "opertype.h"
#include "language.h"
#include "sockets.h"
#include "uplink.h"

user_map UserListByNick, UserListByUID;

int OperCount = 0;
unsigned MaxUserCount = 0;
time_t MaxUserTime = 0;

std::list<User *> User::quitting_users;

User::User(const Anope::string &snick, const Anope::string &sident, const Anope::string &shost, const Anope::string &svhost, const Anope::string &uip, Server *sserver, const Anope::string &srealname, time_t ts, const Anope::string &smodes, const Anope::string &suid, NickCore *account) : ip(uip)
{
        if (snick.empty() || sident.empty() || shost.empty())
                throw CoreException("Bad args passed to User::User");

        /* we used to do this by calloc, no more. */
        quit = false;
        server = NULL;
        invalid_pw_count = invalid_pw_time = lastmemosend = lastnickreg = lastmail = 0;
        on_access = false;

        this->nick = snick;
        this->ident = sident;
        this->host = shost;
        this->vhost = svhost;
        this->chost = svhost;
        this->server = sserver;
        this->realname = srealname;
        this->timestamp = this->signon = ts;
        this->SetModesInternal(sserver, "%s", smodes.c_str());
        this->uid = suid;
        this->super_admin = false;
        this->nc = NULL;

        size_t old = UserListByNick.size();
        UserListByNick[snick] = this;
        if (!suid.empty())
                UserListByUID[suid] = this;
        if (old == UserListByNick.size())
                Log(LOG_DEBUG) << "Duplicate user " << snick << " in user table?";

        this->Login(account);
        this->UpdateHost();

        if (sserver) // Our bots are introduced on startup with no server
        {
                ++sserver->users;
                if (server->IsSynced())
                        Log(this, "connect") << (!vhost.empty() && vhost != host ? "(" + vhost + ") " : "") << "(" << srealname << ") " << (!uip.empty() && uip != host ? "[" + uip + "] " : "") << "connected to the network (" << sserver->GetName() << ")";
        }

        if (UserListByNick.size() > MaxUserCount)
        {
                MaxUserCount = UserListByNick.size();
                MaxUserTime = Anope::CurTime;
                if (sserver && sserver->IsSynced())
                        Log(this, "maxusers") << "connected - new maximum user count: " << UserListByNick.size();
        }

        bool exempt = false;
        if (server && server->IsULined())
                exempt = true;
        FOREACH_MOD(OnUserConnect, (this, exempt));
}

static void CollideKill(User *target, const Anope::string &reason)
{
        if (target->server != Me)
                target->Kill(Me, reason);
        else
        {
                // Be sure my user is really dead
                IRCD->SendQuit(target, "%s", reason.c_str());

                // Reintroduce my client
                if (BotInfo *bi = dynamic_cast<BotInfo *>(target))
                        bi->OnKill();
                else
                        target->Quit(reason);
        }
}

static void Collide(User *u, const Anope::string &id, const Anope::string &type)
{
        // Kill incoming user
        IRCD->SendKill(Me, id, type);
        // Quit colliding user
        CollideKill(u, type);
}

User* User::OnIntroduce(const Anope::string &snick, const Anope::string &sident, const Anope::string &shost, const Anope::string &svhost, const Anope::string &sip, Server *sserver, const Anope::string &srealname, time_t ts, const Anope::string &smodes, const Anope::string &suid, NickCore *nc)
{
        // How IRCds handle collisions varies a lot, for safety well just always kill both sides
        // With properly set qlines, this can almost never happen anyway

        User *u = User::Find(snick, true);
        if (u)
        {
                Collide(u, !suid.empty() ? suid : snick, "Nick collision");
                return NULL;
        }

        if (!suid.empty())
        {
                u = User::Find(suid);
                if (u)
                {
                        Collide(u, suid, "ID collision");
                        return NULL;
                }
        }

        return new User(snick, sident, shost, svhost, sip, sserver, srealname, ts, smodes, suid, nc);
}

void User::ChangeNick(const Anope::string &newnick, time_t ts)
{
        /* Sanity check to make sure we don't segfault */
        if (newnick.empty())
                throw CoreException("User::ChangeNick() got a bad argument");
        
        this->super_admin = false;
        Log(this, "nick") << "(" << this->realname << ") changed nick to " << newnick;

        Anope::string old = this->nick;
        this->timestamp = ts;

        if (this->nick.equals_ci(newnick))
                this->nick = newnick;
        else
        {
                NickAlias *old_na = NickAlias::Find(this->nick);
                if (old_na && (this->IsIdentified(true) || this->IsRecognized()))
                        old_na->last_seen = Anope::CurTime;
                
                UserListByNick.erase(this->nick);

                this->nick = newnick;

                User* &other = UserListByNick[this->nick];
                if (other)
                {
                        CollideKill(this, "Nick collision");
                        CollideKill(other, "Nick collision");
                        return;
                }
                other = this;

                on_access = false;
                NickAlias *na = NickAlias::Find(this->nick);
                if (na)
                        on_access = na->nc->IsOnAccess(this);

                if (na && na->nc == this->Account())
                {
                        na->last_seen = Anope::CurTime;
                        this->UpdateHost();
                }
        }

        FOREACH_MOD(OnUserNickChange, (this, old));
}

void User::SetDisplayedHost(const Anope::string &shost)
{
        if (shost.empty())
                throw CoreException("empty host? in MY services? it seems it's more likely than I thought.");

        this->vhost = shost;

        Log(this, "host") << "changed vhost to " << shost;

        FOREACH_MOD(OnSetDisplayedHost, (this));

        this->UpdateHost();
}

const Anope::string &User::GetDisplayedHost() const
{
        if (!this->vhost.empty())
                return this->vhost;
        else if (this->HasMode("CLOAK") && !this->GetCloakedHost().empty())
                return this->GetCloakedHost();
        else
                return this->host;
}

void User::SetCloakedHost(const Anope::string &newhost)
{
        if (newhost.empty())
                throw CoreException("empty host in User::SetCloakedHost");

        chost = newhost;

        Log(this, "host") << "changed cloaked host to " << newhost;

        this->UpdateHost();
}

const Anope::string &User::GetCloakedHost() const
{
        return chost;
}

const Anope::string &User::GetUID() const
{
        if (!this->uid.empty() && IRCD->RequiresID)
                return this->uid;
        else
                return this->nick;
}

void User::SetVIdent(const Anope::string &sident)
{
        this->vident = sident;

        Log(this, "ident") << "changed vident to " << sident;

        this->UpdateHost();
}

const Anope::string &User::GetVIdent() const
{
        if (!this->vident.empty())
                return this->vident;
        else
                return this->ident;
}

void User::SetIdent(const Anope::string &sident)
{
        this->ident = sident;

        Log(this, "ident") << "changed real ident to " << sident;

        this->UpdateHost();
}

const Anope::string &User::GetIdent() const
{
        return this->ident;
}

Anope::string User::GetMask() const
{
        return this->nick + "!" + this->ident + "@" + this->host;
}

Anope::string User::GetDisplayedMask() const
{
        return this->nick + "!" + this->GetVIdent() + "@" + this->GetDisplayedHost();
}

void User::SetRealname(const Anope::string &srealname)
{
        if (srealname.empty())
                throw CoreException("realname empty in SetRealname");

        this->realname = srealname;
        NickAlias *na = NickAlias::Find(this->nick);

        if (na && (this->IsIdentified(true) || this->IsRecognized()))
                na->last_realname = srealname;

        Log(this, "realname") << "changed realname to " << srealname;
}

User::~User()
{
        if (this->server != NULL)
        {
                if (this->server->IsSynced())
                        Log(this, "disconnect") << "(" << this->realname << ") disconnected from the network (" << this->server->GetName() << ")";
                --this->server->users;
        }

        FOREACH_MOD(OnPreUserLogoff, (this));

        ModeManager::StackerDel(this);
        this->Logout();

        if (this->HasMode("OPER"))
                --OperCount;

        while (!this->chans.empty())
                this->chans.begin()->second->chan->DeleteUser(this);

        UserListByNick.erase(this->nick);
        if (!this->uid.empty())
                UserListByUID.erase(this->uid);

        FOREACH_MOD(OnPostUserLogoff, (this));
}

void User::SendMessage(BotInfo *source, const char *fmt, ...)
{
        va_list args;
        char buf[BUFSIZE] = "";

        const char *translated_message = Language::Translate(this, fmt);

        va_start(args, fmt);
        vsnprintf(buf, BUFSIZE - 1, translated_message, args);

        this->SendMessage(source, Anope::string(buf));

        va_end(args);
}

void User::SendMessage(BotInfo *source, const Anope::string &msg)
{
        const char *translated_message = Language::Translate(this, msg.c_str());

        /* Send privmsg instead of notice if:
        * - UsePrivmsg is enabled
        * - The user is not registered and NSDefMsg is enabled
        * - The user is registered and has set /ns set msg on
        */
        bool send_privmsg = Config->UsePrivmsg && ((!this->nc && Config->DefPrivmsg) || (this->nc && this->nc->HasExt("MSG")));
        sepstream sep(translated_message, '\n', true);
        for (Anope::string tok; sep.GetToken(tok);)
        {
                if (send_privmsg)
                        IRCD->SendPrivmsg(source, this->GetUID(), "%s", tok.c_str());
                else
                        IRCD->SendNotice(source, this->GetUID(), "%s", tok.c_str());
        }
}

void User::Identify(NickAlias *na)
{
        if (this->nick.equals_ci(na->nick))
        {
                na->last_usermask = this->GetIdent() + "@" + this->GetDisplayedHost();
                na->last_realhost = this->GetIdent() + "@" + this->host;
                na->last_realname = this->realname;
                na->last_seen = Anope::CurTime;
        }

        IRCD->SendLogin(this, na);

        this->Login(na->nc);

        FOREACH_MOD(OnNickIdentify, (this));

        if (this->IsServicesOper())
        {
                if (!this->nc->o->ot->modes.empty())
                {
                        this->SetModes(NULL, "%s", this->nc->o->ot->modes.c_str());
                        this->SendMessage(NULL, "Changing your usermodes to \002%s\002", this->nc->o->ot->modes.c_str());
                        UserMode *um = ModeManager::FindUserModeByName("OPER");
                        if (um && !this->HasMode("OPER") && this->nc->o->ot->modes.find(um->mchar) != Anope::string::npos)
                                IRCD->SendOper(this);
                }
                if (IRCD->CanSetVHost && !this->nc->o->vhost.empty())
                {
                        this->SendMessage(NULL, "Changing your vhost to \002%s\002", this->nc->o->vhost.c_str());
                        this->SetDisplayedHost(this->nc->o->vhost);
                        IRCD->SendVhost(this, "", this->nc->o->vhost);
                }
        }
}


void User::Login(NickCore *core)
{
        if (!core || core == this->nc)
                return;

        this->Logout();
        this->nc = core;
        core->users.push_back(this);

        this->UpdateHost();

        if (this->server->IsSynced())
                Log(this, "account") << "is now identified as " << this->nc->display;
        
        FOREACH_MOD(OnUserLogin, (this));
}

void User::Logout()
{
        if (!this->nc)
                return;
        
        Log(this, "account") << "is no longer identified as " << this->nc->display;

        std::list<User *>::iterator it = std::find(this->nc->users.begin(), this->nc->users.end(), this);
        if (it != this->nc->users.end())
                this->nc->users.erase(it);

        this->nc = NULL;
}

NickCore *User::Account() const
{
        return this->nc;
}

bool User::IsIdentified(bool check_nick) const
{
        if (check_nick && this->nc)
        {
                NickAlias *na = NickAlias::Find(this->nick);
                return na && *na->nc == *this->nc;
        }

        return this->nc ? true : false;
}

bool User::IsRecognized(bool check_secure) const
{
        if (check_secure && on_access)
        {
                const NickAlias *na = NickAlias::Find(this->nick);

                if (!na || na->nc->HasExt("NS_SECURE"))
                        return false;
        }

        return on_access;
}

bool User::IsServicesOper()
{
        if (!this->nc || !this->nc->IsServicesOper())
                // No opertype.
                return false;
        else if (this->nc->o->require_oper && !this->HasMode("OPER"))
                return false;
        else if (!this->nc->o->certfp.empty() && this->fingerprint != this->nc->o->certfp)
                // Certfp mismatch
                return false;
        else if (!this->nc->o->hosts.empty())
        {
                bool match = false;
                Anope::string match_host = this->GetIdent() + "@" + this->host;
                for (unsigned i = 0; i < this->nc->o->hosts.size(); ++i)
                        if (Anope::Match(match_host, this->nc->o->hosts[i]))
                                match = true;
                if (match == false)
                        return false;
        }

        EventReturn MOD_RESULT;
        FOREACH_RESULT(IsServicesOper, MOD_RESULT, (this));
        if (MOD_RESULT == EVENT_STOP)
                return false;

        return true;
}

bool User::HasCommand(const Anope::string &command)
{
        if (this->IsServicesOper())
                return this->nc->o->ot->HasCommand(command);
        return false;
}

bool User::HasPriv(const Anope::string &priv)
{
        if (this->IsServicesOper())
                return this->nc->o->ot->HasPriv(priv);
        return false;
}

void User::UpdateHost()
{
        if (this->host.empty())
                return;

        NickAlias *na = NickAlias::Find(this->nick);
        on_access = false;
        if (na)
                on_access = na->nc->IsOnAccess(this);

        if (na && (this->IsIdentified(true) || this->IsRecognized()))
        {
                Anope::string last_usermask = this->GetIdent() + "@" + this->GetDisplayedHost();
                Anope::string last_realhost = this->GetIdent() + "@" + this->host;
                na->last_usermask = last_usermask;
                na->last_realhost = last_realhost;
        }
}

bool User::HasMode(const Anope::string &mname) const
{
        return this->modes.count(mname);
}

void User::SetModeInternal(const MessageSource &source, UserMode *um, const Anope::string &param)
{
        if (!um)
                return;

        this->modes[um->name] = param;

        if (um->name == "OPER")
        {
                ++OperCount;

                if (this->IsServicesOper())
                {
                        if (!this->nc->o->ot->modes.empty())
                        {
                                this->SetModes(NULL, "%s", this->nc->o->ot->modes.c_str());
                                this->SendMessage(NULL, "Changing your usermodes to \002%s\002", this->nc->o->ot->modes.c_str());
                                UserMode *oper = ModeManager::FindUserModeByName("OPER");
                                if (oper && !this->HasMode("OPER") && this->nc->o->ot->modes.find(oper->mchar) != Anope::string::npos)
                                        IRCD->SendOper(this);
                        }
                        if (IRCD->CanSetVHost && !this->nc->o->vhost.empty())
                        {
                                this->SendMessage(NULL, "Changing your vhost to \002%s\002", this->nc->o->vhost.c_str());
                                this->SetDisplayedHost(this->nc->o->vhost);
                                IRCD->SendVhost(this, "", this->nc->o->vhost);
                        }
                }
        }

        if (um->name == "CLOAK" || um->name == "VHOST")
                this->UpdateHost();

        FOREACH_MOD(OnUserModeSet, (source, this, um->name));
}

void User::RemoveModeInternal(const MessageSource &source, UserMode *um)
{
        if (!um)
                return;

        this->modes.erase(um->name);

        if (um->name == "OPER")
                --OperCount;

        if (um->name == "CLOAK" || um->name == "VHOST")
        {
                this->vhost.clear();
                this->UpdateHost();
        }

        FOREACH_MOD(OnUserModeUnset, (source, this, um->name));
}

void User::SetMode(BotInfo *bi, UserMode *um, const Anope::string &param)
{
        if (!um || HasMode(um->name))
                return;

        ModeManager::StackerAdd(bi, this, um, true, param);
        SetModeInternal(bi, um, param);
}

void User::SetMode(BotInfo *bi, const Anope::string &uname, const Anope::string &param)
{
        SetMode(bi, ModeManager::FindUserModeByName(uname), param);
}

void User::RemoveMode(BotInfo *bi, UserMode *um, const Anope::string &param)
{
        if (!um || !HasMode(um->name))
                return;

        ModeManager::StackerAdd(bi, this, um, false, param);
        RemoveModeInternal(bi, um);
}

void User::RemoveMode(BotInfo *bi, const Anope::string &name, const Anope::string &param)
{
        RemoveMode(bi, ModeManager::FindUserModeByName(name), param);
}

void User::SetModes(BotInfo *bi, const char *umodes, ...)
{
        char buf[BUFSIZE] = "";
        va_list args;
        Anope::string modebuf, sbuf;
        int add = -1;
        va_start(args, umodes);
        vsnprintf(buf, BUFSIZE - 1, umodes, args);
        va_end(args);

        spacesepstream sep(buf);
        sep.GetToken(modebuf);
        for (unsigned i = 0, end = modebuf.length(); i < end; ++i)
        {
                UserMode *um;

                switch (modebuf[i])
                {
                        case '+':
                                add = 1;
                                continue;
                        case '-':
                                add = 0;
                                continue;
                        default:
                                if (add == -1)
                                        continue;
                                um = ModeManager::FindUserModeByChar(modebuf[i]);
                                if (!um)
                                        continue;
                }

                if (add)
                {
                        if (um->type == MODE_PARAM && sep.GetToken(sbuf))
                                this->SetMode(bi, um, sbuf);
                        else
                                this->SetMode(bi, um);
                }
                else
                        this->RemoveMode(bi, um);
        }
}

void User::SetModesInternal(const MessageSource &source, const char *umodes, ...)
{
        char buf[BUFSIZE] = "";
        va_list args;
        Anope::string modebuf, sbuf;
        int add = -1;
        va_start(args, umodes);
        vsnprintf(buf, BUFSIZE - 1, umodes, args);
        va_end(args);

        if (this->server && this->server->IsSynced() && Anope::string(buf) != "+")
                Log(this, "mode") << "changes modes to " << buf;

        spacesepstream sep(buf);
        sep.GetToken(modebuf);
        for (unsigned i = 0, end = modebuf.length(); i < end; ++i)
        {
                UserMode *um;

                switch (modebuf[i])
                {
                        case '+':
                                add = 1;
                                continue;
                        case '-':
                                add = 0;
                                continue;
                        default:
                                if (add == -1)
                                        continue;
                                um = ModeManager::FindUserModeByChar(modebuf[i]);
                                if (!um)
                                        continue;
                }

                if (add)
                {
                        if (um->type == MODE_PARAM && sep.GetToken(sbuf))
                                this->SetModeInternal(source, um, sbuf);
                        else
                                this->SetModeInternal(source, um);
                }
                else
                        this->RemoveModeInternal(source, um);
        }
}

Anope::string User::GetModes() const
{
        Anope::string m, params;

        for (ModeList::const_iterator it = this->modes.begin(), it_end = this->modes.end(); it != it_end; ++it)
        {
                UserMode *um = ModeManager::FindUserModeByName(it->first);
                if (um == NULL)
                        continue;

                m += um->mchar;

                if (!it->second.empty())
                        params += " " + it->second;
        }

        return m + params;
}

const User::ModeList &User::GetModeList() const
{
        return modes;
}

ChanUserContainer *User::FindChannel(Channel *c) const
{
        User::ChanUserList::const_iterator it = this->chans.find(c);
        if (it != this->chans.end())
                return it->second;
        return NULL;
}

bool User::IsProtected()
{
        return this->HasMode("PROTECTED") || this->HasMode("GOD") || this->HasPriv("protected") || (this->server && this->server->IsULined());
}

void User::Kill(const MessageSource &source, const Anope::string &reason)
{
        Anope::string real_reason = source.GetName() + " (" + reason + ")";

        IRCD->SendSVSKill(source, this, "%s", real_reason.c_str());
}

void User::KillInternal(const MessageSource &source, const Anope::string &reason)
{
        if (this->quit)
        {
                Log(LOG_DEBUG) << "Duplicate quit for " << this->nick;
                return;
        }

        Log(this, "killed") << "was killed by " << source.GetName() << " (Reason: " << reason << ")";

        this->Quit(reason);
}

void User::Quit(const Anope::string &reason)
{
        if (this->quit)
        {
                Log(LOG_DEBUG) << "Duplicate quit for " << this->nick;
                return;
        }

        FOREACH_MOD(OnUserQuit, (this, reason));

        this->quit = true;
        quitting_users.push_back(this);
}

bool User::Quitting() const
{
        return this->quit;
}

Anope::string User::Mask() const
{
        Anope::string mask;
        const Anope::string &mident = this->GetIdent();
        const Anope::string &mhost = this->GetDisplayedHost();

        if (mident[0] == '~')
                mask = "*" + mident + "@";
        else
                mask = mident + "@";

        sockaddrs addr(mhost);
        if (addr.valid() && addr.sa.sa_family == AF_INET)
        {
                size_t dot = mhost.find('.');
                mask += mhost.substr(0, dot) + (dot == Anope::string::npos ? "" : ".*");
        }
        else
        {
                size_t dot = mhost.find('.');
                if (dot != Anope::string::npos && mhost.find('.', dot + 1) != Anope::string::npos)
                        mask += "*" + mhost.substr(dot);
                else
                        mask += mhost;
        }

        return mask;
}

bool User::BadPassword()
{
        if (!Config->GetBlock("options")->Get<int>("badpasslimit"))
                return false;

        if (Config->GetBlock("options")->Get<time_t>("badpasstimeout") > 0 && this->invalid_pw_time > 0 && this->invalid_pw_time < Anope::CurTime - Config->GetBlock("options")->Get<time_t>("badpasstimeout"))
                this->invalid_pw_count = 0;
        ++this->invalid_pw_count;
        this->invalid_pw_time = Anope::CurTime;
        if (this->invalid_pw_count >= Config->GetBlock("options")->Get<int>("badpasslimit"))
        {
                this->Kill(Me->GetName(), "Too many invalid passwords");
                return true;
        }

        return false;
}

User* User::Find(const Anope::string &name, bool nick_only)
{
        if (!nick_only && IRCD->RequiresID)
        {
                user_map::iterator it = UserListByUID.find(name);
                if (it != UserListByUID.end())
                        return it->second;

                if (IRCD->AmbiguousID)
                        return NULL;
        }

        user_map::iterator it = UserListByNick.find(name);
        if (it != UserListByNick.end())
                return it->second;

        return NULL;
}

void User::QuitUsers()
{
        for (std::list<User *>::iterator it = quitting_users.begin(), it_end = quitting_users.end(); it != it_end; ++it)
                delete *it;
        quitting_users.clear();
}