static char *packettoa(char *result,unsigned char *packet, int len)
{
struct iphdr *iph = (struct iphdr*)packet;
char nbuf1[40], nbuf2[40];
if (verbose && iph->protocol == IPPROTO_TCP) {
struct tcphdr *tcph = (struct tcphdr*) (packet + 4 * iph->ihl);
sprintf(result,"proto=%s %d byte packet seq=%u ack=%u id=%u frag=%u from %s:%d to %s:%d",
ip_proto_name(iph->protocol), len, tcph->seq, tcph->ack_seq,
iph->id, iph->frag_off,
ip_ntoa(iph->saddr,nbuf1),tcph->source,
ip_ntoa(iph->daddr,nbuf2),tcph->dest);
} else {
sprintf(result,"proto=%s %d byte packet from %s to %s",
ip_proto_name(iph->protocol), len,
ip_ntoa(iph->saddr,nbuf1),
ip_ntoa(iph->daddr,nbuf2));
}
return result;
}
/*
* Receive a burst of packets, lookup for ICMP echo requets, and, if any,
* send back ICMP echo replies.
*/
static void
reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
struct rte_mbuf *pkt;
struct ether_hdr *eth_h;
struct vlan_hdr *vlan_h;
struct arp_hdr *arp_h;
struct ipv4_hdr *ip_h;
struct icmp_hdr *icmp_h;
struct ether_addr eth_addr;
uint32_t ip_addr;
uint16_t nb_rx;
uint16_t nb_tx;
uint16_t nb_replies;
uint16_t eth_type;
uint16_t vlan_id;
uint16_t arp_op;
uint16_t arp_pro;
uint8_t i;
int l2_len;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
uint64_t start_tsc;
uint64_t end_tsc;
uint64_t core_cycles;
#endif
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
/*
* First, receive a burst of packets.
*/
nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
nb_pkt_per_burst);
if (unlikely(nb_rx == 0))
return;
#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
#endif
fs->rx_packets += nb_rx;
nb_replies = 0;
for (i = 0; i < nb_rx; i++) {
pkt = pkts_burst[i];
eth_h = (struct ether_hdr *) pkt->pkt.data;
eth_type = RTE_BE_TO_CPU_16(eth_h->ether_type);
l2_len = sizeof(struct ether_hdr);
if (verbose_level > 0) {
printf("\nPort %d pkt-len=%u nb-segs=%u\n",
fs->rx_port, pkt->pkt.pkt_len, pkt->pkt.nb_segs);
ether_addr_dump(" ETH: src=", ð_h->s_addr);
ether_addr_dump(" dst=", ð_h->d_addr);
}
if (eth_type == ETHER_TYPE_VLAN) {
vlan_h = (struct vlan_hdr *)
((char *)eth_h + sizeof(struct ether_hdr));
l2_len += sizeof(struct vlan_hdr);
eth_type = rte_be_to_cpu_16(vlan_h->eth_proto);
if (verbose_level > 0) {
vlan_id = rte_be_to_cpu_16(vlan_h->vlan_tci)
& 0xFFF;
printf(" [vlan id=%u]", vlan_id);
}
}
if (verbose_level > 0) {
printf(" type=0x%04x\n", eth_type);
}
/* Reply to ARP requests */
if (eth_type == ETHER_TYPE_ARP) {
arp_h = (struct arp_hdr *) ((char *)eth_h + l2_len);
arp_op = RTE_BE_TO_CPU_16(arp_h->arp_op);
arp_pro = RTE_BE_TO_CPU_16(arp_h->arp_pro);
if (verbose_level > 0) {
printf(" ARP: hrd=%d proto=0x%04x hln=%d "
"pln=%d op=%u (%s)\n",
RTE_BE_TO_CPU_16(arp_h->arp_hrd),
arp_pro, arp_h->arp_hln,
arp_h->arp_pln, arp_op,
arp_op_name(arp_op));
}
if ((RTE_BE_TO_CPU_16(arp_h->arp_hrd) !=
ARP_HRD_ETHER) ||
(arp_pro != ETHER_TYPE_IPv4) ||
(arp_h->arp_hln != 6) ||
(arp_h->arp_pln != 4)
) {
rte_pktmbuf_free(pkt);
if (verbose_level > 0)
printf("\n");
continue;
}
if (verbose_level > 0) {
memcpy(ð_addr,
arp_h->arp_data.arp_ip.arp_sha, 6);
ether_addr_dump(" sha=", ð_addr);
memcpy(&ip_addr,
arp_h->arp_data.arp_ip.arp_sip, 4);
ipv4_addr_dump(" sip=", ip_addr);
printf("\n");
memcpy(ð_addr,
arp_h->arp_data.arp_ip.arp_tha, 6);
ether_addr_dump(" tha=", ð_addr);
memcpy(&ip_addr,
arp_h->arp_data.arp_ip.arp_tip, 4);
ipv4_addr_dump(" tip=", ip_addr);
printf("\n");
}
if (arp_op != ARP_OP_REQUEST) {
rte_pktmbuf_free(pkt);
continue;
}
/*
* Build ARP reply.
*/
/* Use source MAC address as destination MAC address. */
ether_addr_copy(ð_h->s_addr, ð_h->d_addr);
/* Set source MAC address with MAC address of TX port */
ether_addr_copy(&ports[fs->tx_port].eth_addr,
ð_h->s_addr);
arp_h->arp_op = rte_cpu_to_be_16(ARP_OP_REPLY);
memcpy(ð_addr, arp_h->arp_data.arp_ip.arp_tha, 6);
memcpy(arp_h->arp_data.arp_ip.arp_tha,
arp_h->arp_data.arp_ip.arp_sha, 6);
memcpy(arp_h->arp_data.arp_ip.arp_sha,
ð_h->s_addr, 6);
/* Swap IP addresses in ARP payload */
memcpy(&ip_addr, arp_h->arp_data.arp_ip.arp_sip, 4);
memcpy(arp_h->arp_data.arp_ip.arp_sip,
arp_h->arp_data.arp_ip.arp_tip, 4);
memcpy(arp_h->arp_data.arp_ip.arp_tip, &ip_addr, 4);
pkts_burst[nb_replies++] = pkt;
continue;
}
if (eth_type != ETHER_TYPE_IPv4) {
rte_pktmbuf_free(pkt);
continue;
}
ip_h = (struct ipv4_hdr *) ((char *)eth_h + l2_len);
if (verbose_level > 0) {
ipv4_addr_dump(" IPV4: src=", ip_h->src_addr);
ipv4_addr_dump(" dst=", ip_h->dst_addr);
printf(" proto=%d (%s)\n",
ip_h->next_proto_id,
ip_proto_name(ip_h->next_proto_id));
}
/*
* Check if packet is a ICMP echo request.
*/
icmp_h = (struct icmp_hdr *) ((char *)ip_h +
sizeof(struct ipv4_hdr));
if (! ((ip_h->next_proto_id == IPPROTO_ICMP) &&
(icmp_h->icmp_type == IP_ICMP_ECHO_REQUEST) &&
(icmp_h->icmp_code == 0))) {
rte_pktmbuf_free(pkt);
continue;
}
if (verbose_level > 0)
printf(" ICMP: echo request seq id=%d\n",
rte_be_to_cpu_16(icmp_h->icmp_seq_nb));
/*
* Prepare ICMP echo reply to be sent back.
* - switch ethernet source and destinations addresses,
* - switch IPv4 source and destinations addresses,
* - set IP_ICMP_ECHO_REPLY in ICMP header.
* No need to re-compute the IP header checksum.
* Reset ICMP checksum.
*/
ether_addr_copy(ð_h->s_addr, ð_addr);
ether_addr_copy(ð_h->d_addr, ð_h->s_addr);
ether_addr_copy(ð_addr, ð_h->d_addr);
ip_addr = ip_h->src_addr;
ip_h->src_addr = ip_h->dst_addr;
ip_h->dst_addr = ip_addr;
icmp_h->icmp_type = IP_ICMP_ECHO_REPLY;
icmp_h->icmp_cksum = 0;
pkts_burst[nb_replies++] = pkt;
}
/* Send back ICMP echo replies, if any. */
if (nb_replies > 0) {
nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst,
nb_replies);
fs->tx_packets += nb_tx;
#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
#endif
if (unlikely(nb_tx < nb_replies)) {
fs->fwd_dropped += (nb_replies - nb_tx);
do {
rte_pktmbuf_free(pkts_burst[nb_tx]);
} while (++nb_tx < nb_replies);
}
}
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
end_tsc = rte_rdtsc();
core_cycles = (end_tsc - start_tsc);
fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
#endif
}
