sockets.h

Go to the documentation of this file.

/*
 *
 * (C) 2003-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */

#ifndef SOCKETS_H
#define SOCKETS_H

#ifndef _WIN32
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#endif

#include "anope.h"

#define NET_BUFSIZE 65535

union CoreExport sockaddrs
{
        sockaddr sa;
        sockaddr_in sa4;
        sockaddr_in6 sa6;

        sockaddrs(const Anope::string &address = "");

        void clear();

        size_t size() const;

        int port() const;

        Anope::string addr() const;

        bool operator()() const;

        bool operator==(const sockaddrs &other) const;
        /* The same as above but not */
        inline bool operator!=(const sockaddrs &other) const { return !(*this == other); }

        void pton(int type, const Anope::string &address, int pport = 0);

        void ntop(int type, const void *src);
};

class CoreExport cidr
{
        sockaddrs addr;
        Anope::string cidr_ip;
        unsigned short cidr_len;
 public:
        cidr(const Anope::string &ip);
        cidr(const Anope::string &ip, unsigned char len);
        Anope::string mask() const;
        bool match(const sockaddrs &other);

        bool operator<(const cidr &other) const;
        bool operator==(const cidr &other) const;
        bool operator!=(const cidr &other) const;

        struct CoreExport hash
        {
                size_t operator()(const cidr &s) const;
        };
};

class SocketException : public CoreException
{
 public:
        SocketException(const Anope::string &message) : CoreException(message) { }

        virtual ~SocketException() throw() { }
};

enum SocketFlag
{
        SF_DEAD = 1,
        SF_READABLE,
        SF_WRITABLE,
        SF_CONNECTING,
        SF_CONNECTED,
        SF_ACCEPTING,
        SF_ACCEPTED,
        SF_SIZE
};

class CoreExport SocketIO
{
 public:
        virtual ~SocketIO() { }

        virtual int Recv(Socket *s, char *buf, size_t sz);

        virtual int Send(Socket *s, const char *buf, size_t sz);
        int Send(Socket *s, const Anope::string &buf);

        virtual ClientSocket *Accept(ListenSocket *s);

        virtual SocketFlag FinishAccept(ClientSocket *cs);

        virtual void Bind(Socket *s, const Anope::string &ip, int port = 0);

        virtual void Connect(ConnectionSocket *s, const Anope::string &target, int port);

        virtual SocketFlag FinishConnect(ConnectionSocket *s);

        virtual void Destroy() { }
};

class CoreExport Socket
{
 protected:
        /* Socket FD */
        int sock;
        /* Is this an IPv6 socket? */
        bool ipv6;

 public:
        std::bitset<SF_SIZE> flags;

        /* Sockaddrs for bind() (if it's bound) */
        sockaddrs bindaddr;

        /* I/O functions used for this socket */
        SocketIO *io;

        Socket();

        Socket(int sock, bool ipv6 = false, int type = SOCK_STREAM);

        virtual ~Socket();

        int GetFD() const;

        bool IsIPv6() const;

        bool SetBlocking(bool state);

        void Bind(const Anope::string &ip, int port = 0);

        virtual bool Process();

        virtual bool ProcessRead();

        virtual bool ProcessWrite();

        virtual void ProcessError();
};

class CoreExport BufferedSocket : public virtual Socket
{
 protected:
        /* Things read from the socket */
        Anope::string read_buffer;
        /* Things to be written to the socket */
        Anope::string write_buffer;
        /* How much data was received from this socket on this recv() */
        int recv_len;

 public:
        BufferedSocket();
        virtual ~BufferedSocket();

        bool ProcessRead() anope_override;

        bool ProcessWrite() anope_override;

        const Anope::string GetLine();

 protected:
        virtual void Write(const char *buffer, size_t l);
 public:
        void Write(const char *message, ...);
        void Write(const Anope::string &message);

        int ReadBufferLen() const;

        int WriteBufferLen() const;
};

class CoreExport BinarySocket : public virtual Socket
{
 protected:
        struct DataBlock
        {
                char *orig;
                char *buf;
                size_t len;

                DataBlock(const char *b, size_t l);
                ~DataBlock();
        };

        /* Data to be written out */
        std::deque<DataBlock *> write_buffer;

 public:
        BinarySocket();
        virtual ~BinarySocket();

        bool ProcessRead() anope_override;

        bool ProcessWrite() anope_override;

        virtual void Write(const char *buffer, size_t l);
        void Write(const char *message, ...);
        void Write(const Anope::string &message);

        virtual bool Read(const char *buffer, size_t l);
};

class CoreExport ListenSocket : public virtual Socket
{
 public:
        ListenSocket(const Anope::string &bindip, int port, bool ipv6);
        virtual ~ListenSocket();

        bool ProcessRead();

        virtual ClientSocket *OnAccept(int fd, const sockaddrs &addr) = 0;
};

class CoreExport ConnectionSocket : public virtual Socket
{
 public:
        /* Sockaddrs for connection ip/port */
        sockaddrs conaddr;

        ConnectionSocket();

        void Connect(const Anope::string &TargetHost, int Port);

        bool Process() anope_override;

        void ProcessError() anope_override;

        virtual void OnConnect();

        virtual void OnError(const Anope::string &error);
};

class CoreExport ClientSocket : public virtual Socket
{
 public:
        /* Listen socket this connection came from */
        ListenSocket *ls;
        /* Clients address */
        sockaddrs clientaddr;

        ClientSocket(ListenSocket *ls, const sockaddrs &addr);

        bool Process() anope_override;

        void ProcessError() anope_override;

        virtual void OnAccept();

        virtual void OnError(const Anope::string &error);
};

class CoreExport Pipe : public Socket
{
 public:
        int write_pipe;

        Pipe();
        ~Pipe();

        bool ProcessRead() anope_override;

        void Write(const char *data, size_t sz);
        inline void Write(const Anope::string &data) { this->Write(data.c_str(), data.length() + 1); }

        int Read(char *data, size_t sz);

        bool SetWriteBlocking(bool state);

        void Notify();

        virtual void OnNotify() = 0;
};

extern CoreExport uint32_t TotalRead;
extern CoreExport uint32_t TotalWritten;
extern CoreExport SocketIO NormalSocketIO;

#endif // SOCKET_H