inspsocket.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *   Copyright (C) 2006-2007 Craig Edwards <[email protected]>
 *   Copyright (C) 2006 Oliver Lupton <[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/>.
 */
 
 
#ifndef INSPSOCKET_H
#define INSPSOCKET_H
 
#include "timer.h"
 
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, long secs_from_now, time_t now) : Timer(secs_from_now, now), sock(thesock), sfd(fd) { }
 
        virtual void Tick(time_t now);
};
 
class CoreExport StreamSocket : public EventHandler
{
        reference<Module> IOHook;
        std::deque<std::string> sendq;
        size_t sendq_len;
        std::string error;
 protected:
        std::string recvq;
 public:
        StreamSocket() : sendq_len(0) {}
        inline Module* GetIOHook();
        inline void AddIOHook(Module* m);
        inline void DelIOHook();
        virtual void HandleEvent(EventType et, int errornum = 0);
        virtual void DoRead();
        virtual void DoWrite();
 
        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;
 
        void WriteData(const std::string& data);
        bool GetNextLine(std::string& line, char delim = '\n');
        inline size_t getSendQSize() const { return sendq_len; }
 
        virtual void Close();
        virtual CullResult cull();
};
class CoreExport BufferedSocket : public StreamSocket
{
 public:
        SocketTimeout* Timeout;
 
        BufferedSocketState state;
 
        BufferedSocket();
        BufferedSocket(int newfd);
 
        void DoConnect(const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip);
 
        virtual void OnConnected();
 
        virtual void OnDataReady() = 0;
 
        virtual void OnTimeout();
 
        virtual ~BufferedSocket();
 protected:
        virtual void DoWrite();
        BufferedSocketError BeginConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long timeout);
        BufferedSocketError BeginConnect(const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip);
};
 
#include "modules.h"
 
inline Module* StreamSocket::GetIOHook() { return IOHook; }
inline void StreamSocket::AddIOHook(Module* m) { IOHook = m; }
inline void StreamSocket::DelIOHook() { IOHook = NULL; }
#endif