/**************************************************************************** * netuip/uip_input.c * The uIP TCP/IP stack code. * * Copyright (C) 2007-2009, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Adapted for NuttX from logic in uIP which also has a BSD-like license: * * uIP is an implementation of the TCP/IP protocol stack intended for * small 8-bit and 16-bit microcontrollers. * * uIP provides the necessary protocols for Internet communication, * with a very small code footprint and RAM requirements - the uIP * code size is on the order of a few kilobytes and RAM usage is on * the order of a few hundred bytes. * * Original author Adam Dunkels * Copyright () 2001-2003, Adam Dunkels. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /**************************************************************************** * uIP is a small implementation of the IP, UDP and TCP protocols (as * well as some basic ICMP stuff). The implementation couples the IP, * UDP, TCP and the application layers very tightly. To keep the size * of the compiled code down, this code frequently uses the goto * statement. While it would be possible to break the uip_input() * function into many smaller functions, this would increase the code * size because of the overhead of parameter passing and the fact that * the optimizer would not be as efficient. * * The principle is that we have a small buffer, called the d_buf, * in which the device driver puts an incoming packet. The TCP/IP * stack parses the headers in the packet, and calls the * application. If the remote host has sent data to the application, * this data is present in the d_buf and the application read the * data from there. It is up to the application to put this data into * a byte stream if needed. The application will not be fed with data * that is out of sequence. * * If the application wishes to send data to the peer, it should put * its data into the d_buf. The d_appdata pointer points to the * first available byte. The TCP/IP stack will calculate the * checksums, and fill in the necessary header fields and finally send * the packet back to the peer. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #ifdef CONFIG_NET #include #include #include #include #include #include #include #include #ifdef CONFIG_NET_IPv6 # include "uip_neighbor.h" #endif /* CONFIG_NET_IPv6 */ #include "uip/uip.h" #include "tcp/tcp.h" #include "udp/udp.h" #include "pkt/pkt.h" #include "icmp/icmp.h" #include "igmp/igmp.h" /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /* Macros. */ #define BUF ((struct uip_ip_hdr *)&dev->d_buf[UIP_LLH_LEN]) #define FBUF ((struct uip_ip_hdr *)&uip_reassbuf[0]) /* IP fragment re-assembly */ #define IP_MF 0x20 #define UIP_REASS_BUFSIZE (CONFIG_NET_BUFSIZE - UIP_LLH_LEN) #define UIP_REASS_FLAG_LASTFRAG 0x01 /**************************************************************************** * Public Variables ****************************************************************************/ /**************************************************************************** * Private Variables ****************************************************************************/ #if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) static uint8_t uip_reassbuf[UIP_REASS_BUFSIZE]; static uint8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)]; static const uint8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01}; static uint16_t uip_reasslen; static uint8_t uip_reassflags; #endif /* UIP_REASSEMBLY */ /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Function: uip_reass * * Description: * IP fragment reassembly: not well-tested. * * Assumptions: * ****************************************************************************/ #if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) static uint8_t uip_reass(void) { struct uip_ip_hdr *pbuf = BUF; struct uip_ip_hdr *pfbuf = FBUF; uint16_t offset; uint16_t len; uint16_t i; /* If uip_reasstmr 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 (!uip_reasstmr) { memcpy(uip_reassbuf, &pbuf->vhl, UIP_IPH_LEN); uip_reasstmr = UIP_REASS_MAXAGE; uip_reassflags = 0; /* Clear the bitmap. */ memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap)); } /* 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 (uiphdr_addr_cmp(pbuf->srcipaddr, pfbuf->srcipaddr) && uiphdr_addr_cmp(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 > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE) { uip_reasstmr = 0; goto nullreturn; } /* Copy the fragment into the reassembly buffer, at the right offset. */ memcpy(&uip_reassbuf[UIP_IPH_LEN + 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. */ uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8 ) & 7] & ~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. */ uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8 ) & 7]; for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) { uip_reassbitmap[i] = 0xff; } uip_reassbitmap[(offset + len) / (8 * 8)] |= ~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) { uip_reassflags |= UIP_REASS_FLAG_LASTFRAG; uip_reasslen = 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 (uip_reassflags & UIP_REASS_FLAG_LASTFRAG) { /* Check all bytes up to and including all but the last byte in * the bitmap. */ for (i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) { if (uip_reassbitmap[i] != 0xff) { goto nullreturn; } } /* Check the last byte in the bitmap. It should contain just the * right amount of bits. */ if (uip_reassbitmap[uip_reasslen / (8 * 8)] != (uint8_t)~bitmap_bits[uip_reasslen / 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. */ uip_reasstmr = 0; memcpy(pbuf, pfbuf, uip_reasslen); /* Pretend to be a "normal" (i.e., not fragmented) IP packet from * now on. */ pbuf->ipoffset[0] = pbuf->ipoffset[1] = 0; pbuf->len[0] = uip_reasslen >> 8; pbuf->len[1] = uip_reasslen & 0xff; pbuf->ipchksum = 0; pbuf->ipchksum = ~(uip_ipchksum(dev)); return uip_reasslen; } } nullreturn: return 0; } #endif /* UIP_REASSEMBLY */ /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Function: uip_input * * Description: * * Returned Value: * OK The packet was processed (or dropped) and can be discarded. * ERROR There is a matching connection, but could not dispatch the packet * yet. Currently useful for UDP when a packet arrives before a recv * call is in place. * * Assumptions: * ****************************************************************************/ int uip_input(struct uip_driver_s *dev) { struct uip_ip_hdr *pbuf = BUF; uint16_t iplen; /* This is where the input processing starts. */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.recv++; #endif /* Start of IP input header processing code. */ #ifdef CONFIG_NET_IPv6 /* Check validity of the IP header. */ if ((pbuf->vtc & 0xf0) != 0x60) { /* IP version and header length. */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; g_netstats.ip.vhlerr++; #endif nlldbg("Invalid IPv6 version: %d\n", pbuf->vtc >> 4); goto drop; } #else /* CONFIG_NET_IPv6 */ /* Check validity of the IP header. */ if (pbuf->vhl != 0x45) { /* IP version and header length. */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; g_netstats.ip.vhlerr++; #endif nlldbg("Invalid IP version or header length: %02x\n", pbuf->vhl); goto drop; } #endif /* CONFIG_NET_IPv6 */ /* Check the size of the packet. If the size reported to us in d_len is * smaller the size reported in the IP header, we assume that the packet * has been corrupted in transit. If the size of d_len is larger than the * size reported in the IP packet header, the packet has been padded and * we set d_len to the correct value. */ #ifdef CONFIG_NET_IPv6 /* The length reported in the IPv6 header is the length of the payload * that follows the header. However, uIP uses the d_len variable for * holding the size of the entire packet, including the IP header. For * IPv4 this is not a problem as the length field in the IPv4 header * contains the length of the entire packet. But for IPv6 we need to add * the size of the IPv6 header (40 bytes). */ iplen = (pbuf->len[0] << 8) + pbuf->len[1] + UIP_IPH_LEN; #else iplen = (pbuf->len[0] << 8) + pbuf->len[1]; #endif /* CONFIG_NET_IPv6 */ if (iplen <= dev->d_len) { dev->d_len = iplen; } else { nlldbg("IP packet shorter than length in IP header\n"); goto drop; } #ifndef CONFIG_NET_IPv6 /* Check the fragment flag. */ if ((pbuf->ipoffset[0] & 0x3f) != 0 || pbuf->ipoffset[1] != 0) { #if UIP_REASSEMBLY dev->d_len = uip_reass(); if (dev->d_len == 0) { goto drop; } #else /* UIP_REASSEMBLY */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; g_netstats.ip.fragerr++; #endif nlldbg("IP fragment dropped\n"); goto drop; #endif /* UIP_REASSEMBLY */ } #endif /* CONFIG_NET_IPv6 */ /* If IP broadcast support is configured, we check for a broadcast * UDP packet, which may be destined to us (even if there is no IP * address yet assigned to the device as is the case when we are * negotiating over DHCP for an address). */ #if defined(CONFIG_NET_BROADCAST) && defined(CONFIG_NET_UDP) if (pbuf->proto == UIP_PROTO_UDP && #ifndef CONFIG_NET_IPv6 uip_ipaddr_cmp(uip_ip4addr_conv(pbuf->destipaddr), g_alloneaddr)) #else uip_ipaddr_cmp(pbuf->destipaddr, g_alloneaddr)) #endif { return udp_input(dev); } /* In most other cases, the device must be assigned a non-zero IP * address. Another exception is when CONFIG_NET_PINGADDRCONF is * enabled... */ else #endif #ifdef CONFIG_NET_ICMP if (uip_ipaddr_cmp(dev->d_ipaddr, g_allzeroaddr)) { /* If we are configured to use ping IP address configuration and * hasn't been assigned an IP address yet, we accept all ICMP * packets. */ #if defined(CONFIG_NET_PINGADDRCONF) && !defined(CONFIG_NET_IPv6) if (pbuf->proto == UIP_PROTO_ICMP) { nlldbg("Possible ping config packet received\n"); icmp_input(dev); goto drop; } else #endif { nlldbg("No IP address assigned\n"); goto drop; } } /* Check if the packet is destined for out IP address */ else #endif { /* Check if the packet is destined for our IP address. */ #ifndef CONFIG_NET_IPv6 if (!uip_ipaddr_cmp(uip_ip4addr_conv(pbuf->destipaddr), dev->d_ipaddr)) { #ifdef CONFIG_NET_IGMP uip_ipaddr_t destip = uip_ip4addr_conv(pbuf->destipaddr); if (igmp_grpfind(dev, &destip) == NULL) #endif { #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; #endif goto drop; } } #else /* CONFIG_NET_IPv6 */ /* For IPv6, packet reception is a little trickier as we need to * make sure that we listen to certain multicast addresses (all * hosts multicast address, and the solicited-node multicast * address) as well. However, we will cheat here and accept all * multicast packets that are sent to the ff02::/16 addresses. */ if (!uip_ipaddr_cmp(pbuf->destipaddr, dev->d_ipaddr) && pbuf->destipaddr[0] != 0xff02) { #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; #endif goto drop; } #endif /* CONFIG_NET_IPv6 */ } #ifndef CONFIG_NET_IPv6 if (uip_ipchksum(dev) != 0xffff) { /* Compute and check the IP header checksum. */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; g_netstats.ip.chkerr++; #endif nlldbg("Bad IP checksum\n"); goto drop; } #endif /* CONFIG_NET_IPv6 */ /* Everything looks good so far. Now process the incoming packet * according to the protocol. */ switch (pbuf->proto) { #ifdef CONFIG_NET_TCP case UIP_PROTO_TCP: /* TCP input */ tcp_input(dev); break; #endif #ifdef CONFIG_NET_UDP case UIP_PROTO_UDP: /* UDP input */ udp_input(dev); break; #endif /* Check for ICMP input */ #ifdef CONFIG_NET_ICMP #ifndef CONFIG_NET_IPv6 case UIP_PROTO_ICMP: /* ICMP input */ #else case UIP_PROTO_ICMP6: /* ICMP6 input */ #endif icmp_input(dev); break; #endif /* Check for ICMP input */ #ifdef CONFIG_NET_IGMP #ifndef CONFIG_NET_IPv6 case UIP_PROTO_IGMP: /* IGMP input */ igmp_input(dev); break; #endif #endif default: /* Unrecognized/unsupported protocol */ #ifdef CONFIG_NET_STATISTICS g_netstats.ip.drop++; g_netstats.ip.protoerr++; #endif nlldbg("Unrecognized IP protocol\n"); goto drop; } /* Return and let the caller do any pending transmission. */ return OK; /* Drop the packet. NOTE that OK is returned meaning that the * packet has been processed (although processed unsuccessfully). */ drop: dev->d_len = 0; return OK; } #endif /* CONFIG_NET */