crofctl.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 CROFCTL_H
#define CROFCTL_H 1

#include <map>
#include <string>
#include <bitset>

#include "openflow/openflow.h"
#include "croflexception.h"
#include "cmemory.h"
#include "rofl/common/cctlid.h"
#include "rofl/common/csocket.h"
#include "rofl/common/crofchan.h"
#include "openflow/messages/cofmsg.h"
#include "rofl/common/openflow/cofport.h"
#include "rofl/common/openflow/cofports.h"
#include "rofl/common/openflow/coftables.h"
#include "rofl/common/openflow/cofasyncconfig.h"
#include "rofl/common/openflow/cofrole.h"
#include "rofl/common/openflow/cofdescstats.h"
#include "rofl/common/openflow/cofaggrstats.h"
#include "rofl/common/openflow/cofgroupfeaturesstats.h"
#include "rofl/common/openflow/cofpacketqueues.h"
#include "rofl/common/openflow/cofflowstatsarray.h"
#include "rofl/common/openflow/coftablestatsarray.h"
#include "rofl/common/openflow/cofportstatsarray.h"
#include "rofl/common/openflow/cofqueuestatsarray.h"
#include "rofl/common/openflow/cofgroupstatsarray.h"
#include "rofl/common/openflow/cofgroupdescstatsarray.h"
#include "rofl/common/openflow/cofmeterstatsarray.h"
#include "rofl/common/openflow/cofmeterconfigarray.h"
#include "rofl/common/openflow/cofmeterfeatures.h"
#include "rofl/common/cauxid.h"

#include "rofl/common/ciosrv.h"
#include "rofl/common/thread_helper.h"
#include "rofl/common/logging.h"
#include "rofl/common/openflow/cofmatch.h"
#include "rofl/common/openflow/cofhelloelemversionbitmap.h"
#include "rofl/common/ctransactions.h"


namespace rofl {

class eRofCtlBase               : public RoflException {
public:
        eRofCtlBase(const std::string& __arg) : RoflException(__arg) {};
};
class eRofCtlNotFound   : public eRofCtlBase {
public:
        eRofCtlNotFound(const std::string& __arg) : eRofCtlBase(__arg) {};
};

class crofctl;

class crofctl_env {
        friend class crofctl;
        static std::set<crofctl_env*> rofctl_envs;
public:

        crofctl_env()
        { crofctl_env::rofctl_envs.insert(this); };

        virtual
        ~crofctl_env()
        { crofctl_env::rofctl_envs.erase(this); };

protected:

        virtual void
        handle_chan_established(
                        rofl::crofctl& ctl)
        {};

        virtual void
        handle_chan_terminated(
                        rofl::crofctl& ctl)
        {};

        virtual void
        handle_conn_established(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid)
        {};

        virtual void
        handle_conn_terminated(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid)
        {};

        virtual void
        handle_conn_refused(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid)
        {};

        virtual void
        handle_conn_failed(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid)
        {};

        virtual void
        handle_conn_writable(
                        rofl::crofctl& ctl,
                        const rofl::cauxid& auxid)
        {};

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

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)
        {};

        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)
        {};

};



class crofctl :
                public rofl::crofchan_env,
                public rofl::ctransactions_env,
                public ciosrv
{
        enum crofctl_timer_t {
                TIMER_RUN_ENGINE       = 0,
        };

        enum crofctl_event_t {
                EVENT_NONE             = 0,
                EVENT_CHAN_TERMINATED  = 1,
                EVENT_CONN_TERMINATED  = 2,
                EVENT_CONN_REFUSED     = 3,
                EVENT_CONN_FAILED      = 4,
        };

        enum crofctl_flag_t {
                FLAG_ENGINE_IS_RUNNING = (1 << 0),
        };

public:

        static rofl::crofctl&
        get_ctl(
                        const rofl::cctlid& ctlid);

        crofctl(
                        crofctl_env* env,
                        const cctlid& ctlid,
                        bool remove_on_channel_close,
                        const rofl::openflow::cofhello_elem_versionbitmap& versionbitmap) :
                                env(env),
                                ctlid(ctlid),
                                rofchan(this, versionbitmap),
                                transactions(this),
                                remove_on_channel_close(remove_on_channel_close),
                                async_config_role_default_template(rofl::openflow13::OFP_VERSION),
                                async_config(rofl::openflow13::OFP_VERSION) {
                rofl::logging::debug << "[rofl-common][crofctl] "
                                << "instance created, ctlid: " << ctlid.str() << std::endl;
                init_async_config_role_default_template();
                async_config = get_async_config_role_default_template();
                crofctl::rofctls[ctlid] = this;
        };

        virtual
        ~crofctl() {
                rofl::logging::debug << "[rofl-common][crofctl] "
                                << "instance destroyed, ctlid: " << ctlid.str() << std::endl;
                crofctl::rofctls.erase(ctlid);
        };

        const rofl::cctlid&
        get_ctlid() const
        { return ctlid; };

public:

        std::list<rofl::cauxid>
        get_conn_index() const
        { return rofchan.get_conn_index(); };

        void
        connect(
                        const rofl::cauxid& auxid,
                        enum rofl::csocket::socket_type_t socket_type,
                        const rofl::cparams& socket_params)
        { rofchan.add_conn(auxid, socket_type, socket_params); };

        void
        disconnect(
                        const rofl::cauxid& auxid)
        { rofchan.drop_conn(auxid); };

        void
        add_connection(
                        crofconn* conn) {
                if (NULL == conn) {
                        return;
                }
                rofchan.add_conn(conn->get_aux_id(), conn);
        };

public:

        bool
        is_established() const
        { return rofchan.is_established(); };

        uint8_t
        get_version_negotiated() const
        { return rofchan.get_version(); };
        const rofl::openflow::cofhello_elem_versionbitmap&
        get_versions_available() const
        { return rofchan.get_versionbitmap(); };

        bool
        remove_on_channel_termination() const
        { return remove_on_channel_close; };

        rofl::caddress
        get_peer_addr(const rofl::cauxid& auxid) const
        { return rofchan.get_conn(auxid).get_rofsocket().get_socket().get_raddr(); };

public:

        rofl::openflow::cofrole&
        set_role()
        { return role; };

        const rofl::openflow::cofrole&
        get_role() const
        { return role; };

        bool
        is_slave() const;

        rofl::openflow::cofasync_config&
        set_async_config()
        { return async_config; };

        const rofl::openflow::cofasync_config&
        get_async_config() const
        { return async_config; };

        const rofl::openflow::cofasync_config&
        get_async_config_role_default_template() const
        { return async_config_role_default_template; };

public:

        void
        send_features_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint64_t dpid,
                        uint32_t n_buffers,
                        uint8_t n_tables,
                        uint32_t capabilities,
                        uint8_t of13_auxiliary_id = 0,
                        uint32_t of10_actions_bitmap = 0,
                        const rofl::openflow::cofports& ports = rofl::openflow::cofports());

        void
        send_get_config_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint16_t flags,
                        uint16_t miss_send_len);

        void
        send_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint16_t stats_type,
                        uint16_t stats_flags,
                        uint8_t *body = NULL,
                        size_t bodylen = 0);

        void
        send_desc_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofdesc_stats_reply& desc_stats,
                        uint16_t stats_flags = 0);

        void
        send_flow_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofflowstatsarray& flow_stats,
                        uint16_t stats_flags = 0);

        void
        send_aggr_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofaggr_stats_reply& aggr_stats,
                        uint16_t stats_flags = 0);

        void
        send_table_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::coftablestatsarray& tablestatsarray,
                        uint16_t stats_flags = 0);

        void
        send_port_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofportstatsarray& portstatsarray,
                        uint16_t stats_flags = 0);

        void
        send_queue_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofqueuestatsarray& queuestatsarray,
                        uint16_t stats_flags = 0);

        void
        send_group_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofgroupstatsarray& groupstatsarray,
                        uint16_t stats_flags = 0);

        void
        send_group_desc_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofgroupdescstatsarray& groupdescs,
                        uint16_t stats_flags = 0);

        void
        send_group_features_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofgroup_features_stats_reply& group_features_stats,
                        uint16_t stats_flags = 0);

        void
        send_table_features_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::coftables& tables,
                        uint16_t stats_flags = 0);

        void
        send_port_desc_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofports& ports,
                        uint16_t stats_flags = 0);

        void
        send_experimenter_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint32_t exp_id,
                        uint32_t exp_type,
                        const cmemory& body,
                        uint16_t stats_flags = 0);

        void
        send_meter_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofmeterstatsarray& meter_stats_array,
                        uint16_t stats_flags = 0);

        void
        send_meter_config_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofmeterconfigarray& meter_config_array,
                        uint16_t stats_flags = 0);

        void
        send_meter_features_stats_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofmeter_features& meter_features,
                        uint16_t stats_flags = 0);

        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
                        const rofl::openflow::cofmatch& match,
                        uint8_t *data,
                        size_t datalen);

        void
        send_barrier_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid);

        void
        send_error_message(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint16_t type,
                        uint16_t code,
                        uint8_t* data = NULL,
                        size_t datalen = 0);

        void
        send_experimenter_message(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint32_t experimenter_id,
                        uint32_t exp_type,
                        uint8_t *body = NULL,
                        size_t bodylen = 0);

        void
        send_flow_removed_message(
                        const rofl::cauxid& auxid,
                        const 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);

        void
        send_queue_get_config_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        uint32_t portno,
                        const rofl::openflow::cofpacket_queues& queues);


        void
        send_role_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofrole& role);

        void
        send_get_async_config_reply(
                        const rofl::cauxid& auxid,
                        uint32_t xid,
                        const rofl::openflow::cofasync_config& async_config);

public:

        friend std::ostream&
        operator<< (std::ostream& os, const crofctl& ctl) {
                os << indent(0) << "<crofctl ";
                os << "ctlid:0x" << ctl.ctlid.str() << " ";
                os << ">" << std::endl;
                rofl::indent i(2);
                os << ctl.rofchan;
                return os;
        };

        std::string
        str() const {
                std::stringstream ss;
                ss << "ctlid: " << get_ctlid().get_ctlid_s() << " ";
                return ss.str();
        };

private:

        virtual void
        handle_conn_established(
                        crofchan& chan,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofctl] ctlid:0x" << ctlid.str()
                                                << " control connection established, auxid: " << auxid.str() << std::endl;
                call_env().handle_conn_established(*this, auxid);

                if (auxid == rofl::cauxid(0)) {
                        rofl::logging::info << "[rofl-common][crofctl] ctlid:0x" << ctlid.str()
                                                        << " OFP control channel established, " << chan.str() << std::endl;

                        call_env().handle_chan_established(*this); // main connection
                }
        };

        virtual void
        handle_conn_terminated(
                        crofchan& chan,
                        const rofl::cauxid& auxid) {
                rofl::logging::info << "[rofl-common][crofctl] ctlid:0x" << ctlid.str()
                                                << " control connection terminated, auxid: " << auxid.str() << std::endl;
                rofl::RwLock rwlock(conns_terminated_rwlock, rofl::RwLock::RWLOCK_WRITE);
                conns_terminated.push_back(auxid);
                push_on_eventqueue(EVENT_CONN_TERMINATED);

                if (auxid == rofl::cauxid(0)) {
                        rofl::logging::info << "[rofl-common][crofctl] ctlid:0x" << ctlid.str()
                                        << " OFP control channel terminated, " << chan.str() << std::endl;
                        transactions.clear();
                        push_on_eventqueue(EVENT_CHAN_TERMINATED);
                }
        };

        virtual void
        handle_conn_refused(
                        crofchan& chan,
                        const rofl::cauxid& auxid) {
                rofl::RwLock rwlock(conns_refused_rwlock, rofl::RwLock::RWLOCK_WRITE);
                conns_refused.push_back(auxid);
                push_on_eventqueue(EVENT_CONN_REFUSED);
        };

        virtual void
        handle_conn_failed(
                        crofchan& chan,
                        const rofl::cauxid& auxid) {
                rofl::RwLock rwlock(conns_failed_rwlock, rofl::RwLock::RWLOCK_WRITE);
                conns_failed.push_back(auxid);
                push_on_eventqueue(EVENT_CONN_FAILED);
        };

        virtual void
        handle_write(
                        rofl::crofchan& chan,
                        const rofl::cauxid& auxid)
        { call_env().handle_conn_writable(*this, auxid); };

        virtual void
        recv_message(
                        rofl::crofchan& chan,
                        const rofl::cauxid& aux_id,
                        rofl::openflow::cofmsg *msg);

        virtual uint32_t
        get_async_xid(
                        rofl::crofchan& chan)
        { return transactions.get_async_xid(); };

        virtual uint32_t
        get_sync_xid(
                        rofl::crofchan& chan,
                        uint8_t msg_type = 0,
                        uint16_t msg_sub_type = 0)
        { return transactions.add_ta(cclock(/*secs=*/5), msg_type, msg_sub_type); };

        virtual void
        release_sync_xid(
                        rofl::crofchan& chan,
                        uint32_t xid)
        { transactions.drop_ta(xid); };

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

public:

        class crofctl_find_by_ctlid {
                cctlid ctlid;
        public:
                crofctl_find_by_ctlid(const cctlid& ctlid) : ctlid(ctlid) {};
                bool operator() (const crofctl* rofctl) {
                        return (rofctl->get_ctlid() == ctlid);
                };
        };

private:

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

        crofctl_env&
        call_env() {
                if (crofctl_env::rofctl_envs.find(env) == crofctl_env::rofctl_envs.end()) {
                        throw eRofCtlNotFound("rofl::crofctl::call_env() environment not found");
                }
                return *env;
        };

        void
        init_async_config_role_default_template();

        void
        check_role();

        void
        push_on_eventqueue(
                        enum crofctl_event_t event = EVENT_NONE) {
                if (EVENT_NONE != event) {
                        events.push_back(event);
                }
                if (not flags.test(FLAG_ENGINE_IS_RUNNING)) {
                        register_timer(TIMER_RUN_ENGINE, rofl::ctimespec(0));
                }
        };

        void
        work_on_eventqueue();

        void
        event_chan_terminated();

        void
        event_conn_established();

        void
        event_conn_terminated();

        void
        event_conn_refused();

        void
        event_conn_failed();

private:

        void
        experimenter_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter* msg);

        void
        error_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_error* msg);

        void
        features_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_features_request* msg);

        void
        get_config_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_config_request* msg);

        void
        set_config_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_set_config* msg);

        void
        packet_out_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_packet_out* msg);

        void
        flow_mod_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_mod* msg);

        void
        group_mod_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_mod* msg);

        void
        port_mod_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_mod* msg);

        void
        table_mod_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_mod* msg);

        void
        meter_mod_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_mod* msg);

        void
        stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_stats* msg);

        void
        desc_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_desc_stats_request* msg);

        void
        table_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_stats_request* msg);

        void
        port_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_stats_request* msg);

        void
        flow_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_flow_stats_request* msg);

        void
        aggregate_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_aggr_stats_request* msg);

        void
        queue_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_stats_request* msg);

        void
        group_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_stats_request* msg);

        void
        group_desc_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_desc_stats_request* msg);

        void
        group_features_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_group_features_stats_request* msg);

        void
        meter_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_stats_request* msg);

        void
        meter_config_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_config_stats_request* msg);

        void
        meter_features_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_meter_features_stats_request* msg);

        void
        table_features_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_table_features_stats_request* msg);

        void
        port_desc_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_port_desc_stats_request* msg);

        void
        experimenter_stats_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_experimenter_stats_request* msg);

        void
        role_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_role_request* msg);

        void
        barrier_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_barrier_request* msg);

        void
        queue_get_config_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_queue_get_config_request* msg);

        void
        get_async_config_request_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_get_async_config_request* msg);

        void
        set_async_config_rcvd(
                        const rofl::cauxid& auxid,
                        rofl::openflow::cofmsg_set_async_config* msg);

private:

        static std::map<rofl::cctlid, rofl::crofctl*> rofctls;

        // environment
        rofl::crofctl_env*      env;
        // handle for this crofctl instance
        rofl::cctlid            ctlid;
        // OFP control channel
        rofl::crofchan          rofchan;
        // pending OFP transactions
        rofl::ctransactions     transactions;

        bool                    remove_on_channel_close;
        rofl::openflow::cofasync_config async_config_role_default_template;
        rofl::openflow::cofasync_config async_config;
        rofl::openflow::cofrole role;

        std::deque<enum crofctl_event_t> events;

        PthreadRwLock           conns_terminated_rwlock;
        std::list<rofl::cauxid> conns_terminated;
        PthreadRwLock           conns_refused_rwlock;
        std::list<rofl::cauxid> conns_refused;
        PthreadRwLock           conns_failed_rwlock;
        std::list<rofl::cauxid> conns_failed;

        std::bitset<32>         flags;
};

}; // end of namespace

#endif