inspsocket.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2019 linuxdaemon <[email protected]>
 *   Copyright (C) 2013, 2015-2016 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2013, 2017-2019 Sadie Powell <[email protected]>
 *   Copyright (C) 2012 Robby <[email protected]>
 *   Copyright (C) 2009 Uli Schlachter <[email protected]>
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2009 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *   Copyright (C) 2006, 2010 Craig Edwards <[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
 
#include "timer.h"
 
class IOHook;
 
enum BufferedSocketState
{
        I_DISCONNECTED,
        I_CONNECTING,
        I_CONNECTED,
        I_ERROR
};
 
enum BufferedSocketError
{
        I_ERR_NONE,
        I_ERR_DISCONNECT,
        I_ERR_TIMEOUT,
        I_ERR_SOCKET,
        I_ERR_CONNECT,
        I_ERR_BIND,
        I_ERR_WRITE,
        I_ERR_NOMOREFDS,
        I_ERR_OTHER
};
 
/* Required forward declarations */
class BufferedSocket;
 
class CoreExport SocketTimeout : public Timer
{
 private:
        BufferedSocket* sock;
 
        int sfd;
 
 public:
        SocketTimeout(int fd, BufferedSocket* thesock, unsigned int secs_from_now)
                : Timer(secs_from_now)
                , sock(thesock)
                , sfd(fd)
        {
        }
 
        bool Tick(time_t now) CXX11_OVERRIDE;
};
 
class CoreExport StreamSocket : public EventHandler
{
 public:
        class SendQueue
        {
         public:
                typedef std::string Element;
 
                typedef std::deque<Element> Container;
 
                typedef Container::const_iterator const_iterator;
 
                SendQueue() : nbytes(0) { }
 
                bool empty() const { return (nbytes == 0); }
 
                Container::size_type size() const { return data.size(); }
 
                size_t bytes() const { return nbytes; }
 
                const Element& front() const { return data.front(); }
 
                const_iterator begin() const { return data.begin(); }
 
                const_iterator end() const { return data.end(); }
 
                void pop_front()
                {
                        nbytes -= data.front().length();
                        data.pop_front();
                }
 
                void erase_front(Element::size_type n)
                {
                        nbytes -= n;
                        data.front().erase(0, n);
                }
 
                void push_front(const Element& newdata)
                {
                        data.push_front(newdata);
                        nbytes += newdata.length();
                }
 
                void push_back(const Element& newdata)
                {
                        data.push_back(newdata);
                        nbytes += newdata.length();
                }
 
                void clear()
                {
                        data.clear();
                        nbytes = 0;
                }
 
                void moveall(SendQueue& other)
                {
                        nbytes += other.bytes();
                        data.insert(data.end(), other.data.begin(), other.data.end());
                        other.clear();
                }
 
         private:
                Container data;
 
                size_t nbytes;
        };
 
        enum Type
        {
                SS_UNKNOWN,
                SS_USER
        };
 
 private:
        bool closeonempty;
 
        bool closing;
 
        IOHook* iohook;
 
        SendQueue sendq;
 
        std::string error;
 
        void CheckError(BufferedSocketError err);
 
        void DoRead();
 
        void FlushSendQ(SendQueue& sq);
 
        int ReadToRecvQ(std::string& rq);
 
        int HookChainRead(IOHook* hook, std::string& rq);
 
 protected:
        std::string recvq;
 
        void SwapInternals(StreamSocket& other);
 
 public:
        const Type type;
        StreamSocket(Type sstype = SS_UNKNOWN)
                : closeonempty(false)
                , closing(false)
                , iohook(NULL)
                , type(sstype)
        {
        }
        IOHook* GetIOHook() const;
        void AddIOHook(IOHook* hook);
        void DelIOHook();
 
        void DoWrite();
 
        void OnEventHandlerRead() CXX11_OVERRIDE;
 
        void OnEventHandlerWrite() CXX11_OVERRIDE;
 
        void OnEventHandlerError(int errcode) CXX11_OVERRIDE;
 
        void SetError(const std::string& err) { if (error.empty()) error = err; }
 
        const std::string& getError() const { return error; }
 
        virtual void OnDataReady() = 0;
        virtual void OnError(BufferedSocketError e) = 0;
 
        virtual bool OnSetEndPoint(const irc::sockets::sockaddrs& local, const irc::sockets::sockaddrs& remote);
 
        void WriteData(const std::string& data);
        bool GetNextLine(std::string& line, char delim = '\n');
        size_t getSendQSize() const;
 
        SendQueue& GetSendQ() { return sendq; }
 
        virtual void Close();
 
        void Close(bool writeblock);
 
        CullResult cull() CXX11_OVERRIDE;
 
        IOHook* GetModHook(Module* mod) const;
};
class CoreExport BufferedSocket : public StreamSocket
{
 public:
        SocketTimeout* Timeout;
 
        BufferedSocketState state;
 
        BufferedSocket();
        BufferedSocket(int newfd);
 
        void DoConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned int maxtime);
 
        virtual void OnConnected();
 
        void OnDataReady() CXX11_OVERRIDE = 0;
 
        virtual void OnTimeout();
 
        virtual ~BufferedSocket();
 protected:
        void OnEventHandlerWrite() CXX11_OVERRIDE;
        BufferedSocketError BeginConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned int timeout);
};
 
inline IOHook* StreamSocket::GetIOHook() const { return iohook; }
inline void StreamSocket::DelIOHook() { iohook = NULL; }