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 » modules

m_services_account.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.
 *
 * ---------------------------------------------------
 */

#include "inspircd.h"
#include "account.h"

/* $ModDesc: Povides support for ircu-style services accounts, including chmode +R, etc. */

class AChannel_R : public SimpleChannelModeHandler
{
 public:
        AChannel_R(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'R') { }
};

class AUser_R : public SimpleUserModeHandler
{
 public:
        AUser_R(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'R') { }
};

class AChannel_M : public SimpleChannelModeHandler
{
 public:
        AChannel_M(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'M') { }
};

class ModuleServicesAccount : public Module
{

        AChannel_R* m1;
        AChannel_M* m2;
        AUser_R* m3;
 public:
        ModuleServicesAccount(InspIRCd* Me) : Module(Me)
        {

                m1 = new AChannel_R(ServerInstance);
                m2 = new AChannel_M(ServerInstance);
                m3 = new AUser_R(ServerInstance);
                if (!ServerInstance->Modes->AddMode(m1) || !ServerInstance->Modes->AddMode(m2) || !ServerInstance->Modes->AddMode(m3))
                        throw ModuleException("You cannot load m_services.so and m_services_account.so at the same time (or some other module has claimed our modes)!");

                Implementation eventlist[] = { I_OnWhois, I_OnUserPreMessage, I_OnUserPreNotice, I_OnUserPreJoin,
                        I_OnSyncUserMetaData, I_OnUserQuit, I_OnCleanup, I_OnDecodeMetaData, I_On005Numeric };

                ServerInstance->Modules->Attach(eventlist, this, 9);
        }

        virtual void On005Numeric(std::string &t)
        {
                ServerInstance->AddExtBanChar('R');
                ServerInstance->AddExtBanChar('M');
        }

        /* <- :twisted.oscnet.org 330 w00t2 w00t2 w00t :is logged in as */
        virtual void OnWhois(User* source, User* dest)
        {
                std::string *account;
                dest->GetExt("accountname", account);

                if (account)
                {
                        ServerInstance->SendWhoisLine(source, dest, 330, "%s %s %s :is logged in as", source->nick.c_str(), dest->nick.c_str(), account->c_str());
                }
        }


        virtual int OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
        {
                std::string *account;

                if (!IS_LOCAL(user))
                        return 0;

                user->GetExt("accountname", account);

                if ((ServerInstance->ULine(user->nick.c_str())) || (ServerInstance->ULine(user->server)))
                {
                        // user is ulined, can speak regardless
                        return 0;
                }

                if (target_type == TYPE_CHANNEL)
                {
                        Channel* c = (Channel*)dest;

                        if ((c->IsModeSet('M')) && (!account))
                        {
                                // user messaging a +M channel and is not registered
                                user->WriteNumeric(477, ""+std::string(user->nick)+" "+std::string(c->name)+" :You need to be identified to a registered account to message this channel");
                                return 1;
                        }

                        if (account)
                        {
                                if (c->IsExtBanned(*account, 'M'))
                                {
                                        // may not speak
                                        user->WriteNumeric(477, ""+std::string(user->nick)+" "+std::string(c->name)+" :You may not speak in this channel");
                                        return 1;
                                }
                        }
                }

                if (target_type == TYPE_USER)
                {
                        User* u = (User*)dest;

                        if ((u->modes['R'-65]) && (!account))
                        {
                                // user messaging a +R user and is not registered
                                user->WriteNumeric(477, ""+ user->nick +" "+ u->nick +" :You need to be identified to a registered account to message this user");
                                return 1;
                        }
                }
                return 0;
        }

        virtual int OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
        {
                return OnUserPreMessage(user, dest, target_type, text, status, exempt_list);
        }

        virtual int OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string &privs, const std::string &keygiven)
        {
                std::string *account;
                user->GetExt("accountname", account);

                if (chan)
                {
                        if (chan->IsModeSet('R'))
                        {
                                if (!account)
                                {
                                        if ((ServerInstance->ULine(user->nick.c_str())) || (ServerInstance->ULine(user->server)))
                                        {
                                                // user is ulined, won't be stopped from joining
                                                return 0;
                                        }
                                        // joining a +R channel and not identified
                                        user->WriteNumeric(477, user->nick + " " + chan->name + " :You need to be identified to a registered account to join this channel");
                                        return 1;
                                }
                        }

                        if (account)
                        {
                                if (chan->IsExtBanned(*account, 'R'))
                                {
                                        // may not join
                                        user->WriteNumeric(ERR_BANNEDFROMCHAN, "%s %s :Cannot join channel (You're banned)", user->nick.c_str(),  chan->name.c_str());
                                        return 1;
                                }
                        }
                }
                return 0;
        }

        // Whenever the linking module wants to send out data, but doesnt know what the data
        // represents (e.g. it is metadata, added to a User or Channel by a module) then
        // this method is called. We should use the ProtoSendMetaData function after we've
        // corrected decided how the data should look, to send the metadata on its way if
        // it is ours.
        virtual void OnSyncUserMetaData(User* user, Module* proto, void* opaque, const std::string &extname, bool displayable)
        {
                // check if the linking module wants to know about OUR metadata
                if (extname == "accountname")
                {
                        // check if this user has an swhois field to send
                        std::string* account;
                        user->GetExt("accountname", account);
                        if (account)
                        {
                                // remove any accidental leading/trailing spaces
                                trim(*account);

                                // call this function in the linking module, let it format the data how it
                                // sees fit, and send it on its way. We dont need or want to know how.
                                proto->ProtoSendMetaData(opaque,TYPE_USER,user,extname,*account);
                        }
                }
        }

        // when a user quits, tidy up their metadata
        virtual void OnUserQuit(User* user, const std::string &message, const std::string &oper_message)
        {
                std::string* account;
                user->GetExt("accountname", account);
                if (account)
                {
                        user->Shrink("accountname");
                        delete account;
                }
        }

        // if the module is unloaded, tidy up all our dangling metadata
        virtual void OnCleanup(int target_type, void* item)
        {
                if (target_type == TYPE_USER)
                {
                        User* user = (User*)item;
                        std::string* account;
                        user->GetExt("accountname", account);
                        if (account)
                        {
                                user->Shrink("accountname");
                                delete account;
                        }
                }
        }

        // Whenever the linking module receives metadata from another server and doesnt know what
        // to do with it (of course, hence the 'meta') it calls this method, and it is up to each
        // module in turn to figure out if this metadata key belongs to them, and what they want
        // to do with it.
        // In our case we're only sending a single string around, so we just construct a std::string.
        // Some modules will probably get much more complex and format more detailed structs and classes
        // in a textual way for sending over the link.
        virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata)
        {
                // check if its our metadata key, and its associated with a user
                if ((target_type == TYPE_USER) && (extname == "accountname"))
                {
                        User* dest = (User*)target;

                        /* logging them out? */
                        if (extdata.empty())
                        {
                                std::string* account;
                                dest->GetExt("accountname", account);
                                if (account)
                                {
                                        dest->Shrink("accountname");
                                        delete account;
                                }
                        }
                        else
                        {
                                // if they dont already have an accountname field, accept the remote server's
                                std::string* text;
                                if (!dest->GetExt("accountname", text))
                                {
                                        text = new std::string(extdata);
                                        // remove any accidental leading/trailing spaces
                                        trim(*text);
                                        dest->Extend("accountname", text);

                                        if (IS_LOCAL(dest))
                                                dest->WriteNumeric(900, "%s %s %s :You are now logged in as %s", dest->nick.c_str(), dest->GetFullHost().c_str(), text->c_str(), text->c_str());

                                        AccountData ac;
                                        ac.user = dest;
                                        ac.account = *text;
                                        Event n((char*)&ac, this, "account_login");
                                        n.Send(ServerInstance);
                                }
                        }
                }
        }

        virtual ~ModuleServicesAccount()
        {
                ServerInstance->Modes->DelMode(m1);
                ServerInstance->Modes->DelMode(m2);
                ServerInstance->Modes->DelMode(m3);
                delete m1;
                delete m2;
                delete m3;
        }

        virtual Version GetVersion()
        {
                return Version("$Id: m_services_account.cpp 10379 2008-09-02 20:09:01Z brain $",VF_COMMON|VF_VENDOR,API_VERSION);
        }
};

MODULE_INIT(ModuleServicesAccount)