#!/usr/bin/env python3
import unittest
from framework import VppTestCase, VppTestRunner
from vpp_udp_encap import find_udp_encap, VppUdpEncap
from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable, VppMplsLabel, \
FibPathType
from scapy.packet import Raw
from scapy.layers.l2 import Ether
from scapy.layers.inet import IP, UDP
from scapy.layers.inet6 import IPv6
from scapy.contrib.mpls import MPLS
NUM_PKTS = 67
class TestUdpEncap(VppTestCase):
""" UDP Encap Test Case """
@classmethod
def setUpClass(cls):
super(TestUdpEncap, cls).setUpClass()
@classmethod
def tearDownClass(cls):
super(TestUdpEncap, cls).tearDownClass()
def setUp(self):
super(TestUdpEncap, self).setUp()
# create 2 pg interfaces
self.create_pg_interfaces(range(4))
# setup interfaces
# assign them different tables.
table_id = 0
self.tables = []
for i in self.pg_interfaces:
i.admin_up()
if table_id != 0:
tbl = VppIpTable(self, table_id)
tbl.add_vpp_config()
self.tables.append(tbl)
tbl = VppIpTable(self, table_id, is_ip6=1)
tbl.add_vpp_config()
self.tables.append(tbl)
i.set_table_ip4(table_id)
i.set_table_ip6(table_id)
i.config_ip4()
i.resolve_arp()
i.config_ip6()
i.resolve_ndp()
table_id += 1
def tearDown(self):
for i in self.pg_interfaces:
i.unconfig_ip4()
i.unconfig_ip6()
i.set_table_ip4(0)
i.set_table_ip6(0)
i.admin_down()
super(TestUdpEncap, self).tearDown()
def validate_outer4(self, rx, encap_obj):
self.assertEqual(rx[IP].src, encap_obj.src_ip_s)
self.assertEqual(rx[IP].dst, encap_obj.dst_ip_s)
self.assertEqual(rx[UDP].sport, encap_obj.src_port)
self.assertEqual(rx[UDP].dport, encap_obj.dst_port)
def validate_outer6(self, rx, encap_obj):
self.assertEqual(rx[IPv6].src, encap_obj.src_ip_s)
self.assertEqual(rx[IPv6].dst, encap_obj.dst_ip_s)
self.assertEqual(rx[UDP].sport, encap_obj.src_port)
self.assertEqual(rx[UDP].dport, encap_obj.dst_port)
def validate_inner4(self, rx, tx, ttl=None):
self.assertEqual(rx[IP].src, tx[IP].src)
self.assertEqual(rx[IP].dst, tx[IP].dst)
if ttl:
self.assertEqual(rx[IP].ttl, ttl)
else:
self.assertEqual(rx[IP].ttl, tx[IP].ttl)
def validate_inner6(self, rx, tx):
self.assertEqual(rx.src, tx[IPv6].src)
self.assertEqual(rx.dst, tx[IPv6].dst)
self.assertEqual(rx.hlim, tx[IPv6].hlim)
def test_udp_encap(self):
""" UDP Encap test
"""
#
# construct a UDP encap object through each of the peers
# v4 through the first two peers, v6 through the second.
#
udp_encap_0 = VppUdpEncap(self,
self.pg0.local_ip4,
self.pg0.remote_ip4,
330, 440)
udp_encap_1 = VppUdpEncap(self,
self.pg1.local_ip4,
self.pg1.remote_ip4,
331, 441,
table_id=1)
udp_encap_2 = VppUdpEncap(self,
self.pg2.local_ip6,
self.pg2.remote_ip6,
332, 442,
table_id=2)
udp_encap_3 = VppUdpEncap(self,
self.pg3.local_ip6,
self.pg3.remote_ip6,
333, 443,
@media only all and (prefers-color-scheme: dark) {
.highlight .hll { background-color: #49483e }
.highlight .c { color: #75715e } /* Comment */
.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
.highlight .k { color: #66d9ef } /* Keyword */
.highlight .l { color: #ae81ff } /* Literal */
.highlight .n { color: #f8f8f2 } /* Name */
.highlight .o { color: #f92672 } /* Operator */
.highlight .p { color: #f8f8f2 } /* Punctuation */
.highlight .ch { color: #75715e } /* Comment.Hashbang */
.highlight .cm { color: #75715e } /* Comment.Multiline */
.highlight .cp { color: #75715e } /* Comment.Preproc */
.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
.highlight .c1 { color: #75715e } /* Comment.Single */
.highlight .cs { color: #75715e } /* Comment.Special */
.highlight .gd { color: #f92672 } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gi { color: #a6e22e } /* Generic.Inserted */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #75715e } /* Generic.Subheading */
.highlight .kc { color: #66d9ef } /* Keyword.Constant */
.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
.highlight .kn { color: #f92672 } /* Keyword.Namespace */
.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
.highlight .kt { color: #66d9ef } /* Keyword.Type */
.highlight .ld { color: #e6db74 } /* Literal.Date */
.highlight .m { color: #ae81ff } /* Literal.Number */
.highlight .s { color: #e6db74 } /* Literal.String */
.highlight .na { color: #a6e22e } /* Name.Attribute */
.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
.highlight .nc { color: #a6e22e } /* Name.Class */
.highlight .no { color: #66d9ef } /* Name.Constant */
.highlight .nd { color: #a6e22e } /* Name.Decorator */
.highlight .ni { color: #f8f8f2 } /* Name.Entity */
.highlight .ne { color: #a6e22e } /* Name.Exception */
.highlight .nf { color: #a6e22e } /* Name.Function */
.highlight .nl { color: #f8f8f2 } /* Name.Label */
.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
.highlight .nx { color: #a6e22e } /* Name.Other */
.highlight .py { color: #f8f8f2 } /* Name.Property */
.highlight .nt { color: #f92672 } /* Name.Tag */
.highlight .nv { color: #f8f8f2 } /* Name.Variable */
.highlight .ow { color: #f92672 } /* Operator.Word */
.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
.highlight .sc { color: #e6db74 } /* Literal.String.Char */
.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
.highlight .se { color: #ae81ff } /* Literal.String.Escape */
.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
.highlight .sx { color: #e6db74 } /* Literal.String.Other */
.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
}
@media (prefers-color-scheme: light) {
.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 */
}
/*
* flowprobe.c - ipfix probe plugin
*
* Copyright (c) 2016 Cisco and/or its affiliates.
* 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.
*/
/**
* @file
* @brief Per-packet IPFIX flow record generator plugin
*
* This file implements vpp plugin registration mechanics,
* debug CLI, and binary API handling.
*/
#include <vnet/vnet.h>
#include <vpp/app/version.h>
#include <vnet/plugin/plugin.h>
#include <flowprobe/flowprobe.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#include <vlibsocket/api.h>
/* define message IDs */
#include <flowprobe/flowprobe_msg_enum.h>
/* define message structures */
#define vl_typedefs
#include <flowprobe/flowprobe_all_api_h.h>
#undef vl_typedefs
/* define generated endian-swappers */
#define vl_endianfun
#include <flowprobe/flowprobe_all_api_h.h>
#undef vl_endianfun
/* instantiate all the print functions we know about */
#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
#define vl_printfun
#include <flowprobe/flowprobe_all_api_h.h>
#undef vl_printfun
flowprobe_main_t flowprobe_main;
vlib_node_registration_t flowprobe_walker_node;
static vlib_node_registration_t flowprobe_timer_node;
uword flowprobe_walker_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
vlib_frame_t * f);
/* Get the API version number */
#define vl_api_version(n,v) static u32 api_version=(v);
#include <flowprobe/flowprobe_all_api_h.h>
#undef vl_api_version
#define REPLY_MSG_ID_BASE fm->msg_id_base
#include <vlibapi/api_helper_macros.h>
/* Define the per-interface configurable features */
/* *INDENT-OFF* */
VNET_FEATURE_INIT (flow_perpacket_ip4, static) =
{
.arc_name = "ip4-output",
.node_name = "flowprobe-ip4",
.runs_before = VNET_FEATURES ("interface-output"),
};
VNET_FEATURE_INIT (flow_perpacket_ip6, static) =
{
.arc_name = "ip6-output",
.node_name = "flowprobe-ip6",
.runs_before = VNET_FEATURES ("interface-output"),
};
VNET_FEATURE_INIT (flow_perpacket_l2, static) =
{
.arc_name = "interface-output",
.node_name = "flowprobe-l2",
.runs_before = VNET_FEATURES ("interface-tx"),
};
/* *INDENT-ON* */
/* Macro to finish up custom dump fns */
#define FINISH \
vec_add1 (s, 0); \
vl_print (handle, (char *)s); \
vec_free (s); \
return handle;
static inline ipfix_field_specifier_t *
flowprobe_template_ip4_fields (ipfix_field_specifier_t * f)
{
#define flowprobe_template_ip4_field_count() 4
/* sourceIpv4Address, TLV type 8, u32 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
sourceIPv4Address, 4);
f++;
/* destinationIPv4Address, TLV type 12, u32 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
destinationIPv4Address, 4);
f++;
/* protocolIdentifier, TLV type 4, u8 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
protocolIdentifier, 1);
f++;
/* octetDeltaCount, TLV type 1, u64 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
octetDeltaCount, 8);
f++;
return f;
}
static inline ipfix_field_specifier_t *
flowprobe_template_ip6_fields (ipfix_field_specifier_t * f)
{
#define flowprobe_template_ip6_field_count() 4
/* sourceIpv6Address, TLV type 27, 16 octets */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
sourceIPv6Address, 16);
f++;
/* destinationIPv6Address, TLV type 28, 16 octets */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
destinationIPv6Address, 16);
f++;
/* protocolIdentifier, TLV type 4, u8 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
protocolIdentifier, 1);
f++;
/* octetDeltaCount, TLV type 1, u64 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
octetDeltaCount, 8);
f++;
return f;
}
static inline ipfix_field_specifier_t *
flowprobe_template_l2_fields (ipfix_field_specifier_t * f)
{
#define flowprobe_template_l2_field_count() 3
/* sourceMacAddress, TLV type 56, u8[6] we hope */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
sourceMacAddress, 6);
f++;
/* destinationMacAddress, TLV type 80, u8[6] we hope */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
destinationMacAddress, 6);
f++;
/* ethernetType, TLV type 256, u16 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
ethernetType, 2);
f++;
return f;
}
static inline ipfix_field_specifier_t *
flowprobe_template_common_fields (ipfix_field_specifier_t * f)
{
#define flowprobe_template_common_field_count() 3
/* ingressInterface, TLV type 10, u32 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
ingressInterface, 4);
f++;
/* egressInterface, TLV type 14, u32 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
egressInterface, 4);
f++;
/* packetDeltaCount, TLV type 2, u64 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
packetDeltaCount, 8);
f++;
return f;
}
static inline ipfix_field_specifier_t *
flowprobe_template_l4_fields (ipfix_field_specifier_t * f)
{
#define flowprobe_template_l4_field_count() 2
/* sourceTransportPort, TLV type 7, u16 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
sourceTransportPort, 2);
f++;
/* destinationTransportPort, TLV type 11, u16 */
f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
destinationTransportPort, 2);
f++;
return f;
}
/**
* @brief Create an IPFIX template packet rewrite string
* @param frm flow_report_main_t *
* @param fr flow_report_t *
* @param collector_address ip4_address_t * the IPFIX collector address
* @param src_address ip4_address_t * the source address we should use
* @param collector_port u16 the collector port we should use, host byte order
* @returns u8 * vector containing the indicated IPFIX template packet
*/
static inline u8 *
flowprobe_template_rewrite_inline (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port,
flowprobe_variant_t which)
{
ip4_header_t *ip;
udp_header_t *udp;
ipfix_message_header_t *h;
ipfix_set_header_t *s;
ipfix_template_header_t *t;
ipfix_field_specifier_t *f;
ipfix_field_specifier_t *first_field;
u8 *rewrite = 0;
ip4_ipfix_template_packet_t *tp;
u32 field_count = 0;
flow_report_stream_t *stream;
flowprobe_main_t *fm = &flowprobe_main;
flowprobe_record_t flags = fr->opaque.as_uword;
bool collect_ip4 = false, collect_ip6 = false;
stream = &frm->streams[fr->stream_index];
if (flags & FLOW_RECORD_L3)
{
collect_ip4 = which == FLOW_VARIANT_L2_IP4 || which == FLOW_VARIANT_IP4;
collect_ip6 = which == FLOW_VARIANT_L2_IP6 || which == FLOW_VARIANT_IP6;
if (which == FLOW_VARIANT_L2_IP4)
flags |= FLOW_RECORD_L2_IP4;
if (which == FLOW_VARIANT_L2_IP6)
flags |= FLOW_RECORD_L2_IP6;
}
field_count += flowprobe_template_common_field_count ();
if (flags & FLOW_RECORD_L2)
field_count += flowprobe_template_l2_field_count ();
if (collect_ip4)
field_count += flowprobe_template_ip4_field_count ();
if (collect_ip6)
field_count += flowprobe_template_ip6_field_count ();
if (flags & FLOW_RECORD_L4)
field_count += flowprobe_template_l4_field_count ();
/* allocate rewrite space */
vec_validate_aligned
(rewrite, sizeof (ip4_ipfix_template_packet_t)
+ field_count * sizeof (ipfix_field_specifier_t) - 1,
CLIB_CACHE_LINE_BYTES);
tp = (ip4_ipfix_template_packet_t *) rewrite;
ip = (ip4_header_t *) & tp->ip4;
udp = (udp_header_t *) (ip + 1);
h = (ipfix_message_header_t *) (udp + 1);
s = (ipfix_set_header_t *) (h + 1);
t = (ipfix_template_header_t *) (s + 1);
first_field = f = (ipfix_field_specifier_t *) (t + 1);
ip->ip_version_and_header_length = 0x45;
ip->ttl = 254;
ip->protocol = IP_PROTOCOL_UDP;
ip->src_address.as_u32 = src_address->as_u32;
ip->dst_address.as_u32 = collector_address->as_u32;
udp->src_port = clib_host_to_net_u16 (stream->src_port);
udp->dst_port = clib_host_to_net_u16 (collector_port);
udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
/* FIXUP: message header export_time */
/* FIXUP: message header sequence_number */
h->domain_id = clib_host_to_net_u32 (stream->domain_id);
/* Add TLVs to the template */
f = flowprobe_template_common_fields (f);
if (flags & FLOW_RECORD_L2)
f = flowprobe_template_l2_fields (f);
if (collect_ip4)
f = flowprobe_template_ip4_fields (f);
if (collect_ip6)
f = flowprobe_template_ip6_fields (f);
if (flags & FLOW_RECORD_L4)
f = flowprobe_template_l4_fields (f);
/* Back to the template packet... */
ip = (ip4_header_t *) & tp->ip4;
udp = (udp_header_t *) (ip + 1);
ASSERT (f - first_field);
/* Field count in this template */
t->id_count = ipfix_id_count (fr->template_id, f - first_field);
fm->template_size[flags] = (u8 *) f - (u8 *) s;
/* set length in octets */
s->set_id_length =
ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
/* message length in octets */
h->version_length = version_length ((u8 *) f - (u8 *) h);
ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
ip->checksum = ip4_header_checksum (ip);
return rewrite;
}
static u8 *
flowprobe_template_rewrite_ip6 (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port)
{
return flowprobe_template_rewrite_inline
(frm, fr, collector_address, src_address, collector_port,
FLOW_VARIANT_IP6);
}
static u8 *
flowprobe_template_rewrite_ip4 (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port)
{
return flowprobe_template_rewrite_inline
(frm, fr, collector_address, src_address, collector_port,
FLOW_VARIANT_IP4);
}
static u8 *
flowprobe_template_rewrite_l2 (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port)
{
return flowprobe_template_rewrite_inline
(frm, fr, collector_address, src_address, collector_port,
FLOW_VARIANT_L2);
}
static u8 *
flowprobe_template_rewrite_l2_ip4 (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port)
{
return flowprobe_template_rewrite_inline
(frm, fr, collector_address, src_address, collector_port,
FLOW_VARIANT_L2_IP4);
}
static u8 *
flowprobe_template_rewrite_l2_ip6 (flow_report_main_t * frm,
flow_report_t * fr,
ip4_address_t * collector_address,
ip4_address_t * src_address,
u16 collector_port)
{
return flowprobe_template_rewrite_inline
(frm, fr, collector_address, src_address, collector_port,
FLOW_VARIANT_L2_IP6);
}
/**
* @brief Flush accumulated data
* @param frm flow_report_main_t *
* @param fr flow_report_t *
* @param f vlib_frame_t *
*
* <em>Notes:</em>
* This function must simply return the incoming frame, or no template packets
* will be sent.
*/
vlib_frame_t *
flowprobe_data_callback_ip4 (flow_report_main_t * frm,
flow_report_t * fr,
vlib_frame_t * f, u32 * to_next, u32 node_index)
{
flowprobe_flush_callback_ip4 ();
return f;
}
vlib_frame_t *
flowprobe_data_callback_ip6 (flow_report_main_t * frm,
flow_report_t * fr,
vlib_frame_t * f, u32 * to_next, u32 node_index)
{
flowprobe_flush_callback_ip6 ();
return f;
}
vlib_frame_t *
flowprobe_data_callback_l2 (flow_report_main_t * frm,
flow_report_t * fr,
vlib_frame_t * f, u32 * to_next, u32 node_index)
{
flowprobe_flush_callback_l2 ();
return f;
}
static int
flowprobe_template_add_del (u32 domain_id, u16 src_port,
flowprobe_record_t flags,
vnet_flow_data_callback_t * flow_data_callback,
vnet_flow_rewrite_callback_t * rewrite_callback,
bool is_add, u16 * template_id)
{
flow_report_main_t *frm = &flow_report_main;
vnet_flow_report_add_del_args_t a = {
.rewrite_callback = rewrite_callback,
.flow_data_callback = flow_data_callback,
.is_add = is_add,
.domain_id = domain_id,
.src_port = src_port,
.opaque.as_uword = flags,
};
return vnet_flow_report_add_del (frm, &a, template_id);
}
static void
flowprobe_expired_timer_callback (u32 * expired_timers)
{
vlib_main_t *vm = vlib_get_main ();
flowprobe_main_t *fm = &flowprobe_main;
u32 my_cpu_number = vm->thread_index;
int i;
u32 poolindex;
for (i = 0; i < vec_len (expired_timers); i++)
{
poolindex = expired_timers[i] & 0x7FFFFFFF;
vec_add1 (fm->expired_passive_per_worker[my_cpu_number], poolindex);
}
}
static clib_error_t *
flowprobe_create_state_tables (u32 active_timer)
{
flowprobe_main_t *fm = &flowprobe_main;
vlib_thread_main_t *tm = &vlib_thread_main;
vlib_main_t *vm = vlib_get_main ();
clib_error_t *error = 0;
u32 num_threads;
int i;
/* Decide how many worker threads we have */
num_threads = 1 /* main thread */ + tm->n_threads;
/* Hash table per worker */
fm->ht_log2len = FLOWPROBE_LOG2_HASHSIZE;
/* Init per worker flow state and timer wheels */
if (active_timer)
{
vec_validate (fm->timers_per_worker, num_threads - 1);
vec_validate (fm->expired_passive_per_worker, num_threads - 1);
vec_validate (fm->hash_per_worker, num_threads - 1);
vec_validate (fm->pool_per_worker, num_threads - 1);
for (i = 0; i < num_threads; i++)
{
int j;
pool_alloc (fm->pool_per_worker[i], 1 << fm->ht_log2len);
vec_resize (fm->hash_per_worker[i], 1 << fm->ht_log2len);
for (j = 0; j < (1 << fm->ht_log2len); j++)
fm->hash_per_worker[i][j] = ~0;
fm->timers_per_worker[i] =
clib_mem_alloc (sizeof (TWT (tw_timer_wheel)));
tw_timer_wheel_init_2t_1w_2048sl (fm->timers_per_worker[i],
flowprobe_expired_timer_callback,
1.0, 1024);
}
fm->disabled = true;
}
else
{
f64 now = vlib_time_now (vm);
vec_validate (fm->stateless_entry, num_threads - 1);
for (i = 0; i < num_threads; i++)
fm->stateless_entry[i].last_exported = now;
fm->disabled = false;
}
fm->initialized = true;
return error;
}
static int
validate_feature_on_interface (flowprobe_main_t * fm, u32 sw_if_index,
u8 which)
{
vec_validate_init_empty (fm->flow_per_interface, sw_if_index, ~0);
if (fm->flow_per_interface[sw_if_index] == (u8) ~ 0)
return -1;
else if (fm->flow_per_interface[sw_if_index] != which)
return 0;
else
return 1;
}
/**
* @brief configure / deconfigure the IPFIX flow-per-packet
* @param fm flowprobe_main_t * fm
* @param sw_if_index u32 the desired interface
* @param is_add int 1 to enable the feature, 0 to disable it
* @returns 0 if successful, non-zero otherwise
*/
static int
flowprobe_tx_interface_add_del_feature (flowprobe_main_t * fm,
u32 sw_if_index, u8 which, int is_add)
{
vlib_main_t *vm = vlib_get_main ();
int rv = 0;
u16 template_id = 0;
flowprobe_record_t flags = fm->record;
fm->flow_per_interface[sw_if_index] = (is_add) ? which : (u8) ~ 0;
fm->template_per_flow[which] += (is_add) ? 1 : -1;
if (is_add && fm->template_per_flow[which] > 1)
template_id = fm->template_reports[flags];
if ((is_add && fm->template_per_flow[which] == 1) ||
(!is_add && fm->template_per_flow[which] == 0))
{
if (which == FLOW_VARIANT_L2)
{
if (fm->record & FLOW_RECORD_L2)
{
rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
flowprobe_data_callback_l2,
flowprobe_template_rewrite_l2,
is_add, &template_id);
}
if (fm->record & FLOW_RECORD_L3 || fm->record & FLOW_RECORD_L4)
{
rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
flowprobe_data_callback_l2,
flowprobe_template_rewrite_l2_ip4,
is_add, &template_id);
fm->template_reports[flags | FLOW_RECORD_L2_IP4] =
(is_add) ? template_id : 0;
rv =
flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
flowprobe_data_callback_l2,
flowprobe_template_rewrite_l2_ip6,
is_add, &template_id);
fm->template_reports[flags | FLOW_RECORD_L2_IP6] =
(is_add) ? template_id : 0;
/* Special case L2 */
fm->context[FLOW_VARIANT_L2_IP4].flags =
flags | FLOW_RECORD_L2_IP4;
fm->context[FLOW_VARIANT_L2_IP6].flags =
flags | FLOW_RECORD_L2_IP6;
fm->template_reports[flags] = template_id;
}
}
else if (which == FLOW_VARIANT_IP4)
rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
flowprobe_data_callback_ip4,
flowprobe_template_rewrite_ip4,
is_add, &template_id);
else if (which == FLOW_VARIANT_IP6)
rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
flowprobe_data_callback_ip6,
flowprobe_template_rewrite_ip6,
is_add, &template_id);
}
if (rv && rv != VNET_API_ERROR_VALUE_EXIST)
{
clib_warning ("vnet_flow_report_add_del returned %d", rv);
return -1;
}
if (which != (u8) ~ 0)
{
fm->context[which].flags = fm->record;
fm->template_reports[flags] = (is_add) ? template_id : 0;
}
if (which == FLOW_VARIANT_IP4)
vnet_feature_enable_disable ("ip4-output", "flowprobe-ip4",
sw_if_index, is_add, 0, 0);
else if (which == FLOW_VARIANT_IP6)
vnet_feature_enable_disable ("ip6-output", "flowprobe-ip6",
sw_if_index, is_add, 0, 0);
else if (which == FLOW_VARIANT_L2)
vnet_feature_enable_disable ("interface-output", "flowprobe-l2",
sw_if_index, is_add, 0, 0);
/* Stateful flow collection */
if (is_add && !fm->initialized)
{
flowprobe_create_state_tables (fm->active_timer);
if (fm->active_timer)
vlib_process_signal_event (vm, flowprobe_timer_node.index, 1, 0);
}
return 0;
}
/**
* @brief API message handler
* @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
*/
void vl_api_flowprobe_tx_interface_add_del_t_handler
(vl_api_flowprobe_tx_interface_add_del_t * mp)
{
flowprobe_main_t *fm = &flowprobe_main;
vl_api_flowprobe_tx_interface_add_del_reply_t *rmp;
u32 sw_if_index = ntohl (mp->sw_if_index);
int rv = 0;
VALIDATE_SW_IF_INDEX (mp);
if (mp->which != FLOW_VARIANT_IP4 && mp->which != FLOW_VARIANT_L2
&& mp->which != FLOW_VARIANT_IP6)
{
rv = VNET_API_ERROR_UNIMPLEMENTED;
goto out;
}
if (fm->record == 0)
{
clib_warning ("Please specify flowprobe params record first...");
rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
goto out;
}
rv = validate_feature_on_interface (fm, sw_if_index, mp->which);
if ((rv == 1 && mp->is_add == 1) || rv == 0)
{
rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
goto out;
}
rv = flowprobe_tx_interface_add_del_feature
(fm, sw_if_index, mp->which, mp->is_add);
out:
BAD_SW_IF_INDEX_LABEL;
REPLY_MACRO (VL_API_FLOWPROBE_TX_INTERFACE_ADD_DEL_REPLY);
}
/**
* @brief API message custom-dump function
* @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
* @param handle void * print function handle
* @returns u8 * output string
*/
static void *vl_api_flowprobe_tx_interface_add_del_t_print
(vl_api_flowprobe_tx_interface_add_del_t * mp, void *handle)
{
u8 *s;
s = format (0, "SCRIPT: flowprobe_tx_interface_add_del ");
s = format (s, "sw_if_index %d is_add %d which %d ",
clib_host_to_net_u32 (mp->sw_if_index),
(int) mp->is_add, (int) mp->which);
FINISH;
}
#define vec_neg_search(v,E) \
({ \
word _v(i) = 0; \
while (_v(i) < vec_len(v) && v[_v(i)] == E) \
{ \
_v(i)++; \
} \
if (_v(i) == vec_len(v)) \
_v(i) = ~0; \
_v(i); \
})
static int
flowprobe_params (flowprobe_main_t * fm, u8 record_l2,
u8 record_l3, u8 record_l4,
u32 active_timer, u32 passive_timer)
{
flowprobe_record_t flags = 0;
if (vec_neg_search (fm->flow_per_interface, (u8) ~ 0) != ~0)
return ~0;
if (record_l2)
flags |= FLOW_RECORD_L2;
if (record_l3)
flags |= FLOW_RECORD_L3;
if (record_l4)
flags |= FLOW_RECORD_L4;
fm->record = flags;
/*
* Timers: ~0 is default, 0 is off
*/
fm->active_timer =
(active_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_ACTIVE : active_timer);
fm->passive_timer =
(passive_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_PASSIVE : passive_timer);
return 0;
}
void
vl_api_flowprobe_params_t_handler (vl_api_flowprobe_params_t * mp)
{
flowprobe_main_t *fm = &flowprobe_main;
vl_api_flowprobe_params_reply_t *rmp;
int rv = 0;
rv = flowprobe_params
(fm, mp->record_l2, mp->record_l3, mp->record_l4,
clib_net_to_host_u32 (mp->active_timer),
clib_net_to_host_u32 (mp->passive_timer));
REPLY_MACRO (VL_API_FLOWPROBE_PARAMS_REPLY);
}
/* List of message types that this plugin understands */
#define foreach_flowprobe_plugin_api_msg \
_(FLOWPROBE_TX_INTERFACE_ADD_DEL, flowprobe_tx_interface_add_del) \
_(FLOWPROBE_PARAMS, flowprobe_params)
/* *INDENT-OFF* */
VLIB_PLUGIN_REGISTER () = {
.version = VPP_BUILD_VER,
.description = "Flow per Packet",
};
/* *INDENT-ON* */
u8 *
format_flowprobe_entry (u8 * s, va_list * args)
{
flowprobe_entry_t *e = va_arg (*args, flowprobe_entry_t *);
s = format (s, " %d/%d", e->key.rx_sw_if_index, e->key.tx_sw_if_index);
s = format (s, " %U %U", format_ethernet_address, &e->key.src_mac,
format_ethernet_address, &e->key.dst_mac);
s = format (s, " %U -> %U",
format_ip46_address, &e->key.src_address, IP46_TYPE_ANY,
format_ip46_address, &e->key.dst_address, IP46_TYPE_ANY);
s = format (s, " %d", e->key.protocol);
s = format (s, " %d %d\n", clib_net_to_host_u16 (e->key.src_port),
clib_net_to_host_u16 (e->key.dst_port));
return s;
}
static clib_error_t *
flowprobe_show_table_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cm)
{
flowprobe_main_t *fm = &flowprobe_main;
int i;
flowprobe_entry_t *e;
vlib_cli_output (vm, "Dumping IPFIX table");
for (i = 0; i < vec_len (fm->pool_per_worker); i++)
{
/* *INDENT-OFF* */
pool_foreach (e, fm->pool_per_worker[i], (
{
vlib_cli_output (vm, "%U",
format_flowprobe_entry,
e);
}));
/* *INDENT-ON* */
}
return 0;
}
static clib_error_t *
flowprobe_show_stats_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cm)
{
flowprobe_main_t *fm = &flowprobe_main;
int i;
vlib_cli_output (vm, "IPFIX table statistics");
vlib_cli_output (vm, "Flow entry size: %d\n", sizeof (flowprobe_entry_t));
vlib_cli_output (vm, "Flow pool size per thread: %d\n",
0x1 << FLOWPROBE_LOG2_HASHSIZE);
for (i = 0; i < vec_len (fm->pool_per_worker); i++)
vlib_cli_output (vm, "Pool utilisation thread %d is %d%%\n", i,
(100 * pool_elts (fm->pool_per_worker[i])) /
(0x1 << FLOWPROBE_LOG2_HASHSIZE));
return 0;
}
static clib_error_t *
flowprobe_tx_interface_add_del_feature_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
flowprobe_main_t *fm = &flowprobe_main;
u32 sw_if_index = ~0;
int is_add = 1;
u8 which = FLOW_VARIANT_IP4;
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "disable"))
is_add = 0;
else if (unformat (input, "%U", unformat_vnet_sw_interface,
fm->vnet_main, &sw_if_index));
else if (unformat (input, "ip4"))
which = FLOW_VARIANT_IP4;
else if (unformat (input, "ip6"))
which = FLOW_VARIANT_IP6;
else if (unformat (input, "l2"))
which = FLOW_VARIANT_L2;
else
break;
}
if (fm->record == 0)
return clib_error_return (0,
"Please specify flowprobe params record first...");
if (sw_if_index == ~0)
return clib_error_return (0, "Please specify an interface...");
rv = validate_feature_on_interface (fm, sw_if_index, which);
if (rv == 1)
{
if (is_add)
return clib_error_return (0,
"Datapath is already enabled for given interface...");
}
else if (rv == 0)
return clib_error_return (0,
"Interface has enable different datapath ...");
rv =
flowprobe_tx_interface_add_del_feature (fm, sw_if_index, which, is_add);
switch (rv)
{
case 0:
break;
case VNET_API_ERROR_INVALID_SW_IF_INDEX:
return clib_error_return
(0, "Invalid interface, only works on physical ports");
break;
case VNET_API_ERROR_UNIMPLEMENTED:
return clib_error_return (0, "ip6 not supported");
break;
default:
return clib_error_return (0, "flowprobe_enable_disable returned %d",
rv);
}
return 0;
}
static clib_error_t *
flowprobe_params_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
flowprobe_main_t *fm = &flowprobe_main;
bool record_l2 = false, record_l3 = false, record_l4 = false;
u32 active_timer = ~0;
u32 passive_timer = ~0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "active %d", &active_timer))
;
else if (unformat (input, "passive %d", &passive_timer))
;
else if (unformat (input, "record"))
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "l2"))
record_l2 = true;
else if (unformat (input, "l3"))
record_l3 = true;
else if (unformat (input, "l4"))
record_l4 = true;
else
break;
}
else
break;
}
if (passive_timer > 0 && active_timer > passive_timer)
return clib_error_return (0,
"Passive timer has to be greater than active one...");
if (flowprobe_params (fm, record_l2, record_l3, record_l4,
active_timer, passive_timer))
return clib_error_return (0,
"Couldn't change flowperpacket params when feature is enabled on some interface ...");
return 0;
}
/*?
* '<em>flowprobe feature add-del</em>' commands to enable/disable
* per-packet IPFIX flow record generation on an interface
*
* @cliexpar
* @parblock
* To enable per-packet IPFIX flow-record generation on an interface:
* @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0}
*
* To disable per-packet IPFIX flow-record generation on an interface:
* @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0 disable}
* @cliexend
* @endparblock
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (flowprobe_enable_disable_command, static) = {
.path = "flowprobe feature add-del",
.short_help =
"flowprobe feature add-del <interface-name> <l2|ip4|ip6> disable",
.function = flowprobe_tx_interface_add_del_feature_command_fn,
};
VLIB_CLI_COMMAND (flowprobe_params_command, static) = {
.path = "flowprobe params",
.short_help =
"flowprobe params record <[l2] [l3] [l4]> [active <timer> passive <timer>]",
.function = flowprobe_params_command_fn,
};
VLIB_CLI_COMMAND (flowprobe_show_table_command, static) = {
.path = "show flowprobe table",
.short_help = "show flowprobe table",
.function = flowprobe_show_table_fn,
};
VLIB_CLI_COMMAND (flowprobe_show_stats_command, static) = {
.path = "show flowprobe statistics",
.short_help = "show flowprobe statistics",
.function = flowprobe_show_stats_fn,
};
/* *INDENT-ON* */
/**
* @brief Set up the API message handling tables
* @param vm vlib_main_t * vlib main data structure pointer
* @returns 0 to indicate all is well
*/
static clib_error_t *
flowprobe_plugin_api_hookup (vlib_main_t * vm)
{
flowprobe_main_t *fm = &flowprobe_main;
#define _(N,n) \
vl_msg_api_set_handlers((VL_API_##N + fm->msg_id_base), \
#n, \
vl_api_##n##_t_handler, \
vl_noop_handler, \
vl_api_##n##_t_endian, \
vl_api_##n##_t_print, \
sizeof(vl_api_##n##_t), 1);
foreach_flowprobe_plugin_api_msg;
#undef _
return 0;
}
#define vl_msg_name_crc_list
#include <flowprobe/flowprobe_all_api_h.h>
#undef vl_msg_name_crc_list
static void
setup_message_id_table (flowprobe_main_t * fm, api_main_t * am)
{
#define _(id,n,crc) \
vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + fm->msg_id_base);
foreach_vl_msg_name_crc_flowprobe;
#undef _
}
/*
* Main-core process, sending an interrupt to the per worker input
* process that spins the per worker timer wheel.
*/
static uword
timer_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
{
uword *event_data = 0;
vlib_main_t **worker_vms = 0, *worker_vm;
flowprobe_main_t *fm = &flowprobe_main;
/* Wait for Godot... */
vlib_process_wait_for_event_or_clock (vm, 1e9);
uword event_type = vlib_process_get_events (vm, &event_data);
if (event_type != 1)
clib_warning ("bogus kickoff event received, %d", event_type);
vec_reset_length (event_data);
int i;
if (vec_len (vlib_mains) == 0)
vec_add1 (worker_vms, vm);
else
{
for (i = 0; i < vec_len (vlib_mains); i++)
{
worker_vm = vlib_mains[i];
if (worker_vm)
vec_add1 (worker_vms, worker_vm);
}
}
f64 sleep_duration = 0.1;
while (1)
{
/* Send an interrupt to each timer input node */
sleep_duration = 0.1;
for (i = 0; i < vec_len (worker_vms); i++)
{
worker_vm = worker_vms[i];
if (worker_vm)
{
vlib_node_set_interrupt_pending (worker_vm,
flowprobe_walker_node.index);
sleep_duration =
(fm->expired_passive_per_worker[i] > 0) ? 1e-4 : 0.1;
}
}
vlib_process_suspend (vm, sleep_duration);
}
return 0; /* or not */
}
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (flowprobe_timer_node,static) = {
.function = timer_process,
.name = "flowprobe-timer-process",
.type = VLIB_NODE_TYPE_PROCESS,
};
/* *INDENT-ON* */
/**
* @brief Set up the API message handling tables
* @param vm vlib_main_t * vlib main data structure pointer
* @returns 0 to indicate all is well, or a clib_error_t
*/
static clib_error_t *
flowprobe_init (vlib_main_t * vm)
{
flowprobe_main_t *fm = &flowprobe_main;
vlib_thread_main_t *tm = &vlib_thread_main;
clib_error_t *error = 0;
u8 *name;
u32 num_threads;
int i;
fm->vnet_main = vnet_get_main ();
/* Construct the API name */
name = format (0, "flowprobe_%08x%c", api_version, 0);
/* Ask for a correctly-sized block of API message decode slots */
fm->msg_id_base = vl_msg_api_get_msg_ids
((char *) name, VL_MSG_FIRST_AVAILABLE);
/* Hook up message handlers */
error = flowprobe_plugin_api_hookup (vm);
/* Add our API messages to the global name_crc hash table */
setup_message_id_table (fm, &api_main);
vec_free (name);
/* Set up time reference pair */
fm->vlib_time_0 = vlib_time_now (vm);
fm->nanosecond_time_0 = unix_time_now_nsec ();
memset (fm->template_reports, 0, sizeof (fm->template_reports));
memset (fm->template_size, 0, sizeof (fm->template_size));
memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
/* Decide how many worker threads we have */
num_threads = 1 /* main thread */ + tm->n_threads;
/* Allocate per worker thread vectors per flavour */
for (i = 0; i < FLOW_N_VARIANTS; i++)
{
vec_validate (fm->context[i].buffers_per_worker, num_threads - 1);
vec_validate (fm->context[i].frames_per_worker, num_threads - 1);
vec_validate (fm->context[i].next_record_offset_per_worker,
num_threads - 1);
}
fm->active_timer = FLOWPROBE_TIMER_ACTIVE;
fm->passive_timer = FLOWPROBE_TIMER_PASSIVE;
return error;
}
VLIB_INIT_FUNCTION (flowprobe_init);
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
