RTL-lwIP-0.4: ip_frag.c File Reference

00107 {
00108   struct pbuf *q;
00109   struct ip_hdr *fraghdr, *iphdr;
00110   u16_t offset, len;
00111   u16_t i;
00112 
00113 #ifdef IP_STATS
00114   ++lwip_stats.ip_frag.recv;
00115 #endif /* IP_STATS */
00116 
00117   iphdr = (struct ip_hdr *) ip_reassbuf;
00118   fraghdr = (struct ip_hdr *) p->payload;
00119   /* If ip_reasstmr is zero, no packet is present in the buffer, so we
00120      write the IP header of the fragment into the reassembly
00121      buffer. The timer is updated with the maximum age. */
00122   if (ip_reasstmr == 0) {
00123     DEBUGF(IP_REASS_DEBUG, ("ip_reass: new packet\n"));
00124     memcpy(iphdr, fraghdr, IP_HLEN);
00125     ip_reasstmr = IP_REASS_MAXAGE;
00126     sys_timeout(IP_REASS_TMO, ip_reass_timer, NULL);
00127     ip_reassflags = 0;
00128     /* Clear the bitmap. */
00129     memset(ip_reassbitmap, 0, sizeof(ip_reassbitmap));
00130   }
00131 
00132   /* Check if the incoming fragment matches the one currently present
00133      in the reasembly buffer. If so, we proceed with copying the
00134      fragment into the buffer. */
00135   if (ip_addr_cmp(&iphdr->src, &fraghdr->src) &&
00136       ip_addr_cmp(&iphdr->dest, &fraghdr->dest) &&
00137       IPH_ID(iphdr) == IPH_ID(fraghdr)) {
00138     DEBUGF(IP_REASS_DEBUG, ("ip_reass: matching old packet\n"));
00139 #ifdef IP_STATS
00140     ++lwip_stats.ip_frag.cachehit;
00141 #endif /* IP_STATS */
00142     /* Find out the offset in the reassembly buffer where we should
00143        copy the fragment. */
00144     len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
00145     offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
00146 
00147     /* If the offset or the offset + fragment length overflows the
00148        reassembly buffer, we discard the entire packet. */
00149     if (offset > IP_REASS_BUFSIZE || offset + len > IP_REASS_BUFSIZE) {
00150       DEBUGF(IP_REASS_DEBUG,
00151              ("ip_reass: fragment outside of buffer (%d:%d/%d).\n", offset,
00152               offset + len, IP_REASS_BUFSIZE));
00153       sys_untimeout(ip_reass_timer, NULL);
00154       ip_reasstmr = 0;
00155       goto nullreturn;
00156     }
00157 
00158     /* Copy the fragment into the reassembly buffer, at the right
00159        offset. */
00160     DEBUGF(IP_REASS_DEBUG,
00161            ("ip_reass: copying with offset %d into %d:%d\n", offset,
00162             IP_HLEN + offset, IP_HLEN + offset + len));
00163     i = IPH_HL(fraghdr) * 4;
00164     copy_from_pbuf(p, &i, &ip_reassbuf[IP_HLEN + offset], len);
00165 
00166     /* Update the bitmap. */
00167     if (offset / (8 * 8) == (offset + len) / (8 * 8)) {
00168       DEBUGF(IP_REASS_DEBUG,
00169              ("ip_reass: updating single byte in bitmap.\n"));
00170       /* If the two endpoints are in the same byte, we only update
00171          that byte. */
00172       ip_reassbitmap[offset / (8 * 8)] |=
00173           bitmap_bits[(offset / 8) & 7] &
00174           ~bitmap_bits[((offset + len) / 8) & 7];
00175     } else {
00176       /* If the two endpoints are in different bytes, we update the
00177          bytes in the endpoints and fill the stuff inbetween with
00178          0xff. */
00179       ip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8) & 7];
00180       DEBUGF(IP_REASS_DEBUG,
00181              ("ip_reass: updating many bytes in bitmap (%d:%d).\n",
00182               1 + offset / (8 * 8), (offset + len) / (8 * 8)));
00183       for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
00184         ip_reassbitmap[i] = 0xff;
00185       }
00186       ip_reassbitmap[(offset + len) / (8 * 8)] |=
00187           ~bitmap_bits[((offset + len) / 8) & 7];
00188     }
00189 
00190     /* If this fragment has the More Fragments flag set to zero, we
00191        know that this is the last fragment, so we can calculate the
00192        size of the entire packet. We also set the
00193        IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
00194        the final fragment. */
00195 
00196     if ((ntohs(IPH_OFFSET(fraghdr)) & IP_MF) == 0) {
00197       ip_reassflags |= IP_REASS_FLAG_LASTFRAG;
00198       ip_reasslen = offset + len;
00199       DEBUGF(IP_REASS_DEBUG,
00200              ("ip_reass: last fragment seen, total len %d\n",
00201               ip_reasslen));
00202     }
00203 
00204     /* Finally, we check if we have a full packet in the buffer. We do
00205        this by checking if we have the last fragment and if all bits
00206        in the bitmap are set. */
00207     if (ip_reassflags & IP_REASS_FLAG_LASTFRAG) {
00208       /* Check all bytes up to and including all but the last byte in
00209          the bitmap. */
00210       for (i = 0; i < ip_reasslen / (8 * 8) - 1; ++i) {
00211         if (ip_reassbitmap[i] != 0xff) {
00212           DEBUGF(IP_REASS_DEBUG,
00213                  ("ip_reass: last fragment seen, bitmap %d/%d failed (%x)\n",
00214                   i, ip_reasslen / (8 * 8) - 1, ip_reassbitmap[i]));
00215           goto nullreturn;
00216         }
00217       }
00218       /* Check the last byte in the bitmap. It should contain just the
00219          right amount of bits. */
00220       if (ip_reassbitmap[ip_reasslen / (8 * 8)] !=
00221           (u8_t) ~ bitmap_bits[ip_reasslen / 8 & 7]) {
00222         DEBUGF(IP_REASS_DEBUG,
00223                ("ip_reass: last fragment seen, bitmap %d didn't contain %x (%x)\n",
00224                 ip_reasslen / (8 * 8), ~bitmap_bits[ip_reasslen / 8 & 7],
00225                 ip_reassbitmap[ip_reasslen / (8 * 8)]));
00226         goto nullreturn;
00227       }
00228 
00229       /* Pretend to be a "normal" (i.e., not fragmented) IP packet
00230          from now on. */
00231       ip_reasslen += IP_HLEN;
00232 
00233       IPH_LEN_SET(iphdr, htons(ip_reasslen));
00234       IPH_OFFSET_SET(iphdr, 0);
00235       IPH_CHKSUM_SET(iphdr, 0);
00236       IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
00237 
00238       /* If we have come this far, we have a full packet in the
00239          buffer, so we allocate a pbuf and copy the packet into it. We
00240          also reset the timer. */
00241       sys_untimeout(ip_reass_timer, NULL);
00242       ip_reasstmr = 0;
00243       pbuf_free(p);
00244       p = pbuf_alloc(PBUF_LINK, ip_reasslen, PBUF_POOL);
00245       if (p != NULL) {
00246         i = 0;
00247         for (q = p; q != NULL; q = q->next) {
00248           /* Copy enough bytes to fill this pbuf in the chain. The
00249              available data in the pbuf is given by the q->len
00250              variable. */
00251           DEBUGF(IP_REASS_DEBUG,
00252                  ("ip_reass: memcpy from %p (%d) to %p, %d bytes\n",
00253                   &ip_reassbuf[i], i, q->payload,
00254                   q->len > ip_reasslen - i ? ip_reasslen - i : q->len));
00255           memcpy(q->payload, &ip_reassbuf[i],
00256                 q->len > ip_reasslen - i ? ip_reasslen - i : q->len);
00257           i += q->len;
00258         }
00259 #ifdef IP_STATS
00260         ++lwip_stats.ip_frag.fw;
00261 #endif /* IP_STATS */
00262       } else {
00263 #ifdef IP_STATS
00264         ++lwip_stats.ip_frag.memerr;
00265 #endif /* IP_STATS */
00266       }
00267       DEBUGF(IP_REASS_DEBUG, ("ip_reass: p %p\n", (void*)p));
00268       return p;
00269     }
00270   }
00271 
00272 nullreturn:
00273 #ifdef IP_STATS
00274   ++lwip_stats.ip_frag.drop;
00275 #endif /* IP_STATS */
00276   pbuf_free(p);
00277   return NULL;
00278 }

Defines
#define	htons HTONS
#define	htonl HTONL
#define	IP_REASS_BUFSIZE 5760
#define	IP_REASS_MAXAGE 30
#define	IP_REASS_TMO 1000
#define	IP_REASS_FLAG_LASTFRAG 0x01
#define	MAX_MTU 1500
Functions
pbuf *	copy_from_pbuf (struct pbuf p, u16_t offset, u8_t *buffer, u16_t len)
void	ip_reass_timer (int signo)
pbuf *	ip_reass (struct pbuf *p)
err_t	ip_frag (struct pbuf p, struct netif netif, struct ip_addr *dest)
Variables
u8_t	ip_reassbuf [IP_HLEN+IP_REASS_BUFSIZE]
u8_t	ip_reassbitmap [IP_REASS_BUFSIZE/(8 *8)]
const u8_t	bitmap_bits [8]
u16_t	ip_reasslen
u8_t	ip_reassflags
u8_t	ip_reasstmr
u8_t	buf [MAX_MTU]
ip_frag.c File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation
