dunedaq::dpdklibs::udp Namespace Reference

Classes
struct	ipaddr
struct	ipv4_udp_packet_hdr

Enumerations
enum	{ MIN_TOS = 0 , DEFAULT_TOS = MIN_TOS , DEFAULT_TTL = 8 }

Functions
rte_le16_t	packet_fill (struct ipv4_udp_packet_hdr *packet_hdr)
void	pktgen_udp_hdr_ctor (struct ipv4_udp_packet_hdr *packet_hdr, rte_le16_t packet_len, int sport=55677, int dport=55678)
void	pktgen_ipv4_ctor (struct ipv4_udp_packet_hdr *packet_hdr, rte_le16_t packet_len, const std::string &src_ip_addr="0.0.0.0", const std::string &dst_ip_addr="0.0.0.0")
void	pktgen_ether_hdr_ctor (struct ipv4_udp_packet_hdr *packet_hdr, const std::string &dst_mac_address="0a:00:10:c2:15:c1", const int port_id=0)
bool	get_ether_addr6 (const char *s0, struct rte_ether_addr *ea)
void	construct_packets_for_burst (const int port_id, const std::string &dst_mac_addr, const int payload_bytes, const int burst_size, rte_mbuf **bufs)
static int8_t	get_xdigit (char ch)
std::uint16_t	get_payload_size_udp_hdr (struct rte_udp_hdr *udp_hdr)
std::uint16_t	get_payload_size (struct ipv4_udp_packet_hdr *ipv4_udp_hdr)
rte_be32_t	ip_address_dotdecimal_to_binary (std::uint8_t byte1, std::uint8_t byte2, std::uint8_t byte3, std::uint8_t byte4)
struct ipaddr	ip_address_binary_to_dotdecimal (rte_le32_t binary_ipv4_address)
std::string	get_ipv4_decimal_addr_str (struct ipaddr ipv4_address)
char *	get_udp_payload (const rte_mbuf *mbuf)
void	hex_digits_to_stream (std::ostringstream &ostrs, int value, char separator=':', char fill='0', int digits=2)
std::string	get_udp_header_str (struct rte_mbuf *mbuf)
std::string	get_udp_packet_str (struct rte_mbuf *mbuf)
void	add_file_contents_to_vector (const std::string &filename, std::vector< char > &buffervec)
std::vector< std::pair< const void *, int > >	get_ethernet_packets (const std::vector< char > &buffervec)
void	set_daqethheader_test_values (detdataformats::DAQEthHeader &daqethheader_obj) noexcept
std::string	get_rte_mbuf_str (const rte_mbuf *mbuf) noexcept
std::string	get_opmon_string (const StreamUID &sid)

Variables
struct dunedaq::dpdklibs::udp::ipv4_udp_packet_hdr	__rte_packed

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MIN_TOS
DEFAULT_TOS
DEFAULT_TTL

Definition at line 19 of file PacketCtor.cpp.

{
  MIN_TOS = 0,
  DEFAULT_TOS = MIN_TOS,
  DEFAULT_TTL = 8
};

Function Documentation

add_file_contents_to_vector()

void dunedaq::dpdklibs::udp::add_file_contents_to_vector	(	const std::string &	filename,
		std::vector< char > &	buffervec )

Definition at line 171 of file Utils.cpp.

{
 
  char byte = 0x0;
 
  std::ifstream packetfile;
  packetfile.open(filename, std::ios::binary);
 
  if (!packetfile) {
    throw ::dunedaq::datahandlinglibs::CannotOpenFile(ERS_HERE, filename);
  }
 
  while (packetfile.get(byte)) {
    buffervec.push_back(byte);
  }
 
  packetfile.close();
}

construct_packets_for_burst()

void dunedaq::dpdklibs::udp::construct_packets_for_burst	(	const int	port_id,
		const std::string &	dst_mac_addr,
		const int	payload_bytes,
		const int	burst_size,
		rte_mbuf **	bufs )

Definition at line 225 of file PacketCtor.cpp.

{
  struct ipv4_udp_packet_hdr packet_hdr;
 
  constexpr int eth_header_bytes = 14;
  constexpr int udp_header_bytes = 8;
  constexpr int ipv4_header_bytes = 20;
 
  int eth_packet_bytes =
    eth_header_bytes + ipv4_header_bytes + udp_header_bytes + sizeof(detdataformats::DAQEthHeader) + payload_bytes;
  int ipv4_packet_bytes = eth_packet_bytes - eth_header_bytes;
  int udp_datagram_bytes = ipv4_packet_bytes - ipv4_header_bytes;
 
  // Get info for the ethernet header (protocol stack level 2)
  pktgen_ether_hdr_ctor(&packet_hdr, dst_mac_addr, port_id);
 
  // Get info for the internet header (protocol stack level 3)
  pktgen_ipv4_ctor(&packet_hdr, ipv4_packet_bytes);
 
  // Get info for the UDP header (protocol stack level 4)
  pktgen_udp_hdr_ctor(&packet_hdr, udp_datagram_bytes);
 
  detdataformats::DAQEthHeader daqethheader_obj;
  set_daqethheader_test_values(daqethheader_obj);
 
  void* dataloc = nullptr;
  for (int i_pkt = 0; i_pkt < burst_size; ++i_pkt) {
 
    dataloc = rte_pktmbuf_mtod(bufs[i_pkt], char*);
    rte_memcpy(dataloc, &packet_hdr, sizeof(packet_hdr));
 
    dataloc = rte_pktmbuf_mtod_offset(bufs[i_pkt], char*, sizeof(packet_hdr));
    rte_memcpy(dataloc, &daqethheader_obj, sizeof(daqethheader_obj));
 
    bufs[i_pkt]->pkt_len = eth_packet_bytes;
    bufs[i_pkt]->data_len = eth_packet_bytes;
  }
}

get_ether_addr6()

bool dunedaq::dpdklibs::udp::get_ether_addr6	(	const char *	s0,
		struct rte_ether_addr *	ea )

Definition at line 39 of file PacketCtor.cpp.

{
  const char* s = s0;
  int i;
 
  for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) {
    int8_t x;
 
    x = get_xdigit(*s++);
    if (x < 0)
      return false;
 
    ea->addr_bytes[i] = x << 4;
    x = get_xdigit(*s++);
    if (x < 0)
      return false;
    ea->addr_bytes[i] |= x;
 
    if (i < RTE_ETHER_ADDR_LEN - 1 && *s++ != ':')
      return false;
  }
 
  /* return true if at end of string */
  return *s == '\0';
}

get_ethernet_packets()

std::vector< std::pair< const void *, int > > dunedaq::dpdklibs::udp::get_ethernet_packets

(

const std::vector< char > &

buffervec

)

Definition at line 191 of file Utils.cpp.

{
 
  std::vector<std::pair<const void*, int>> ethernet_packets;
  const std::vector<uint16_t> allowed_ethertypes{ 0x0800, 0x0806 };
 
  for (int byte_index = 0; byte_index < buffervec.size();) {
    const auto buf_ptr = &buffervec.at(byte_index);
    auto hdr = reinterpret_cast<const ipv4_udp_packet_hdr*>(buf_ptr);
 
    // A sanity check
    bool match = false;
    for (auto allowed_ethertype : allowed_ethertypes) {
      if (hdr->eth_hdr.ether_type == rte_be_to_cpu_16(allowed_ethertype)) {
        match = true;
        break;
      }
    }
 
    if (!match) {
      std::stringstream msgstr;
      msgstr << "Ether type in ethernet header (value " << std::hex << rte_be_to_cpu_16(hdr->eth_hdr.ether_type)
             << std::dec << ") either unknown or unsupported";
      throw dunedaq::dpdklibs::BadPacketHeaderIssue(ERS_HERE, msgstr.str());
    }
 
    int ipv4_packet_size = rte_be_to_cpu_16(hdr->ipv4_hdr.total_length);
    constexpr int min_packet_size = sizeof(rte_ipv4_hdr) + sizeof(rte_udp_hdr);
    constexpr int max_packet_size = 10000;
 
    if (ipv4_packet_size < min_packet_size || ipv4_packet_size > max_packet_size) {
      std::stringstream msgstr;
      msgstr << "Calculated IPv4 packet size of " << ipv4_packet_size << " bytes is out of the required range of ("
             << min_packet_size << ", " << max_packet_size << ") bytes";
      throw dunedaq::dpdklibs::BadPacketHeaderIssue(ERS_HERE, msgstr.str());
    }
 
    int ethernet_packet_size = sizeof(rte_ether_hdr) + ipv4_packet_size;
    ethernet_packets.emplace_back(std::pair<const void*, int>{ buf_ptr, ethernet_packet_size });
    byte_index += ethernet_packet_size;
  }
 
  return ethernet_packets;
}

get_ipv4_decimal_addr_str()

std::string dunedaq::dpdklibs::udp::get_ipv4_decimal_addr_str

(

struct ipaddr

ipv4_address

)

Definition at line 56 of file Utils.cpp.

{
  std::ostringstream ostrs;
  ostrs << (unsigned)ipv4_address.addr_bytes[3] << '.' << (unsigned)ipv4_address.addr_bytes[2] << '.'
        << (unsigned)ipv4_address.addr_bytes[1] << '.' << (unsigned)ipv4_address.addr_bytes[0];
  return ostrs.str();
  /*printf("%i.%i.%i.%i",
        ipv4_address.addr_bytes[3],
        ipv4_address.addr_bytes[2],
        ipv4_address.addr_bytes[1],
        ipv4_address.addr_bytes[0]);
  */
}

get_opmon_string()

std::string dunedaq::dpdklibs::udp::get_opmon_string

(

const StreamUID &

sid

)

Definition at line 282 of file Utils.cpp.

{
  std::stringstream opmonstr;
  opmonstr << "det" << sid.det_id << "_crt" << sid.crate_id << "_slt" << sid.slot_id << "_str" << sid.stream_id;
  return opmonstr.str();
}

get_payload_size()

std::uint16_t dunedaq::dpdklibs::udp::get_payload_size

(

struct ipv4_udp_packet_hdr *

ipv4_udp_hdr

)

Definition at line 35 of file Utils.cpp.

{
  return rte_be_to_cpu_16(ipv4_udp_hdr->udp_hdr.dgram_len) - sizeof(struct rte_udp_hdr);
}

get_payload_size_udp_hdr()

std::uint16_t dunedaq::dpdklibs::udp::get_payload_size_udp_hdr

(

struct rte_udp_hdr *

udp_hdr

)

Definition at line 29 of file Utils.cpp.

{
  return rte_be_to_cpu_16(udp_hdr->dgram_len) - sizeof(struct rte_udp_hdr);
}

get_rte_mbuf_str()

std::string dunedaq::dpdklibs::udp::get_rte_mbuf_str ( const rte_mbuf * mbuf )

noexcept

Definition at line 251 of file Utils.cpp.

{
  std::stringstream ss;
 
  ss << "\nrte_mbuf info:";
  ss << "\npkt_len: " << mbuf->pkt_len;
  ss << "\ndata_len: " << mbuf->data_len;
  ss << "\nBuffer address: " << std::hex << mbuf->buf_addr;
  ss << "\nRef count: " << std::dec << rte_mbuf_refcnt_read(mbuf);
  ss << "\nport: " << mbuf->port;
  ss << "\nol_flags: " << std::hex << mbuf->ol_flags;
  ss << "\npacket_type: " << std::dec << mbuf->packet_type;
  ss << "\nl2 type: " << static_cast<int>(mbuf->l2_type);
  ss << "\nl3 type: " << static_cast<int>(mbuf->l3_type);
  ss << "\nl4 type: " << static_cast<int>(mbuf->l4_type);
  ss << "\ntunnel type: " << static_cast<int>(mbuf->tun_type);
  ss << "\nInner l2 type: " << static_cast<int>(mbuf->inner_l2_type);
  ss << "\nInner l3 type: " << static_cast<int>(mbuf->inner_l3_type);
  ss << "\nInner l4 type: " << static_cast<int>(mbuf->inner_l4_type);
  ss << "\nbuf_len: " << mbuf->buf_len;
  ss << "\nl2_len: " << mbuf->l2_len;
  ss << "\nl3_len: " << mbuf->l3_len;
  ss << "\nl4_len: " << mbuf->l4_len;
  ss << "\nouter_l2_len: " << mbuf->outer_l2_len;
  ss << "\nouter_l3_len: " << mbuf->outer_l3_len;
  ss << std::dec;
 
  return ss.str();
}

get_udp_header_str()

std::string dunedaq::dpdklibs::udp::get_udp_header_str

(

struct rte_mbuf *

mbuf

)

Definition at line 109 of file Utils.cpp.

{
  struct ipv4_udp_packet_hdr* pkt = rte_pktmbuf_mtod(mbuf, struct ipv4_udp_packet_hdr*);
  std::ostringstream ostrs;
  ostrs << "\n------ start of packet ----- \n";
  ostrs << "dst mac addr: ";
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[0]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[1]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[2]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[3]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[4]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.dst_addr.addr_bytes[5], '\n');
  ostrs << "src mac addr: ";
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[0]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[1]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[2]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[3]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[4]);
  hex_digits_to_stream(ostrs, (int)pkt->eth_hdr.src_addr.addr_bytes[5], '\n');
  ostrs << "ethtype: " << (unsigned)pkt->eth_hdr.ether_type << '\n';
 
  ostrs << "------ IP header ----- \n";
  ostrs << "ipv4 version: " << (unsigned)pkt->ipv4_hdr.version_ihl << '\n';
  ostrs << "ipv4 type_of_service: " << (unsigned)pkt->ipv4_hdr.type_of_service << '\n';
  ostrs << "ipv4 total lenght: " << (unsigned)rte_be_to_cpu_16(pkt->ipv4_hdr.total_length) << '\n';
  ostrs << "ipv4 packet_id: " << (unsigned)pkt->ipv4_hdr.packet_id << '\n';
  ostrs << "ipv4 fragment_offset: " << (unsigned)pkt->ipv4_hdr.fragment_offset << '\n';
  ostrs << "ipv4 time_to_live: " << (unsigned)pkt->ipv4_hdr.time_to_live << '\n';
  ostrs << "ipv4 next_proto_id: " << (unsigned)pkt->ipv4_hdr.next_proto_id << '\n';
  ostrs << "ipv4 checksum: " << (unsigned)rte_be_to_cpu_16(pkt->ipv4_hdr.hdr_checksum) << '\n';
  std::string srcaddr =
    get_ipv4_decimal_addr_str(ip_address_binary_to_dotdecimal(rte_be_to_cpu_32(pkt->ipv4_hdr.src_addr)));
  std::string dstaddr =
    get_ipv4_decimal_addr_str(ip_address_binary_to_dotdecimal(rte_be_to_cpu_32(pkt->ipv4_hdr.dst_addr)));
  ostrs << "src_addr: " << srcaddr << '\n';
  ostrs << "dst_addr: " << dstaddr << '\n';
 
  ostrs << "------ UDP header ----- \n";
  ostrs << "UDP src_port: " << (unsigned)rte_be_to_cpu_16(pkt->udp_hdr.src_port) << '\n';
  ostrs << "UDP dst_port: " << (unsigned)rte_be_to_cpu_16(pkt->udp_hdr.dst_port) << '\n';
  ostrs << "UDP len: " << (unsigned)rte_be_to_cpu_16(pkt->udp_hdr.dgram_len) << '\n';
  ostrs << "UDP checksum: " << (unsigned)rte_be_to_cpu_16(pkt->udp_hdr.dgram_cksum) << '\n';
 
  return ostrs.str();
}

get_udp_packet_str()

std::string dunedaq::dpdklibs::udp::get_udp_packet_str

(

struct rte_mbuf *

mbuf

)

Definition at line 156 of file Utils.cpp.

{
  struct ipv4_udp_packet_hdr* pkt = rte_pktmbuf_mtod(mbuf, struct ipv4_udp_packet_hdr*);
  char* payload = (char*)(pkt);
  std::ostringstream ostrs;
  std::uint8_t byte;
  for (byte = 0; byte < rte_be_to_cpu_16(pkt->udp_hdr.dgram_len); byte++) {
    hex_digits_to_stream(ostrs, (unsigned)(*(payload + byte)), ' ');
    // printf("%02x ", *(payload + byte) & 0xFF);
    // printf("%s", (payload + byte));
  }
  return ostrs.str();
}

get_udp_payload()

char * dunedaq::dpdklibs::udp::get_udp_payload

(

const rte_mbuf *

mbuf

)

Definition at line 71 of file Utils.cpp.

{
  struct ipv4_udp_packet_hdr* udp_packet = rte_pktmbuf_mtod(mbuf, struct ipv4_udp_packet_hdr*);
  // dump_udp_header(udp_packet);
  // uint16_t payload_size = get_payload_size(udp_packet);
  char* payload = (char*)(udp_packet + 1);
  return payload;
 
  /*
  if (dump_mode == 10) {
    return payload;
  }
 
  if (dump_mode == 0 || dump_mode == 3) {
    printf("UDP Payload size: %i\n", payload_size);
    uint byte;
    for (byte = 0; byte < payload_size; byte++) {
      printf("%02x ", *(payload + byte) & 0xFF);
      //printf("%s", (payload + byte));
    }
    printf("\n");
  }
 
  if (dump_mode == 1 || dump_mode == 3) {
    printf("%s\n", payload);
  }
  return payload;
  */
}

get_xdigit()

int8_t dunedaq::dpdklibs::udp::get_xdigit ( char ch )

static

Definition at line 27 of file PacketCtor.cpp.

{
  if (ch >= '0' && ch <= '9')
    return ch - '0';
  if (ch >= 'a' && ch <= 'f')
    return ch - 'a' + 10;
  if (ch >= 'A' && ch <= 'F')
    return ch - 'A' + 10;
  return -1;
}

hex_digits_to_stream()

void dunedaq::dpdklibs::udp::hex_digits_to_stream ( std::ostringstream & ostrs, int value, char separator = ':', char fill = '0', int digits = 2 )

inline

Definition at line 102 of file Utils.cpp.

                                                                         :', char fill = '0', int digits = 2)
{
  ostrs << std::setfill(fill) << std::setw(digits) << std::hex << value << std::dec << separator;
}

ip_address_binary_to_dotdecimal()

struct ipaddr dunedaq::dpdklibs::udp::ip_address_binary_to_dotdecimal

(

rte_le32_t

binary_ipv4_address

)

Definition at line 48 of file Utils.cpp.

{
  struct ipaddr addr;
  memcpy(&addr, &binary_ipv4_address, sizeof(rte_le32_t));
  return addr;
}

ip_address_dotdecimal_to_binary()

rte_be32_t dunedaq::dpdklibs::udp::ip_address_dotdecimal_to_binary	(	std::uint8_t	byte1,
		std::uint8_t	byte2,
		std::uint8_t	byte3,
		std::uint8_t	byte4 )

Definition at line 41 of file Utils.cpp.

{
  rte_le32_t ip_address = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
  return rte_cpu_to_be_32(ip_address);
}

packet_fill()

rte_le16_t dunedaq::dpdklibs::udp::packet_fill

(

struct ipv4_udp_packet_hdr *

packet_hdr

)

Definition at line 66 of file PacketCtor.cpp.

{
  // rte_le16_t total_length = 64;
  // char message[] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 
  rte_le16_t total_length = 2000;
  char message[] =
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE";
 
  char* payload = (char*)(packet_hdr + 1);
  memcpy(payload, message, total_length);
  return total_length;
}

pktgen_ether_hdr_ctor()

void dunedaq::dpdklibs::udp::pktgen_ether_hdr_ctor	(	struct ipv4_udp_packet_hdr *	packet_hdr,
		const std::string &	router_mac_address,
		const int	port_id )

pktgen_ether_hdr_ctor - Ethernet header constructor routine.

DESCRIPTION Construct the ethernet header for a given packet buffer.

RETURNS: Pointer to memory after the ethernet header.

SEE ALSO:

Definition at line 206 of file PacketCtor.cpp.

{
  // pg_ether_addr_copy(&pkt->eth_src_addr, &eth->src_addr);
  // pg_ether_addr_copy(&pkt->eth_dst_addr, &eth->dst_addr);
 
  /* src and dest addr */
  // See definition dpdk-20.08/lib/librte_net/rte_ether.c is defined as static -> not exposed to the lib... redefining
  // here
 
  get_ether_addr6(router_mac_address.c_str(), &packet_hdr->eth_hdr.dst_addr);
 
  rte_eth_macaddr_get(port_id, &packet_hdr->eth_hdr.src_addr);
 
  /* normal ethernet header */
  packet_hdr->eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
  return;
}

pktgen_ipv4_ctor()

void dunedaq::dpdklibs::udp::pktgen_ipv4_ctor	(	struct ipv4_udp_packet_hdr *	packet_hdr,
		rte_le16_t	packet_len,
		const std::string &	src_ip_addr,
		const std::string &	dst_ip_addr )

pktgen_ipv4_ctor - Construct the IPv4 header for a packet

DESCRIPTION Constructor for the IPv4 header for a given packet.

RETURNS: N/A

SEE ALSO:

Definition at line 137 of file PacketCtor.cpp.

{
  /* IPv4 Header constructor */
 
  /* Zero out the header space */
  memset((char*)&packet_hdr->ipv4_hdr, 0, sizeof(struct rte_ipv4_hdr));
 
  IpAddr src(src_ip_addr);
  IpAddr dst(dst_ip_addr);
 
  struct ipaddr src_reversed_order;
  src_reversed_order.addr_bytes[3] = src.addr_bytes[0];
  src_reversed_order.addr_bytes[2] = src.addr_bytes[1];
  src_reversed_order.addr_bytes[1] = src.addr_bytes[2];
  src_reversed_order.addr_bytes[0] = src.addr_bytes[3];
 
  struct ipaddr dst_reversed_order;
  dst_reversed_order.addr_bytes[3] = dst.addr_bytes[0];
  dst_reversed_order.addr_bytes[2] = dst.addr_bytes[1];
  dst_reversed_order.addr_bytes[1] = dst.addr_bytes[2];
  dst_reversed_order.addr_bytes[0] = dst.addr_bytes[3];
 
  rte_le32_t src_addr_ser = *((rte_le32_t*)&src_reversed_order);
  rte_le32_t dst_addr_ser = *((rte_le32_t*)&dst_reversed_order);
 
  packet_hdr->ipv4_hdr.src_addr = rte_cpu_to_be_32(src_addr_ser);
  packet_hdr->ipv4_hdr.dst_addr = rte_cpu_to_be_32(dst_addr_ser);
 
  packet_hdr->ipv4_hdr.version_ihl = (IPV4_VERSION << 4) | (sizeof(struct rte_ipv4_hdr) / 4);
 
  packet_hdr->ipv4_hdr.total_length = rte_cpu_to_be_16(packet_len); // Payload + udp_hdr + iphdr
  packet_hdr->ipv4_hdr.time_to_live = DEFAULT_TTL;
  packet_hdr->ipv4_hdr.type_of_service = DEFAULT_TOS;
 
  // https://perso.telecom-paristech.fr/drossi/paper/rossi17ipid.pdf
  packet_hdr->ipv4_hdr.packet_id = rte_cpu_to_be_16(0); // I put a constant here..
  packet_hdr->ipv4_hdr.fragment_offset = 0;
  packet_hdr->ipv4_hdr.next_proto_id = IPPROTO_UDP;
 
  packet_hdr->ipv4_hdr.hdr_checksum = 0;
  // packet_hdr->ipv4_hdr.hdr_checksum = rte_ipv4_cksum(&packet_hdr->ipv4_hdr);
 
  // UDP checksum
  packet_hdr->udp_hdr.dgram_cksum = 0;
  // packet_hdr->udp_hdr.dgram_cksum = rte_ipv4_udptcp_cksum(&packet_hdr->ipv4_hdr, (void *) &packet_hdr->udp_hdr);
  // if (packet_hdr->udp_hdr.dgram_cksum == 0) {
  //     packet_hdr->udp_hdr.dgram_cksum = 0xFFFF;
  // }
  return;
}

pktgen_udp_hdr_ctor()

void dunedaq::dpdklibs::udp::pktgen_udp_hdr_ctor	(	struct ipv4_udp_packet_hdr *	packet_hdr,
		rte_le16_t	packet_len,
		int	sport,
		int	dport )

pktgen_udp_hdr_ctor - UDP header constructor routine.

DESCRIPTION Construct the UDP header in a packer buffer.

RETURNS: next header location

SEE ALSO:

Definition at line 111 of file PacketCtor.cpp.

{
  packet_hdr->udp_hdr.dgram_len = rte_cpu_to_be_16(packet_len);
 
  packet_hdr->udp_hdr.src_port = rte_cpu_to_be_16(sport);
  packet_hdr->udp_hdr.dst_port = rte_cpu_to_be_16(dport);
 
  packet_hdr->udp_hdr.dgram_cksum = 0; // checksum must be set to 0 in the L4 header by the caller.
  // TODO  I think that the payload must be already there and continuous in memory..
  return;
}

set_daqethheader_test_values()

void dunedaq::dpdklibs::udp::set_daqethheader_test_values ( detdataformats::DAQEthHeader & daqethheader_obj )

noexcept

Definition at line 237 of file Utils.cpp.

{
  daqethheader_obj.version = 0;
  daqethheader_obj.det_id = 1;
  daqethheader_obj.crate_id = 2;
  daqethheader_obj.slot_id = 3;
  daqethheader_obj.stream_id = 4;
  daqethheader_obj.reserved = 5;
  daqethheader_obj.seq_id = 6;
  daqethheader_obj.block_length = 7;
  daqethheader_obj.timestamp = 8;
}

Variable Documentation

__rte_packed

struct dunedaq::dpdklibs::udp::ipv4_udp_packet_hdr dunedaq::dpdklibs::udp::__rte_packed