crofbase.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/. */

/*
 * crofbase.h
 *
 *  Created on: 25.10.2012
 *      Author: andreas
 */

#ifndef CROFBASE_H
#define CROFBASE_H 1

#include <map>
#include <set>
#include <list>
#include <vector>
#include <bitset>
#include <algorithm>
#include <endian.h>
#include <string.h>
#include <time.h>
#ifndef htobe16
        #include "endian_conversion.h"
#endif

#include "rofl/common/ciosrv.h"
#include "rofl/common/croflexception.h"
#include "rofl/common/csocket.h"
#include "rofl/common/thread_helper.h"
#include "rofl/common/logging.h"
#include "rofl/common/crofdpt.h"
#include "rofl/common/crofctl.h"
#include "rofl/common/openflow/openflow.h"
#include "rofl/common/openflow/cofhelloelemversionbitmap.h"
#include "rofl/common/crandom.h"

namespace rofl {


/* error classes */
class eRofBase                      : public RoflException {};   // base error class crofbase
class eRofBaseIsBusy                : public eRofBase {}; // this FwdElem is already controlled
class eRofBaseNotConnected          : public eRofBase {}; // this instance is not connected to the specified cofdpt/cofctl instance
class eRofBaseNotImpl               : public eRofBase {}; // this FwdElem's method is not implemented
class eRofBaseNoCtrl                : public eRofBase {}; // no controlling entity attached to this FwdElem
class eRofBaseNotFound              : public eRofBase {}; // internal entity not found
class eRofBaseInval                 : public eRofBase {}; // invalid parameter (e.g. invalid packet type)
class eRofBaseNotAttached           : public eRofBase {}; // received command from entity being not attached
class eRofBaseNoRequest             : public eRofBase {}; // no request packet found for session
class eRofBaseXidInval              : public eRofBase {}; // invalid xid in session exchange
class eRofBaseExists                : public eRofBase {}; // fwdelem with either this dpid or dpname already exists
class eRofBaseOFportNotFound        : public eRofBase {}; // cofport instance not found
class eRofBaseTableNotFound         : public eRofBase {}; // flow-table not found (e.g. unknown table_id in flow_mod)
class eRofBaseGotoTableNotFound     : public eRofBase {}; // table-id specified in OFPIT_GOTO_TABLE invalid
class eRofBaseFspSupportDisabled    : public eRofBase {};
class eRofBaseCongested             : public eRofBase {}; // control channel is congested, dropping messages



class crofbase :
        public ciosrv,
        public csocket_env,
        public crofconn_env,
        public ctransactions_env,
        public crofctl_env,
        public crofdpt_env
{
public:

        crofbase(
                        const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap =
                                        rofl::openflow::cofhello_elem_versionbitmap());

        virtual
        ~crofbase();

public:

        void
        close_dpt_listening() {
                while (not dpt_sockets.empty()) {
                        unsigned int sockid = dpt_sockets.begin()->first;
                        drop_dpt_listening(sockid);
                }
        };

        rofl::csocket&
        add_dpt_listening(
                        unsigned int sockid,
                        enum rofl::csocket::socket_type_t socket_type,
                        const rofl::cparams& params) {
                if (dpt_sockets.find(sockid) != dpt_sockets.end()) {
                        delete dpt_sockets[sockid];
                        dpt_sockets.erase(sockid);
                }
                dpt_sockets[sockid] = csocket::csocket_factory(socket_type, this);
                dpt_sockets[sockid]->listen(params);
                return *(dpt_sockets[sockid]);
        };

        rofl::csocket&
        set_dpt_listening(
                        unsigned int sockid,
                        enum rofl::csocket::socket_type_t socket_type,
                        const rofl::cparams& params) {
                if (dpt_sockets.find(sockid) == dpt_sockets.end()) {
                        dpt_sockets[sockid] = csocket::csocket_factory(socket_type, this);
                        dpt_sockets[sockid]->listen(params);
                }
                return *(dpt_sockets[sockid]);
        };

        const rofl::csocket&
        get_dpt_listening(
                        unsigned int sockid) const {
                if (dpt_sockets.find(sockid) == dpt_sockets.end()) {
                        throw eRofBaseNotFound();
                }
                return *(dpt_sockets.at(sockid));
        };

        void
        drop_dpt_listening(
                        unsigned int sockid) {
                if (dpt_sockets.find(sockid) == dpt_sockets.end()) {
                        return;
                }
                delete dpt_sockets[sockid];
                dpt_sockets.erase(sockid);
        };

        bool
        has_dpt_listening(
                        unsigned int sockid) {
                return (not (dpt_sockets.find(sockid) == dpt_sockets.end()));
        };

public:

        void
        close_ctl_listening() {
                while (not ctl_sockets.empty()) {
                        unsigned int sockid = ctl_sockets.begin()->first;
                        drop_ctl_listening(sockid);
                }
        };

        rofl::csocket&
        add_ctl_listening(
                        unsigned int sockid,
                        enum rofl::csocket::socket_type_t socket_type,
                        const rofl::cparams& params) {
                if (ctl_sockets.find(sockid) != ctl_sockets.end()) {
                        delete ctl_sockets[sockid];
                        ctl_sockets.erase(sockid);
                }
                ctl_sockets[sockid] = csocket::csocket_factory(socket_type, this);
                ctl_sockets[sockid]->listen(params);
                return *(ctl_sockets[sockid]);
        };

        rofl::csocket&
        set_ctl_listening(
                        unsigned int sockid,
                        enum rofl::csocket::socket_type_t socket_type,
                        const rofl::cparams& params) {
                if (ctl_sockets.find(sockid) == ctl_sockets.end()) {
                        ctl_sockets[sockid] = csocket::csocket_factory(socket_type, this);
                        ctl_sockets[sockid]->listen(params);
                }
                return *(ctl_sockets[sockid]);
        };

        const rofl::csocket&
        get_ctl_listening(
                        unsigned int sockid) const {
                if (ctl_sockets.find(sockid) == ctl_sockets.end()) {
                        throw eRofBaseNotFound();
                }
                return *(ctl_sockets.at(sockid));
        };

        void
        drop_ctl_listening(
                        unsigned int sockid) {
                if (ctl_sockets.find(sockid) == ctl_sockets.end()) {
                        return;
                }
                delete ctl_sockets[sockid];
                ctl_sockets.erase(sockid);
        };

        bool
        has_ctl_listening(
                        unsigned int sockid) {
                return (not (ctl_sockets.find(sockid) == ctl_sockets.end()));
        };

public:

        rofl::cdptid
        get_idle_dptid() const {
                uint64_t id = 0;
                while (has_dpt(rofl::cdptid(id))) {
                        id++;
                }
                return rofl::cdptid(id);
        };

        void
        drop_dpts() {
                for (std::map<rofl::cdptid, crofdpt*>::iterator
                                it = rofdpts.begin(); it != rofdpts.end(); ++it) {
                        delete it->second;
                }
                rofdpts.clear();
        };

        rofl::crofdpt&
        add_dpt(
                const rofl::cdptid& dptid,
                const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap,
                bool remove_on_channel_close = false,
                const rofl::cdpid& dpid = rofl::cdpid(0)) {
                if (rofdpts.find(dptid) != rofdpts.end()) {
                        delete rofdpts[dptid];
                        rofdpts.erase(dptid);
                }
                rofdpts[dptid] = new crofdpt(this, dptid, remove_on_channel_close, versionbitmap, dpid);
                return *(rofdpts[dptid]);
        };

        rofl::crofdpt&
        set_dpt(
                const rofl::cdptid& dptid,
                const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap,
                bool remove_on_channel_close = false,
                const rofl::cdpid& dpid = rofl::cdpid(0)) {
                if (rofdpts.find(dptid) == rofdpts.end()) {
                        rofdpts[dptid] = new crofdpt(this, dptid, remove_on_channel_close, versionbitmap, dpid);
                }
                return *(rofdpts[dptid]);
        };

        rofl::crofdpt&
        set_dpt(
                        const rofl::cdptid& dptid) {
                if (rofdpts.find(dptid) == rofdpts.end()) {
                        throw eRofBaseNotFound();
                }
                return *(rofdpts[dptid]);
        };

        const rofl::crofdpt&
        get_dpt(
                        const rofl::cdptid& dptid) const {
                if (rofdpts.find(dptid) == rofdpts.end()) {
                        throw eRofBaseNotFound();
                }
                return *(rofdpts.at(dptid));
        };

        void
        drop_dpt(
                rofl::cdptid dptid) { // make a copy here, do not use a const reference
                if (rofdpts.find(dptid) == rofdpts.end()) {
                        return;
                }
                delete rofdpts[dptid];
                rofdpts.erase(dptid);
        };

        bool
        has_dpt(
                const rofl::cdptid& dptid) const {
                return (not (rofdpts.find(dptid) == rofdpts.end()));
        };

public:

        rofl::cctlid
        get_idle_ctlid() const {
                uint64_t id = 0;
                while (has_ctl(rofl::cctlid(id))) {
                        id++;
                }
                return rofl::cctlid(id);
        };

        void
        drop_ctls() {
                for (std::map<rofl::cctlid, crofctl*>::iterator
                                it = rofctls.begin(); it != rofctls.end(); ++it) {
                        delete it->second;
                }
                rofctls.clear();
        };

        rofl::crofctl&
        add_ctl(
                const rofl::cctlid& ctlid,
                const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap,
                bool remove_on_channel_close = false) {
                if (rofctls.find(ctlid) != rofctls.end()) {
                        delete rofctls[ctlid];
                        rofctls.erase(ctlid);
                }
                rofctls[ctlid] = new crofctl(this, ctlid, remove_on_channel_close, versionbitmap);
                return *(rofctls[ctlid]);
        };

        rofl::crofctl&
        set_ctl(
                const rofl::cctlid& ctlid,
                const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap,
                bool remove_on_channel_close = false) {
                if (rofctls.find(ctlid) == rofctls.end()) {
                        rofctls[ctlid] = new crofctl(this, ctlid, remove_on_channel_close, versionbitmap);
                }
                return *(rofctls[ctlid]);
        };

        rofl::crofctl&
        set_ctl(
                        const rofl::cctlid& ctlid) {
                if (rofctls.find(ctlid) == rofctls.end()) {
                        throw eRofBaseNotFound();
                }
                return *(rofctls[ctlid]);
        };

        const rofl::crofctl&
        get_ctl(
                        const rofl::cctlid& ctlid) const {
                if (rofctls.find(ctlid) == rofctls.end()) {
                        throw eRofBaseNotFound();
                }
                return *(rofctls.at(ctlid));
        };

        void
        drop_ctl(
                rofl::cctlid ctlid) { // make a copy here, do not use a const reference
                if (rofctls.find(ctlid) == rofctls.end()) {
                        return;
                }
                delete rofctls[ctlid];
                rofctls.erase(ctlid);
        };

        bool
        has_ctl(
                const rofl::cctlid& ctlid) const {
                return (not (rofctls.find(ctlid) == rofctls.end()));
        };

public:

        static uint32_t
        get_ofp_no_buffer(
                        uint8_t ofp_version);

        static uint32_t
        get_ofp_controller_port(
                        uint8_t ofp_version);

        static uint32_t
        get_ofp_flood_port(
                        uint8_t ofp_version);

        static uint8_t
        get_ofp_command(
                        uint8_t ofp_version,
                        const enum openflow::ofp_flow_mod_command& cmd);

        rofl::openflow::cofhello_elem_versionbitmap&
        set_versionbitmap()
        { return versionbitmap; };

        const rofl::openflow::cofhello_elem_versionbitmap&
        get_versionbitmap() const
        { return versionbitmap; };

        uint8_t
        get_highest_supported_ofp_version() const
        { return versionbitmap.get_highest_ofp_version(); };

        bool
        is_ofp_version_supported(
                        uint8_t ofp_version) const
        { return versionbitmap.has_ofp_version(ofp_version); };

protected:

        virtual void
        handle_dpt_open(
                        rofl::crofdpt& dpt) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "dptid: " << dpt.get_dptid().str() << " "
                                << "control channel established " << std::endl;
        };

        virtual void
        handle_dpt_close(
                        rofl::crofdpt& dpt) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "dptid: " << dpt.get_dptid().str() << " "
                                << "control channel terminated " << std::endl;
        };

        virtual void
        handle_conn_established(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "dptid: " << dpt.get_dptid().str() << " "
                                << "control connection established, "
                                << "auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_terminated(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "dptid: " << dpt.get_dptid().str() << " "
                                << "control connection terminated, "
                                << "auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_refused(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection refused, "
                                << "dptid: " << dpt.get_dptid().str()  << " auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_failed(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection failed, "
                                << "dptid: " << dpt.get_dptid().str()  << " auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_writable(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection is writable, "
                                << "dptid: " << dpt.get_dptid().str()  << " auxid: " << auxid.str() << std::endl;
        };

protected:

        virtual void
        handle_ctl_open(
                        rofl::crofctl& ctl) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "ctlid: " << ctl.get_ctlid().str() << " "
                                << "control channel established " << std::endl;
        };

        virtual void
        handle_ctl_close(
                        rofl::crofctl& ctl) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "ctlid: " << ctl.get_ctlid().str() << " "
                                << "control channel terminated " << std::endl;
        };

        virtual void
        handle_conn_established(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "ctlid: " << ctl.get_ctlid().str() << " "
                                << "control connection established, "
                                << "auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_terminated(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] "
                                << "ctlid: " << ctl.get_ctlid().str() << " "
                                << "control connection terminated, "
                                << "auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_refused(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection refused, "
                                << "ctlid: " << ctl.get_ctlid().str()  << " auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_failed(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection failed, "
                                << "ctlid: " << ctl.get_ctlid().str()  << " auxid: " << auxid.str() << std::endl;
        };

        virtual void
        handle_conn_writable(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofbase] connection is writable, "
                                << "ctlid: " << ctl.get_ctlid().str()  << " auxid: " << auxid.str() << std::endl;
        };

protected:

        virtual void
        handle_features_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_features_reply& msg)
        {};

        virtual void
        handle_features_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_get_config_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_config_reply& msg)
        {};

        virtual void
        handle_get_config_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_stats_reply& msg)
        {};

        virtual void
        handle_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid,
                        uint8_t stats_type)
        {};

        virtual void
        handle_desc_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_desc_stats_reply& msg)
        {};

        virtual void
        handle_desc_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_table_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_stats_reply& msg)
        {};

        virtual void
        handle_table_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_port_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_stats_reply& msg)
        {};

        virtual void
        handle_port_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_flow_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_stats_reply& msg)
        {};

        virtual void
        handle_flow_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_aggregate_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_aggr_stats_reply& msg)
        {};

        virtual void
        handle_aggregate_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_queue_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_stats_reply& msg)
        {};

        virtual void
        handle_queue_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_group_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_stats_reply& msg)
        {};

        virtual void
        handle_group_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_group_desc_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_desc_stats_reply& msg)
        {};

        virtual void
        handle_group_desc_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_group_features_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_features_stats_reply& msg)
        {};

        virtual void
        handle_group_features_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_meter_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_stats_reply& msg)
        {};

        virtual void
        handle_meter_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_meter_config_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_config_stats_reply& msg)
        {};

        virtual void
        handle_meter_config_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_meter_features_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_features_stats_reply& msg)
        {};

        virtual void
        handle_meter_features_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_table_features_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_features_stats_reply& msg)
        {};

        virtual void
        handle_table_features_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_port_desc_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_desc_stats_reply& msg)
        {};

        virtual void
        handle_port_desc_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_experimenter_stats_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter_stats_reply& msg)
        {};

        virtual void
        handle_experimenter_stats_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_packet_in(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_packet_in& msg)
        {};

        virtual void
        handle_barrier_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_barrier_reply& msg)
        {};

        virtual void
        handle_barrier_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_flow_removed(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_removed& msg)
        {};

        virtual void
        handle_port_status(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_status& msg)
        {};

        virtual void
        handle_queue_get_config_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_get_config_reply& msg)
        {};

        virtual void
        handle_queue_get_config_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_error_message(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_error& msg)
        {};

        virtual void
        handle_experimenter_message(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter& msg)
        {};

        virtual void
        handle_experimenter_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_role_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_role_reply& msg)
        {};

        virtual void
        handle_role_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

        virtual void
        handle_get_async_config_reply(
                        rofl::crofdpt& dpt,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_async_config_reply& msg)
        {};

        virtual void
        handle_get_async_config_reply_timeout(
                        rofl::crofdpt& dpt,
                        uint32_t xid)
        {};

protected:

        virtual void
        handle_features_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_features_request& msg)
        {};

        virtual void
        handle_get_config_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_config_request& msg)
        {};

        virtual void
        handle_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_stats_request& msg)
        {};

        virtual void
        handle_desc_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_desc_stats_request& msg)
        {};

        virtual void
        handle_table_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_stats_request& msg)
        {};

        virtual void
        handle_port_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_stats_request& msg)
        {};

        virtual void
        handle_flow_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_stats_request& msg)
        {};

        virtual void
        handle_aggregate_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_aggr_stats_request& msg)
        {};

        virtual void
        handle_queue_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_stats_request& msg)
        {};

        virtual void
        handle_group_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_stats_request& msg)
        {};

        virtual void
        handle_group_desc_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_desc_stats_request& msg)
        {};

        virtual void
        handle_group_features_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_features_stats_request& msg)
        {};

        virtual void
        handle_meter_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_stats_request& msg)
        {};

        virtual void
        handle_meter_config_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_config_stats_request& msg)
        {};

        virtual void
        handle_meter_features_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_features_stats_request& msg)
        {};

        virtual void
        handle_table_features_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_features_stats_request& msg)
        {};

        virtual void
        handle_port_desc_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_desc_stats_request& msg)
        {};

        virtual void
        handle_experimenter_stats_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter_stats_request& msg)
        {};

        virtual void
        handle_packet_out(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_packet_out& msg)
        {};

        virtual void
        handle_barrier_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_barrier_request& msg)
        {};

        virtual void
        handle_flow_mod(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_mod& msg)
        {};

        virtual void
        handle_group_mod(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_mod& msg)
        {};

        virtual void
        handle_table_mod(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_mod& msg)
        {};

        virtual void
        handle_port_mod(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_mod& msg)
        {};

        virtual void
        handle_queue_get_config_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_get_config_request& msg)
        {};

        virtual void
        handle_set_config(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_set_config& msg)
        {};

        virtual void
        handle_experimenter_message(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter& msg)
        {};

        virtual void
        handle_error_message(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_error& msg)
        {};

        virtual void
        handle_role_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_role_request& msg)
        {};

        virtual void
        handle_get_async_config_request(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_async_config_request& msg)
        {};

        virtual void
        handle_set_async_config(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_set_async_config& msg)
        {};

        virtual void
        handle_meter_mod(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_mod& msg)
        {};

protected:

        void
        send_packet_in_message(
                        const rofl::cauxid& auxid,
                        uint32_t buffer_id,
                        uint16_t total_len,
                        uint8_t reason,
                        uint8_t table_id,
                        uint64_t cookie,
                        uint16_t in_port, // for OF1.0
                        rofl::openflow::cofmatch &match,
                        uint8_t *data,
                        size_t datalen);

        void
        send_flow_removed_message(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmatch& match,
                        uint64_t cookie,
                        uint16_t priority,
                        uint8_t reason,
                        uint8_t table_id,
                        uint32_t duration_sec,
                        uint32_t duration_nsec,
                        uint16_t idle_timeout,
                        uint16_t hard_timeout,
                        uint64_t packet_count,
                        uint64_t byte_count);

        void
        send_port_status_message(
                        const rofl::cauxid& auxid,
                        uint8_t reason,
                        const rofl::openflow::cofport& port);

public:

        friend std::ostream&
        operator<< (std::ostream& os, crofbase const& rofbase) {
                os << "<crofbase >" << std::endl;
                for (std::map<cctlid, crofctl*>::const_iterator
                                it = rofbase.rofctls.begin(); it != rofbase.rofctls.end(); ++it) {
                        rofl::indent i(2);
                        os << it->first;
                }
                for (std::map<cdptid, crofdpt*>::const_iterator
                                it = rofbase.rofdpts.begin(); it != rofbase.rofdpts.end(); ++it) {
                        rofl::indent i(2);
                        os << it->first;
                }
                return os;
        };

private:

        virtual void
        role_request_rcvd(
                        rofl::crofctl& ctl,
                        uint32_t role,
                        uint64_t rcvd_generation_id);

private:

        virtual void
        handle_connect_refused(
                        crofconn& conn);

        virtual void
        handle_connect_failed(
                        crofconn& conn);

        virtual void
        handle_connected(
                        crofconn& conn,
                        uint8_t ofp_version);

        virtual void
        handle_closed(
                        crofconn& conn)
        {};

        virtual void
        handle_write(
                        crofconn& conn)
        {};

        virtual void
        recv_message(
                        crofconn& conn,
                        rofl::openflow::cofmsg *msg)
        { delete msg; };

        virtual uint32_t
        get_async_xid(
                        crofconn& conn)
        { return transactions.get_async_xid(); };

        virtual uint32_t
        get_sync_xid(
                        crofconn& conn,
                        uint8_t msg_type = 0,
                        uint16_t msg_sub_type = 0)
        { return transactions.add_ta(cclock(5, 0), msg_type, msg_sub_type); };

        virtual void
        release_sync_xid(
                        crofconn& conn,
                        uint32_t xid)
        { transactions.drop_ta(xid); };

private:

        virtual void
        ta_expired(ctransactions& tas, ctransaction& ta)
        {};

private:

        virtual void
        handle_listen(
                        csocket& socket,
                        int newsd);

        virtual void
        handle_accepted(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_accept_refused(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_connected(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_connect_refused(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_connect_failed(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_read(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_write(
                        csocket& socket)
        { /*  do nothing here */ };

        virtual void
        handle_closed(
                        csocket& socket);

private:

        enum crofbase_event_t {
                EVENT_NONE         = 0,
                EVENT_CTL_DETACHED = 1,
                EVENT_DPT_DETACHED = 2,
        };

        enum crofbase_timer_t {
                TIMER_NONE         = 0,
                TIMER_RUN_ENGINE   = 1,
        };

private:

        bool
        is_dpt_listening(
                        csocket& socket) const {
                for (std::map<unsigned int, csocket*>::const_iterator
                                it = dpt_sockets.begin(); it != dpt_sockets.end(); ++it) {
                        if (it->second == &socket) {
                                return true;
                        }
                }
                return false;
        };

        bool
        is_ctl_listening(
                        csocket& socket) const {
                for (std::map<unsigned int, csocket*>::const_iterator
                                it = ctl_sockets.begin(); it != ctl_sockets.end(); ++it) {
                        if (it->second == &socket) {
                                return true;
                        }
                }
                return false;
        };

        void
        drop_dpt_listening(
                        csocket& socket) {
                for (std::map<unsigned int, csocket*>::const_iterator
                                it = dpt_sockets.begin(); it != dpt_sockets.end(); ++it) {
                        if (it->second == &socket) {
                                drop_dpt_listening(it->first); return;
                        }
                }
        };

        void
        drop_ctl_listening(
                        csocket& socket) {
                for (std::map<unsigned int, csocket*>::const_iterator
                                it = ctl_sockets.begin(); it != ctl_sockets.end(); ++it) {
                        if (it->second == &socket) {
                                drop_ctl_listening(it->first); return;
                        }
                }
        };

        virtual void
        handle_chan_established(
                        crofdpt& dpt) {
                handle_dpt_open(dpt);
        };

        virtual void
        handle_chan_terminated(
                        crofdpt& dpt) {
                // destroy crofdpt object, when is was created upon an incoming connection from a peer entity
                if (dpt.remove_on_channel_termination()) {
                        dpts_detached.insert(dpt.get_dptid());
                        push_on_eventqueue(EVENT_DPT_DETACHED);
                } else {
                        handle_dpt_close(dpt);
                }
        };

        virtual void
        handle_chan_established(
                        crofctl& ctl) {
                handle_ctl_open(ctl);
        };

        virtual void
        handle_chan_terminated(
                        crofctl& ctl) {
                // destroy crofctl object, when is was created upon an incoming connection from a peer entity
                if (ctl.remove_on_channel_termination()) {
                        ctls_detached.insert(ctl.get_ctlid());
                        push_on_eventqueue(EVENT_CTL_DETACHED);
                } else {
                        handle_ctl_close(ctl);
                }
        };

        virtual void
        handle_timeout(
                        int opaque,
                        void* data = (void*)0) {
                switch (opaque) {
                case TIMER_RUN_ENGINE: {
                        work_on_eventqueue();
                } break;
                default: {
                        // do nothing
                };
                }
        };

        void
        push_on_eventqueue(
                        enum crofbase_event_t event = EVENT_NONE) {
                if (EVENT_NONE != event) {
                        eventqueue.push_back(event);
                }
                register_timer(TIMER_RUN_ENGINE, rofl::ctimespec(/*second(s)=*/0));
        };

        void
        work_on_eventqueue() {
                while (not eventqueue.empty()) {
                        crofbase_event_t event = eventqueue.front();
                        eventqueue.pop_front();
                        switch (event) {
                        case EVENT_CTL_DETACHED: {
                                event_ctls_detached();
                        } break;
                        case EVENT_DPT_DETACHED: {
                                event_dpts_detached();
                        } break;
                        default: {
                                // do nothing for unknown event types
                        };
                        }
                }
        };

        void
        event_ctls_detached() {
                for (std::set<rofl::cctlid>::iterator
                                it = ctls_detached.begin(); it != ctls_detached.end(); ++it) {
                        handle_ctl_close(rofl::crofctl::get_ctl(*it));
                        rofl::logging::info << "[rofl-common][crofbase] "
                                        << "dropping crofctl instance, ctlid:" << it->str() << std::endl;
                        drop_ctl(*it);
                }
                ctls_detached.clear();
        };

        void
        event_dpts_detached() {
                for (std::set<rofl::cdptid>::iterator
                                it = dpts_detached.begin(); it != dpts_detached.end(); ++it) {
                        handle_dpt_close(rofl::crofdpt::get_dpt(*it));
                        rofl::logging::info << "[rofl-common][crofbase] "
                                        << "dropping crofdpt instance, dptid:" << it->str() << std::endl;
                        drop_dpt(*it);
                }
                dpts_detached.clear();
        };

private:

        static std::set<crofbase*>              rofbases;

        std::map<cctlid, crofctl*>              rofctls;
        std::map<cdptid, crofdpt*>              rofdpts;
        std::map<unsigned int, csocket*>
                                                                        dpt_sockets;
        std::map<unsigned int, csocket*>
                                                                        ctl_sockets;
        // supported OpenFlow versions
        rofl::openflow::cofhello_elem_versionbitmap
                                                                        versionbitmap;
        // pending OpenFlow transactions
        ctransactions                                   transactions;
        // generation_id used for roles initially defined?
        bool                                                    generation_is_defined;
        // cached generation_id as defined by OpenFlow
        uint64_t                                                cached_generation_id;
        // event-queue
        std::list<enum crofbase_event_t>
                                                                        eventqueue;
        // ephemeral set of crofdpt instances in detached state
        std::set<rofl::cdptid>                  dpts_detached;
        // ephemeral set of crofctl instances in detached state
        std::set<rofl::cctlid>                  ctls_detached;
};

}; // end of namespace

#endif