openflow-interface.cc

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Blake Hurd  <naimorai@gmail.com>
 */
#ifdef NS3_OPENFLOW
 
#include "openflow-interface.h"
 
#include "openflow-switch-net-device.h"
 
namespace ns3
{
 
NS_LOG_COMPONENT_DEFINE("OpenFlowInterface");
 
namespace ofi
{
 
Stats::Stats(ofp_stats_types _type, size_t body_len)
{
    type = _type;
    size_t min_body = 0;
    size_t max_body = 0;
 
    switch (type)
    {
    case OFPST_DESC:
        break;
    case OFPST_FLOW:
        min_body = max_body = sizeof(ofp_flow_stats_request);
        break;
    case OFPST_AGGREGATE:
        min_body = max_body = sizeof(ofp_aggregate_stats_request);
        break;
    case OFPST_TABLE:
        break;
    case OFPST_PORT:
        min_body = 0;
        max_body =
            std::numeric_limits<size_t>::max(); // Not sure about this one. This would guarantee
                                                // that the body_len is always acceptable.
        break;
    case OFPST_PORT_TABLE:
        break;
    default:
        NS_LOG_ERROR("received stats request of unknown type " << type);
        return; // -EINVAL;
    }
 
    if ((min_body != 0 || max_body != 0) && (body_len < min_body || body_len > max_body))
    {
        NS_LOG_ERROR("stats request type " << type << " with bad body length " << body_len);
        return; // -EINVAL;
    }
}
 
int
Stats::DoInit(const void* body, int body_len, void** state)
{
    switch (type)
    {
    case OFPST_DESC:
        return 0;
    case OFPST_FLOW:
        return FlowStatsInit(body, body_len, state);
    case OFPST_AGGREGATE:
        return AggregateStatsInit(body, body_len, state);
    case OFPST_TABLE:
        return 0;
    case OFPST_PORT:
        return PortStatsInit(body, body_len, state);
    case OFPST_PORT_TABLE:
        return 0;
    case OFPST_VENDOR:
        return 0;
    }
 
    return 0;
}
 
int
Stats::DoDump(Ptr<OpenFlowSwitchNetDevice> swtch, void* state, ofpbuf* buffer)
{
    switch (type)
    {
    case OFPST_DESC:
        return DescStatsDump(state, buffer);
    case OFPST_FLOW:
        return FlowStatsDump(swtch, (FlowStatsState*)state, buffer);
    case OFPST_AGGREGATE:
        return AggregateStatsDump(swtch, (ofp_aggregate_stats_request*)state, buffer);
    case OFPST_TABLE:
        return TableStatsDump(swtch, state, buffer);
    case OFPST_PORT:
        return PortStatsDump(swtch, (PortStatsState*)state, buffer);
    case OFPST_PORT_TABLE:
        return PortTableStatsDump(swtch, state, buffer);
    case OFPST_VENDOR:
        return 0;
    }
 
    return 0;
}
 
void
Stats::DoCleanup(void* state)
{
    switch (type)
    {
    case OFPST_DESC:
        break;
    case OFPST_FLOW:
        free((FlowStatsState*)state);
        break;
    case OFPST_AGGREGATE:
        free((ofp_aggregate_stats_request*)state);
        break;
    case OFPST_TABLE:
        break;
    case OFPST_PORT:
        free(((PortStatsState*)state)->ports);
        free((PortStatsState*)state);
        break;
    case OFPST_PORT_TABLE:
        break;
    case OFPST_VENDOR:
        break;
    }
}
 
int
Stats::DescStatsDump(void* state, ofpbuf* buffer)
{
    ofp_desc_stats* ods = (ofp_desc_stats*)ofpbuf_put_zeros(buffer, sizeof *ods);
    strncpy(ods->mfr_desc,
            OpenFlowSwitchNetDevice::GetManufacturerDescription(),
            sizeof ods->mfr_desc);
    strncpy(ods->hw_desc, OpenFlowSwitchNetDevice::GetHardwareDescription(), sizeof ods->hw_desc);
    strncpy(ods->sw_desc, OpenFlowSwitchNetDevice::GetSoftwareDescription(), sizeof ods->sw_desc);
    strncpy(ods->serial_num, OpenFlowSwitchNetDevice::GetSerialNumber(), sizeof ods->serial_num);
    return 0;
}
 
#define MAX_FLOW_STATS_BYTES 4096
 
int
Stats::FlowStatsInit(const void* body, int body_len, void** state)
{
    const ofp_flow_stats_request* fsr = (ofp_flow_stats_request*)body;
    FlowStatsState* s = (FlowStatsState*)xmalloc(sizeof *s);
 
    s->table_idx = fsr->table_id == 0xff ? 0 : fsr->table_id;
    memset(&s->position, 0, sizeof s->position);
    s->rq = *fsr;
    *state = s;
    return 0;
}
 
int
Stats_FlowDumpCallback(sw_flow* flow, void* state)
{
    Stats::FlowStatsState* s = (Stats::FlowStatsState*)state;
 
    // Fill Flow Stats
    ofp_flow_stats* ofs;
    int length = sizeof *ofs + flow->sf_acts->actions_len;
    ofs = (ofp_flow_stats*)ofpbuf_put_zeros(s->buffer, length);
    ofs->length = htons(length);
    ofs->table_id = s->table_idx;
    ofs->match.wildcards = htonl(flow->key.wildcards);
    ofs->match.in_port = flow->key.flow.in_port;
    memcpy(ofs->match.dl_src, flow->key.flow.dl_src, ETH_ADDR_LEN);
    memcpy(ofs->match.dl_dst, flow->key.flow.dl_dst, ETH_ADDR_LEN);
    ofs->match.dl_vlan = flow->key.flow.dl_vlan;
    ofs->match.dl_type = flow->key.flow.dl_type;
    ofs->match.nw_src = flow->key.flow.nw_src;
    ofs->match.nw_dst = flow->key.flow.nw_dst;
    ofs->match.nw_proto = flow->key.flow.nw_proto;
    ofs->match.tp_src = flow->key.flow.tp_src;
    ofs->match.tp_dst = flow->key.flow.tp_dst;
    ofs->duration = htonl(s->now - flow->created);
    ofs->priority = htons(flow->priority);
    ofs->idle_timeout = htons(flow->idle_timeout);
    ofs->hard_timeout = htons(flow->hard_timeout);
    ofs->packet_count = htonll(flow->packet_count);
    ofs->byte_count = htonll(flow->byte_count);
    memcpy(ofs->actions, flow->sf_acts->actions, flow->sf_acts->actions_len);
 
    return s->buffer->size >= MAX_FLOW_STATS_BYTES;
}
 
int
Stats::FlowStatsDump(Ptr<OpenFlowSwitchNetDevice> swtch, FlowStatsState* s, ofpbuf* buffer)
{
    sw_flow_key match_key;
 
    flow_extract_match(&match_key, &s->rq.match);
 
    s->buffer = buffer;
    s->now = time_now();
    while (s->table_idx < swtch->GetChain()->n_tables &&
           (s->rq.table_id == 0xff || s->rq.table_id == s->table_idx))
    {
        sw_table* table = swtch->GetChain()->tables[s->table_idx];
 
        if (table->iterate(table,
                           &match_key,
                           s->rq.out_port,
                           &s->position,
                           Stats::FlowDumpCallback,
                           s))
        {
            break;
        }
 
        s->table_idx++;
        memset(&s->position, 0, sizeof s->position);
    }
    return s->buffer->size >= MAX_FLOW_STATS_BYTES;
}
 
int
Stats::AggregateStatsInit(const void* body, int body_len, void** state)
{
    // ofp_aggregate_stats_request *s = (ofp_aggregate_stats_request*)body;
    *state = (ofp_aggregate_stats_request*)body;
    return 0;
}
 
int
Stats_AggregateDumpCallback(sw_flow* flow, void* state)
{
    ofp_aggregate_stats_reply* s = (ofp_aggregate_stats_reply*)state;
    s->packet_count += flow->packet_count;
    s->byte_count += flow->byte_count;
    s->flow_count++;
    return 0;
}
 
int
Stats::AggregateStatsDump(Ptr<OpenFlowSwitchNetDevice> swtch,
                          ofp_aggregate_stats_request* s,
                          ofpbuf* buffer)
{
    ofp_aggregate_stats_request* rq = s;
    ofp_aggregate_stats_reply* rpy =
        (ofp_aggregate_stats_reply*)ofpbuf_put_zeros(buffer, sizeof *rpy);
    sw_flow_key match_key;
    flow_extract_match(&match_key, &rq->match);
    int table_idx = rq->table_id == 0xff ? 0 : rq->table_id;
 
    sw_table_position position;
    memset(&position, 0, sizeof position);
 
    while (table_idx < swtch->GetChain()->n_tables &&
           (rq->table_id == 0xff || rq->table_id == table_idx))
    {
        sw_table* table = swtch->GetChain()->tables[table_idx];
        int error = table->iterate(table,
                                   &match_key,
                                   rq->out_port,
                                   &position,
                                   Stats::AggregateDumpCallback,
                                   rpy);
        if (error)
        {
            return error;
        }
 
        table_idx++;
        memset(&position, 0, sizeof position);
    }
 
    rpy->packet_count = htonll(rpy->packet_count);
    rpy->byte_count = htonll(rpy->byte_count);
    rpy->flow_count = htonl(rpy->flow_count);
    return 0;
}
 
int
Stats::TableStatsDump(Ptr<OpenFlowSwitchNetDevice> swtch, void* state, ofpbuf* buffer)
{
    sw_chain* ft = swtch->GetChain();
    for (int i = 0; i < ft->n_tables; i++)
    {
        ofp_table_stats* ots = (ofp_table_stats*)ofpbuf_put_zeros(buffer, sizeof *ots);
        sw_table_stats stats;
        ft->tables[i]->stats(ft->tables[i], &stats);
        strncpy(ots->name, stats.name, sizeof ots->name);
        ots->table_id = i;
        ots->wildcards = htonl(stats.wildcards);
        ots->max_entries = htonl(stats.max_flows);
        ots->active_count = htonl(stats.n_flows);
        ots->lookup_count = htonll(stats.n_lookup);
        ots->matched_count = htonll(stats.n_matched);
    }
    return 0;
}
 
// stats for the port table which is similar to stats for the flow tables
int
Stats::PortTableStatsDump(Ptr<OpenFlowSwitchNetDevice> swtch, void* state, ofpbuf* buffer)
{
    ofp_vport_table_stats* opts = (ofp_vport_table_stats*)ofpbuf_put_zeros(buffer, sizeof *opts);
    opts->max_vports = htonl(swtch->GetVPortTable().max_vports);
    opts->active_vports = htonl(swtch->GetVPortTable().active_vports);
    opts->lookup_count = htonll(swtch->GetVPortTable().lookup_count);
    opts->port_match_count = htonll(swtch->GetVPortTable().port_match_count);
    opts->chain_match_count = htonll(swtch->GetVPortTable().chain_match_count);
 
    return 0;
}
 
int
Stats::PortStatsInit(const void* body, int body_len, void** state)
{
    PortStatsState* s = (PortStatsState*)xmalloc(sizeof *s);
 
    // the body contains a list of port numbers
    s->ports = (uint32_t*)xmalloc(body_len);
    memcpy(s->ports, body, body_len);
    s->num_ports = body_len / sizeof(uint32_t);
 
    *state = s;
    return 0;
}
 
int
Stats::PortStatsDump(Ptr<OpenFlowSwitchNetDevice> swtch, PortStatsState* s, ofpbuf* buffer)
{
    ofp_port_stats* ops;
    uint32_t port;
 
    // port stats are different depending on whether port is physical or virtual
    for (size_t i = 0; i < s->num_ports; i++)
    {
        port = ntohl(s->ports[i]);
        // physical port?
        if (port <= OFPP_MAX)
        {
            Port p = swtch->GetSwitchPort(port);
 
            if (!p.netdev)
            {
                continue;
            }
 
            ops = (ofp_port_stats*)ofpbuf_put_zeros(buffer, sizeof *ops);
            ops->port_no = htonl(swtch->GetSwitchPortIndex(p));
            ops->rx_packets = htonll(p.rx_packets);
            ops->tx_packets = htonll(p.tx_packets);
            ops->rx_bytes = htonll(p.rx_bytes);
            ops->tx_bytes = htonll(p.tx_bytes);
            ops->rx_dropped = htonll(-1);
            ops->tx_dropped = htonll(p.tx_dropped);
            ops->rx_errors = htonll(-1);
            ops->tx_errors = htonll(-1);
            ops->rx_frame_err = htonll(-1);
            ops->rx_over_err = htonll(-1);
            ops->rx_crc_err = htonll(-1);
            ops->collisions = htonll(-1);
            ops->mpls_ttl0_dropped = htonll(p.mpls_ttl0_dropped);
            ops++;
        }
        else if (port >= OFPP_VP_START && port <= OFPP_VP_END) // virtual port?
        {
            // lookup the virtual port
            vport_table_t vt = swtch->GetVPortTable();
            vport_table_entry* vpe = vport_table_lookup(&vt, port);
            if (!vpe)
            {
                NS_LOG_ERROR("vport entry not found!");
                continue;
            }
            // only tx_packets and tx_bytes are really relevant for virtual ports
            ops = (ofp_port_stats*)ofpbuf_put_zeros(buffer, sizeof *ops);
            ops->port_no = htonl(vpe->vport);
            ops->rx_packets = htonll(-1);
            ops->tx_packets = htonll(vpe->packet_count);
            ops->rx_bytes = htonll(-1);
            ops->tx_bytes = htonll(vpe->byte_count);
            ops->rx_dropped = htonll(-1);
            ops->tx_dropped = htonll(-1);
            ops->rx_errors = htonll(-1);
            ops->tx_errors = htonll(-1);
            ops->rx_frame_err = htonll(-1);
            ops->rx_over_err = htonll(-1);
            ops->rx_crc_err = htonll(-1);
            ops->collisions = htonll(-1);
            ops->mpls_ttl0_dropped = htonll(-1);
            ops++;
        }
    }
    return 0;
}
 
bool
Action::IsValidType(ofp_action_type type)
{
    switch (type)
    {
    case OFPAT_OUTPUT:
    case OFPAT_SET_VLAN_VID:
    case OFPAT_SET_VLAN_PCP:
    case OFPAT_STRIP_VLAN:
    case OFPAT_SET_DL_SRC:
    case OFPAT_SET_DL_DST:
    case OFPAT_SET_NW_SRC:
    case OFPAT_SET_NW_DST:
    case OFPAT_SET_TP_SRC:
    case OFPAT_SET_TP_DST:
    case OFPAT_SET_MPLS_LABEL:
    case OFPAT_SET_MPLS_EXP:
        return true;
    default:
        return false;
    }
}
 
uint16_t
Action::Validate(ofp_action_type type,
                 size_t len,
                 const sw_flow_key* key,
                 const ofp_action_header* ah)
{
    size_t size = 0;
 
    switch (type)
    {
    case OFPAT_OUTPUT: {
        if (len != sizeof(ofp_action_output))
        {
            return OFPBAC_BAD_LEN;
        }
 
        ofp_action_output* oa = (ofp_action_output*)ah;
 
        // To prevent loops, make sure there's no action to send to the OFP_TABLE virtual port.
 
        // port is now 32-bit
        if (oa->port == OFPP_NONE || oa->port == key->flow.in_port) // htonl(OFPP_NONE);
        { // if (oa->port == htons(OFPP_NONE) || oa->port == key->flow.in_port)
            return OFPBAC_BAD_OUT_PORT;
        }
 
        return ACT_VALIDATION_OK;
    }
    case OFPAT_SET_VLAN_VID:
        size = sizeof(ofp_action_vlan_vid);
        break;
    case OFPAT_SET_VLAN_PCP:
        size = sizeof(ofp_action_vlan_pcp);
        break;
    case OFPAT_STRIP_VLAN:
        size = sizeof(ofp_action_header);
        break;
    case OFPAT_SET_DL_SRC:
    case OFPAT_SET_DL_DST:
        size = sizeof(ofp_action_dl_addr);
        break;
    case OFPAT_SET_NW_SRC:
    case OFPAT_SET_NW_DST:
        size = sizeof(ofp_action_nw_addr);
        break;
    case OFPAT_SET_TP_SRC:
    case OFPAT_SET_TP_DST:
        size = sizeof(ofp_action_tp_port);
        break;
    case OFPAT_SET_MPLS_LABEL:
        size = sizeof(ofp_action_mpls_label);
        break;
    case OFPAT_SET_MPLS_EXP:
        size = sizeof(ofp_action_mpls_exp);
        break;
    default:
        break;
    }
 
    if (len != size)
    {
        return OFPBAC_BAD_LEN;
    }
    return ACT_VALIDATION_OK;
}
 
void
Action::Execute(ofp_action_type type, ofpbuf* buffer, sw_flow_key* key, const ofp_action_header* ah)
{
    switch (type)
    {
    case OFPAT_OUTPUT:
        break;
    case OFPAT_SET_VLAN_VID:
        set_vlan_vid(buffer, key, ah);
        break;
    case OFPAT_SET_VLAN_PCP:
        set_vlan_pcp(buffer, key, ah);
        break;
    case OFPAT_STRIP_VLAN:
        strip_vlan(buffer, key, ah);
        break;
    case OFPAT_SET_DL_SRC:
    case OFPAT_SET_DL_DST:
        set_dl_addr(buffer, key, ah);
        break;
    case OFPAT_SET_NW_SRC:
    case OFPAT_SET_NW_DST:
        set_nw_addr(buffer, key, ah);
        break;
    case OFPAT_SET_TP_SRC:
    case OFPAT_SET_TP_DST:
        set_tp_port(buffer, key, ah);
        break;
    case OFPAT_SET_MPLS_LABEL:
        set_mpls_label(buffer, key, ah);
        break;
    case OFPAT_SET_MPLS_EXP:
        set_mpls_exp(buffer, key, ah);
        break;
    default:
        break;
    }
}
 
bool
VPortAction::IsValidType(ofp_vport_action_type type)
{
    switch (type)
    {
    case OFPPAT_POP_MPLS:
    case OFPPAT_PUSH_MPLS:
    case OFPPAT_SET_MPLS_LABEL:
    case OFPPAT_SET_MPLS_EXP:
        return true;
    default:
        return false;
    }
}
 
uint16_t
VPortAction::Validate(ofp_vport_action_type type, size_t len, const ofp_action_header* ah)
{
    size_t size = 0;
 
    switch (type)
    {
    case OFPPAT_POP_MPLS:
        size = sizeof(ofp_vport_action_pop_mpls);
        break;
    case OFPPAT_PUSH_MPLS:
        size = sizeof(ofp_vport_action_push_mpls);
        break;
    case OFPPAT_SET_MPLS_LABEL:
        size = sizeof(ofp_vport_action_set_mpls_label);
        break;
    case OFPPAT_SET_MPLS_EXP:
        size = sizeof(ofp_vport_action_set_mpls_exp);
        break;
    default:
        break;
    }
 
    if (len != size)
    {
        return OFPBAC_BAD_LEN;
    }
    return ACT_VALIDATION_OK;
}
 
void
VPortAction::Execute(ofp_vport_action_type type,
                     ofpbuf* buffer,
                     const sw_flow_key* key,
                     const ofp_action_header* ah)
{
    switch (type)
    {
    case OFPPAT_POP_MPLS: {
        ofp_vport_action_pop_mpls* opapm = (ofp_vport_action_pop_mpls*)ah;
        pop_mpls_act(nullptr, buffer, key, &opapm->apm);
        break;
    }
    case OFPPAT_PUSH_MPLS: {
        ofp_vport_action_push_mpls* opapm = (ofp_vport_action_push_mpls*)ah;
        push_mpls_act(nullptr, buffer, key, &opapm->apm);
        break;
    }
    case OFPPAT_SET_MPLS_LABEL: {
        ofp_vport_action_set_mpls_label* oparml = (ofp_vport_action_set_mpls_label*)ah;
        set_mpls_label_act(buffer, key, oparml->label_out);
        break;
    }
    case OFPPAT_SET_MPLS_EXP: {
        ofp_vport_action_set_mpls_exp* oparme = (ofp_vport_action_set_mpls_exp*)ah;
        set_mpls_exp_act(buffer, key, oparme->exp);
        break;
    }
    default:
        break;
    }
}
 
bool
EricssonAction::IsValidType(er_action_type type)
{
    switch (type)
    {
    case ERXT_POP_MPLS:
    case ERXT_PUSH_MPLS:
        return true;
    default:
        return false;
    }
}
 
uint16_t
EricssonAction::Validate(er_action_type type, size_t len)
{
    size_t size = 0;
 
    switch (type)
    {
    case ERXT_POP_MPLS:
        size = sizeof(er_action_pop_mpls);
        break;
    case ERXT_PUSH_MPLS:
        size = sizeof(er_action_push_mpls);
        break;
    default:
        break;
    }
 
    if (len != size)
    {
        return OFPBAC_BAD_LEN;
    }
    return ACT_VALIDATION_OK;
}
 
void
EricssonAction::Execute(er_action_type type,
                        ofpbuf* buffer,
                        const sw_flow_key* key,
                        const er_action_header* ah)
{
    switch (type)
    {
    case ERXT_POP_MPLS: {
        er_action_pop_mpls* erapm = (er_action_pop_mpls*)ah;
        pop_mpls_act(nullptr, buffer, key, &erapm->apm);
        break;
    }
    case ERXT_PUSH_MPLS: {
        er_action_push_mpls* erapm = (er_action_push_mpls*)ah;
        push_mpls_act(nullptr, buffer, key, &erapm->apm);
        break;
    }
    default:
        break;
    }
}
 
/* static */
TypeId
Controller::GetTypeId()
{
    static TypeId tid = TypeId("ns3::ofi::Controller")
                            .SetParent<Object>()
                            .SetGroupName("OpenFlow")
                            .AddConstructor<Controller>();
    return tid;
}
 
Controller::~Controller()
{
    m_switches.clear();
}
 
void
Controller::AddSwitch(Ptr<OpenFlowSwitchNetDevice> swtch)
{
    if (m_switches.find(swtch) != m_switches.end())
    {
        NS_LOG_INFO("This Controller has already registered this switch!");
    }
    else
    {
        m_switches.insert(swtch);
    }
}
 
void
Controller::SendToSwitch(Ptr<OpenFlowSwitchNetDevice> swtch, void* msg, size_t length)
{
    if (m_switches.find(swtch) == m_switches.end())
    {
        NS_LOG_ERROR("Can't send to this switch, not registered to the Controller.");
        return;
    }
 
    swtch->ForwardControlInput(msg, length);
}
 
ofp_flow_mod*
Controller::BuildFlow(sw_flow_key key,
                      uint32_t buffer_id,
                      uint16_t command,
                      void* acts,
                      size_t actions_len,
                      int idle_timeout,
                      int hard_timeout)
{
    ofp_flow_mod* ofm = (ofp_flow_mod*)malloc(sizeof(ofp_flow_mod) + actions_len);
    ofm->header.version = OFP_VERSION;
    ofm->header.type = OFPT_FLOW_MOD;
    ofm->header.length = htons(sizeof(ofp_flow_mod) + actions_len);
    ofm->command = htons(command);
    ofm->idle_timeout = htons(idle_timeout);
    ofm->hard_timeout = htons(hard_timeout);
    ofm->buffer_id = htonl(buffer_id);
    ofm->priority = OFP_DEFAULT_PRIORITY;
    memcpy(ofm->actions, acts, actions_len);
 
    ofm->match.wildcards = key.wildcards;  // Wildcard fields
    ofm->match.in_port = key.flow.in_port; // Input switch port
    memcpy(ofm->match.dl_src,
           key.flow.dl_src,
           sizeof ofm->match.dl_src); // Ethernet source address.
    memcpy(ofm->match.dl_dst,
           key.flow.dl_dst,
           sizeof ofm->match.dl_dst);              // Ethernet destination address.
    ofm->match.dl_vlan = key.flow.dl_vlan;         // Input VLAN OFP_VLAN_NONE;
    ofm->match.dl_type = key.flow.dl_type;         // Ethernet frame type ETH_TYPE_IP;
    ofm->match.nw_proto = key.flow.nw_proto;       // IP Protocol
    ofm->match.nw_src = key.flow.nw_src;           // IP source address
    ofm->match.nw_dst = key.flow.nw_dst;           // IP destination address
    ofm->match.tp_src = key.flow.tp_src;           // TCP/UDP source port
    ofm->match.tp_dst = key.flow.tp_dst;           // TCP/UDP destination port
    ofm->match.mpls_label1 = key.flow.mpls_label1; // Top of label stack htonl(MPLS_INVALID_LABEL);
    ofm->match.mpls_label2 =
        key.flow.mpls_label1; // Second label (if available) htonl(MPLS_INVALID_LABEL);
 
    return ofm;
}
 
uint8_t
Controller::GetPacketType(ofpbuf* buffer)
{
    ofp_header* hdr = (ofp_header*)ofpbuf_try_pull(buffer, sizeof(ofp_header));
    uint8_t type = hdr->type;
    ofpbuf_push_uninit(buffer, sizeof(ofp_header));
    return type;
}
 
void
Controller::StartDump(StatsDumpCallback* cb)
{
    if (cb)
    {
        int error = 1;
        while (error > 0) // Switch's StatsDump returns 1 if the reply isn't complete.
        {
            error = cb->swtch->StatsDump(cb);
        }
 
        if (error != 0) // When the reply is complete, error will equal zero if there's no errors.
        {
            NS_LOG_WARN("Dump Callback Error: " << strerror(-error));
        }
 
        // Clean up
        cb->swtch->StatsDone(cb);
    }
}
 
/* static */
TypeId
DropController::GetTypeId()
{
    static TypeId tid = TypeId("ns3::ofi::DropController")
                            .SetParent<Controller>()
                            .SetGroupName("OpenFlow")
                            .AddConstructor<DropController>();
    return tid;
}
 
void
DropController::ReceiveFromSwitch(Ptr<OpenFlowSwitchNetDevice> swtch, ofpbuf* buffer)
{
    if (m_switches.find(swtch) == m_switches.end())
    {
        NS_LOG_ERROR("Can't receive from this switch, not registered to the Controller.");
        return;
    }
 
    // We have received any packet at this point, so we pull the header to figure out what type of
    // packet we're handling.
    uint8_t type = GetPacketType(buffer);
 
    if (type == OFPT_PACKET_IN) // The switch didn't understand the packet it received, so it
                                // forwarded it to the controller.
    {
        ofp_packet_in* opi = (ofp_packet_in*)ofpbuf_try_pull(buffer, offsetof(ofp_packet_in, data));
        int port = ntohs(opi->in_port);
 
        // Create matching key.
        sw_flow_key key;
        key.wildcards = 0;
        flow_extract(buffer, port != -1 ? port : OFPP_NONE, &key.flow);
 
        ofp_flow_mod* ofm = BuildFlow(key,
                                      opi->buffer_id,
                                      OFPFC_ADD,
                                      nullptr,
                                      0,
                                      OFP_FLOW_PERMANENT,
                                      OFP_FLOW_PERMANENT);
        SendToSwitch(swtch, ofm, ofm->header.length);
    }
}
 
TypeId
LearningController::GetTypeId()
{
    static TypeId tid =
        TypeId("ns3::ofi::LearningController")
            .SetParent<Controller>()
            .SetGroupName("Openflow")
            .AddConstructor<LearningController>()
            .AddAttribute("ExpirationTime",
                          "Time it takes for learned MAC state entry/created flow to expire.",
                          TimeValue(Seconds(0)),
                          MakeTimeAccessor(&LearningController::m_expirationTime),
                          MakeTimeChecker());
    return tid;
}
 
void
LearningController::ReceiveFromSwitch(Ptr<OpenFlowSwitchNetDevice> swtch, ofpbuf* buffer)
{
    if (m_switches.find(swtch) == m_switches.end())
    {
        NS_LOG_ERROR("Can't receive from this switch, not registered to the Controller.");
        return;
    }
 
    // We have received any packet at this point, so we pull the header to figure out what type of
    // packet we're handling.
    uint8_t type = GetPacketType(buffer);
 
    if (type == OFPT_PACKET_IN) // The switch didn't understand the packet it received, so it
                                // forwarded it to the controller.
    {
        ofp_packet_in* opi = (ofp_packet_in*)ofpbuf_try_pull(buffer, offsetof(ofp_packet_in, data));
        int port = ntohs(opi->in_port);
 
        // Create matching key.
        sw_flow_key key;
        key.wildcards = 0;
        flow_extract(buffer, port != -1 ? port : OFPP_NONE, &key.flow);
 
        uint16_t out_port = OFPP_FLOOD;
        uint16_t in_port = ntohs(key.flow.in_port);
 
        // If the destination address is learned to a specific port, find it.
        Mac48Address dst_addr;
        dst_addr.CopyFrom(key.flow.dl_dst);
        if (!dst_addr.IsBroadcast())
        {
            LearnState_t::iterator st = m_learnState.find(dst_addr);
            if (st != m_learnState.end())
            {
                out_port = st->second.port;
            }
            else
            {
                NS_LOG_INFO("Setting to flood; don't know yet what port " << dst_addr
                                                                          << " is connected to");
            }
        }
        else
        {
            NS_LOG_INFO("Setting to flood; this packet is a broadcast");
        }
 
        // Create output-to-port action
        ofp_action_output x[1];
        x[0].type = htons(OFPAT_OUTPUT);
        x[0].len = htons(sizeof(ofp_action_output));
        x[0].port = out_port;
 
        // Create a new flow that outputs matched packets to a learned port, OFPP_FLOOD if there's
        // no learned port.
        ofp_flow_mod* ofm = BuildFlow(key,
                                      opi->buffer_id,
                                      OFPFC_ADD,
                                      x,
                                      sizeof(x),
                                      OFP_FLOW_PERMANENT,
                                      m_expirationTime.IsZero() ? OFP_FLOW_PERMANENT
                                                                : m_expirationTime.GetSeconds());
        SendToSwitch(swtch, ofm, ofm->header.length);
 
        // We can learn a specific port for the source address for future use.
        Mac48Address src_addr;
        src_addr.CopyFrom(key.flow.dl_src);
        LearnState_t::iterator st = m_learnState.find(src_addr);
        if (st == m_learnState.end()) // We haven't learned our source MAC yet.
        {
            LearnedState ls;
            ls.port = in_port;
            m_learnState.insert(std::make_pair(src_addr, ls));
            NS_LOG_INFO("Learned that " << src_addr << " can be found over port " << in_port);
 
            // Learn src_addr goes to a certain port.
            ofp_action_output x2[1];
            x2[0].type = htons(OFPAT_OUTPUT);
            x2[0].len = htons(sizeof(ofp_action_output));
            x2[0].port = in_port;
 
            // Switch MAC Addresses and ports to the flow we're modifying
            src_addr.CopyTo(key.flow.dl_dst);
            dst_addr.CopyTo(key.flow.dl_src);
            key.flow.in_port = out_port;
            ofp_flow_mod* ofm2 = BuildFlow(
                key,
                -1,
                OFPFC_MODIFY,
                x2,
                sizeof(x2),
                OFP_FLOW_PERMANENT,
                m_expirationTime.IsZero() ? OFP_FLOW_PERMANENT : m_expirationTime.GetSeconds());
            SendToSwitch(swtch, ofm2, ofm2->header.length);
        }
    }
}
 
void
ExecuteActions(Ptr<OpenFlowSwitchNetDevice> swtch,
               uint64_t packet_uid,
               ofpbuf* buffer,
               sw_flow_key* key,
               const ofp_action_header* actions,
               size_t actions_len,
               int ignore_no_fwd)
{
    NS_LOG_FUNCTION_NOARGS();
    /* Every output action needs a separate clone of 'buffer', but the common
     * case is just a single output action, so that doing a clone and then
     * freeing the original buffer is wasteful.  So the following code is
     * slightly obscure just to avoid that. */
    int prev_port;
    size_t max_len = 0;                   // Initialize to make compiler happy
    uint16_t in_port = key->flow.in_port; // ntohs(key->flow.in_port);
    uint8_t* p = (uint8_t*)actions;
 
    prev_port = -1;
 
    if (actions_len == 0)
    {
        NS_LOG_INFO("No actions set to this flow. Dropping packet.");
        return;
    }
 
    /* The action list was already validated, so we can be a bit looser
     * in our sanity-checking. */
    while (actions_len > 0)
    {
        ofp_action_header* ah = (ofp_action_header*)p;
        size_t len = htons(ah->len);
 
        if (prev_port != -1)
        {
            swtch->DoOutput(packet_uid, in_port, max_len, prev_port, ignore_no_fwd);
            prev_port = -1;
        }
 
        if (ah->type == htons(OFPAT_OUTPUT))
        {
            ofp_action_output* oa = (ofp_action_output*)p;
 
            // port is now 32-bits
            prev_port = oa->port; // ntohl(oa->port);
            // prev_port = ntohs(oa->port);
            max_len = ntohs(oa->max_len);
        }
        else
        {
            uint16_t type = ntohs(ah->type);
            if (Action::IsValidType(
                    (ofp_action_type)type)) // Execute a built-in OpenFlow action against 'buffer'.
            {
                Action::Execute((ofp_action_type)type, buffer, key, ah);
            }
            else if (type == OFPAT_VENDOR)
            {
                ExecuteVendor(buffer, key, ah);
            }
        }
 
        p += len;
        actions_len -= len;
    }
 
    if (prev_port != -1)
    {
        swtch->DoOutput(packet_uid, in_port, max_len, prev_port, ignore_no_fwd);
    }
}
 
uint16_t
ValidateActions(const sw_flow_key* key, const ofp_action_header* actions, size_t actions_len)
{
    uint8_t* p = (uint8_t*)actions;
    int err;
 
    while (actions_len >= sizeof(ofp_action_header))
    {
        ofp_action_header* ah = (ofp_action_header*)p;
        size_t len = ntohs(ah->len);
        uint16_t type;
 
        /* Make there's enough remaining data for the specified length
         * and that the action length is a multiple of 64 bits. */
        if ((actions_len < len) || (len % 8) != 0)
        {
            return OFPBAC_BAD_LEN;
        }
 
        type = ntohs(ah->type);
        if (Action::IsValidType((ofp_action_type)type)) // Validate built-in OpenFlow actions.
        {
            err = Action::Validate((ofp_action_type)type, len, key, ah);
            if (err != ACT_VALIDATION_OK)
            {
                return err;
            }
        }
        else if (type == OFPAT_VENDOR)
        {
            err = ValidateVendor(key, ah, len);
            if (err != ACT_VALIDATION_OK)
            {
                return err;
            }
        }
        else
        {
            return OFPBAC_BAD_TYPE;
        }
 
        p += len;
        actions_len -= len;
    }
 
    // Check if there's any trailing garbage.
    if (actions_len != 0)
    {
        return OFPBAC_BAD_LEN;
    }
 
    return ACT_VALIDATION_OK;
}
 
void
ExecuteVPortActions(Ptr<OpenFlowSwitchNetDevice> swtch,
                    uint64_t packet_uid,
                    ofpbuf* buffer,
                    sw_flow_key* key,
                    const ofp_action_header* actions,
                    size_t actions_len)
{
    /* Every output action needs a separate clone of 'buffer', but the common
     * case is just a single output action, so that doing a clone and then
     * freeing the original buffer is wasteful.  So the following code is
     * slightly obscure just to avoid that. */
    int prev_port;
    size_t max_len = 0; // Initialize to make compiler happy
    uint16_t in_port = ntohs(key->flow.in_port);
    uint8_t* p = (uint8_t*)actions;
    uint16_t type;
    ofp_action_output* oa;
 
    prev_port = -1;
    /* The action list was already validated, so we can be a bit looser
     * in our sanity-checking. */
    while (actions_len > 0)
    {
        ofp_action_header* ah = (ofp_action_header*)p;
        size_t len = htons(ah->len);
        if (prev_port != -1)
        {
            swtch->DoOutput(packet_uid, in_port, max_len, prev_port, false);
            prev_port = -1;
        }
 
        if (ah->type == htons(OFPAT_OUTPUT))
        {
            oa = (ofp_action_output*)p;
            prev_port = ntohl(oa->port);
            max_len = ntohs(oa->max_len);
        }
        else
        {
            type = ah->type; // ntohs(ah->type);
            VPortAction::Execute((ofp_vport_action_type)type, buffer, key, ah);
        }
 
        p += len;
        actions_len -= len;
    }
 
    if (prev_port != -1)
    {
        swtch->DoOutput(packet_uid, in_port, max_len, prev_port, false);
    }
}
 
uint16_t
ValidateVPortActions(const ofp_action_header* actions, size_t actions_len)
{
    uint8_t* p = (uint8_t*)actions;
    int err;
 
    while (actions_len >= sizeof(ofp_action_header))
    {
        ofp_action_header* ah = (ofp_action_header*)p;
        size_t len = ntohs(ah->len);
        uint16_t type;
 
        /* Make there's enough remaining data for the specified length
         * and that the action length is a multiple of 64 bits. */
        if ((actions_len < len) || (len % 8) != 0)
        {
            return OFPBAC_BAD_LEN;
        }
 
        type = ntohs(ah->type);
        if (VPortAction::IsValidType(
                (ofp_vport_action_type)type)) // Validate "built-in" OpenFlow port table actions.
        {
            err = VPortAction::Validate((ofp_vport_action_type)type, len, ah);
            if (err != ACT_VALIDATION_OK)
            {
                return err;
            }
        }
        else
        {
            return OFPBAC_BAD_TYPE;
        }
 
        p += len;
        actions_len -= len;
    }
 
    // Check if there's any trailing garbage.
    if (actions_len != 0)
    {
        return OFPBAC_BAD_LEN;
    }
 
    return ACT_VALIDATION_OK;
}
 
void
ExecuteVendor(ofpbuf* buffer, const sw_flow_key* key, const ofp_action_header* ah)
{
    ofp_action_vendor_header* avh = (ofp_action_vendor_header*)ah;
 
    switch (ntohl(avh->vendor))
    {
    case NX_VENDOR_ID:
        // Nothing to execute yet.
        break;
    case ER_VENDOR_ID: {
        const er_action_header* erah = (const er_action_header*)avh;
        EricssonAction::Execute((er_action_type)ntohs(erah->subtype), buffer, key, erah);
        break;
    }
    default:
        // This should not be possible due to prior validation.
        NS_LOG_INFO("attempt to execute action with unknown vendor: " << ntohl(avh->vendor));
        break;
    }
}
 
uint16_t
ValidateVendor(const sw_flow_key* key, const ofp_action_header* ah, uint16_t len)
{
    ofp_action_vendor_header* avh;
    int ret = ACT_VALIDATION_OK;
 
    if (len < sizeof(ofp_action_vendor_header))
    {
        return OFPBAC_BAD_LEN;
    }
 
    avh = (ofp_action_vendor_header*)ah;
 
    switch (ntohl(avh->vendor))
    {
    case NX_VENDOR_ID:                // Validate Nicara OpenFlow actions.
        ret = OFPBAC_BAD_VENDOR_TYPE; // Nothing to validate yet.
        break;
    case ER_VENDOR_ID: // Validate Ericsson OpenFlow actions.
    {
        const er_action_header* erah = (const er_action_header*)avh;
        ret = EricssonAction::Validate((er_action_type)ntohs(erah->subtype), len);
        break;
    }
    default:
        return OFPBAC_BAD_VENDOR;
    }
 
    return ret;
}
 
} // namespace ofi
 
} // namespace ns3
 
#endif // NS3_OPENFLOW