static void send_arp_request(struct ofp_ifnet *dev, uint32_t gw)
{
char buf[sizeof(struct ofp_ether_vlan_header) +
sizeof(struct ofp_arphdr)];
struct ofp_arphdr *arp;
struct ofp_ether_header *e1 = (struct ofp_ether_header *)buf;
struct ofp_ether_vlan_header *e2 =
(struct ofp_ether_vlan_header *)buf;
size_t size;
odp_packet_t pkt;
memset(buf, 0, sizeof(buf));
memset(e1->ether_dhost, 0xff, OFP_ETHER_ADDR_LEN);
memcpy(e1->ether_shost, dev->mac, OFP_ETHER_ADDR_LEN);
if (ETH_WITH_VLAN(dev)) {
arp = (struct ofp_arphdr *) (e2 + 1);
e2->evl_encap_proto = odp_cpu_to_be_16(OFP_ETHERTYPE_VLAN);
e2->evl_tag = odp_cpu_to_be_16(dev->vlan);
e2->evl_proto = odp_cpu_to_be_16(OFP_ETHERTYPE_ARP);
size = sizeof(*arp) + sizeof(*e2);
} else {
arp = (struct ofp_arphdr *) (e1 + 1);
e1->ether_type = odp_cpu_to_be_16(OFP_ETHERTYPE_ARP);
size = sizeof(*arp) + sizeof(*e1);
}
arp->hrd = odp_cpu_to_be_16(OFP_ARPHDR_ETHER);
arp->pro = odp_cpu_to_be_16(OFP_ETHERTYPE_IP);
arp->hln = OFP_ETHER_ADDR_LEN;
arp->pln = sizeof(struct ofp_in_addr);
arp->op = odp_cpu_to_be_16(OFP_ARPOP_REQUEST);
memcpy(arp->eth_src, e1->ether_shost, OFP_ETHER_ADDR_LEN);
arp->ip_src = dev->ip_addr;
memcpy(arp->eth_dst, e1->ether_dhost, OFP_ETHER_ADDR_LEN);
arp->ip_dst = gw;
pkt = ofp_packet_alloc(size);
if (pkt == ODP_PACKET_INVALID) {
OFP_ERR("ofp_packet_alloc failed");
return;
}
memcpy(odp_packet_data(pkt), buf, size);
if (odp_unlikely(ofp_if_type(dev) == OFP_IFT_VXLAN)) {
ofp_vxlan_send_arp_request(pkt, dev);
return;
}
odp_packet_has_eth_set(pkt, 1);
odp_packet_has_arp_set(pkt, 1);
odp_packet_l2_offset_set(pkt, 0);
odp_packet_l3_offset_set(pkt, size - sizeof(struct ofp_arphdr));
if (send_pkt_out(dev, pkt) == OFP_PKT_DROP)
odp_packet_free(pkt);
}
enum ofp_return_code ofp_send_frame(struct ofp_ifnet *dev, odp_packet_t pkt)
{
struct ofp_ether_header *eth, eth_tmp;
struct ofp_ether_vlan_header *eth_vlan, eth_vlan_tmp;
uint32_t pkt_len, eth_hdr_len;
enum ofp_return_code rc;
if (ofp_if_type(dev) == OFP_IFT_GRE) {
OFP_ERR("Send frame on GRE port");
return OFP_PKT_DROP;
}
ofp_packet_user_area_reset(pkt);
/* Contsruct ethernet header */
eth = odp_packet_l2_ptr(pkt, NULL);
eth_vlan = odp_packet_l2_ptr(pkt, NULL);
if (odp_be_to_cpu_16(eth->ether_type) == OFP_ETHERTYPE_VLAN) {
if (dev->vlan) {
/* change vlan */
eth_vlan->evl_tag = odp_cpu_to_be_16(dev->vlan);
} else {
/* remove existing vlan */
eth_vlan_tmp = *eth_vlan;
eth = odp_packet_pull_head(pkt, 4);
if (!eth) {
OFP_ERR("odp_packet_pull_head failed");
return OFP_PKT_DROP;
}
odp_packet_l3_offset_set(pkt,
odp_packet_l3_offset(pkt) - 4);
ofp_copy_mac(eth->ether_dhost, eth_vlan_tmp.evl_dhost);
ofp_copy_mac(eth->ether_shost, eth_vlan_tmp.evl_shost);
eth->ether_type = eth_vlan_tmp.evl_proto;
}
} else {
if (dev->vlan) {
/* insert vlan */
eth_tmp = *eth;
eth_vlan = odp_packet_push_head(pkt, 4);
if (!eth_vlan) {
OFP_ERR("odp_packet_push_head failed");
return OFP_PKT_DROP;
}
odp_packet_l3_offset_set(pkt,
odp_packet_l3_offset(pkt) + 4);
ofp_copy_mac(eth_vlan->evl_dhost, eth_tmp.ether_dhost);
ofp_copy_mac(eth_vlan->evl_shost, eth_tmp.ether_shost);
eth_vlan->evl_encap_proto =
odp_cpu_to_be_16(OFP_ETHERTYPE_VLAN);
eth_vlan->evl_tag = odp_cpu_to_be_16(dev->vlan);
eth_vlan->evl_proto = eth_tmp.ether_type;
}
}
if (dev->vlan)
eth_hdr_len = OFP_ETHER_HDR_LEN + OFP_ETHER_VLAN_ENCAP_LEN;
else
eth_hdr_len = OFP_ETHER_HDR_LEN;
pkt_len = odp_packet_len(pkt) - eth_hdr_len;
if (pkt_len > dev->if_mtu) {
OFP_ERR("Packet size bigger than MTU: %d %d", pkt_len,
dev->if_mtu);
return OFP_PKT_DROP;
}
rc = send_pkt_out(dev, pkt);
if (rc != OFP_PKT_PROCESSED)
return rc;
return ofp_send_pending_pkt();
}
enum ofp_return_code ofp_arp_processing(odp_packet_t *pkt)
{
struct ofp_arphdr *arp;
struct ofp_ifnet *dev = odp_packet_user_ptr(*pkt);
struct ofp_ifnet *outdev = dev;
uint16_t vlan = dev->vlan;
uint8_t inner_from_mac[OFP_ETHER_ADDR_LEN];
uint32_t is_ours;
arp = (struct ofp_arphdr *)odp_packet_l3_ptr(*pkt, NULL);
if (odp_unlikely(arp == NULL)) {
OFP_DBG("arp is NULL");
return OFP_PKT_DROP;
}
/* save the received arp info */
if (odp_be_to_cpu_16(arp->op) == OFP_ARPOP_REPLY)
ofp_add_mac(dev, arp->ip_src, arp->eth_src);
OFP_DBG("Device IP: %s, Packet Dest IP: %s",
ofp_print_ip_addr(dev->ip_addr),
ofp_print_ip_addr(arp->ip_dst));
/* Check for VXLAN interface */
if (odp_unlikely(ofp_if_type(dev) == OFP_IFT_VXLAN)) {
ofp_vxlan_update_devices(*pkt, arp, &vlan, &dev, &outdev,
inner_from_mac);
}
is_ours = dev->ip_addr && dev->ip_addr == (ofp_in_addr_t)(arp->ip_dst);
if (!is_ours && !global_param->arp.check_interface) {
/* This may be for some other local interface. */
uint32_t flags;
struct ofp_nh_entry *nh;
nh = ofp_get_next_hop(dev->vrf, arp->ip_dst, &flags);
if (nh)
is_ours = nh->flags & OFP_RTF_LOCAL;
}
/* on our interface an ARP request */
if (is_ours &&
odp_be_to_cpu_16(arp->op) == OFP_ARPOP_REQUEST) {
struct ofp_arphdr tmp;
struct ofp_ether_header tmp_eth;
struct ofp_ether_vlan_header tmp_eth_vlan;
void *l2_addr = odp_packet_l2_ptr(*pkt, NULL);
struct ofp_ether_header *eth =
(struct ofp_ether_header *)l2_addr;
struct ofp_ether_vlan_header *eth_vlan =
(struct ofp_ether_vlan_header *)l2_addr;
ofp_add_mac(dev, arp->ip_src, arp->eth_src);
if (vlan)
tmp_eth_vlan = *eth_vlan;
else
tmp_eth = *eth;
OFP_DBG("Reply to ARPOP_REQ from ip %s"
#ifdef SP
"on IF %d"
#endif
" mac %s ip %s",
ofp_print_ip_addr(arp->ip_src),
#ifdef SP
dev->linux_index,
#endif
ofp_print_mac(dev->mac),
ofp_print_ip_addr(arp->ip_dst));
tmp = *arp;
tmp.ip_dst = arp->ip_src;
tmp.ip_src = arp->ip_dst;
memcpy(&tmp.eth_dst, &arp->eth_src, OFP_ETHER_ADDR_LEN);
memcpy(&tmp.eth_src, dev->mac, OFP_ETHER_ADDR_LEN);
tmp.op = odp_cpu_to_be_16(OFP_ARPOP_REPLY);
*arp = tmp;
if (vlan) {
memcpy(tmp_eth_vlan.evl_dhost, &arp->eth_dst,
OFP_ETHER_ADDR_LEN);
memcpy(tmp_eth_vlan.evl_shost, &arp->eth_src,
OFP_ETHER_ADDR_LEN);
*eth_vlan = tmp_eth_vlan;
} else {
memcpy(tmp_eth.ether_dhost, &arp->eth_dst,
OFP_ETHER_ADDR_LEN);
memcpy(tmp_eth.ether_shost, &arp->eth_src,
OFP_ETHER_ADDR_LEN);
*eth = tmp_eth;
}
if (odp_unlikely(ofp_if_type(dev) == OFP_IFT_VXLAN)) {
/* Restore the original vxlan header and
update the addresses */
ofp_vxlan_restore_and_update_header
(*pkt, outdev, inner_from_mac);
}
return send_pkt_out(outdev, *pkt);
}
return OFP_PKT_CONTINUE;
}
enum ofp_return_code ofp_nd6_ns_output(struct ofp_ifnet *dev,
uint8_t *daddr6, uint8_t *taddr6)
{
size_t size = 0;
size_t iter = 0;
struct ofp_ether_header *e1;
struct ofp_ether_vlan_header *e2;
struct ofp_ip6_hdr *ip6hdr;
struct ofp_icmp6_hdr *icmp;
odp_packet_t pkt;
if (dev->vlan)
size = sizeof(struct ofp_ether_vlan_header);
else
size = sizeof(struct ofp_ether_header);
size += sizeof(struct ofp_ip6_hdr) + sizeof(struct ofp_icmp6_hdr) +
16 /*target addr*/ + 8; /* option*/
pkt = ofp_packet_alloc(size);
if (pkt == ODP_PACKET_INVALID)
return OFP_PKT_DROP;
odp_packet_has_eth_set(pkt, 1);
odp_packet_l2_offset_set(pkt, iter);
if (dev->vlan) {
e2 = (struct ofp_ether_vlan_header *)odp_packet_l2_ptr(pkt,
NULL);
iter += sizeof(*e2);
memset(e2->evl_dhost, 0xff, OFP_ETHER_ADDR_LEN);
memcpy(e2->evl_shost, dev->mac, OFP_ETHER_ADDR_LEN);
e2->evl_encap_proto = odp_cpu_to_be_16(OFP_ETHERTYPE_VLAN);
e2->evl_tag = odp_cpu_to_be_16(dev->vlan);
e2->evl_proto = odp_cpu_to_be_16(OFP_ETHERTYPE_IPV6);
} else {
e1 = (struct ofp_ether_header *)odp_packet_l2_ptr(pkt, NULL);
iter += sizeof(*e1);
memset(e1->ether_dhost, 0xff, OFP_ETHER_ADDR_LEN);
memcpy(e1->ether_shost, dev->mac, OFP_ETHER_ADDR_LEN);
e1->ether_type = odp_cpu_to_be_16(OFP_ETHERTYPE_IPV6);
}
odp_packet_l3_offset_set(pkt, iter);
ip6hdr = (struct ofp_ip6_hdr *)odp_packet_l3_ptr(pkt, NULL);
iter += sizeof(*ip6hdr);
ip6hdr->ofp_ip6_flow = 0;
ip6hdr->ofp_ip6_vfc = OFP_IPV6_VERSION;
ip6hdr->ofp_ip6_plen = odp_cpu_to_be_16(32);
/*sizeof(*icmp) + sizeof taddr + 8*/
/* for checksum calculation */
ip6hdr->ofp_ip6_nxt = 0;
ip6hdr->ofp_ip6_hlim = OFP_IPPROTO_ICMPV6;
/* XXX should be multicast address*/
memcpy(ip6hdr->ip6_src.ofp_s6_addr, dev->ip6_addr, 16);
if (ofp_ip6_is_set(daddr6))
memcpy(ip6hdr->ip6_dst.ofp_s6_addr, daddr6, 16);
else {
/* Solicited-node multicast address */
ip6hdr->ip6_dst.ofp_s6_addr16[0] = OFP_IPV6_ADDR_INT16_MLL;
ip6hdr->ip6_dst.ofp_s6_addr16[1] = 0;
ip6hdr->ip6_dst.ofp_s6_addr32[1] = 0;
ip6hdr->ip6_dst.ofp_s6_addr32[2] = OFP_IPV6_ADDR_INT32_ONE;
ip6hdr->ip6_dst.ofp_s6_addr32[3] = *((uint32_t *)taddr6 + 3);
ip6hdr->ip6_dst.ofp_s6_addr[12] = 0xff;
}
odp_packet_l4_offset_set(pkt, iter);
icmp = (struct ofp_icmp6_hdr *)odp_packet_l4_ptr(pkt, NULL);
iter += sizeof(*icmp) + 8 /* option */;
icmp->icmp6_type = OFP_ND_NEIGHBOR_SOLICIT;
icmp->icmp6_code = 0;
icmp->icmp6_cksum = 0;
icmp->ofp_icmp6_data32[0] = 0; /* Reserved */
memcpy(&icmp->ofp_icmp6_data8[4], taddr6, 16);
/* Option: Source link-layer address */
icmp->ofp_icmp6_data8[20] = OFP_ND_OPT_SOURCE_LINKADDR;
icmp->ofp_icmp6_data8[21] = 1; /* 8 octets */
memcpy(&icmp->ofp_icmp6_data8[22], dev->mac, 6);
icmp->icmp6_cksum = ofp_cksum_buffer(&ip6hdr->ofp_ip6_plen, 68);
ip6hdr->ofp_ip6_nxt = OFP_IPPROTO_ICMPV6;
ip6hdr->ofp_ip6_hlim = 255;
if (send_pkt_out(dev, pkt) == OFP_PKT_DROP) {
OFP_ERR("Drop packet");
odp_packet_free(pkt);
return OFP_PKT_DROP;
}
return OFP_PKT_PROCESSED;
}
static enum ofp_return_code ofp_fragment_pkt(odp_packet_t pkt,
struct ofp_ifnet *dev_out,
uint8_t is_local_address)
{
struct ofp_ip *ip, *ip_new;
uint16_t vlan = dev_out->vlan;
int tot_len, pl_len, seg_len, pl_pos, flen, hwlen;
uint16_t frag, frag_new;
uint8_t *payload_new;
uint32_t payload_offset;
odp_pool_t pkt_pool;
odp_packet_t pkt_new;
struct ofp_ether_header *eth, *eth_new;
struct ofp_ether_vlan_header *eth_vlan, *eth_new_vlan;
int ret = OFP_PKT_PROCESSED;
if (!vlan)
eth = odp_packet_l2_ptr(pkt, NULL);
else
eth_vlan = odp_packet_l2_ptr(pkt, NULL);
ip = (struct ofp_ip *)odp_packet_l3_ptr(pkt, NULL);
pkt_pool = ofp_packet_pool;
tot_len = odp_be_to_cpu_16(ip->ip_len);
pl_len = tot_len - (ip->ip_hl<<2);
seg_len = (dev_out->if_mtu - sizeof(struct ofp_ip)) & 0xfff8;
pl_pos = 0;
frag = odp_be_to_cpu_16(ip->ip_off);
payload_offset = odp_packet_l3_offset(pkt) + (ip->ip_hl<<2);
OFP_UPDATE_PACKET_STAT(tx_eth_frag, 1);
while (pl_pos < pl_len) {
flen = (pl_len - pl_pos) > seg_len ?
seg_len : (pl_len - pl_pos);
hwlen = flen + sizeof(struct ofp_ip) +
(vlan ? sizeof(struct ofp_ether_vlan_header) :
sizeof(struct ofp_ether_header));
pkt_new = odp_packet_alloc(pkt_pool, hwlen);
if (pkt_new == ODP_PACKET_INVALID) {
OFP_ERR("odp_packet_alloc failed");
return OFP_PKT_DROP;
}
odp_packet_user_ptr_set(pkt_new, odp_packet_user_ptr(pkt));
odp_packet_l2_offset_set(pkt_new, 0);
if (vlan) {
eth_new_vlan = odp_packet_l2_ptr(pkt_new, NULL);
*eth_new_vlan = *eth_vlan;
ip_new = (struct ofp_ip *)(eth_new_vlan + 1);
odp_packet_l3_offset_set(pkt_new,
OFP_ETHER_HDR_LEN +
OFP_ETHER_VLAN_ENCAP_LEN);
} else {
eth_new = odp_packet_l2_ptr(pkt_new, NULL);
*eth_new = *eth;
ip_new = (struct ofp_ip *)(eth_new + 1);
odp_packet_l3_offset_set(pkt_new,
OFP_ETHER_HDR_LEN);
}
*ip_new = *ip;
payload_new = (uint8_t *)(ip_new + 1);
if (odp_packet_copydata_out(pkt, payload_offset + pl_pos,
flen, payload_new) < 0) {
OFP_ERR("odp_packet_copydata_out failed");
return OFP_PKT_DROP;
};
ip_new->ip_len = odp_cpu_to_be_16(flen + sizeof(*ip_new));
frag_new = frag + pl_pos/8;
pl_pos += flen;
if (pl_pos < pl_len)
frag_new |= OFP_IP_MF;
ip_new->ip_off = odp_cpu_to_be_16(frag_new);
ip_new->ip_sum = 0;
ip_new->ip_sum = ofp_cksum_buffer((uint16_t *)ip_new,
sizeof(*ip_new));
if (is_local_address)
ret = send_pkt_loop(dev_out, pkt_new);
else
ret = send_pkt_out(dev_out, pkt_new);
if (ret == OFP_PKT_DROP) {
odp_packet_free(pkt_new);
return OFP_PKT_DROP;
}
}
odp_packet_free(pkt);
return OFP_PKT_PROCESSED;
}
enum ofp_return_code ofp_arp_processing(odp_packet_t pkt)
{
struct ofp_arphdr *arp;
struct ofp_ifnet *dev = odp_packet_user_ptr(pkt);
struct ofp_ifnet *outdev = dev;
uint16_t vlan = dev->vlan;
uint8_t inner_from_mac[OFP_ETHER_ADDR_LEN];
arp = (struct ofp_arphdr *)odp_packet_l3_ptr(pkt, NULL);
if (odp_unlikely(arp == NULL)) {
OFP_DBG("arp is NULL");
return OFP_PKT_DROP;
}
/* save the received arp info */
if (odp_be_to_cpu_16(arp->op) == OFP_ARPOP_REPLY)
ofp_add_mac(dev, arp->ip_src, arp->eth_src);
OFP_DBG("Device IP: %s, Packet Dest IP: %s",
ofp_print_ip_addr(dev->ip_addr),
ofp_print_ip_addr(arp->ip_dst));
/* Check for VXLAN interface */
if (odp_unlikely(!PHYS_PORT(dev->port))) {
switch (dev->port) {
case GRE_PORTS:
/* Never happens. */
break;
case VXLAN_PORTS: {
ofp_vxlan_update_devices(arp, &vlan, &dev, &outdev,
inner_from_mac);
break;
}
} /* switch */
}
/* on our interface an ARP request */
if ((dev->ip_addr) && dev->ip_addr == (ofp_in_addr_t)(arp->ip_dst) &&
odp_be_to_cpu_16(arp->op) == OFP_ARPOP_REQUEST) {
struct ofp_arphdr tmp;
struct ofp_ether_header tmp_eth;
struct ofp_ether_vlan_header tmp_eth_vlan;
void *l2_addr = odp_packet_l2_ptr(pkt, NULL);
struct ofp_ether_header *eth =
(struct ofp_ether_header *)l2_addr;
struct ofp_ether_vlan_header *eth_vlan =
(struct ofp_ether_vlan_header *)l2_addr;
ofp_add_mac(dev, arp->ip_src, arp->eth_src);
if (vlan)
tmp_eth_vlan = *eth_vlan;
else
tmp_eth = *eth;
OFP_DBG("Reply to ARPOP_REQ from ip %s"
#ifdef SP
"on IF %d"
#endif
" mac %s ip %s",
ofp_print_ip_addr(arp->ip_src),
#ifdef SP
dev->linux_index,
#endif
ofp_print_mac(dev->mac),
ofp_print_ip_addr(arp->ip_dst));
tmp = *arp;
tmp.ip_dst = arp->ip_src;
tmp.ip_src = arp->ip_dst;
memcpy(&tmp.eth_dst, &arp->eth_src, OFP_ETHER_ADDR_LEN);
memcpy(&tmp.eth_src, dev->mac, OFP_ETHER_ADDR_LEN);
tmp.op = odp_cpu_to_be_16(OFP_ARPOP_REPLY);
*arp = tmp;
if (vlan) {
memcpy(tmp_eth_vlan.evl_dhost, &arp->eth_dst,
OFP_ETHER_ADDR_LEN);
memcpy(tmp_eth_vlan.evl_shost, &arp->eth_src,
OFP_ETHER_ADDR_LEN);
*eth_vlan = tmp_eth_vlan;
} else {
memcpy(tmp_eth.ether_dhost, &arp->eth_dst,
OFP_ETHER_ADDR_LEN);
memcpy(tmp_eth.ether_shost, &arp->eth_src,
OFP_ETHER_ADDR_LEN);
*eth = tmp_eth;
}
if (odp_unlikely(!PHYS_PORT(dev->port))) {
switch (dev->port) {
case GRE_PORTS:
/* Never happens. */
break;
case VXLAN_PORTS: {
/* Restore the original vxlan header and
update the addresses */
ofp_vxlan_restore_and_update_header
(pkt, outdev, inner_from_mac);
break;
}
} /* switch */
} /* not phys port */
return send_pkt_out(outdev, pkt);
}
return OFP_PKT_CONTINUE;
}
