void
pktgen_send_ping4( uint32_t pid, uint8_t seq_idx )
{
port_info_t * info = &pktgen.info[pid];
pkt_seq_t * ppkt = &info->seq_pkt[PING_PKT];
pkt_seq_t * spkt = &info->seq_pkt[seq_idx];
struct rte_mbuf * m ;
uint8_t qid = 0;
m = rte_pktmbuf_alloc(info->q[qid].special_mp);
if ( unlikely(m == NULL) ) {
pktgen_log_warning("No packet buffers found");
return;
}
*ppkt = *spkt; // Copy the sequence setup to the ping setup.
pktgen_packet_ctor(info, PING_PKT, ICMP4_ECHO);
rte_memcpy((uint8_t *)m->buf_addr + m->data_off, (uint8_t *)&ppkt->hdr, ppkt->pktSize);
m->pkt_len = ppkt->pktSize;
m->data_len = ppkt->pktSize;
pktgen_send_mbuf(m, pid, qid);
pktgen_set_q_flags(info, qid, DO_TX_FLUSH);
}
void pktgen_compile_pkt(port_info_t * info, uint32_t seqnum,
cmdline_etheraddr_t *daddr, cmdline_etheraddr_t * saddr,
cmdline_ipaddr_t * ip_daddr, cmdline_ipaddr_t * ip_saddr,
uint32_t sport, uint32_t dport, char type, char proto,
uint16_t vlanid, uint32_t pktsize)
{
pkt_seq_t * pkt;
if ( seqnum >= NUM_EXTRA_TX_PKTS )
return;
pkt = &info->seq_pkt[seqnum + EXTRA_TX_PKT];
memcpy(&pkt->eth_dst_addr, daddr->mac, 6);
memcpy(&pkt->eth_src_addr, saddr->mac, 6);
pkt->ip_mask = size_to_mask(ip_saddr->prefixlen);
pkt->ip_src_addr = htonl(ip_saddr->addr.ipv4.s_addr);
pkt->ip_dst_addr = htonl(ip_daddr->addr.ipv4.s_addr);
pkt->dport = dport;
pkt->sport = sport;
pkt->pktSize = pktsize-FCS_SIZE;
pkt->ipProto = (proto == 'u')? PG_IPPROTO_UDP :
(proto == 'i')? PG_IPPROTO_ICMP : PG_IPPROTO_TCP;
// Force the IP protocol to IPv4 if this is a ICMP packet.
if ( proto == 'i' )
type = '4';
pkt->ethType = (type == '4')? ETHER_TYPE_IPv4 :
(type == '6')? ETHER_TYPE_IPv6 :
(type == 'n')? ETHER_TYPE_VLAN : ETHER_TYPE_IPv4;
pkt->vlanid = vlanid;
pktgen_packet_ctor(info, seqnum, -1);
}
void
pktgen_set_vlanid(port_info_t * info, uint16_t vlanid)
{
info->vlanid = vlanid;
info->seq_pkt[SINGLE_PKT].vlanid = info->vlanid;
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_set_port_value(port_info_t * info, char type, uint32_t portValue)
{
if ( type == 'd' )
info->seq_pkt[SINGLE_PKT].dport = (uint16_t)portValue;
else
info->seq_pkt[SINGLE_PKT].sport = (uint16_t)portValue;
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_ping6(port_info_t * info)
{
memcpy(&info->pkt[PING_PKT],
&info->pkt[SINGLE_PKT], sizeof(pkt_seq_t));
info->pkt[PING_PKT].ipProto = PG_IPPROTO_ICMP;
pktgen_packet_ctor(info, PING_PKT, ICMP6_ECHO);
pktgen_set_port_flags(info, SEND_PING6_REQUEST);
}
void
pktgen_set_vlan(port_info_t * info, uint32_t onOff)
{
if ( onOff == ENABLE_STATE )
pktgen_set_port_flags(info, SEND_VLAN_ID);
else
pktgen_clr_port_flags(info, SEND_VLAN_ID);
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_set_ipaddr(port_info_t * info, char type, cmdline_ipaddr_t * ip)
{
if ( type == 's' ) {
info->seq_pkt[SINGLE_PKT].ip_mask = size_to_mask(ip->prefixlen);
info->seq_pkt[SINGLE_PKT].ip_src_addr = ntohl(ip->addr.ipv4.s_addr);
} else
info->seq_pkt[SINGLE_PKT].ip_dst_addr = ntohl(ip->addr.ipv4.s_addr);
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_set_pkt_size(port_info_t * info, uint32_t size)
{
if ( (size - FCS_SIZE) < MIN_PKT_SIZE)
size = (MIN_PKT_SIZE + FCS_SIZE);
else if ( (size - FCS_SIZE) > MAX_PKT_SIZE)
size = MAX_PKT_SIZE + FCS_SIZE;
info->seq_pkt[SINGLE_PKT].pktSize = (size - FCS_SIZE);
pktgen_packet_ctor(info, SINGLE_PKT, -1);
pktgen_packet_rate(info);
}
void
pktgen_set_proto(port_info_t * info, char type)
{
info->seq_pkt[SINGLE_PKT].ipProto = (type == 'u')? PG_IPPROTO_UDP :
(type == 'i') ? PG_IPPROTO_ICMP : PG_IPPROTO_TCP;
// ICMP only works on IPv4 packets.
if ( type == 'i' )
info->seq_pkt[SINGLE_PKT].ethType = ETHER_TYPE_IPv4;
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_port_defaults(uint32_t pid, uint8_t seq)
{
port_info_t * info = &pktgen.info[pid];
pkt_seq_t * pkt = &info->seq_pkt[seq];
port_info_t * dst_info;
pkt->pktSize = MIN_PKT_SIZE;
pkt->sport = DEFAULT_SRC_PORT;
pkt->dport = DEFAULT_DST_PORT;
pkt->ipProto = PG_IPPROTO_TCP;
pkt->ethType = ETHER_TYPE_IPv4;
pkt->vlanid = DEFAULT_VLAN_ID;
info->transmit_count = DEFAULT_TX_COUNT;
info->tx_rate = DEFAULT_TX_RATE;
info->tx_burst = DEFAULT_PKT_BURST;
info->vlanid = DEFAULT_VLAN_ID;
info->seqCnt = 0;
info->seqIdx = 0;
info->prime_cnt = DEFAULT_PRIME_COUNT;
info->delta = 0;
pktgen_packet_rate(info);
pkt->ip_mask = DEFAULT_NETMASK;
if ( (pid & 1) == 0 ) {
pkt->ip_src_addr = DEFAULT_IP_ADDR | (pid << 8) | 1;
pkt->ip_dst_addr = DEFAULT_IP_ADDR | ((pid+1) << 8) | 1;
dst_info = info + 1;
} else {
pkt->ip_src_addr = DEFAULT_IP_ADDR | (pid << 8) | 1;
pkt->ip_dst_addr = DEFAULT_IP_ADDR | ((pid-1) << 8) | 1;
dst_info = info - 1;
}
if (dst_info->seq_pkt != NULL)
ether_addr_copy(&dst_info->seq_pkt[SINGLE_PKT].eth_src_addr,
&pkt->eth_dst_addr);
else
memset(&pkt->eth_dst_addr, 0, sizeof (pkt->eth_dst_addr));
pktgen_packet_ctor(info, seq, -1);
pktgen.flags |= PRINT_LABELS_FLAG;
}
void
pktgen_process_arp( struct rte_mbuf * m, uint32_t pid, uint32_t vlan )
{
port_info_t * info = &pktgen.info[pid];
pkt_seq_t * pkt;
struct ether_hdr *eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
arpPkt_t * arp = (arpPkt_t *)ð[1];
/* Adjust for a vlan header if present */
if ( vlan )
arp = (arpPkt_t *)((char *)arp + sizeof(struct vlan_hdr));
// Process all ARP requests if they are for us.
if ( arp->op == htons(ARP_REQUEST) ) {
if ((rte_atomic32_read(&info->port_flags) & PROCESS_GARP_PKTS) &&
(arp->tpa._32 == arp->spa._32) ) { /* Must be a GARP packet */
pkt = pktgen_find_matching_ipdst(info, arp->spa._32);
/* Found a matching packet, replace the dst address */
if ( pkt ) {
rte_memcpy(&pkt->eth_dst_addr, &arp->sha, 6);
pktgen_set_q_flags(info, wr_get_txque(pktgen.l2p, rte_lcore_id(), pid), DO_TX_CLEANUP);
pktgen_redisplay(0);
}
return;
}
pkt = pktgen_find_matching_ipsrc(info, arp->tpa._32);
/* ARP request not for this interface. */
if ( likely(pkt != NULL) ) {
/* Grab the source MAC address as the destination address for the port. */
if ( unlikely(pktgen.flags & MAC_FROM_ARP_FLAG) ) {
uint32_t i;
rte_memcpy(&pkt->eth_dst_addr, &arp->sha, 6);
for (i = 0; i < info->seqCnt; i++)
pktgen_packet_ctor(info, i, -1);
}
// Swap the two MAC addresses
ethAddrSwap(&arp->sha, &arp->tha);
// Swap the two IP addresses
inetAddrSwap(&arp->tpa._32, &arp->spa._32);
// Set the packet to ARP reply
arp->op = htons(ARP_REPLY);
// Swap the MAC addresses
ethAddrSwap(ð->d_addr, ð->s_addr);
// Copy in the MAC address for the reply.
rte_memcpy(&arp->sha, &pkt->eth_src_addr, 6);
rte_memcpy(ð->s_addr, &pkt->eth_src_addr, 6);
pktgen_send_mbuf(m, pid, 0);
// Flush all of the packets in the queue.
pktgen_set_q_flags(info, 0, DO_TX_FLUSH);
// No need to free mbuf as it was reused
return;
}
} else if ( arp->op == htons(ARP_REPLY) ) {
pkt = pktgen_find_matching_ipsrc(info, arp->tpa._32);
// ARP request not for this interface.
if ( likely(pkt != NULL) ) {
// Grab the real destination MAC address
if ( pkt->ip_dst_addr == ntohl(arp->spa._32) )
rte_memcpy(&pkt->eth_dst_addr, &arp->sha, 6);
pktgen.flags |= PRINT_LABELS_FLAG;
}
}
}
void
pktgen_set_pkt_type(port_info_t * info, char type)
{
info->seq_pkt[SINGLE_PKT].ethType = (type == '6')? ETHER_TYPE_IPv6 : ETHER_TYPE_IPv4;
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
void pktgen_set_dst_mac(port_info_t * info, cmdline_etheraddr_t * mac)
{
memcpy(&info->seq_pkt[SINGLE_PKT].eth_dst_addr, mac->mac, 6);
pktgen_packet_ctor(info, SINGLE_PKT, -1);
}
