void arp_out(FAR struct net_driver_s *dev) { struct ether_addr ethaddr; FAR struct eth_hdr_s *peth = ETHBUF; FAR struct arp_iphdr_s *pip = IPBUF; in_addr_t ipaddr; in_addr_t destipaddr; int ret; #if defined(CONFIG_NET_PKT) || defined(CONFIG_NET_ARP_SEND) /* Skip sending ARP requests when the frame to be transmitted was * written into a packet socket. */ if (IFF_IS_NOARP(dev->d_flags)) { /* Clear the indication and let the packet continue on its way. */ IFF_CLR_NOARP(dev->d_flags); return; } #endif /* Find the destination IP address in the ARP table and construct * the Ethernet header. If the destination IP address isn't on the * local network, we use the default router's IP address instead. * * If not ARP table entry is found, we overwrite the original IP * packet with an ARP request for the IP address. */ /* First check if destination is a local broadcast. */ if (net_ipv4addr_hdrcmp(pip->eh_destipaddr, g_broadcast_ipaddr)) { memcpy(peth->dest, g_broadcast_ethaddr.ether_addr_octet, ETHER_ADDR_LEN); goto finish_header; } #ifdef CONFIG_NET_IGMP /* Check if the destination address is a multicast address * * - IPv4: multicast addresses lie in the class D group -- The address range * 224.0.0.0 to 239.255.255.255 (224.0.0.0/4) * * - IPv6 multicast addresses are have the high-order octet of the * addresses=0xff (ff00::/8.) */ if (NTOHS(pip->eh_destipaddr[0]) >= 0xe000 && NTOHS(pip->eh_destipaddr[0]) <= 0xefff) { /* Build the well-known IPv4 IGMP Ethernet address. The first * three bytes are fixed; the final three variable come from the * last three bytes of the IPv4 address (network order). * * Address range : 01:00:5e:00:00:00 to 01:00:5e:7f:ff:ff */ FAR const uint8_t *ip = (FAR uint8_t *)pip->eh_destipaddr; peth->dest[0] = g_multicast_ethaddr[0]; peth->dest[1] = g_multicast_ethaddr[1]; peth->dest[2] = g_multicast_ethaddr[2]; peth->dest[3] = ip[1] & 0x7f; peth->dest[4] = ip[2]; peth->dest[5] = ip[3]; goto finish_header; } #endif /* Check if the destination address is on the local network. */ destipaddr = net_ip4addr_conv32(pip->eh_destipaddr); if (!net_ipv4addr_maskcmp(destipaddr, dev->d_ipaddr, dev->d_netmask)) { /* Destination address is not on the local network */ #ifdef CONFIG_NET_ROUTE /* We have a routing table.. find the correct router to use in * this case (or, as a fall-back, use the device's default router * address). We will use the router IP address instead of the * destination address when determining the MAC address. */ netdev_ipv4_router(dev, destipaddr, &ipaddr); #else /* Use the device's default router IP address instead of the * destination address when determining the MAC address. */ net_ipv4addr_copy(ipaddr, dev->d_draddr); #endif } /* The destination address is on the local network. Check if it is * the sub-net broadcast address. */ else if (net_ipv4addr_broadcast(destipaddr, dev->d_netmask)) { /* Yes.. then we won't need to know the destination MAC address */ memcpy(peth->dest, g_broadcast_ethaddr.ether_addr_octet, ETHER_ADDR_LEN); goto finish_header; } else { /* Else, we use the destination IP address. */ net_ipv4addr_copy(ipaddr, destipaddr); } /* Check if we already have this destination address in the ARP table */ ret = arp_find(ipaddr, ðaddr); if (ret < 0) { ninfo("ARP request for IP %08lx\n", (unsigned long)ipaddr); /* The destination address was not in our ARP table, so we overwrite * the IP packet with an ARP request. */ arp_format(dev, ipaddr); arp_dump(ARPBUF); return; } /* Build an Ethernet header. */ memcpy(peth->dest, ethaddr.ether_addr_octet, ETHER_ADDR_LEN); /* Finish populating the Ethernet header */ finish_header: memcpy(peth->src, dev->d_mac.ether.ether_addr_octet, ETHER_ADDR_LEN); peth->type = HTONS(ETHTYPE_IP); dev->d_len += ETH_HDRLEN; }
static uint8_t devif_reassembly(void) { FAR struct ipv4_hdr_s *pbuf = BUF; FAR struct ipv4_hdr_s *pfbuf = FBUF; uint16_t offset; uint16_t len; uint16_t i; /* If g_reassembly_timer is zero, no packet is present in the buffer, so * we write the IP header of the fragment into the reassembly buffer. The * timer is updated with the maximum age. */ if (!g_reassembly_timer) { memcpy(g_reassembly_buffer, &pbuf->vhl, IPv4_HDRLEN); g_reassembly_timer = CONFIG_NET_TCP_REASS_MAXAGE; g_reassembly_flags = 0; /* Clear the bitmap. */ memset(g_reassembly_bitmap, 0, sizeof(g_reassembly_bitmap)); } /* Check if the incoming fragment matches the one currently present * in the reassembly buffer. If so, we proceed with copying the * fragment into the buffer. */ if (net_ipv4addr_hdrcmp(pbuf->srcipaddr, pfbuf->srcipaddr) && net_ipv4addr_hdrcmp(pbuf->destipaddr, pfbuf->destipaddr) && pbuf->g_ipid[0] == pfbuf->g_ipid[0] && pbuf->g_ipid[1] == pfbuf->g_ipid[1]) { len = (pbuf->len[0] << 8) + pbuf->len[1] - (pbuf->vhl & 0x0f) * 4; offset = (((pbuf->ipoffset[0] & 0x3f) << 8) + pbuf->ipoffset[1]) * 8; /* If the offset or the offset + fragment length overflows the * reassembly buffer, we discard the entire packet. */ if (offset > TCP_REASS_BUFSIZE || offset + len > TCP_REASS_BUFSIZE) { g_reassembly_timer = 0; goto nullreturn; } /* Copy the fragment into the reassembly buffer, at the right offset. */ memcpy(&g_reassembly_buffer[IPv4_HDRLEN + offset], (char *)pbuf + (int)((pbuf->vhl & 0x0f) * 4), len); /* Update the bitmap. */ if (offset / (8 * 8) == (offset + len) / (8 * 8)) { /* If the two endpoints are in the same byte, we only update that byte. */ g_reassembly_bitmap[offset / (8 * 8)] |= g_bitmap_bits[(offset / 8 ) & 7] & ~g_bitmap_bits[((offset + len) / 8 ) & 7]; } else { /* If the two endpoints are in different bytes, we update the bytes * in the endpoints and fill the stuff inbetween with 0xff. */ g_reassembly_bitmap[offset / (8 * 8)] |= g_bitmap_bits[(offset / 8 ) & 7]; for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) { g_reassembly_bitmap[i] = 0xff; } g_reassembly_bitmap[(offset + len) / (8 * 8)] |= ~g_bitmap_bits[((offset + len) / 8 ) & 7]; } /* If this fragment has the More Fragments flag set to zero, we know that * this is the last fragment, so we can calculate the size of the entire * packet. We also set the IP_REASS_FLAG_LASTFRAG flag to indicate that * we have received the final fragment. */ if ((pbuf->ipoffset[0] & IP_MF) == 0) { g_reassembly_flags |= TCP_REASS_LASTFRAG; g_reassembly_len = offset + len; } /* Finally, we check if we have a full packet in the buffer. We do this * by checking if we have the last fragment and if all bits in the bitmap * are set. */ if (g_reassembly_flags & TCP_REASS_LASTFRAG) { /* Check all bytes up to and including all but the last byte in * the bitmap. */ for (i = 0; i < g_reassembly_len / (8 * 8) - 1; ++i) { if (g_reassembly_bitmap[i] != 0xff) { goto nullreturn; } } /* Check the last byte in the bitmap. It should contain just the * right amount of bits. */ if (g_reassembly_bitmap[g_reassembly_len / (8 * 8)] != (uint8_t)~g_bitmap_bits[g_reassembly_len / 8 & 7]) { goto nullreturn; } /* If we have come this far, we have a full packet in the buffer, * so we allocate a pbuf and copy the packet into it. We also reset * the timer. */ g_reassembly_timer = 0; memcpy(pbuf, pfbuf, g_reassembly_len); /* Pretend to be a "normal" (i.e., not fragmented) IP packet from * now on. */ pbuf->ipoffset[0] = pbuf->ipoffset[1] = 0; pbuf->len[0] = g_reassembly_len >> 8; pbuf->len[1] = g_reassembly_len & 0xff; pbuf->ipchksum = 0; pbuf->ipchksum = ~(ipv4_chksum(dev)); return g_reassembly_len; } }