Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » src

users.cpp

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

/* $Core */

#include "inspircd.h"
#include <stdarg.h>
#include "socketengine.h"
#include "xline.h"
#include "bancache.h"
#include "commands/cmd_whowas.h"

/* XXX: Used for speeding up WriteCommon operations */
unsigned long uniq_id = 1;

static unsigned long* already_sent = NULL;


void InitializeAlreadySent(SocketEngine* SE)
{
        already_sent = new unsigned long[SE->GetMaxFds()];
        memset(already_sent, 0, SE->GetMaxFds() * sizeof(unsigned long));
}


std::string User::ProcessNoticeMasks(const char *sm)
{
        bool adding = true, oldadding = false;
        const char *c = sm;
        std::string output;

        while (c && *c)
        {
                switch (*c)
                {
                        case '+':
                                adding = true;
                        break;
                        case '-':
                                adding = false;
                        break;
                        case '*':
                                for (unsigned char d = 'A'; d <= 'z'; d++)
                                {
                                        if (ServerInstance->SNO->IsEnabled(d))
                                        {
                                                if ((!IsNoticeMaskSet(d) && adding) || (IsNoticeMaskSet(d) && !adding))
                                                {
                                                        if ((oldadding != adding) || (!output.length()))
                                                                output += (adding ? '+' : '-');

                                                        this->SetNoticeMask(d, adding);

                                                        output += d;
                                                }
                                        }
                                        oldadding = adding;
                                }
                        break;
                        default:
                                if ((*c >= 'A') && (*c <= 'z') && (ServerInstance->SNO->IsEnabled(*c)))
                                {
                                        if ((!IsNoticeMaskSet(*c) && adding) || (IsNoticeMaskSet(*c) && !adding))
                                        {
                                                if ((oldadding != adding) || (!output.length()))
                                                        output += (adding ? '+' : '-');

                                                this->SetNoticeMask(*c, adding);

                                                output += *c;
                                        }
                                }
                                else
                                        this->WriteNumeric(ERR_UNKNOWNSNOMASK, "%s %c :is unknown snomask char to me", this->nick.c_str(), *c);

                                oldadding = adding;
                        break;
                }

                *c++;
        }

        return output;
}

void User::StartDNSLookup()
{
        try
        {
                bool cached = false;
                const char* sip = this->GetIPString(false);

                /* Special case for 4in6 (Have i mentioned i HATE 4in6?) */
                if (!strncmp(sip, "0::ffff:", 8))
                        res_reverse = new UserResolver(this->ServerInstance, this, sip + 8, DNS_QUERY_PTR4, cached);
                else
                        res_reverse = new UserResolver(this->ServerInstance, this, sip, this->GetProtocolFamily() == AF_INET ? DNS_QUERY_PTR4 : DNS_QUERY_PTR6, cached);

                this->ServerInstance->AddResolver(res_reverse, cached);
        }
        catch (CoreException& e)
        {
                ServerInstance->Logs->Log("USERS", DEBUG,"Error in resolver: %s",e.GetReason());
        }
}

bool User::IsNoticeMaskSet(unsigned char sm)
{
        if (!isalpha(sm))
                return false;
        return (snomasks[sm-65]);
}

void User::SetNoticeMask(unsigned char sm, bool value)
{
        if (!isalpha(sm))
                return;
        snomasks[sm-65] = value;
}

const char* User::FormatNoticeMasks()
{
        static char data[MAXBUF];
        int offset = 0;

        for (int n = 0; n < 64; n++)
        {
                if (snomasks[n])
                        data[offset++] = n+65;
        }

        data[offset] = 0;
        return data;
}

bool User::IsModeSet(unsigned char m)
{
        if (!isalpha(m))
                return false;
        return (modes[m-65]);
}

void User::SetMode(unsigned char m, bool value)
{
        if (!isalpha(m))
                return;
        modes[m-65] = value;
}

const char* User::FormatModes()
{
        static char data[MAXBUF];
        int offset = 0;
        for (int n = 0; n < 64; n++)
        {
                if (modes[n])
                        data[offset++] = n+65;
        }
        data[offset] = 0;
        return data;
}

void User::DecrementModes()
{
        ServerInstance->Logs->Log("USERS", DEBUG, "DecrementModes()");
        for (unsigned char n = 'A'; n <= 'z'; n++)
        {
                if (modes[n-65])
                {
                        ServerInstance->Logs->Log("USERS", DEBUG,"DecrementModes() found mode %c", n);
                        ModeHandler* mh = ServerInstance->Modes->FindMode(n, MODETYPE_USER);
                        if (mh)
                        {
                                ServerInstance->Logs->Log("USERS", DEBUG,"Found handler %c and call ChangeCount", n);
                                mh->ChangeCount(-1);
                        }
                }
        }
}

User::User(InspIRCd* Instance, const std::string &uid) : ServerInstance(Instance)
{
        server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName);
        reset_due = ServerInstance->Time();
        age = ServerInstance->Time();
        Penalty = 0;
        lines_in = lastping = signon = idle_lastmsg = nping = registered = 0;
        bytes_in = bytes_out = cmds_in = cmds_out = 0;
        quietquit = OverPenalty = ExemptFromPenalty = quitting = exempt = haspassed = dns_done = false;
        fd = -1;
        recvq.clear();
        sendq.clear();
        res_forward = res_reverse = NULL;
        Visibility = NULL;
        ip = NULL;
        MyClass = NULL;
        io = NULL;
        AllowedUserModes = NULL;
        AllowedChanModes = NULL;
        AllowedOperCommands = NULL;
        chans.clear();
        invites.clear();

        if (uid.empty())
                uuid.assign(Instance->GetUID(), 0, UUID_LENGTH - 1);
        else
                uuid.assign(uid, 0, UUID_LENGTH - 1);

        ServerInstance->Logs->Log("USERS", DEBUG,"New UUID for user: %s (%s)", uuid.c_str(), uid.empty() ? "allocated new" : "used remote");

        user_hash::iterator finduuid = Instance->Users->uuidlist->find(uuid);
        if (finduuid == Instance->Users->uuidlist->end())
                (*Instance->Users->uuidlist)[uuid] = this;
        else
                throw CoreException("Duplicate UUID "+std::string(uuid)+" in User constructor");
}

User::~User()
{
        /* NULL for remote users :) */
        if (this->MyClass)
        {
                this->MyClass->RefCount--;
                ServerInstance->Logs->Log("USERS", DEBUG, "User destructor -- connect refcount now: %lu", this->MyClass->RefCount);
        }
        if (this->AllowedOperCommands)
        {
                delete AllowedOperCommands;
                AllowedOperCommands = NULL;
        }

        if (this->AllowedUserModes)
        {
                delete[] AllowedUserModes;
                AllowedUserModes = NULL;
        }

        if (this->AllowedChanModes)
        {
                delete[] AllowedChanModes;
                AllowedChanModes = NULL;
        }

        this->InvalidateCache();
        this->DecrementModes();

        if (ip)
        {
                ServerInstance->Users->RemoveCloneCounts(this);

                if (this->GetProtocolFamily() == AF_INET)
                {
                        delete (sockaddr_in*)ip;
                }
#ifdef SUPPORT_IP6LINKS
                else
                {
                        delete (sockaddr_in6*)ip;
                }
#endif
        }

        ServerInstance->Users->uuidlist->erase(uuid);
}

const std::string& User::MakeHost()
{
        if (!this->cached_makehost.empty())
                return this->cached_makehost;

        char nhost[MAXBUF];
        /* This is much faster than snprintf */
        char* t = nhost;
        for(const char* n = ident.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '@';
        for(const char* n = host.c_str(); *n; n++)
                *t++ = *n;
        *t = 0;

        this->cached_makehost.assign(nhost);

        return this->cached_makehost;
}

const std::string& User::MakeHostIP()
{
        if (!this->cached_hostip.empty())
                return this->cached_hostip;

        char ihost[MAXBUF];
        /* This is much faster than snprintf */
        char* t = ihost;
        for(const char* n = ident.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '@';
        for(const char* n = this->GetIPString(); *n; n++)
                *t++ = *n;
        *t = 0;

        this->cached_hostip = ihost;

        return this->cached_hostip;
}

void User::CloseSocket()
{
        if (this->fd > -1)
        {
                ServerInstance->SE->Shutdown(this, 2);
                ServerInstance->SE->Close(this);
        }
}

const std::string& User::GetFullHost()
{
        if (!this->cached_fullhost.empty())
                return this->cached_fullhost;

        char result[MAXBUF];
        char* t = result;
        for(const char* n = nick.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '!';
        for(const char* n = ident.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '@';
        for(const char* n = dhost.c_str(); *n; n++)
                *t++ = *n;
        *t = 0;

        this->cached_fullhost = result;

        return this->cached_fullhost;
}

char* User::MakeWildHost()
{
        static char nresult[MAXBUF];
        char* t = nresult;
        *t++ = '*';     *t++ = '!';
        *t++ = '*';     *t++ = '@';
        for(const char* n = dhost.c_str(); *n; n++)
                *t++ = *n;
        *t = 0;
        return nresult;
}

int User::ReadData(void* buffer, size_t size)
{
        if (IS_LOCAL(this))
        {
#ifndef WIN32
                return read(this->fd, buffer, size);
#else
                return recv(this->fd, (char*)buffer, size, 0);
#endif
        }
        else
                return 0;
}


const std::string& User::GetFullRealHost()
{
        if (!this->cached_fullrealhost.empty())
                return this->cached_fullrealhost;

        char fresult[MAXBUF];
        char* t = fresult;
        for(const char* n = nick.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '!';
        for(const char* n = ident.c_str(); *n; n++)
                *t++ = *n;
        *t++ = '@';
        for(const char* n = host.c_str(); *n; n++)
                *t++ = *n;
        *t = 0;

        this->cached_fullrealhost = fresult;

        return this->cached_fullrealhost;
}

bool User::IsInvited(const irc::string &channel)
{
        time_t now = time(NULL);
        InvitedList::iterator safei;
        for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
        {
                if (channel == i->first)
                {
                        if (i->second != 0 && now > i->second)
                        {
                                /* Expired invite, remove it. */
                                safei = i;
                                --i;
                                invites.erase(safei);
                                continue;
                        }
                        return true;
                }
        }
        return false;
}

InvitedList* User::GetInviteList()
{
        time_t now = time(NULL);
        /* Weed out expired invites here. */
        InvitedList::iterator safei;
        for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
        {
                if (i->second != 0 && now > i->second)
                {
                        /* Expired invite, remove it. */
                        safei = i;
                        --i;
                        invites.erase(safei);
                }
        }
        return &invites;
}

void User::InviteTo(const irc::string &channel, time_t invtimeout)
{
        time_t now = time(NULL);
        if (invtimeout != 0 && now > invtimeout) return; /* Don't add invites that are expired from the get-go. */
        for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
        {
                if (channel == i->first)
                {
                        if (i->second != 0 && invtimeout > i->second)
                        {
                                i->second = invtimeout;
                        }

                        return;
                }
        }
        invites.push_back(std::make_pair(channel, invtimeout));
}

void User::RemoveInvite(const irc::string &channel)
{
        for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++)
        {
                if (channel == i->first)
                {
                        invites.erase(i);
                        return;
                }
        }
}

bool User::HasModePermission(unsigned char mode, ModeType type)
{
        if (!IS_LOCAL(this))
                return true;

        if (!IS_OPER(this))
                return false;

        if (!AllowedUserModes || !AllowedChanModes)
                return false;

        return ((type == MODETYPE_USER ? AllowedUserModes : AllowedChanModes))[(mode - 'A')];
        
}

bool User::HasPermission(const std::string &command)
{
        /*
         * users on remote servers can completely bypass all permissions based checks.
         * This prevents desyncs when one server has different type/class tags to another.
         * That having been said, this does open things up to the possibility of source changes
         * allowing remote kills, etc - but if they have access to the src, they most likely have
         * access to the conf - so it's an end to a means either way.
         */
        if (!IS_LOCAL(this))
                return true;

        // are they even an oper at all?
        if (!IS_OPER(this))
        {
                return false;
        }

        if (!AllowedOperCommands)
                return false;

        if (AllowedOperCommands->find(command) != AllowedOperCommands->end())
                return true;
        else if (AllowedOperCommands->find("*") != AllowedOperCommands->end())
                return true;

        return false;
}

bool User::AddBuffer(const std::string &a)
{
        std::string::size_type start = 0;
        std::string::size_type i = a.find('\r');

        /*
         * The old implementation here took a copy, and rfind() on \r, removing as it found them, before
         * copying a second time onto the recvq. That's ok, but involves three copies minimum (recv() to buffer,
         * buffer to here, here to recvq) - The new method now copies twice (recv() to buffer, buffer to recvq).
         *
         * We use find() instead of rfind() for clarity, however unlike the old code, our scanning of the string is
         * contiguous: as we specify a startpoint, we never see characters we have scanned previously, making this
         * marginally faster in cases with a number of \r hidden early on in the buffer.
         *
         * How it works:
         * Start at first pos of string, find first \r, append everything in the chunk (excluding \r) to recvq. Set
         * i ahead of the \r, search for next \r, add next chunk to buffer... repeat.
         *              -- w00t (7 may, 2008)
         */
        if (i == std::string::npos)
        {
                // no \r that we need to dance around, just add to buffer
                recvq.append(a);
        }
        else
        {
                // While we can find the end of a chunk to add
                while (i != std::string::npos)
                {
                        // Append the chunk that we have
                        recvq.append(a, start, (i - start));

                        // Start looking for the next one
                        start = i + 1;
                        i = a.find('\r', start);
                }

                if (start != a.length())
                {
                        /*
                         * This is here to catch a corner case when we get something like:
                         * NICK w0
                         * 0t\r\nU
                         * SER ...
                         * in successive calls to us.
                         *
                         * Without this conditional, the 'U' on the second case will be dropped,
                         * which is most *certainly* not the behaviour we want!
                         *              -- w00t
                         */
                        recvq.append(a, start, (a.length() - start));
                }
        }

        if (this->MyClass && (recvq.length() > this->MyClass->GetRecvqMax()))
        {
                ServerInstance->Users->QuitUser(this, "RecvQ exceeded");
                ServerInstance->SNO->WriteToSnoMask('A', "User %s RecvQ of %lu exceeds connect class maximum of %lu",this->nick.c_str(),(unsigned long int)recvq.length(),this->MyClass->GetRecvqMax());
                return false;
        }

        return true;
}

bool User::BufferIsReady()
{
        return (recvq.find('\n') != std::string::npos);
}

void User::ClearBuffer()
{
        recvq.clear();
}

std::string User::GetBuffer()
{
        try
        {
                if (recvq.empty())
                        return "";

                /* Strip any leading \r or \n off the string.
                 * Usually there are only one or two of these,
                 * so its is computationally cheap to do.
                 */
                std::string::iterator t = recvq.begin();
                while (t != recvq.end() && (*t == '\r' || *t == '\n'))
                {
                        recvq.erase(t);
                        t = recvq.begin();
                }

                for (std::string::iterator x = recvq.begin(); x != recvq.end(); x++)
                {
                        /* Find the first complete line, return it as the
                         * result, and leave the recvq as whats left
                         */
                        if (*x == '\n')
                        {
                                std::string ret = std::string(recvq.begin(), x);
                                recvq.erase(recvq.begin(), x + 1);
                                return ret;
                        }
                }
                return "";
        }

        catch (...)
        {
                ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::GetBuffer()");
                return "";
        }
}

void User::AddWriteBuf(const std::string &data)
{
        if (this->quitting)
                return;

        if (this->MyClass && (sendq.length() + data.length() > this->MyClass->GetSendqMax()))
        {
                /*
                 * Fix by brain - Set the error text BEFORE calling, because
                 * if we dont it'll recursively  call here over and over again trying
                 * to repeatedly add the text to the sendq!
                 */
                ServerInstance->Users->QuitUser(this, "SendQ exceeded");
                ServerInstance->SNO->WriteToSnoMask('A', "User %s SendQ of %lu exceeds connect class maximum of %lu",this->nick.c_str(),(unsigned long int)sendq.length() + data.length(),this->MyClass->GetSendqMax());
                return;
        }

        if (data.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */
                sendq.append(data.substr(0,MAXBUF - 4)).append("\r\n"); /* MAXBUF-4 = 510 */
        else
                sendq.append(data);
}

// send AS MUCH OF THE USERS SENDQ as we are able to (might not be all of it)
void User::FlushWriteBuf()
{
        if (this->fd == FD_MAGIC_NUMBER)
        {
                sendq.clear();
                return;
        }

        if ((sendq.length()) && (this->fd != FD_MAGIC_NUMBER))
        {
                int old_sendq_length = sendq.length();
                int n_sent = ServerInstance->SE->Send(this, this->sendq.data(), this->sendq.length(), 0);

                if (n_sent == -1)
                {
                        if (errno == EAGAIN)
                        {
                                /* The socket buffer is full. This isnt fatal,
                                 * try again later.
                                 */
                                ServerInstance->SE->WantWrite(this);
                        }
                        else
                        {
                                /* Fatal error, set write error and bail */
                                ServerInstance->Users->QuitUser(this, errno ? strerror(errno) : "Write error");
                                return;
                        }
                }
                else
                {
                        /* advance the queue */
                        if (n_sent)
                                this->sendq = this->sendq.substr(n_sent);
                        /* update the user's stats counters */
                        this->bytes_out += n_sent;
                        this->cmds_out++;
                        if (n_sent != old_sendq_length)
                                this->ServerInstance->SE->WantWrite(this);
                }
        }

        /* note: NOT else if! */
        if (this->sendq.empty())
        {
                FOREACH_MOD(I_OnBufferFlushed,OnBufferFlushed(this));
        }
}

void User::Oper(const std::string &opertype, const std::string &opername)
{
        char* mycmd;
        char* savept;
        char* savept2;

        if (this->IsModeSet('o'))
                this->UnOper();

        this->modes[UM_OPERATOR] = 1;
        this->WriteServ("MODE %s :+o", this->nick.c_str());
        FOREACH_MOD(I_OnOper, OnOper(this, opertype));

        ServerInstance->SNO->WriteToSnoMask('o',"%s (%s@%s) is now an IRC operator of type %s (using oper '%s')", this->nick.c_str(), this->ident.c_str(), this->host.c_str(), irc::Spacify(opertype.c_str()), opername.c_str());
        this->WriteNumeric(381, "%s :You are now %s %s", this->nick.c_str(), strchr("aeiouAEIOU", *opertype.c_str()) ? "an" : "a", irc::Spacify(opertype.c_str()));

        ServerInstance->Logs->Log("OPER", DEFAULT, "%s!%s@%s opered as type: %s", this->nick.c_str(), this->ident.c_str(), this->host.c_str(), opertype.c_str());
        this->oper.assign(opertype, 0, 512);
        ServerInstance->Users->all_opers.push_back(this);

        opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper.c_str());
        if (iter_opertype != ServerInstance->Config->opertypes.end())
        {

                if (AllowedOperCommands)
                        AllowedOperCommands->clear();
                else
                        AllowedOperCommands = new std::map<std::string, bool>;

                if (!AllowedChanModes)
                        AllowedChanModes = new bool[64];

                if (!AllowedUserModes)
                        AllowedUserModes = new bool[64];

                memset(AllowedUserModes, 0, 64);
                memset(AllowedChanModes, 0, 64);

                char* Classes = strdup(iter_opertype->second);
                char* myclass = strtok_r(Classes," ",&savept);
                while (myclass)
                {
                        operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass);
                        if (iter_operclass != ServerInstance->Config->operclass.end())
                        {
                                char* CommandList = strdup(iter_operclass->second.commandlist);
                                mycmd = strtok_r(CommandList," ",&savept2);
                                while (mycmd)
                                {
                                        this->AllowedOperCommands->insert(std::make_pair(mycmd, true));
                                        mycmd = strtok_r(NULL," ",&savept2);
                                }
                                free(CommandList);
                                this->AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want.
                                for (unsigned char* c = (unsigned char*)iter_operclass->second.umodelist; *c; ++c)
                                {
                                        if (*c == '*')
                                        {
                                                memset(this->AllowedUserModes, (int)(true), 64);
                                        }
                                        else
                                        {
                                                this->AllowedUserModes[*c - 'A'] = true;
                                        }
                                }
                                for (unsigned char* c = (unsigned char*)iter_operclass->second.cmodelist; *c; ++c)
                                {
                                        if (*c == '*')
                                        {
                                                memset(this->AllowedChanModes, (int)(true), 64);
                                        }
                                        else
                                        {
                                                this->AllowedChanModes[*c - 'A'] = true;
                                        }
                                }
                        }
                        myclass = strtok_r(NULL," ",&savept);
                }
                free(Classes);
        }

        FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype, opername));
}

void User::UnOper()
{
        if (IS_OPER(this))
        {
                /*
                 * unset their oper type (what IS_OPER checks).
                 * note, order is important - this must come before modes as -o attempts
                 * to call UnOper. -- w00t
                 */
                this->oper.clear();

                /* Remove all oper only modes from the user when the deoper - Bug #466*/
                std::string moderemove("-");

                for (unsigned char letter = 'A'; letter <= 'z'; letter++)
                {
                        ModeHandler* mh = ServerInstance->Modes->FindMode(letter, MODETYPE_USER);
                        if (mh && mh->NeedsOper())
                                moderemove += letter;
                }

                std::vector<std::string> parameters;
                parameters.push_back(this->nick);
                parameters.push_back(moderemove);

                ServerInstance->Parser->CallHandler("MODE", parameters, this);
                        
                /* remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 */
                ServerInstance->Users->all_opers.remove(this);

                if (AllowedOperCommands)
                {
                        delete AllowedOperCommands;
                        AllowedOperCommands = NULL;
                }
                if (AllowedUserModes)
                {
                        delete[] AllowedUserModes;
                        AllowedUserModes = NULL;
                }
                if (AllowedChanModes)
                {
                        delete[] AllowedChanModes;
                        AllowedChanModes = NULL;
                }

        }
}

/* adds or updates an entry in the whowas list */
void User::AddToWhoWas()
{
        Command* whowas_command = ServerInstance->Parser->GetHandler("WHOWAS");
        if (whowas_command)
        {
                std::deque<classbase*> params;
                params.push_back(this);
                whowas_command->HandleInternal(WHOWAS_ADD, params);
        }
}

/*
 * Check class restrictions
 */
void User::CheckClass()
{
        ConnectClass* a = this->MyClass;

        if ((!a) || (a->GetType() == CC_DENY))
        {
                ServerInstance->Users->QuitUser(this, "Unauthorised connection");
                return;
        }
        else if ((a->GetMaxLocal()) && (ServerInstance->Users->LocalCloneCount(this) > a->GetMaxLocal()))
        {
                ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (local)");
                ServerInstance->SNO->WriteToSnoMask('A', "WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString());
                return;
        }
        else if ((a->GetMaxGlobal()) && (ServerInstance->Users->GlobalCloneCount(this) > a->GetMaxGlobal()))
        {
                ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (global)");
                ServerInstance->SNO->WriteToSnoMask('A', "WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString());
                return;
        }

        this->nping = ServerInstance->Time() + a->GetPingTime() + ServerInstance->Config->dns_timeout;
}

bool User::CheckLines()
{
        const char* check[] = { "G" , "K", NULL };

        if (!this->exempt)
        {
                for (int n = 0; check[n]; ++n)
                {
                        XLine *r = ServerInstance->XLines->MatchesLine(check[n], this);

                        if (r)
                        {
                                r->Apply(this);
                                return true;
                        }
                }
        }

        return false;
}

void User::FullConnect()
{
        ServerInstance->stats->statsConnects++;
        this->idle_lastmsg = ServerInstance->Time();

        /*
         * You may be thinking "wtf, we checked this in User::AddClient!" - and yes, we did, BUT.
         * At the time AddClient is called, we don't have a resolved host, by here we probably do - which
         * may put the user into a totally seperate class with different restrictions! so we *must* check again.
         * Don't remove this! -- w00t
         */
        this->SetClass();
        
        /* Check the password, if one is required by the user's connect class.
         * This CANNOT be in CheckClass(), because that is called prior to PASS as well!
         */
        if (this->MyClass && !this->MyClass->GetPass().empty() && !this->haspassed)
        {
                ServerInstance->Users->QuitUser(this, "Invalid password");
                return;
        }

        if (this->CheckLines())
                return;

        this->WriteServ("NOTICE Auth :Welcome to \002%s\002!",ServerInstance->Config->Network);
        this->WriteNumeric(RPL_WELCOME, "%s :Welcome to the %s IRC Network %s!%s@%s",this->nick.c_str(), ServerInstance->Config->Network, this->nick.c_str(), this->ident.c_str(), this->host.c_str());
        this->WriteNumeric(RPL_YOURHOSTIS, "%s :Your host is %s, running version InspIRCd-1.2",this->nick.c_str(),ServerInstance->Config->ServerName);
        this->WriteNumeric(RPL_SERVERCREATED, "%s :This server was created %s %s", this->nick.c_str(), __TIME__, __DATE__);
        this->WriteNumeric(RPL_SERVERVERSION, "%s %s InspIRCd-1.2 %s %s %s", this->nick.c_str(), ServerInstance->Config->ServerName, ServerInstance->Modes->UserModeList().c_str(), ServerInstance->Modes->ChannelModeList().c_str(), ServerInstance->Modes->ParaModeList().c_str());

        ServerInstance->Config->Send005(this);
        this->WriteNumeric(RPL_YOURUUID, "%s %s :your unique ID", this->nick.c_str(), this->uuid.c_str());


        this->ShowMOTD();

        /* Now registered */
        if (ServerInstance->Users->unregistered_count)
                ServerInstance->Users->unregistered_count--;

        /* Trigger LUSERS output, give modules a chance too */
        int MOD_RESULT = 0;
        std::string command("LUSERS");
        std::vector<std::string> parameters;
        FOREACH_RESULT(I_OnPreCommand, OnPreCommand(command, parameters, this, true, "LUSERS"));
        if (!MOD_RESULT)
                ServerInstance->CallCommandHandler(command, parameters, this);

        /*
         * We don't set REG_ALL until triggering OnUserConnect, so some module events don't spew out stuff
         * for a user that doesn't exist yet.
         */
        FOREACH_MOD(I_OnUserConnect,OnUserConnect(this));

        this->registered = REG_ALL;

        ServerInstance->PI->Introduce(this);

        FOREACH_MOD(I_OnPostConnect,OnPostConnect(this));

        ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d: %s!%s@%s [%s] [%s]", this->GetPort(), this->nick.c_str(), this->ident.c_str(), this->host.c_str(), this->GetIPString(), this->fullname.c_str());
        ServerInstance->Logs->Log("BANCACHE", DEBUG, "BanCache: Adding NEGATIVE hit for %s", this->GetIPString());
        ServerInstance->BanCache->AddHit(this->GetIPString(), "", "");
}

User* User::UpdateNickHash(const char* New)
{
        //user_hash::iterator newnick;
        user_hash::iterator oldnick = ServerInstance->Users->clientlist->find(this->nick);

        if (!irc::string(this->nick.c_str()).compare(New))
                return oldnick->second;

        if (oldnick == ServerInstance->Users->clientlist->end())
                return NULL; /* doesnt exist */

        User* olduser = oldnick->second;
        (*(ServerInstance->Users->clientlist))[New] = olduser;
        ServerInstance->Users->clientlist->erase(oldnick);
        return olduser;
}

void User::InvalidateCache()
{
        /* Invalidate cache */
        cached_fullhost.clear();
        cached_hostip.clear();
        cached_makehost.clear();
        cached_fullrealhost.clear();
}

bool User::ForceNickChange(const char* newnick)
{
        int MOD_RESULT = 0;

        this->InvalidateCache();

        FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick));

        if (MOD_RESULT)
        {
                ServerInstance->stats->statsCollisions++;
                return false;
        }

        std::deque<classbase*> dummy;
        Command* nickhandler = ServerInstance->Parser->GetHandler("NICK");
        if (nickhandler) // wtfbbq, when would this not be here
        {
                std::vector<std::string> parameters;
                nickhandler->HandleInternal(1, dummy);