iohook.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2019 Robby <[email protected]>
 *   Copyright (C) 2013, 2016-2017 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
 
class StreamSocket;
 
class IOHookProvider : public refcountbase, public ServiceProvider
{
        const bool middlehook;
 
 public:
        enum Type
        {
                IOH_UNKNOWN,
                IOH_SSL
        };
 
        const Type type;
 
        IOHookProvider(Module* mod, const std::string& Name, Type hooktype = IOH_UNKNOWN, bool middle = false)
                : ServiceProvider(mod, Name, SERVICE_IOHOOK), middlehook(middle), type(hooktype) { }
 
        bool IsMiddle() const { return middlehook; }
 
        virtual void OnAccept(StreamSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server) = 0;
 
        virtual void OnConnect(StreamSocket* sock) = 0;
};
 
class IOHook : public classbase
{
 public:
        reference<IOHookProvider> prov;
 
        IOHook(IOHookProvider* provider)
                : prov(provider) { }
 
        virtual int OnStreamSocketWrite(StreamSocket* sock, StreamSocket::SendQueue& sendq) = 0;
 
        virtual void OnStreamSocketClose(StreamSocket* sock) = 0;
 
        virtual int OnStreamSocketRead(StreamSocket* sock, std::string& recvq) = 0;
};
 
class IOHookMiddle : public IOHook
{
        StreamSocket::SendQueue sendq;
 
        std::string precvq;
 
        IOHook* nexthook;
 
 protected:
        std::string& GetRecvQ() { return precvq; }
 
        StreamSocket::SendQueue& GetSendQ() { return sendq; }
 
 public:
        IOHookMiddle(IOHookProvider* provider)
                : IOHook(provider)
                , nexthook(NULL)
        {
        }
 
        const StreamSocket::SendQueue& GetSendQ() const { return sendq; }
 
        IOHook* GetNextHook() const { return nexthook; }
 
        void SetNextHook(IOHook* hook) { nexthook = hook; }
 
        static IOHookMiddle* ToMiddleHook(IOHook* hook)
        {
                if (hook->prov->IsMiddle())
                        return static_cast<IOHookMiddle*>(hook);
                return NULL;
        }
 
        friend class StreamSocket;
};