/*
  Ido Barnea
  Cisco Systems, Inc.
*/

/*
  Copyright (c) 2015-2017 Cisco Systems, Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

/*
Important classes in this file:
CFlowStatUserIdInfo - Information about one packet group id
CFlowStatUserIdMap - Mapping between packet group id (chosen by user) and hardware counter id
CFlowStatHwIdMap - Mapping between hardware id and packet group id
CFlowStatRuleMgr - API to users of the file

General idea of operation:
For each stream needing flow statistics, the user provides packet group id (pg_id). Few streams can have the same pg_id.
We maintain reference count.
When doing start_stream, for the first stream in pg_id, hw_id is associated with the pg_id, and relevant hardware rules are
inserted (on supported hardware). When stopping all streams with the pg_id, the hw_id <--> pg_id mapping is removed, hw_id is
returned to the free hw_id pool, and hardware rules are removed. Counters for the pg_id are kept.
If starting streams again, new hw_id will be assigned, and counters will continue from where they stopped. Only When deleting
all streams using certain pg_id, infromation about this pg_id will be freed.

For each stream we keep state in the m_rx_check.m_hw_id field. Since we keep reference count for certain structs, we want to
protect from illegal operations, like starting stream while it is already starting, stopping when it is stopped...
State machine is:
stream_init: HW_ID_INIT
stream_add: HW_ID_FREE
stream_start: legal hw_id (range is 0..MAX_FLOW_STATS)
stream_stop: HW_ID_FREE
stream_del: HW_ID_INIT
 */
#include <sstream>
#include <string>
#include <iostream>
#include <assert.h>
#include <os_time.h>
#include "internal_api/trex_platform_api.h"
#include "trex_stateless.h"
#include "trex_stateless_messaging.h"
#include "trex_stateless_rx_core.h"
#include "trex_stream.h"
#include "flow_stat_parser.h"
#include "flow_stat.h"


#define FLOW_STAT_ADD_ALL_PORTS 255

static const uint16_t HW_ID_INIT = UINT16_MAX;
static const uint16_t HW_ID_FREE = UINT16_MAX - 1;
static const uint8_t PAYLOAD_RULE_PROTO = 255;
const uint32_t FLOW_STAT_PAYLOAD_IP_ID = IP_ID_RESERVE_BASE + MAX_FLOW_STATS;

inline std::string methodName(const std::string& prettyFunction)
{
    size_t colons = prettyFunction.find("::");
    size_t begin = prettyFunction.substr(0,colons).rfind(" ") + 1;
    size_t end = prettyFunction.rfind("(") - begin;

    return prettyFunction.substr(begin,end) + "()";
}

#define __METHOD_NAME__ methodName(__PRETTY_FUNCTION__)
#ifdef __DEBUG_FUNC_ENTRY__
#define FUNC_ENTRY (std::cout << __METHOD_NAME__ << std::endl);
#ifdef __STREAM_DUMP__
#define stream_dump(stream) stream->Dump(stderr)
#else
#define stream_dump(stream)
#endif
#else
#define FUNC_ENTRY
#endif

/************** class CFlowStatUserIdInfo ***************/
CFlowStatUserIdInfo::CFlowStatUserIdInfo(uint16_t l3_proto, uint8_t l4_proto, uint8_t ipv6_next_h) {
    memset(m_rx_cntr, 0, sizeof(m_rx_cntr));
    memset(m_rx_cntr_base, 0, sizeof(m_rx_cntr));
    memset(m_tx_cntr, 0, sizeof(m_tx_cntr));
    memset(m_tx_cntr_base, 0, sizeof(m_tx_cntr));
    m_hw_id = UINT16_MAX;
    m_l3_proto = l3_proto;
    m_l4_proto = l4_proto;
    m_ipv6_next_h = ipv6_next_h;
    m_ref_count = 1;
    m_trans_ref_count = 0;
    m_was_sent = false;
    for (int i = 0; i < TREX_MAX_PORTS; i++) {
        m_rx_changed[i] = false;
        m_tx_changed[i] = false;
    }
    m_rfc2544_support = false;
}

std::ostream& operator<<(std::ostream& os, const CFlowStatUserIdInfo& cf) {
    os << "hw_id:" << cf.m_hw_id << " l3 proto:" << (uint16_t) cf.m_l3_proto << " ref("
       << (uint16_t) cf.m_ref_count << "," << (uint16_t) cf.m_trans_ref_count << ")";
    os << " rx count (";
    os << cf.m_rx_cntr[0];
    for (int i = 1; i < TREX_MAX_PORTS; i++) {
        os << "," << cf.m_rx_cntr[i];
    }
    os << ")";
    os << " rx count base(";
    os << cf.m_rx_cntr_base[0];
    for (int i = 1; i < TREX_MAX_PORTS; i++) {
        os << "," << cf.m_rx_cntr_base[i];
    }
    os << ")";

    os << " tx count (";
    os << cf.m_tx_cntr[0];
    for (int i = 1; i < TREX_MAX_PORTS; i++) {
        os << "," << cf.m_tx_cntr[i];
    }
    os << ")";
    os << " tx count base(";
    os << cf.m_tx_cntr_base[0];
    for (int i = 1; i < TREX_MAX_PORTS; i++) {
        os << "," << cf.m_tx_cntr_base[i];
    }
    os << ")";

    return os;
}

void CFlowStatUserIdInfo::add_stream(uint8_t proto) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " proto:" << (uint16_t)proto << std::endl;
#endif

    if (proto != m_l4_proto)
        throw TrexFStatEx("Can't use same pg_id for streams with different l4 protocol",
                                    TrexException::T_FLOW_STAT_PG_ID_DIFF_L4);

    m_ref_count++;
}

void CFlowStatUserIdInfo::reset_hw_id() {
    FUNC_ENTRY;

    m_hw_id = UINT16_MAX;
    // we are not attached to hw. Save packet count of session.
    // Next session will start counting from 0.
    for (int i = 0; i < TREX_MAX_PORTS; i++) {
        m_rx_cntr_base[i] += m_rx_cntr[i];
        memset(&m_rx_cntr[i], 0, sizeof(m_rx_cntr[0]));
        m_tx_cntr_base[i] += m_tx_cntr[i];
        memset(&m_tx_cntr[i], 0, sizeof(m_tx_cntr[0]));
    }
}

/************** class CFlowStatUserIdInfoPayload ***************/
void CFlowStatUserIdInfoPayload::add_stream(uint8_t proto) {
    throw TrexFStatEx("For payload rules: Can't have two streams with same pg_id, or same stream on more than one port"
                      , TrexException::T_FLOW_STAT_DUP_PG_ID);
}

void CFlowStatUserIdInfoPayload::reset_hw_id() {
    CFlowStatUserIdInfo::reset_hw_id();

    m_seq_err_base += m_rfc2544_info.m_seq_err;
    m_out_of_order_base += m_rfc2544_info.m_out_of_order;
    m_dup_base += m_rfc2544_info.m_dup;
    m_seq_err_ev_big_base += m_rfc2544_info.m_seq_err_ev_big;
    m_seq_err_ev_low_base += m_rfc2544_info.m_seq_err_ev_low;
    m_rfc2544_info.m_seq_err = 0;
    m_rfc2544_info.m_out_of_order = 0;
    m_rfc2544_info.m_dup = 0;
    m_rfc2544_info.m_seq_err_ev_big = 0;
    m_rfc2544_info.m_seq_err_ev_low = 0;
}

/************** class CFlowStatUserIdMap ***************/
CFlowStatUserIdMap::CFlowStatUserIdMap() {

}

std::ostream& operator<<(std::ostream& os, const CFlowStatUserIdMap& cf) {
    std::map<unsigned int, CFlowStatUserIdInfo*>::const_iterator it;
    for (it = cf.m_map.begin(); it != cf.m_map.end(); it++) {
        CFlowStatUserIdInfo *user_id_info = it->second;
        uint32_t user_id = it->first;
        os << "Flow stat user id info:\n";
        os << "  " << user_id << ":" << *user_id_info << std::endl;
    }
    return os;
}

uint16_t CFlowStatUserIdMap::get_hw_id(uint32_t user_id) {
    CFlowStatUserIdInfo *cf = find_user_id(user_id);

    if (cf == NULL) {
        return HW_ID_FREE;
    } else {
        return cf->get_hw_id();
    }
}

CFlowStatUserIdInfo *
CFlowStatUserIdMap::find_user_id(uint32_t user_id) {
    flow_stat_user_id_map_it_t it = m_map.find(user_id);

    if (it == m_map.end()) {
        return NULL;
    } else {
        return it->second;
    }
}

CFlowStatUserIdInfo *
CFlowStatUserIdMap::add_user_id(uint32_t user_id, uint16_t l3_proto, uint8_t l4_proto, uint8_t ipv6_next_h) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << " proto:" << (uint16_t)proto
              << std::endl;
#endif

    CFlowStatUserIdInfo *new_id;

    if (l4_proto == PAYLOAD_RULE_PROTO) {
        new_id = new CFlowStatUserIdInfoPayload(l3_proto, l4_proto, ipv6_next_h);
    } else {
        new_id = new CFlowStatUserIdInfo(l3_proto, l4_proto, ipv6_next_h);
    }
    if (new_id != NULL) {
        std::pair<flow_stat_user_id_map_it_t, bool> ret;
        ret = m_map.insert(std::pair<uint32_t, CFlowStatUserIdInfo *>(user_id, new_id));
        if (ret.second == false) {
            delete new_id;
            throw TrexFStatEx("packet group id " + std::to_string(user_id) + " already exists"
                              , TrexException::T_FLOW_STAT_ALREADY_EXIST);
        }
        return new_id;
    } else {
        throw TrexFStatEx("Failed allocating memory for new statistic counter"
                          , TrexException::T_FLOW_STAT_ALLOC_FAIL);
    }
}

void CFlowStatUserIdMap::add_stream(uint32_t user_id, uint16_t l3_proto, uint8_t l4_proto, uint8_t ipv6_next_h) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << " l3 proto:" << (uint16_t)l3_proto
              << " l4 proto:" << (uint16_t)l4_proto << " IPv6 next header:" << (uint16_t)ipv6_next_h
              << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        // throws exception on error
        c_user_id = add_user_id(user_id, l3_proto, l4_proto, ipv6_next_h);
    } else {
        c_user_id->add_stream(l4_proto);
    }
}

int CFlowStatUserIdMap::del_stream(uint32_t user_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        throw TrexFStatEx("Trying to delete stream which does not exist"
                          , TrexException::T_FLOW_STAT_DEL_NON_EXIST);
    }

    if (c_user_id->del_stream() == 0) {
        // ref count of this entry became 0. can release this entry.
        m_map.erase(user_id);
        delete c_user_id;
    }

    return 0;
}

int CFlowStatUserIdMap::start_stream(uint32_t user_id, uint16_t hw_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << " hw_id:" << hw_id << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        throw TrexFStatEx("Internal error: Trying to associate non exist group id " + std::to_string(user_id)
                          + " to hardware id " + std::to_string(hw_id)
                          , TrexException::T_FLOW_STAT_ASSOC_NON_EXIST_ID);
    }

    if (c_user_id->is_hw_id()) {
        throw TrexFStatEx("Internal error: Trying to associate hw id " + std::to_string(hw_id) + " to user_id "
                          + std::to_string(user_id) + ", but it is already associated to "
                          + std::to_string(c_user_id->get_hw_id())
                          , TrexException::T_FLOW_STAT_ASSOC_OCC_ID);
    }
    c_user_id->set_hw_id(hw_id);
    c_user_id->add_started_stream();

    return 0;
}

int CFlowStatUserIdMap::start_stream(uint32_t user_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        throw TrexFStatEx("Trying to start stream with non exist packet group id " + std::to_string(user_id)
                          , TrexException::T_FLOW_STAT_NON_EXIST_ID);
    }

    c_user_id->add_started_stream();

    return 0;
}

// return: negative number in case of error.
//         Number of started streams attached to used_id otherwise.
int CFlowStatUserIdMap::stop_stream(uint32_t user_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        throw TrexFStatEx("Trying to stop stream with non exist packet group id" + std::to_string(user_id)
                          , TrexException::T_FLOW_STAT_NON_EXIST_ID);
    }

    return c_user_id->stop_started_stream();
}

bool CFlowStatUserIdMap::is_started(uint32_t user_id) {
    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        return false;
    }

    return c_user_id->is_started();
}

uint16_t CFlowStatUserIdMap::unmap(uint32_t user_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << user_id << std::endl;
#endif

    CFlowStatUserIdInfo *c_user_id;

    c_user_id = find_user_id(user_id);
    if (! c_user_id) {
        return UINT16_MAX;
    }
    uint16_t old_hw_id = c_user_id->get_hw_id();
    c_user_id->reset_hw_id();

    return old_hw_id;
}

/************** class CFlowStatHwIdMap ***************/
CFlowStatHwIdMap::CFlowStatHwIdMap() {
    m_map = NULL; // must call create in order to work with the class
    m_num_free = 0; // to make coverity happy, init this here too.
}

CFlowStatHwIdMap::~CFlowStatHwIdMap() {
    delete[] m_map;
}

void CFlowStatHwIdMap::create(uint16_t size) {
    m_map = new uint32_t[size];
    assert (m_map != NULL);
    m_num_free = size;
    for (int i = 0; i < size; i++) {
        m_map[i] = HW_ID_FREE;
    }
}

std::ostream& operator<<(std::ostream& os, const CFlowStatHwIdMap& cf) {
    int count = 0;

    os << "HW id map:\n";
    os << "  num free:" << cf.m_num_free << std::endl;
    for (int i = 0; i < MAX_FLOW_STATS; i++) {
        if (cf.m_map[i] != 0) {
            count++;
            os << "(" << i << ":" << cf.m_map[i] << ")";
            if (count == 10) {
                os << std::endl;
                count = 0;
            }
        }
    }

    return os;
}

uint16_t CFlowStatHwIdMap::find_free_hw_id() {
    for (int i = 0; i < MAX_FLOW_STATS; i++) {
        if (m_map[i] == HW_ID_FREE)
            return i;
    }

    return HW_ID_FREE;
}

void CFlowStatHwIdMap::map(uint16_t hw_id, uint32_t user_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " hw id:" << hw_id << " user id:" << user_id << std::endl;
#endif

    m_map[hw_id] = user_id;
    m_num_free--;
}

void CFlowStatHwIdMap::unmap(uint16_t hw_id) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " hw id:" << hw_id << std::endl;
#endif

    m_map[hw_id] = HW_ID_FREE;
    m_num_free++;
}

/************** class CFlowStatRuleMgr ***************/
CFlowStatRuleMgr::CFlowStatRuleMgr() {
    m_api = NULL;
    m_max_hw_id = -1;
    m_max_hw_id_payload = -1;
    m_num_started_streams = 0;
    m_ring_to_rx = NULL;
    m_cap = 0;
    m_parser_ipid = NULL;
    m_parser_pl = NULL;
    m_rx_core = NULL;
    m_hw_id_map.create(MAX_FLOW_STATS);
    m_hw_id_map_payload.create(MAX_FLOW_STATS_PAYLOAD);
    memset(m_rx_cant_count_err, 0, sizeof(m_rx_cant_count_err));
    memset(m_tx_cant_count_err, 0, sizeof(m_tx_cant_count_err));
    m_num_ports = 0; // need to call create to init
    m_mode = FLOW_STAT_MODE_NORMAL;
}

CFlowStatRuleMgr::~CFlowStatRuleMgr() {
    delete m_parser_ipid;
    delete m_parser_pl;
#ifdef TREX_SIM
    // In simulator, nobody handles the messages to RX, so need to free them to have clean valgrind run.
    if (m_ring_to_rx) {
        CGenNode *msg = NULL;
        while (! m_ring_to_rx->isEmpty()) {
            m_ring_to_rx->Dequeue(msg);
            delete msg;
        }
    }
#endif
}

void CFlowStatRuleMgr::create() {
    uint16_t num_counters, cap;
    TrexStateless *tstateless = get_stateless_obj();
    assert(tstateless);

    m_api = tstateless->get_platform_api();
    assert(m_api);
    m_api->get_interface_stat_info(0, num_counters, cap);
    m_api->get_port_num(m_num_ports); // This initialize m_num_ports
    for (uint8_t port = 0; port < m_num_ports; port++) {
        assert(m_api->reset_hw_flow_stats(port) == 0);
    }
    m_ring_to_rx = CMsgIns::Ins()->getCpRx()->getRingCpToDp(0);
    assert(m_ring_to_rx);
    m_rx_core = get_rx_sl_core_obj();
    m_cap = cap;

    if ((CGlobalInfo::get_queues_mode() == CGlobalInfo::Q_MODE_ONE_QUEUE)
        || (CGlobalInfo::get_queues_mode() == CGlobalInfo::Q_MODE_RSS)) {
        set_mode(FLOW_STAT_MODE_PASS_ALL);
        m_parser_ipid = new CFlowStatParser(CFlowStatParser::FLOW_STAT_PARSER_MODE_SW);
        m_parser_pl = new CPassAllParser;
    } else {
        m_parser_ipid = m_api->get_flow_stat_parser();
        m_parser_pl = m_api->get_flow_stat_parser();
    }
    assert(m_parser_ipid);
    assert(m_parser_pl);
}

std::ostream& operator<<(std::ostream& os, const CFlowStatRuleMgr& cf) {
    os << "Flow stat rule mgr (" << cf.m_num_ports << ") ports:" << std::endl;
    os << cf.m_hw_id_map;
    os << cf.m_hw_id_map_payload;
    os << cf.m_user_id_map;
    return os;
}

int CFlowStatRuleMgr::compile_stream(const TrexStream * stream, CFlowStatParser *parser) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << stream->m_rx_check.m_pg_id << " en:";
    std::cout << stream->m_rx_check.m_enabled << std::endl;
#endif
    CFlowStatParser_err_t ret = parser->parse(stream->m_pkt.binary, stream->m_pkt.len);

    if (ret != FSTAT_PARSER_E_OK) {
        // if we could not parse the packet, but no stat count needed, it is probably OK.
        if (stream->m_rx_check.m_enabled) {
            throw TrexFStatEx(parser->get_error_str(ret), TrexException::T_FLOW_STAT_BAD_PKT_FORMAT);
        } else {
            return 0;
        }
    }

    return 0;
}

void CFlowStatRuleMgr::copy_state(TrexStream * from, TrexStream * to) {
    to->m_rx_check.m_hw_id = from->m_rx_check.m_hw_id;
}
void CFlowStatRuleMgr::init_stream(TrexStream * stream) {
    stream->m_rx_check.m_hw_id = HW_ID_INIT;
}

int CFlowStatRuleMgr::verify_stream(TrexStream * stream) {
    return add_stream_internal(stream, false);
}

int CFlowStatRuleMgr::add_stream(TrexStream * stream) {
    return add_stream_internal(stream, true);
}

/*
 * Helper function for adding/verifying streams
 * stream - stream to act on
 * do_action - if false, just verify. Do not change any state, or add to database.
 */
int CFlowStatRuleMgr::add_stream_internal(TrexStream * stream, bool do_action) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << stream->m_rx_check.m_pg_id << std::endl;
    stream_dump(stream);
#endif

    if (! stream->m_rx_check.m_enabled) {
        return 0;
    }

    // Init everything here, and not in the constructor, since we relay on other objects
    // By the time a stream is added everything else is initialized.
    if (! m_api ) {
        create();
    }

    TrexPlatformApi::driver_stat_cap_e rule_type = (TrexPlatformApi::driver_stat_cap_e)stream->m_rx_check.m_rule_type;

    if ((m_cap & rule_type) == 0) {
        throw TrexFStatEx("Interface does not support given rule type", TrexException::T_FLOW_STAT_BAD_RULE_TYPE_FOR_IF);
    }

    switch(rule_type) {
    case TrexPlatformApi::IF_STAT_IPV4_ID:
        uint16_t l3_proto;
        // compile_stream throws exception if something goes wrong
        compile_stream(stream, m_parser_ipid);

        if (m_parser_ipid->get_l3_proto(l3_proto) < 0) {
            throw TrexFStatEx("Failed determining l3 proto for packet", TrexException::T_FLOW_STAT_FAILED_FIND_L3);
        }
        uint8_t l4_proto;
        if (m_parser_ipid->get_l4_proto(l4_proto) < 0) {
            throw TrexFStatEx("Failed determining l4 proto for packet", TrexException::T_FLOW_STAT_FAILED_FIND_L4);
        }


        // throws exception if there is error
        if (do_action) {
            // passing 0 in ipv6_next_h. This is not used currently in stateless.
            m_user_id_map.add_stream(stream->m_rx_check.m_pg_id, l3_proto, l4_proto, 0);
        }
        break;
    case TrexPlatformApi::IF_STAT_PAYLOAD:
        uint16_t payload_len;
        // compile_stream throws exception if something goes wrong
        compile_stream(stream, m_parser_pl);

        if (m_parser_pl->get_payload_len(stream->m_pkt.binary, stream->m_pkt.len, payload_len) < 0) {
            throw TrexFStatEx("Failed getting payload len", TrexException::T_FLOW_STAT_BAD_PKT_FORMAT);
        }
        if (payload_len < sizeof(struct flow_stat_payload_header)) {
            throw TrexFStatEx("Need at least " + std::to_string(sizeof(struct latency_header))
                              + " payload bytes for payload rules. Packet only has " + std::to_string(payload_len) + " bytes"
                              , TrexException::T_FLOW_STAT_PAYLOAD_TOO_SHORT);
        }
        if (do_action) {
            m_user_id_map.add_stream(stream->m_rx_check.m_pg_id, 0, PAYLOAD_RULE_PROTO, 0);
        }
        break;
    default:
        throw TrexFStatEx("Wrong rule_type", TrexException::T_FLOW_STAT_BAD_RULE_TYPE);
        break;
    }
    if (do_action) {
        stream->m_rx_check.m_hw_id = HW_ID_FREE;
    }
    return 0;
}

int CFlowStatRuleMgr::del_stream(TrexStream * stream) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << stream->m_rx_check.m_pg_id << std::endl;
    stream_dump(stream);
#endif

    if (! stream->m_rx_check.m_enabled) {
        return 0;
    }

    if (! m_api)
        throw TrexFStatEx("Called del_stream, but no stream was added", TrexException::T_FLOW_STAT_NO_STREAMS_EXIST);

    TrexPlatformApi::driver_stat_cap_e rule_type = (TrexPlatformApi::driver_stat_cap_e)stream->m_rx_check.m_rule_type;
    switch(rule_type) {
    case TrexPlatformApi::IF_STAT_IPV4_ID:
        break;
    case TrexPlatformApi::IF_STAT_PAYLOAD:
        break;
    default:
        throw TrexFStatEx("Wrong rule_type", TrexException::T_FLOW_STAT_BAD_RULE_TYPE);
        break;
    }

    // we got del_stream command for a stream which has valid hw_id.
    // Probably someone forgot to call stop
    if(stream->m_rx_check.m_hw_id < MAX_FLOW_STATS + MAX_FLOW_STATS_PAYLOAD) {
        stop_stream(stream);
    }

    // calling del for same stream twice, or for a stream which was never "added"
    if(stream->m_rx_check.m_hw_id == HW_ID_INIT) {
        return 0;
    }
    m_user_id_map.del_stream(stream->m_rx_check.m_pg_id); // Throws exception in case of error
    stream->m_rx_check.m_hw_id = HW_ID_INIT;

    return 0;
}

// called on all streams, when stream start to transmit
// If stream need flow stat counting, make sure the type of packet is supported, and
// embed needed info in packet.
// If stream does not need flow stat counting, make sure it does not interfere with
// other streams that do need stat counting.
// Might change the IP ID of the stream packet
int CFlowStatRuleMgr::start_stream(TrexStream * stream) {
#ifdef __DEBUG_FUNC_ENTRY__
    std::cout << __METHOD_NAME__ << " user id:" << stream->m_rx_check.m_pg_id << std::endl;
    stream_dump(stream);
#endif

    int ret;
    // Streams which does not need statistics might be started, before any stream that do
    // need statistcs, so start_stream might be called before add_stream
    if (! m_api ) {
        create();
    }

    // first handle streams that do not need rx stat
    if (! stream->m_rx_check.m_enabled) {
        try {
            compile_stream(stream, m_parser_ipid);
        } catch (TrexFStatEx) {
            // If no statistics needed, and we can't parse the stream, that's OK.
            return 0;
        }

        uint32_t ip_id;
        if (m_parser_ipid->get_ip_id(ip_id) < 0) {
            return 0; // if we could not find the ip id, no need to fix
        }
        // verify no reserved IP_ID used, and change if needed
        if (ip_id >= IP_ID_RESERVE_BASE) {
            if (m_parser_ipid->set_ip_id(ip_id & 0xefff) < 0) {
                throw TrexFStatEx("Stream IP ID in reserved range. Failed changing it"
                                  , TrexException::T_FLOW_STAT_FAILED_CHANGE_IP_ID);
            }
        }
        return 0;
    }

    // from here, we know the stream need rx stat

    // Starting a stream which was never added
    if (stream->m_rx_check.m_hw_id == HW_ID_INIT) {
        add_stream(stream);
    }

    if (stream->m_rx_check.m_hw_id < MAX_FLOW_STATS + MAX_FLOW_STATS_PAYLOAD) {
        throw TrexFStatEx("Starting a stream which was already started"
                          , TrexException::T_FLOW_STAT_ALREADY_STARTED);
    }

    TrexPlatformApi::driver_stat_cap_e rule_type = (TrexPlatformApi::driver_stat_cap_e)stream->m_rx_check.m_rule_type;

    if ((m_cap & rule_type) == 0) {
        throw TrexFStatEx("Interface does not support given rule type", TrexException::T_FLOW_STAT_BAD_RULE_TYPE_FOR_IF);
    }
    uint16_t hw_id;

    switch(rule_type) {
    case TrexPlatformApi::IF_STAT_IPV4_ID:
        // compile_stream throws exception if something goes wrong
        if ((ret = compile_stream(stream, m_parser_ipid)) < 0)
            return ret;
        break;
    case TrexPlatformApi::IF_STAT_PAYLOAD<style>.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/*</span>
<span class="cm"> * Copyright (c) 2016 Cisco and/or its affiliates.</span>
<span class="cm"> * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);</span>
<span class="cm"> * you may not use this file except in compliance with the License.</span>
<span class="cm"> * You may obtain a copy of the License at:</span>
<span class="cm"> *</span>
<span class="cm"> *     http://www.apache.org/licenses/LICENSE-2.0</span>
<span class="cm"> *</span>
<span class="cm"> * Unless required by applicable law or agreed to in writing, software</span>
<span class="cm"> * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,</span>
<span class="cm"> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span>
<span class="cm"> * See the License for the specific language governing permissions and</span>
<span class="cm"> * limitations under the License.</span>
<span class="cm"> */</span>
<span class="cm">/**</span>
<span class="cm"> * @file</span>
<span class="cm"> * @brief L2 LISP-GPE decap code.</span>
<span class="cm"> *</span>
<span class="cm"> */</span>
<span class="cp">#include</span> <span class="cpf">&lt;vlib/vlib.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">&lt;vnet/pg/pg.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">&lt;vnet/lisp-gpe/lisp_gpe.h&gt;</span><span class="cp"></span>

<span class="k">typedef</span> <span class="k">struct</span>
<span class="p">{</span>
  <span class="n">u32</span> <span class="n">next_index</span><span class="p">;</span>
  <span class="n">u32</span> <span class="n">tunnel_index</span><span class="p">;</span>
  <span class="n">u32</span> <span class="n">error</span><span class="p">;</span>
  <span class="n">lisp_gpe_header_t</span> <span class="n">h</span><span class="p">;</span>
<span class="p">}</span> <span class="n">lisp_gpe_rx_trace_t</span><span class="p">;</span>

<span class="k">static</span> <span class="n">u8</span> <span class="o">*</span>
<span class="nf">format_lisp_gpe_rx_trace</span> <span class="p">(</span><span class="n">u8</span> <span class="o">*</span> <span class="n">s</span><span class="p">,</span> <span class="kt">va_list</span> <span class="o">*</span> <span class="n">args</span><span class="p">)</span>
<span class="p">{</span>
  <span class="n">CLIB_UNUSED</span> <span class="p">(</span><span class="n">vlib_main_t</span> <span class="o">*</span> <span class="n">vm</span><span class="p">)</span> <span class="o">=</span> <span class="n">va_arg</span> <span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="n">vlib_main_t</span> <span class="o">*</span><span class="p">);</span>
  <span class="n">CLIB_UNUSED</span> <span class="p">(</span><span class="n">vlib_node_t</span> <span class="o">*</span> <span class="n">node</span><span class="p">)</span> <span class="o">=</span> <span class="n">va_arg</span> <span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="n">vlib_node_t</span> <span class="o">*</span><span class="p">);</span>
  <span class="n">lisp_gpe_rx_trace_t</span> <span class="o">*</span><span class="n">t</span> <span class="o">=</span> <span class="n">va_arg</span> <span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="n">lisp_gpe_rx_trace_t</span> <span class="o">*</span><span class="p">);</span>

  <span class="k">if</span> <span class="p">(</span><span class="n">t</span><span class="o">-&gt;</span><span class="n">tunnel_index</span> <span class="o">!=</span> <span class="o">~</span><span class="mi">0</span><span class="p">)</span>
    <span class="p">{</span>
      <span class="n">s</span> <span class="o">=</span> <span class="n">format</span> <span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="s">&quot;LISP-GPE: tunnel %d next %d error %d&quot;</span><span class="p">,</span> <span class="n">t</span><span class="o">-&gt;</span><span class="n">tunnel_index</span><span class="p">,</span>
		  <span class="n">t</span><span class="o">-&gt;</span><span class="n">next_index</span><span class="p">,</span> <span class="n">t</span><span class="o">-&gt;</span><span class="n">error</span><span class="p">);</span>
    <span class="p">}</span>
  <span class="k">else</span>
    <span class="p">{</span>
      <span class="n">s</span> <span class="o">=</span> <span class="n">format</span> <span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="s">&quot;LISP-GPE: no tunnel next %d error %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span> <span class="n">t</span><span class="o">-&gt;</span><span class="n">next_index</span><span class="p">,</span>
		  <span class="n">t</span><span class="o">-&gt;</span><span class="n">error</span><span class="p">);</span>
    <span class="p">}</span>
  <span class="n">s</span> <span class="o">=</span> <span class="n">format</span> <span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="s">&quot;</span><span class="se">\n</span><span class="s">  %U&quot;</span><span class="p">,</span> <span class="n">format_lisp_gpe_header_with_length</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">t</span><span class="o">-&gt;</span><span class="n">h</span><span class="p">,</span>
	      <span class="p">(</span><span class="n">u32</span><span class="p">)</span> <span class="k">sizeof</span> <span class="p">(</span><span class="n">t</span><span class="o">-&gt;</span><span class="n">h</span><span class="p">)</span> <span class="cm">/* max size */</span> <span class="p">);</span>
  <span class="k">return</span> <span class="n">s</span><span class="p">;</span>
<span class="p">}</span>

<span class="k">static</span> <span class="n">u32</span> <span class="n">next_proto_to_next_index</span><span class="p">[</span><span class="n">LISP_GPE_NEXT_PROTOS</span><span class="p">]</span> <span class="o">=</span> <span class="p">{</span>
  <span class="n">LISP_GPE_INPUT_NEXT_DROP</span><span class="p">,</span>
  <span class="n">LISP_GPE_INPUT_NEXT_IP4_INPUT</span><span class="p">,</span>
  <span class="n">LISP_GPE_INPUT_NEXT_IP6_INPUT</span><span class="p">,</span>
  <span class="n">LISP_GPE_INPUT_NEXT_L2_INPUT</span><span class="p">,</span>
  <span class="n">LISP_GPE_INPUT_NEXT_DROP</span>
<span class="p">};</span>

<span class="n">always_inline</span> <span class="n">u32</span>
<span class="nf">next_protocol_to_next_index</span> <span class="p">(</span><span class="n">lisp_gpe_header_t</span> <span class="o">*</span> <span class="n">lgh</span><span class="p">,</span> <span class="n">u8</span> <span class="o">*</span> <span class="n">next_header</span><span class="p">)</span>
<span class="p">{</span>
  <span class="n">lisp_gpe_main_t</span> <span class="o">*</span><span class="n">lgm</span> <span class="o">=</span> <span class="n">vnet_lisp_gpe_get_main</span> <span class="p">();</span>

  <span class="cm">/* lisp-gpe router */</span>
  <span class="k">if</span> <span class="p">(</span><span class="n">PREDICT_TRUE</span> <span class="p">((</span><span class="n">lgh</span><span class="o">-&gt;</span><span class="n">flags</span> <span class="o">&amp;</span> <span class="n">LISP_GPE_FLAGS_P</span><span class="p">)</span>
		    <span class="o">||</span> <span class="n">GPE_ENCAP_VXLAN</span> <span class="o">==</span> <span class="n">lgm</span><span class="o">-&gt;</span><span class="n">encap_mode</span><span class="p">))</span>
    <span class="p">{</span>
      <span class="k">if</span> <span class="p">(</span><span class="n">PREDICT_FALSE</span> <span class="p">(</span><span class="n">lgh</span><span class="o">-&gt;</span><span class="n">next_protocol</span> <span class="o">&gt;=</span> <span class="n">LISP_GPE_NEXT_PROTOS</span><span class="p">))</span>
	<span class="k">return</span> <span class="n">LISP_GPE_INPUT_NEXT_DROP</span><span class="p">;</span>

      <span class="k">return</span> <span class="n">next_proto_to_next_index</span><span class="p">[</span><span class="n">lgh</span><span class="o">-&gt;</span><span class="n">next_protocol</span><span class="p">];</span>
    <span class="p">}</span>
  <span class="cm">/* legacy lisp router */</span>
  <span class="k">else</span> <span class="k">if</span> <span class="p">((</span><span class="n">lgh</span><span class="o">-&gt;</span><span class="n">flags</span> <span class="o">&amp;</span> <span class="n">LISP_GPE_FLAGS_P</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span>
    <span class="p">{</span>
      <span class="n">ip4_header_t</span> <span class="o">*</span><span class="n">iph</span> <span class="o">=</span> <span class="p">(</span><span class="n">ip4_header_t</span> <span class="o">*</span><span class="p">)</span> <span class="n">next_header</span><span class="p">;</span>
      <span class="k">if</span> <span class="p">((</span><span class="n">iph</span><span class="o">-&gt;</span><span class="n">ip_version_and_header_length</span> <span class="o">&amp;</span> <span class="mh">0xF0</span><span class="p">)</span> <span class="o">==</span> <span class="mh">0x40</span><span class="p">)</span>
	<span class="k">return</span> <span class="n">LISP_GPE_INPUT_NEXT_IP4_INPUT</span><span class="p">;</span>
      <span class="k">else</span> <span class="k">if</span> <span class="p">((</span><span class="n">iph</span><span class="o">-&gt;</span><span class="n">ip_version_and_header_length</span> <span class="o">&amp;</span> <span class="mh">0xF0</span><span class="p">)</span> <span class="o">==</span> <span class="mh">0x60</span><span class="p">)</span>
	<span class="k">return</span> <span class="n">LISP_GPE_INPUT_NEXT_IP6_INPUT</span><span class="p">;</span>
      <span class="k">else</span>
	<span class="k">return</span> <span class="n">LISP_GPE_INPUT_NEXT_DROP</span><span class="p">;</span>
    <span class="p">}</span>
  <span class="k">else</span>
    <span class="k">return</span> <span class="n">LISP_GPE_INPUT_NEXT_DROP</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">always_inline</span> <span class="n">tunnel_lookup_t</span> <span class="o">*</span>
<span class="nf">next_index_to_iface</span> <span class="p">(</span><span class="n">lisp_gpe_main_t</span> <span class="o">*</span> <span class="n">lgm</span><span class="p">,</span> <span class="n">u32</span> <span class="n">next_index</span><span class="p">)</span>
<span class="p">{</span>
  <span class="k">if</span> <span class="p">(</span><span class="n">LISP_GPE_INPUT_NEXT_IP4_INPUT</span> <span class="o">==</span> <span class="n">next_index</span>
      <span class="o">||</span> <span class="n">LISP_GPE_INPUT_NEXT_IP6_INPUT</span> <span class="o">==</span> <span class="n">next_index</span><span class="p">)</span>
    <span class="k">return</span> <span class="o">&amp;</span><span class="n">lgm</span><span class="o">-&gt;</span><span class="n">l3_ifaces</span><span class="p">;</span>
  <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">LISP_GPE_INPUT_NEXT_L2_INPUT</span> <span class="o">==</span> <span class="n">next_index</span><span class="p">)</span>
    <span class="k">return</span> <span class="o">&amp;</span><span class="n">lgm</span><span class="o">-&gt;</span><span class="n">l2_ifaces</span><span class="p">;</span>
  <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">LISP_GPE_INPUT_NEXT_NSH_INPUT</span> <span class="o">==</span> <span class="n">next_index</span><span class="p">)</span>
    <span class="k">return</span> <span class="o">&amp;</span><span class="n">lgm</span><span class="o">-&gt;</span><span class="n">nsh_ifaces</span><span class="p">;</span>
  <span class="n">clib_warning</span> <span class="p">(</span><span class="s">&quot;next_index not associated to an interface!&quot;</span><span class="p">);</span>
  <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">static_always_inline</span> <span class="kt">void</span>
<span class="nf">incr_decap_stats</span> <span class="p">(</span><span class="n">vnet_main_t</span> <span class="o">*</span> <span class="n">vnm</span><span class="p">,</span> <span class="n">u32</span> <span class="n">thread_index</span><span class="p">,</span> <span class="n">u32</span> <span class="n">length</span><span class="p">,</span>
		  <span class="n">u32</span> <span class="n">sw_if_index</span><span class="p">,</span> <span class="n">u32</span> <span class="o">*</span> <span class="n">last_sw_if_index</span><span class="p">,</span> <span class="n">u32</span> <span class="o">*</span> <span class="n">n_packets</span><span class="p">,</span>
		  <span class="n">u32</span> <span class="o">*</span> <span class="n">n_bytes</span><span class="p">)</span>
<span class="p">{</span>
  <span class="n">vnet_interface_main_t</span> <span class="o">*</span><span class="n">im</span><span class="p">;</span>

  <span class="k">if</span> <span class="p">(</span><span class="n">PREDICT_TRUE</span> <span class="p">(</span><span class="n">sw_if_index</span> <span class="o">==</span> <span class="o">*</span><span class="n">last_sw_if_index</span><span class="p">))</span>
    <span class="p">{</span>
      <span class="o">*</span><span class="n">n_packets</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
      <span class="o">*</span><span class="n">n_bytes</span> <span class="o">+=</span> <span class="n">length</span><span class="p">;</span>
    <span class="p">}</span>
  <span class="k">else</span>
    <span class="p">{</span>
      <span class="k">if</span> <span class="p">(</span><span class="n">PREDICT_TRUE</span> <span class="p">(</span><span class="o">*</span><span class="n">last_sw_if_index</span> <span class="o">!=</span> <span class="o">~</span><span class="mi">0</span><span class="p">))</span>
	<span class="p">{</span>
	  <span class="n">im</span> <span class="o">=</span> <span class="o">&amp;</span><span class="n">vnm</span><span class="o">-&gt;</span><span class="n">interface_main</span><span class="p">;</span>

	  <span class="n">vlib_increment_combined_counter</span> <span class="p">(</span><span class="n">im</span><span class="o">-&gt;</span><span class="n">combined_sw_if_counters</span> <span class="o">+</span>
					   <span class="n">VNET_INTERFACE_COUNTER_RX</span><span class="p">,</span>
					   <span class="n">thread_index</span><span class="p">,</span> <span class="o">*</span><span class="n">last_sw_if_index</span><span class="p">,</span>
					   <span class="o">*</span><span class="n">n_packets</span><span class="p">,</span> <span class="o">*</span><span class="n">n_bytes</span><span class="p">);</span>
	<span class="p">}</span>
      <span class="o">*</span><span class="n">last_sw_if_index</span> <span class="o">=</span> <span class="n">sw_if_index</span><span class="p">;</span>
      <span class="o">*</span><span class="n">n_packets</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
      <span class="o">*</span><span class="n">n_bytes</span> <span class="o">=</span> <span class="n">length</span><span class="p">;</span>
    <span class="p">}</span>
<span class="p">}</span>

<span class="cm">/**</span>
<span class="cm"> * @brief LISP-GPE decap dispatcher.</span>
<span class="cm"> * @node lisp_gpe_input_inline</span>
<span class="cm">