csocket.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef CSOCKET_H
#define CSOCKET_H

#include <list>
#include <bitset>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <fcntl.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <assert.h>

#include "rofl/common/croflexception.h"
#include "rofl/common/ciosrv.h"
#include "rofl/common/csockaddr.h"
#include "rofl/common/logging.h"
#include "rofl/common/cparams.h"

namespace rofl {

class eSocketBase                                       : public RoflException {};
class eSocketRxAgain                            : public eSocketBase {};
class eSocketTxAgain                            : public eSocketBase {};
class eSocketTxAgainCongestion          : public eSocketTxAgain {};
class eSocketTxAgainTxQueueFull         : public eSocketTxAgain {};
class eSocketTxAgainPacketDropped       : public eSocketTxAgain {};
class eSocketNotConnected                       : public eSocketBase {};
class eSocketTypeNotFound                       : public eSocketBase {};
class eSocketParamNotFound                      : public eSocketBase {};

class csocket; // forward declaration

class csocket_env {
        friend class csocket;
public:

        virtual
        ~csocket_env()
        {};

        virtual void
        handle_listen(
                        rofl::csocket& socket,
                        int newsd) = 0;

        virtual void
        handle_accepted(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_accept_refused(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_connected(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_connect_refused(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_connect_failed(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_read(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_write(
                        rofl::csocket& socket) = 0;

        virtual void
        handle_closed(
                        rofl::csocket& socket) = 0;
};


class csocket :
        public virtual ciosrv
{
public:

        /* supported socket types */
        enum socket_type_t {
                SOCKET_TYPE_UNKNOWN             = 0,
                SOCKET_TYPE_PLAIN               = 1,
                SOCKET_TYPE_OPENSSL     = 2,
        };

public:

        static csocket*
        csocket_factory(
                        enum socket_type_t socket_type, csocket_env *owner);

        static cparams
        get_default_params(
                        enum socket_type_t socket_type);

public:

        csocket(
                        csocket_env *env,
                        enum socket_type_t socket_type) :
                                socket_env(env),
                                socket_type(socket_type),
                                sd(-1),
                                domain(0),
                                type(0),
                                protocol(0),
                                backlog(0)
        {};

        virtual
        ~csocket()
        {};

        virtual void
        listen(
                        const rofl::cparams& params) = 0;

        virtual void
        accept(
                        const rofl::cparams& socket_params,
                        int sd) = 0;

        virtual void
        connect(
                        const rofl::cparams& params) = 0;

        virtual void
        reconnect() = 0;


        virtual void
        close() = 0;


        virtual ssize_t
        recv(void *buf, size_t count) = 0;
        virtual ssize_t
        recv(void *buf, size_t count, int flags, rofl::csockaddr& from) = 0;

        virtual void
        send(cmemory *mem, rofl::csockaddr const& dest = rofl::csockaddr()) = 0;


        virtual bool
        is_established() const = 0;

        virtual bool
        write_would_block() const = 0;

public:

        int
        get_sd() const
        { return sd; };

        enum rofl::csocket::socket_type_t
        get_socket_type() const
        { return socket_type; };

        const rofl::cparams&
        get_socket_params() const
        { return socket_params; };

        rofl::csockaddr&
        set_laddr()
        { return laddr; };

        rofl::csockaddr const&
        get_laddr() const
        { return laddr; };

        rofl::csockaddr&
        set_raddr()
        { return raddr; };

        rofl::csockaddr const&
        get_raddr() const
        { return raddr; };

        void
        set_domain(int domain)
        { this->domain = domain; };

        int
        get_domain() const
        { return domain; };

        void
        set_type(int type)
        { this->type = type; };

        int
        get_type() const
        { return type; };

        void
        set_protocol(int protocol)
        { this->protocol = protocol; };

        int
        get_protocol() const
        { return protocol; };


        static bool 
        supports_socket_type(enum socket_type_t socket_type);

        //Common Keys
        static std::string const        PARAM_KEY_DO_RECONNECT;
        static std::string const        PARAM_KEY_REMOTE_HOSTNAME;
        static std::string const        PARAM_KEY_REMOTE_PORT;
        static std::string const        PARAM_KEY_LOCAL_HOSTNAME;
        static std::string const        PARAM_KEY_LOCAL_PORT;
        static std::string const        PARAM_KEY_DOMAIN;
        static std::string const        PARAM_KEY_TYPE;
        static std::string const        PARAM_KEY_PROTOCOL;

        //Common values (non-numeric)
        static std::string const        PARAM_DOMAIN_VALUE_INET_ANY;
        static std::string const        PARAM_DOMAIN_VALUE_INET;
        static std::string const        PARAM_DOMAIN_VALUE_INET6;
        static std::string const        PARAM_TYPE_VALUE_STREAM;
        static std::string const        PARAM_TYPE_VALUE_DGRAM;
        static std::string const        PARAM_PROTOCOL_VALUE_TCP;
        static std::string const        PARAM_PROTOCOL_VALUE_UDP;

        //Socket type specific keys
        static std::string const        PARAM_SSL_KEY_CA_PATH;
        static std::string const        PARAM_SSL_KEY_CA_FILE;
        static std::string const        PARAM_SSL_KEY_CERT;
        static std::string const        PARAM_SSL_KEY_PRIVATE_KEY;
        static std::string const        PARAM_SSL_KEY_PRIVATE_KEY_PASSWORD;
        static std::string const        PARAM_SSL_KEY_VERIFY_MODE;
        static std::string const        PARAM_SSL_KEY_VERIFY_DEPTH;
        static std::string const        PARAM_SSL_KEY_CIPHERS;

public:

        friend std::ostream&
        operator<< (std::ostream& os, csocket const& sock) {
                os << rofl::indent(0) << "<csocket "
                        << "sd:" << sock.sd << " "
                        << "domain:" << sock.domain << " "
                        << "type:" << sock.type << " "
                        << "protocol:" << sock.protocol << " ";
                os << ">" << std::endl;
                os << rofl::indent(2) << "<raddr: >" << std::endl;
                { rofl::indent i(4); os << sock.raddr; };
                os << rofl::indent(2) << "<laddr: >" << std::endl;
                { rofl::indent i(4); os << sock.laddr; };
                return os;
        };

protected:

        csocket_env*        socket_env;                 
        enum socket_type_t  socket_type;                
        int                 sd;                                 
        csockaddr           laddr;                              
        csockaddr           raddr;                              
        int                 domain;                     
        int                 type;                               
        int                 protocol;                   
        int                 backlog;                    
        cparams             socket_params;              
};

}; // end of namespace

#endif