clientprotocolmsg.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2018, 2020-2021 Sadie Powell <[email protected]>
 *   Copyright (C) 2018 Attila Molnar <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
namespace ClientProtocol
{
        namespace Messages
        {
                class Numeric;
                class Join;
                struct Part;
                struct Kick;
                struct Quit;
                struct Nick;
                class Mode;
                struct Topic;
                class Privmsg;
                struct Invite;
                struct Ping;
                struct Pong;
                struct Error;
        }
}
 
class ClientProtocol::Messages::Numeric : public ClientProtocol::Message
{
        char numericstr[4];
 
        void InitCommand(unsigned int number)
        {
                snprintf(numericstr, sizeof(numericstr), "%03u", number);
                SetCommand(numericstr);
        }
 
        void InitFromNumeric(const ::Numeric::Numeric& numeric)
        {
                InitCommand(numeric.GetNumeric());
                for (std::vector<std::string>::const_iterator i = numeric.GetParams().begin(); i != numeric.GetParams().end(); ++i)
                        PushParamRef(*i);
        }
 
 public:
        Numeric(const ::Numeric::Numeric& num, User* user)
                : ClientProtocol::Message(NULL, (num.GetServer() ? num.GetServer() : ServerInstance->FakeClient->server)->GetName())
        {
                if (user->registered & REG_NICK)
                        PushParamRef(user->nick);
                else
                        PushParam("*");
                InitFromNumeric(num);
        }
 
        Numeric(const ::Numeric::Numeric& num, const std::string& target)
                : ClientProtocol::Message(NULL, (num.GetServer() ? num.GetServer() : ServerInstance->FakeClient->server)->GetName())
        {
                PushParamRef(target);
                InitFromNumeric(num);
        }
 
        Numeric(unsigned int num)
                : ClientProtocol::Message(NULL, ServerInstance->Config->GetServerName())
        {
                InitCommand(num);
                PushParam("*");
        }
};
 
class ClientProtocol::Messages::Join : public ClientProtocol::Message
{
        Membership* memb;
 
 public:
        Join()
                : ClientProtocol::Message("JOIN")
                , memb(NULL)
        {
        }
 
        Join(Membership* Memb)
                : ClientProtocol::Message("JOIN", Memb->user)
        {
                SetParams(Memb);
        }
 
        Join(Membership* Memb, const std::string& sourcestrref)
                : ClientProtocol::Message("JOIN", sourcestrref, Memb->user)
        {
                SetParams(Memb);
        }
 
        void SetParams(Membership* Memb)
        {
                memb = Memb;
                PushParamRef(memb->chan->name);
        }
 
        Membership* GetMember() const { return memb; }
};
 
struct ClientProtocol::Messages::Part : public ClientProtocol::Message
{
        Part(Membership* memb, const std::string& reason)
                : ClientProtocol::Message("PART", memb->user)
        {
                PushParamRef(memb->chan->name);
                if (!reason.empty())
                        PushParamRef(reason);
        }
};
 
struct ClientProtocol::Messages::Kick : public ClientProtocol::Message
{
        Kick(User* source, Membership* memb, const std::string& reason)
                : ClientProtocol::Message("KICK", source)
        {
                PushParamRef(memb->chan->name);
                PushParamRef(memb->user->nick);
                PushParamRef(reason);
        }
};
 
struct ClientProtocol::Messages::Quit : public ClientProtocol::Message
{
        Quit(User* source, const std::string& reason)
                : ClientProtocol::Message("QUIT", source)
        {
                if (!reason.empty())
                        PushParamRef(reason);
        }
};
 
struct ClientProtocol::Messages::Nick : public ClientProtocol::Message
{
        Nick(User* source, const std::string& newnick)
                : ClientProtocol::Message("NICK", source)
        {
                PushParamRef(newnick);
        }
};
 
class ClientProtocol::Messages::Mode : public ClientProtocol::Message
{
        Channel* chantarget;
        User* usertarget;
        Modes::ChangeList::List::const_iterator beginit;
        Modes::ChangeList::List::const_iterator lastit;
 
        static std::string ToModeLetters(const Modes::ChangeList::List& list, std::string::size_type maxlinelen, Modes::ChangeList::List::const_iterator beginit, Modes::ChangeList::List::const_iterator& lastit)
        {
                std::string ret;
                std::string::size_type paramlength = 0;
                char output_pm = '\0'; // current output state, '+' or '-'
 
                Modes::ChangeList::List::const_iterator i;
                for (i = beginit; i != list.end(); ++i)
                {
                        const Modes::Change& item = *i;
 
                        const char needed_pm = (item.adding ? '+' : '-');
                        if (needed_pm != output_pm)
                        {
                                output_pm = needed_pm;
                                ret.push_back(output_pm);
                        }
 
                        if (!item.param.empty())
                                paramlength += item.param.length() + 1;
                        if (ret.length() + 1 + paramlength > maxlinelen)
                        {
                                // Mode sequence is getting too long
                                const char c = *ret.rbegin();
                                if ((c == '+') || (c == '-'))
                                        ret.erase(ret.size()-1);
                                break;
                        }
 
                        ret.push_back(item.mh->GetModeChar());
                }
 
                lastit = i;
                return ret;
        }
 
        void PushModeParams()
        {
                for (Modes::ChangeList::List::const_iterator i = beginit; i != lastit; ++i)
                {
                        const Modes::Change& item = *i;
                        if (!item.param.empty())
                                PushParamRef(item.param);
                }
        }
 
 public:
        static std::string ToModeLetters(const Modes::ChangeList& changelist)
        {
                // TODO: This assumes that std::string::max_size() >= UINT_MAX
                Modes::ChangeList::List::const_iterator dummy;
                return ToModeLetters(changelist.getlist(), UINT_MAX, changelist.getlist().begin(), dummy);
        }
 
        Mode(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist, Modes::ChangeList::List::const_iterator beginiter)
                : ClientProtocol::Message("MODE", source)
                , chantarget(Chantarget)
                , usertarget(Usertarget)
                , beginit(beginiter)
        {
                PushParamRef(GetStrTarget());
                PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit));
                PushModeParams();
        }
 
        Mode(User* source, Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist)
                : ClientProtocol::Message("MODE", source)
                , chantarget(Chantarget)
                , usertarget(Usertarget)
                , beginit(changelist.getlist().begin())
        {
                PushParamRef(GetStrTarget());
                PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit));
                PushModeParams();
        }
 
        Mode()
                : ClientProtocol::Message("MODE", ServerInstance->FakeClient)
                , chantarget(NULL)
                , usertarget(NULL)
        {
        }
 
        void SetParams(Channel* Chantarget, User* Usertarget, const Modes::ChangeList& changelist)
        {
                ClearParams();
 
                chantarget = Chantarget;
                usertarget = Usertarget;
                beginit = changelist.getlist().begin();
 
                PushParamRef(GetStrTarget());
                PushParam(ToModeLetters(changelist.getlist(), 450, beginit, lastit));
                PushModeParams();
        }
 
        Modes::ChangeList::List::const_iterator GetBeginIterator() const { return beginit; }
 
        Modes::ChangeList::List::const_iterator GetEndIterator() const { return lastit; }
 
        const std::string& GetStrTarget() const { return (chantarget ? chantarget->name : usertarget->nick); }
 
        User* GetUserTarget() const { return usertarget; }
 
        Channel* GetChanTarget() const { return chantarget; }
};
 
struct ClientProtocol::Messages::Topic : public ClientProtocol::Message
{
        Topic(User* source, const Channel* chan, const std::string& newtopic)
                : ClientProtocol::Message("TOPIC", source)
        {
                PushParamRef(chan->name);
                PushParamRef(newtopic);
        }
};
 
class ClientProtocol::Messages::Privmsg : public ClientProtocol::Message
{
        void PushTargetChan(char status, const Channel* targetchan)
        {
                if (status)
                {
                        std::string rawtarget(1, status);
                        rawtarget.append(targetchan->name);
                        PushParam(rawtarget);
                }
                else
                {
                        PushParamRef(targetchan->name);
                }
        }
 
        void PushTargetUser(const User* targetuser)
        {
                if (targetuser->registered & REG_NICK)
                        PushParamRef(targetuser->nick);
                else
                        PushParam("*");
        }
 
 public:
        enum NoCopy { nocopy };
 
        static const char* CommandStrFromMsgType(MessageType mt)
        {
                return ((mt == MSG_PRIVMSG) ? "PRIVMSG" : "NOTICE");
        }
 
        Privmsg(User* source, const std::string& target, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushParam(target);
                PushParam(text);
        }
 
        Privmsg(User* source, const Channel* targetchan, const std::string& text, MessageType mt = MSG_PRIVMSG, char status = 0)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetChan(status, targetchan);
                PushParam(text);
        }
 
        Privmsg(User* source, const User* targetuser, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetUser(targetuser);
                PushParam(text);
        }
 
        Privmsg(const std::string& source, const std::string& target, const std::string& text, MessageType mt = MSG_PRIVMSG, char status = 0)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                if (status)
                {
                        std::string rawtarget(1, status);
                        rawtarget.append(target);
                        PushParam(rawtarget);
                }
                else
                {
                        PushParam(target);
                }
                PushParam(text);
        }
 
        Privmsg(const std::string& source, const Channel* targetchan, const std::string& text, MessageType mt = MSG_PRIVMSG, char status = 0)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetChan(status, targetchan);
                PushParam(text);
        }
 
        Privmsg(const std::string& source, const User* targetuser, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetUser(targetuser);
                PushParam(text);
        }
 
        Privmsg(NoCopy, User* source, const std::string& target, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushParam(target);
                PushParamRef(text);
        }
 
        Privmsg(NoCopy, User* source, const Channel* targetchan, const std::string& text, MessageType mt = MSG_PRIVMSG, char status = 0)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetChan(status, targetchan);
                PushParamRef(text);
        }
 
        Privmsg(NoCopy, User* source, const User* targetuser, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetUser(targetuser);
                PushParamRef(text);
        }
 
        Privmsg(NoCopy, const std::string& source, const std::string& target, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushParam(target);
                PushParamRef(text);
        }
 
        Privmsg(NoCopy, const std::string& source, const Channel* targetchan, const std::string& text, MessageType mt = MSG_PRIVMSG, char status = 0)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetChan(status, targetchan);
                PushParamRef(text);
        }
 
        Privmsg(NoCopy, const std::string& source, const User* targetuser, const std::string& text, MessageType mt = MSG_PRIVMSG)
                : ClientProtocol::Message(CommandStrFromMsgType(mt), source)
        {
                PushTargetUser(targetuser);
                PushParamRef(text);
        }
};
 
struct ClientProtocol::Messages::Invite : public ClientProtocol::Message
{
        Invite(User* source, User* target, Channel* chan)
                : ClientProtocol::Message("INVITE", source)
        {
                PushParamRef(target->nick);
                PushParamRef(chan->name);
        }
};
 
struct ClientProtocol::Messages::Ping : public ClientProtocol::Message
{
        Ping()
                : ClientProtocol::Message("PING")
        {
                PushParamRef(ServerInstance->Config->GetServerName());
        }
 
        Ping(const std::string& cookie)
                : ClientProtocol::Message("PING")
        {
                PushParamRef(cookie);
        }
};
 
struct ClientProtocol::Messages::Pong : public ClientProtocol::Message
{
        Pong(const std::string& cookie, const std::string& server = "")
                : ClientProtocol::Message("PONG", ServerInstance->Config->GetServerName())
        {
                if (server.empty())
                        PushParamRef(ServerInstance->Config->GetServerName());
                else
                        PushParam(server);
                PushParamRef(cookie);
        }
};
 
struct ClientProtocol::Messages::Error : public ClientProtocol::Message
{
        Error(const std::string& text)
                        : ClientProtocol::Message("ERROR")
        {
                PushParam(text);
        }
};