9 #include <netinet/in.h>
10 #include <netinet/ip6.h>
11 #include <netinet/icmp6.h>
28 #include "pkt/pkt_types.h"
36 #define PKT_TRACE(obj, arg) \
38 std::ostringstream _str; \
40 Pkt##obj::TraceMsg(PacketTraceBuf, __FILE__, __LINE__, _str.str()); \
47 inline bool IsBfdkeepalivePkt(
const AgentHdr &hdr)
50 if ((hdr.
cmd == AGENT_TRAP_BFD) && (hdr.
cmd_param == 0xc0)) {
59 stats_(), agent_(agent), pkt_module_(pkt_module),
60 work_queue_(
TaskScheduler::GetInstance()->GetTaskId(
"Agent::PktHandler"), 0,
62 work_queue_bfd_ka_(
TaskScheduler::GetInstance()->GetTaskId(
"Agent::BFD_KA"), 0,
123 const VlanNH *vlan_nh =
static_cast<const VlanNH *
>(nh);
148 uint16_t sport = pkt->
sport;
158 if (pkt->
ip_proto == IPPROTO_ICMPV6) {
159 protocol = IPPROTO_ICMP;
210 (uint16_t *)&pkt->
sport,
211 (uint16_t *) &pkt->
dport,
223 pkt_info->
ip_proto == IPPROTO_UDP &&
236 pkt_info->
ip_proto == IPPROTO_ICMP) {
253 int len = 0, ret = 0;
271 if (pkt_info->
ip_proto == IPPROTO_UDP &&
273 (pkt_info->
data[0] & 0x20)) {
337 if (is_flow_packet) {
343 PKT_TRACE(Err,
"Flow trap for non-IP packet for interface "
344 "index <" << hdr.
ifindex <<
">");
415 boost::shared_ptr<PacketBufferEnqueueItem>
420 if (IsBfdkeepalivePkt(hdr)) {
431 boost::shared_ptr<PktInfo> pkt_info (
new PktInfo(buff));
432 uint8_t *pkt = buff->data();
446 uint8_t *pkt = buff->data();
455 PKT_TRACE(Err,
"BFD proto_list is not Initialized. Ignoring");
459 boost::shared_ptr<PktInfo> pkt_info (
new PktInfo(buff));
462 pkt_info->is_bfd_keepalive =
true;
463 pkt_info->packet_buffer()->set_module(mod);
474 boost::shared_ptr<PktInfo> pkt_info,
476 pkt_info->packet_buffer()->set_module(mod);
507 pkt_info->
dmac == intf->
mac()) {
518 struct ip *ip_hdr = (
struct ip *)pkt;
531 pkt_info->
eth = (
struct ether_header *) (pkt + len);
535 len +=
sizeof(
struct ether_header);
538 while (pkt_info->
ether_type == ETHERTYPE_VLAN ||
540 pkt_info->
ether_type = ntohs(*((uint16_t *)(pkt + len + 2)));
546 pkt_info->
pbb_header = (uint32_t *)(pkt + len);
559 uint16_t ip_payload_len = 0;
561 struct ip *ip = (
struct ip *)(pkt + len);
567 pkt_info->
ttl = ip->ip_ttl;
568 uint8_t ip_header_len = (ip->ip_hl << 2);
569 ip_payload_len = ip->ip_len - ip_header_len;
570 len += ip_header_len;
571 }
else if (pkt_info->
ether_type == ETHERTYPE_IPV6) {
573 ip6_hdr *ip = (ip6_hdr *)(pkt + len);
576 Ip6Address::bytes_type addr;
578 for (
int i = 0; i < 16; i++) {
579 addr[i] = ip->ip6_src.s6_addr[i];
583 for (
int i = 0; i < 16; i++) {
584 addr[i] = ip->ip6_dst.s6_addr[i];
587 pkt_info->
ttl = ip->ip6_hlim;
589 uint8_t proto = ip->ip6_ctlun.ip6_un1.ip6_un1_nxt;
590 len +=
sizeof(ip6_hdr);
591 if (proto == IPPROTO_FRAGMENT) {
592 ip6_frag *nxt = (ip6_frag *)(pkt + len);
593 proto = nxt->ip6f_nxt;
594 len +=
sizeof(ip6_frag);
607 pkt_info->
transp.
udp = (udphdr *) (pkt + len);
608 len +=
sizeof(udphdr);
609 pkt_info->
data = (pkt + len);
618 pkt_info->
transp.
tcp = (tcphdr *) (pkt + len);
619 len +=
sizeof(tcphdr);
620 pkt_info->
data = (pkt + len);
629 case IPPROTO_SCTP : {
632 pkt_info->
data = (pkt + len);
640 pkt_info->
transp.
icmp = (
struct icmp *) (pkt + len);
643 struct icmp *icmp = (
struct icmp *)(pkt + len);
645 pkt_info->
dport = htons(icmp->icmp_type);
646 if (icmp->icmp_type == ICMP_ECHO || icmp->icmp_type == ICMP_ECHOREPLY) {
647 pkt_info->
dport = ICMP_ECHOREPLY;
648 pkt_info->
sport = htons(icmp->icmp_id);
649 pkt_info->
data = (pkt + len + ICMP_MINLEN);
650 uint16_t icmp_payload_len = ip_payload_len - ICMP_MINLEN;
653 string value(ad->
data_, (
sizeof(ad->
data_) - 1));
654 if (value.compare(0, (
sizeof(ad->
data_) - 1),
660 ((icmp->icmp_type == ICMP_DEST_UNREACH) ||
661 (icmp->icmp_type == ICMP_TIME_EXCEEDED))) {
665 if(
ParseIpPacket(pkt_info, pkt_type, pkt + len +
sizeof(icmp)) == -1) {
672 if (pkt_info->
ip_proto != IPPROTO_ICMP) {
673 uint16_t port = pkt_info->
sport;
675 pkt_info->
dport = port;
683 case IPPROTO_ICMPV6: {
685 icmp6_hdr *icmp = (icmp6_hdr *)(pkt + len);
688 pkt_info->
dport = htons(icmp->icmp6_type);
689 if (icmp->icmp6_type == ICMP6_ECHO_REQUEST ||
690 icmp->icmp6_type == ICMP6_ECHO_REPLY) {
691 pkt_info->
dport = ICMP6_ECHO_REPLY;
692 pkt_info->
sport = htons(icmp->icmp6_id);
694 icmp->icmp6_type < ICMP6_ECHO_REQUEST) {
698 if(
ParseIpPacket(pkt_info, pkt_type, pkt + len +
sizeof(icmp)) == -1) {
705 if (pkt_info->
ip_proto != IPPROTO_ICMPV6) {
706 uint16_t port = pkt_info->
sport;
708 pkt_info->
dport = port;
717 pkt_info->
transp.
igmp = (
struct igmp *) (pkt + len);
722 pkt_info->
data = (pkt + len);
742 uint32_t *control_word = (uint32_t *)(pkt);
746 sizeof(udphdr) +
sizeof(ip);
748 }
else if (pkt_info->
l3_label ==
false) {
749 bool layer2_control_word =
false;
753 layer2_control_word =
true;
759 layer2_control_word =
true;
762 const VrfNH *vrf_nh =
765 layer2_control_word =
true;
769 uint32_t *control_word = (uint32_t *)(pkt);
783 uint32_t mpls_host = ntohl(hdr->
hdr);
784 pkt_info->
tunnel.
label = (mpls_host & 0xFFFFF000) >> 12;
785 uint32_t ret =
sizeof(
MplsHdr);
787 if ((mpls_host & 0x100) == 0) {
789 if (((mpls_host & 0xFFFFF000) >> 12) !=
792 PKT_TRACE(Err,
"Unexpected MPLS Label Stack. Ignoring");
796 mpls_host = ntohl(hdr->
hdr);
797 pkt_info->
tunnel.
label = (mpls_host & 0xFFFFF000) >> 12;
798 if ((mpls_host & 0x100) == 0) {
800 PKT_TRACE(Err,
"Unexpected MPLS Label Stack. Ignoring");
813 PKT_TRACE(Err,
"Invalid MPLS Label <" << label <<
">. Ignoring");
830 if (vrf_nh && vrf_nh->
bridge_nh() ==
true) {
841 if (gre->
protocol != ntohs(VR_GRE_PROTO_MPLS)) {
885 int len =
sizeof(vxlan);
907 if (((pkt_info->
ip_proto == IPPROTO_ICMP) ||
908 (pkt_info->
ip_proto == IPPROTO_IGMP)) && (!pkt_info->
ip)) {
914 if ((pkt_info->
ip_proto == IPPROTO_ICMPV6) && (!pkt_info->
ip6)) {
922 int len = 0, ret = 0;
930 pkt_info->
arp = (ether_arp *) (pkt + len);
933 uint8_t data[
sizeof(in_addr_t)];
936 memcpy(bytes.data, pkt_info->
arp->arp_spa,
sizeof(in_addr_t));
937 in_addr_t spa = ntohl(bytes.addr);
945 pkt_info->
data = (pkt + len);
975 }
else if (!pkt_ok) {
1018 if (tunnel_len < 0) {
1025 if (tunnel_len == 0) {
1032 if (((pkt + len)[0] & 0x60) == 0x60) {
1057 boost::shared_ptr<PktInfo> pkt_info(
new PktInfo(mod, msg));
1059 PKT_TRACE(Err,
"Threshold exceeded while enqueuing IPC Message <" <<
1067 uint16_t offset = htons(pkt_info->
ip->ip_off);
1068 if (((offset & IP_MF) || (offset & IP_OFFMASK)) &&
1071 }
else if (pkt_info->
ip6) {
1072 uint8_t proto = pkt_info->
ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
1073 if (proto == IPPROTO_FRAGMENT) {
1103 if (
agent()->tsn_enabled() ==
false)
1106 if (ip.is_v4() ==
false)
1128 ComponentNHList::const_iterator it = nh->
begin();
1129 while (it != nh->
end()) {
1132 if (tor_nh == NULL) {
1143 ComponentNHList::const_iterator tor_it = tor_nh->
begin();
1144 while (tor_it != tor_nh->
end()) {
1147 if (tun_nh == NULL) {
1151 if (*tun_nh->
GetDip() == ip4) {
1183 memcpy(addr.ether_addr_octet, pkt_info->
eth->ether_shost, ETH_ALEN);
1191 if(bridge_table == NULL) {
1197 if (vm_intf == NULL) {
1213 pkt_info->
arp = (ether_arp *) pkt;
1221 pkt_info->
data = pkt;
1272 else if (dst_ip.is_v4() && vm_intf->
primary_ip_addr().is_unspecified())
1277 const std::vector<VnIpam> &ipam = vn->
GetVnIpam();
1278 for (
unsigned int i = 0; i < ipam.size(); ++i) {
1279 if (dst_ip.is_v4()) {
1280 if (!ipam[i].IsV4()) {
1283 if (ipam[i].default_gw == dst_ip ||
1284 ipam[i].dns_server == dst_ip) {
1288 if (!ipam[i].IsV6()) {
1291 if (ipam[i].default_gw == dst_ip ||
1292 ipam[i].dns_server == dst_ip) {
1306 PKT_TRACE(Err,
"Invalid interface index <" << ifindex <<
">");
1334 q_threshold_exceeded[mod]++;
1341 pkt(buff->data()), len(buff->data_len()), max_pkt_len(buff->buffer_len()),
1343 ether_type(-1), ip_saddr(), ip_daddr(), ip_proto(), sport(), dport(),
1344 ttl(0), icmp_chksum(0), tcp_ack(false), tunnel(),
1345 l3_label(false), is_bfd_keepalive(false), is_segment_hc_pkt(false),
1346 ignore_address(
VmInterface::IGNORE_NONE), same_port_number(false),
1347 is_fat_flow_src_prefix(false), ip_ff_src_prefix(),
1348 is_fat_flow_dst_prefix(false), ip_ff_dst_prefix(),
1349 eth(), arp(), ip(), ip6(), packet_buffer_(buff) {
1354 pkt(buff->data()), len(buff->data_len()), max_pkt_len(buff->buffer_len()),
1356 agent_hdr(hdr), ether_type(-1), ip_saddr(), ip_daddr(), ip_proto(), sport(),
1357 dport(), ttl(0), icmp_chksum(0), tcp_ack(false), tunnel(),
1358 l3_label(false), is_bfd_keepalive(false), is_segment_hc_pkt(false),
1359 ignore_address(
VmInterface::IGNORE_NONE), same_port_number(false),
1360 is_fat_flow_src_prefix(false), ip_ff_src_prefix(),
1361 is_fat_flow_dst_prefix(false), ip_ff_dst_prefix(),
1362 eth(), arp(), ip(), ip6(), packet_buffer_(buff) {
1369 len(), max_pkt_len(), data(), ipc(), family(
Address::UNSPEC),
1371 ip_proto(), sport(), dport(), ttl(0), icmp_chksum(0), tcp_ack(false),
1372 tunnel(), l3_label(false), is_bfd_keepalive(false), is_segment_hc_pkt(false),
1373 ignore_address(
VmInterface::IGNORE_NONE), same_port_number(false),
1374 is_fat_flow_src_prefix(false), ip_ff_src_prefix(),
1375 is_fat_flow_dst_prefix(false), ip_ff_dst_prefix(),
1376 eth(),arp(), ip(), ip6() {
1379 (
module, buff_len, mdata);
1389 pkt(), len(), max_pkt_len(0), data(), ipc(msg), family(
Address::UNSPEC),
1390 type(
PktType::MESSAGE), agent_hdr(), ether_type(-1), ip_saddr(), ip_daddr(),
1391 ip_proto(), sport(), dport(), ttl(0), icmp_chksum(0), tcp_ack(false),
1392 tunnel(), l3_label(false), is_bfd_keepalive(false), is_segment_hc_pkt(false),
1393 ignore_address(
VmInterface::IGNORE_NONE), same_port_number(false),
1394 is_fat_flow_src_prefix(false), ip_ff_src_prefix(),
1395 is_fat_flow_dst_prefix(false), ip_ff_dst_prefix(),
1396 eth(), arp(), ip(), ip6(), packet_buffer_() {
1426 eth = (
struct ether_header *)(
pkt);
1428 transp.tcp = (
struct tcphdr *)(
ip + 1);
1433 std::size_t seed = 0;
1450 boost::hash_combine(seed, agent->
router_id().to_ulong());
1455 boost::hash_combine(seed,
ip_saddr.to_v4().to_ulong());
1458 boost::hash_combine(seed,
ip_daddr.to_v4().to_ulong());
1463 memcpy(words,
ip_saddr.to_v6().to_bytes().data(),
sizeof(words));
1464 boost::hash_combine(seed, words[0]);
1465 boost::hash_combine(seed, words[1]);
1466 boost::hash_combine(seed, words[2]);
1467 boost::hash_combine(seed, words[3]);
1472 memcpy(words,
ip_daddr.to_v6().to_bytes().data(),
sizeof(words));
1473 boost::hash_combine(seed, words[0]);
1474 boost::hash_combine(seed, words[1]);
1475 boost::hash_combine(seed, words[2]);
1476 boost::hash_combine(seed, words[3]);
1482 boost::hash_combine(seed,
ip_proto);
1485 boost::hash_combine(seed,
sport);
1488 boost::hash_combine(seed,
dport);
1494 std::size_t
hash = 0;
1495 boost::hash_combine(
hash, (seed & 0xFFFFFFFF));
1496 boost::hash_combine(
hash, (seed >> 16));
1502 return ntohs(
transp.udp->uh_ulen) -
sizeof(udphdr);
1514 boost::shared_ptr<PktInfo> pkt_info) {
1515 if (!(
proto_list_.at(module)->Enqueue(pkt_info))) {
1523 std::size_t pkt_trace_size,
const AgentHdr *hdr) {
1524 uint16_t hdr_len =
sizeof(
AgentHdr);
1527 memcpy(
pkt, hdr, hdr_len);
boost::asio::ip::address_v6 Ip6Address
boost::asio::ip::address IpAddress
boost::asio::ip::address_v4 Ip4Address
std::string AgentBackTrace(int skip=1)
AgentDBEntry * FindActiveEntry(const DBEntry *key)
bool flow_use_rid_in_hash() const
const NextHop * GetActiveNextHop() const
void incr_pkt_fragments_dropped()
void incr_pkt_invalid_frm_tor()
void incr_pkt_invalid_ip_pkt()
void incr_pkt_drop_due_to_invalid_ethertype()
void incr_pkt_drop_due_to_decode_error()
void incr_pkt_invalid_interface()
uint64_t pkt_drop_due_to_flow_trap() const
void incr_pkt_exceptions()
void incr_pkt_drop_due_to_disable_tnl()
InterfaceTable * interface_table() const
AgentParam * params() const
VrfTable * vrf_table() const
NextHopTable * nexthop_table() const
static const MacAddress & vrrp_mac()
static Agent * GetInstance()
const Interface * vhost_interface() const
AgentStats * stats() const
Ip4Address router_id() const
MplsTable * mpls_table() const
BridgeRouteEntry * FindRoute(const MacAddress &mac)
const VmInterface * FindVmFromDhcpBinding(const MacAddress &mac)
bool layer2_control_word() const
ComponentNHList::const_iterator end() const
COMPOSITETYPE composite_nh_type() const
const Interface * GetFirstLocalEcmpMemberInterface() const
ComponentNHList::const_iterator begin() const
virtual uint32_t EncapsulationLength() const =0
virtual int Send(const AgentHdr &hdr, const PacketBufferPtr &pkt)=0
static const std::string kDiagData
bool is_ip_protocol_set() const
bool is_destination_port_set() const
bool is_destination_ip_set() const
bool is_source_ip_set() const
bool is_source_port_set() const
const Interface * GetInterface() const
bool layer2_control_word() const
const Interface * FindInterface(size_t index) const
const MacAddress & mac() const
bool dhcp_enabled() const
bool IsTunnelEnabled() const
bool dhcp_enabled_v6() const
const uint32_t id() const
static const MacAddress & BroadcastMac()
const NextHop * nexthop() const
bool IsFabricMulticastReservedLabel() const
static const uint32_t kInvalidLabel
NextHop * FindNextHop(size_t index)
PacketBufferPtr Allocate(uint32_t module, uint16_t len, uint32_t mdata)
static bool ComputeDirection(const Interface *intf)
uint32_t EncapHeaderLen() const
int ParseMplsHdr(PktInfo *pkt_info, uint8_t *pkt)
bool IgnoreFragmentedPacket(PktInfo *pkt_info)
bool IsManagedTORPacket(Interface *intf, PktInfo *pkt_info, PktType::Type &pkt_type, uint8_t *pkt, bool *pkt_ok)
int ParseUDPTunnels(PktInfo *pkt_info, uint8_t *pkt)
int ParseControlWord(PktInfo *pkt_info, uint8_t *pkt, const MplsLabel *mpls)
int ParseVxlan(PktInfo *pkt_info, uint8_t *pkt)
void SetOuterMac(PktInfo *pkt_info)
void PktModuleEnqueue(PktModuleName mod, const AgentHdr &hdr, boost::shared_ptr< PktInfo > pkt_info, uint8_t *pkt)
void Send(const AgentHdr &hdr, const PacketBufferPtr &buff)
PktModuleName ParseBfdDataPacket(const AgentHdr &hdr, PktInfo *pkt_info, uint8_t *pkt)
bool IsGwPacket(const Interface *intf, const IpAddress &dst_ip)
int ParseEthernetHeader(PktInfo *pkt_info, uint8_t *pkt)
Proto * bfd_keepalive_proto_
bool IsSegmentHealthCheckPacket(const PktInfo *pkt_info, const Interface *interface)
PktHandlerQueue work_queue_bfd_ka_
void CalculatePortIP(PktInfo *pkt_info)
void SetOuterIp(PktInfo *pkt_info, uint8_t *pkt)
bool ValidateIpPacket(PktInfo *pkt_info)
boost::function< void(PktTrace::Pkt &)> PktTraceCallback
bool IsValidInterface(uint32_t ifindex, Interface **interface)
int ParseIpPacket(PktInfo *pkt_info, PktType::Type &pkt_type, uint8_t *ptr)
static const uint32_t kMulticastControlWord
int ParseMPLSoUDP(PktInfo *pkt_info, uint8_t *pkt)
bool IsBFDHealthCheckPacket(const PktInfo *pkt_info, const Interface *interface)
int ParseMPLSoGRE(PktInfo *pkt_info, uint8_t *pkt)
void HandleRcvPkt(const AgentHdr &hdr, const PacketBufferPtr &buff)
bool IsDiagPacket(PktInfo *pkt_info)
void AddPktTrace(PktModuleName module, PktTrace::Direction dir, const PktInfo *pkt)
void Enqueue(PktModuleName module, boost::shared_ptr< PktInfo > pkt_info)
int ParseUserPkt(PktInfo *pkt_info, Interface *intf, PktType::Type &pkt_type, uint8_t *pkt)
boost::array< PktTrace, MAX_MODULES > pkt_trace_
PktHandler(Agent *, PktModule *pkt_module)
boost::array< Proto *, MAX_MODULES > proto_list_
bool ComputeForwardingMode(PktInfo *pkt_info, const Interface *intf) const
void SendMessage(PktModuleName mod, InterTaskMsg *msg)
bool ProcessPacket(boost::shared_ptr< PacketBufferEnqueueItem > item)
PktModuleName ParsePacket(const AgentHdr &hdr, PktInfo *pkt_info, uint8_t *pkt)
void Register(PktModuleName type, RcvQueueFunc cb)
static const uint32_t kMulticastControlWordSize
bool ProcessBfdDataPacket(boost::shared_ptr< PacketBufferEnqueueItem > item)
bool IsToRDevice(uint32_t vrf_id, const IpAddress &ip)
PktHandlerQueue work_queue_
bool IsDHCPPacket(PktInfo *pkt_info)
bool IsFlowPacket(PktInfo *pkt_info)
void PktTraceIterate(PktModuleName mod, PktTraceCallback cb)
PacketBufferManager * packet_buffer_manager() const
ControlInterface * control_interface() const
static const std::size_t kPktMaxTraceSize
std::vector< Pkt > pkt_buffer_
std::size_t pkt_trace_size_
void AddPktTrace(Direction dir, std::size_t len, uint8_t *msg, const AgentHdr *hdr)
std::size_t pkt_trace_size() const
virtual bool Enqueue(boost::shared_ptr< PktInfo > msg)
The TaskScheduler keeps track of what tasks are currently schedulable. When a task is enqueued it is ...
const Ip4Address * GetDip() const
void SetType(TunnelType::Type type)
const Interface * GetInterface() const
bool IsFatFlowPrefixAggregation(bool ingress, uint8_t protocol, uint16_t *sport, uint16_t *dport, bool *same_port_num, IpAddress *SrcIP, IpAddress *DstIP, bool *is_src_prefix, bool *is_dst_prefix, FatFlowIgnoreAddressType *ignore_addr) const
VmInterface::VmiType vmi_type() const
bool IsFatFlowPortBased(uint8_t protocol, uint16_t port, FatFlowIgnoreAddressType *ignore_addr) const
const FatFlowList & fat_flow_list() const
const VnEntry * vn() const
const Ip4Address & primary_ip_addr() const
bool ExcludeFromFatFlow(Address::Family family, const IpAddress &sip, const IpAddress &dip) const
const Ip6Address & primary_ip6_addr() const
const std::vector< VnIpam > & GetVnIpam() const
AgentRouteTable * GetBridgeRouteTable() const
bool layer2_control_word() const
VrfEntry * FindVrfFromId(size_t index)
bool Enqueue(QueueEntryT entry)
void Shutdown(bool delete_entries=true)
void set_measure_busy_time(bool val) const
void set_name(const std::string &name)
#define LOG(_Level, _Msg)
boost::shared_ptr< PacketBuffer > PacketBufferPtr
#define PKT_TRACE(obj, arg)
#define MPLS_OVER_UDP_DEST_PORT
#define IANA_MPLS_OVER_UDP_DEST_PORT
#define VXLAN_UDP_DEST_PORT
#define DHCPV6_CLIENT_PORT
#define DHCPV6_SERVER_PORT
#define BFD_MULTIHOP_CONTROL_PORT
#define BFD_SINGLEHOP_CONTROL_PORT
void PktRcvd(PktModuleName mod)
uint32_t received[MAX_MODULES]
void PktQThresholdExceeded(PktModuleName mod)
void PktSent(PktModuleName mod)
PktInfo(Agent *agent, uint32_t buff_len, PktHandler::PktModuleName module, uint32_t mdata)
void reset_packet_buffer()
IpAddress ip_ff_src_prefix
std::size_t hash(const Agent *agent, const EcmpLoadBalance &ecmp_has_fields_to_use) const
bool is_fat_flow_dst_prefix
void AllocPacketBuffer(Agent *agent, uint32_t module, uint16_t len, uint32_t mdata)
uint32_t GetUdpPayloadLength() const
struct ether_header * eth
bool is_fat_flow_src_prefix
IpAddress ip_ff_dst_prefix
PacketBufferPtr packet_buffer_
void set_len(uint32_t len)
const AgentHdr & GetAgentHdr() const
PktHandler::PktModuleName module
VmInterface::FatFlowIgnoreAddressType ignore_address
uint8_t pkt[kPktMaxTraceSize]
void Copy(Direction d, std::size_t l, uint8_t *msg, std::size_t pkt_trace_size, const AgentHdr *hdr)
struct ether_header * eth