csocket_plain.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_PLAIN_H
#define CSOCKET_PLAIN_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 <net/if.h>

#include "rofl/common/csocket.h"
#include "rofl/common/ctimerid.h"
#include "rofl/common/caddrinfos.h"
#include "rofl/common/openflow/openflow_common.h"

namespace rofl {


class csocket_plain :
        public csocket
{
protected:

        struct pout_entry_t {
                cmemory *mem;
                csockaddr dest;
                size_t msg_bytes_sent;
                pout_entry_t(cmemory *mem = 0, csockaddr const& dest = csockaddr()) :
                        mem(mem), dest(dest), msg_bytes_sent(0) {};
                pout_entry_t(pout_entry_t const& e) :
                        mem(0), msg_bytes_sent(0) {
                        *this = e;
                };
                struct pout_entry_t&
                operator= (pout_entry_t const& e) {
                        if (this == &e) return *this;
                        mem = e.mem;
                        dest = e.dest;
                        msg_bytes_sent = e.msg_bytes_sent;
                        return *this;
                };
                friend std::ostream&
                operator<< (std::ostream& os, struct pout_entry_t const& entry) {
                        os << indent(0) << "<struct pout_entry_t >" << std::endl;
                        os << indent(2) << "<mem:0x" << entry.mem << " >" << std::endl;
                        os << indent(2) << "<dest:" << entry.dest << " >" << std::endl;
                        os << indent(2) << "<msg_bytes_sent:" << entry.msg_bytes_sent << " >" << std::endl;
                        return os;
                };
        };

        bool                                            had_short_write;
        pthread_rwlock_t                        pout_squeue_lock;       
        std::list<pout_entry_t>         pout_squeue;            
        //Defaults
        static bool const                       PARAM_DEFAULT_VALUE_DO_RECONNECT;
        static std::string const        PARAM_DEFAULT_VALUE_REMOTE_HOSTNAME;
        static std::string const        PARAM_DEFAULT_VALUE_REMOTE_PORT;
        static std::string const        PARAM_DEFAULT_VALUE_LOCAL_HOSTNAME;
        static std::string const        PARAM_DEFAULT_VALUE_LOCAL_PORT;
        static std::string const        PARAM_DEFAULT_VALUE_DOMAIN;
        static std::string const        PARAM_DEFAULT_VALUE_TYPE;
        static std::string const        PARAM_DEFAULT_VALUE_PROTOCOL;

private:

        enum socket_flag_t {
                FLAG_LISTENING = 1,     
                FLAG_CONNECTING         = 2,    
                FLAG_RAW_SOCKET                 = 3,    
                FLAG_CONNECTED                  = 4,    
                FLAG_ACTIVE_SOCKET      = 5,
                FLAG_DO_RECONNECT       = 6,
                FLAG_CLOSING = 7,
                FLAG_TX_WOULD_BLOCK     = 8,    
                FLAG_TX_WOULD_BLOCK_NOTIFIED = 9,       
        };

        std::bitset<16>                         sockflags; 
        enum csocket_plain_timer_t {
                TIMER_RECONNECT         = 1,
        };

        enum csocket_plain_event_t {
                EVENT_CONN_RESET        = 1,
                EVENT_DISCONNECTED      = 2,
        };

        static const unsigned int DEFAULT_MAX_TXQUEUE_SIZE;
        unsigned int                            max_txqueue_size;               // limit for pout_squeue

        ctimerid                                        reconnect_timerid;
        int                                                     reconnect_start_timeout;
        int                                             reconnect_in_seconds;   // reconnect in x seconds
        int                                             reconnect_counter;

#define RECONNECT_START_TIMEOUT 1                                               // start reconnect timeout (default 1s)

public:


        csocket_plain(
                        csocket_env *owner);


        virtual
        ~csocket_plain();


        virtual void
        listen(
                cparams const& params);


        virtual void
        accept(
                cparams const& socket_params, int sd);


        virtual void
        connect(
                cparams const& params);


        virtual void
        reconnect();


        virtual void
        close();


        virtual ssize_t
        recv(
                        void *buf, size_t count) {
                csockaddr from;
                return recv(buf, count, 0, from);
        };

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


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


        virtual bool
        is_established() const { return sockflags.test(FLAG_CONNECTED); };

        virtual bool
        write_would_block() const { return sockflags.test(FLAG_TX_WOULD_BLOCK); };


        static cparams
        get_default_params();


protected:

        virtual void
        listen(
                const csockaddr& la,
                int domain = PF_INET,
                int type = SOCK_STREAM,
                int protocol = 0,
                int backlog = 10,
                std::string devname = std::string(""));



        virtual void
        connect(
                csockaddr ra,
                csockaddr la = csockaddr(),
                int domain = PF_INET,
                int type = SOCK_STREAM,
                int protocol = 0,
                bool do_reconnect = false);


protected:

        //
        // socket specific methods, must be overloaded in derived class
        //

        virtual void
        handle_accepted() {
                if (socket_env) {
                        socket_env->handle_accepted(*this);
                }
        };

        virtual void
        handle_accept_refused() {
                if (socket_env) {
                        socket_env->handle_accept_refused(*this);
                }
        };

        virtual void
        handle_connected() {
                if (socket_env) {
                        socket_env->handle_connected(*this);
                }
        };

        virtual void
        handle_conn_refused() {
                if (socket_env) {
                        socket_env->handle_connect_refused(*this);
                }
        };

        virtual void
        handle_conn_failed() {
                if (socket_env) {
                        socket_env->handle_connect_failed(*this);
                }
        };

        virtual void
        handle_listen(int newsd) {
                if (socket_env) {
                        socket_env->handle_listen(*this, newsd);
                }
        };

        virtual void
        handle_closed() {
                if (socket_env) {
                        socket_env->handle_closed(*this);
                }
        };

        virtual void
        handle_read() {
                if (socket_env) {
                        socket_env->handle_read(*this);
                }
        };

        virtual void
        handle_write() {
                if (socket_env) {
                        socket_env->handle_write(*this);
                }
        };



private:


        void
        backoff_reconnect(
                        bool reset_timeout = false);


        /*
         * inherited from ciosrv
         */


        virtual void
        handle_timeout(
                        int opaque, void *data = (void*)0);

        virtual void
        handle_event(
                        cevent const& ev);


        virtual void
        handle_revent(int fd);


        virtual void
        handle_wevent(int fd);


        virtual void
        handle_xevent(int fd);


protected:


        virtual void
        dequeue_packet();

public:

        friend std::ostream&
        operator<< (std::ostream& os, csocket_plain const& sock) {
                os << dynamic_cast<csocket const&>( sock );
                os << rofl::indent(2) << "<csocket_plain #tx-queue:" << sock.pout_squeue.size() << ">" << std::endl;
                os << rofl::indent(4) << "<flags: ";
                if (sock.sockflags.test(FLAG_LISTENING)) {
                        os << "LISTENING ";
                }
                if (sock.sockflags.test(FLAG_CONNECTING)) {
                        os << "CONNECTING ";
                }
                if (sock.sockflags.test(FLAG_RAW_SOCKET)) {
                        os << "RAW-SOCKET ";
                }
                if (sock.sockflags.test(FLAG_CONNECTED)) {
                        os << "CONNECTED ";
                }
                if (sock.sockflags.test(FLAG_ACTIVE_SOCKET)) {
                        os << "ACTIVE-SOCKET ";
                }
                if (sock.sockflags.test(FLAG_DO_RECONNECT)) {
                        os << "DO-RECONNECT ";
                }
                if (sock.sockflags.test(FLAG_CLOSING)) {
                        os << "CLOSING ";
                }
                if (sock.sockflags.test(FLAG_TX_WOULD_BLOCK)) {
                        os << "TX-WOULD-BLOCK ";
                }
                os << ">" << std::endl;
                return os;
        };

        std::string
        str() const {
                std::stringstream sstr;
                sstr << "sd:" << sd << " local:" << laddr.str() << " remote:" << raddr.str()
                                << " #tx-queue:" << pout_squeue.size() << " flags: ";
                if (sockflags.test(FLAG_LISTENING)) {
                        sstr << "LISTENING, ";
                }
                if (sockflags.test(FLAG_CONNECTING)) {
                        sstr << "CONNECTING, ";
                }
                if (sockflags.test(FLAG_RAW_SOCKET)) {
                        sstr << "RAW-SOCKET, ";
                }
                if (sockflags.test(FLAG_CONNECTED)) {
                        sstr << "CONNECTED, ";
                }
                if (sockflags.test(FLAG_ACTIVE_SOCKET)) {
                        sstr << "ACTIVE-SOCKET, ";
                }
                if (sockflags.test(FLAG_DO_RECONNECT)) {
                        sstr << "DO-RECONNECT, ";
                }
                if (sockflags.test(FLAG_CLOSING)) {
                        sstr << "CLOSING, ";
                }
                if (sockflags.test(FLAG_TX_WOULD_BLOCK)) {
                        sstr << "TX-WOULD-BLOCK, ";
                }
                return sstr.str();
        };
};

}; // end of namespace

#endif