[ipv4] Use a zero address to indicate "no gateway", rather than INADDR_NONE
[people/meteger/gpxe.git] / src / net / ipv4.c
1 #include <string.h>
2 #include <stdint.h>
3 #include <stdlib.h>
4 #include <stdio.h>
5 #include <errno.h>
6 #include <byteswap.h>
7 #include <gpxe/list.h>
8 #include <gpxe/in.h>
9 #include <gpxe/arp.h>
10 #include <gpxe/if_ether.h>
11 #include <gpxe/iobuf.h>
12 #include <gpxe/netdevice.h>
13 #include <gpxe/ip.h>
14 #include <gpxe/tcpip.h>
15 #include <gpxe/dhcp.h>
16 #include <gpxe/settings.h>
17
18 /** @file
19  *
20  * IPv4 protocol
21  *
22  */
23
24 FILE_LICENCE ( GPL2_OR_LATER );
25
26 /* Unique IP datagram identification number */
27 static uint16_t next_ident = 0;
28
29 struct net_protocol ipv4_protocol;
30
31 /** List of IPv4 miniroutes */
32 struct list_head ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes );
33
34 /** List of fragment reassembly buffers */
35 static LIST_HEAD ( frag_buffers );
36
37 /**
38  * Add IPv4 minirouting table entry
39  *
40  * @v netdev            Network device
41  * @v address           IPv4 address
42  * @v netmask           Subnet mask
43  * @v gateway           Gateway address (if any)
44  * @ret miniroute       Routing table entry, or NULL
45  */
46 static struct ipv4_miniroute * __malloc
47 add_ipv4_miniroute ( struct net_device *netdev, struct in_addr address,
48                      struct in_addr netmask, struct in_addr gateway ) {
49         struct ipv4_miniroute *miniroute;
50
51         DBG ( "IPv4 add %s", inet_ntoa ( address ) );
52         DBG ( "/%s ", inet_ntoa ( netmask ) );
53         if ( gateway.s_addr )
54                 DBG ( "gw %s ", inet_ntoa ( gateway ) );
55         DBG ( "via %s\n", netdev->name );
56
57         /* Allocate and populate miniroute structure */
58         miniroute = malloc ( sizeof ( *miniroute ) );
59         if ( ! miniroute ) {
60                 DBG ( "IPv4 could not add miniroute\n" );
61                 return NULL;
62         }
63
64         /* Record routing information */
65         miniroute->netdev = netdev_get ( netdev );
66         miniroute->address = address;
67         miniroute->netmask = netmask;
68         miniroute->gateway = gateway;
69                 
70         /* Add to end of list if we have a gateway, otherwise
71          * to start of list.
72          */
73         if ( gateway.s_addr ) {
74                 list_add_tail ( &miniroute->list, &ipv4_miniroutes );
75         } else {
76                 list_add ( &miniroute->list, &ipv4_miniroutes );
77         }
78
79         return miniroute;
80 }
81
82 /**
83  * Delete IPv4 minirouting table entry
84  *
85  * @v miniroute         Routing table entry
86  */
87 static void del_ipv4_miniroute ( struct ipv4_miniroute *miniroute ) {
88
89         DBG ( "IPv4 del %s", inet_ntoa ( miniroute->address ) );
90         DBG ( "/%s ", inet_ntoa ( miniroute->netmask ) );
91         if ( miniroute->gateway.s_addr )
92                 DBG ( "gw %s ", inet_ntoa ( miniroute->gateway ) );
93         DBG ( "via %s\n", miniroute->netdev->name );
94
95         netdev_put ( miniroute->netdev );
96         list_del ( &miniroute->list );
97         free ( miniroute );
98 }
99
100 /**
101  * Perform IPv4 routing
102  *
103  * @v dest              Final destination address
104  * @ret dest            Next hop destination address
105  * @ret miniroute       Routing table entry to use, or NULL if no route
106  *
107  * If the route requires use of a gateway, the next hop destination
108  * address will be overwritten with the gateway address.
109  */
110 static struct ipv4_miniroute * ipv4_route ( struct in_addr *dest ) {
111         struct ipv4_miniroute *miniroute;
112         int local;
113         int has_gw;
114
115         /* Never attempt to route the broadcast address */
116         if ( dest->s_addr == INADDR_BROADCAST )
117                 return NULL;
118
119         /* Find first usable route in routing table */
120         list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
121                 local = ( ( ( dest->s_addr ^ miniroute->address.s_addr )
122                             & miniroute->netmask.s_addr ) == 0 );
123                 has_gw = ( miniroute->gateway.s_addr );
124                 if ( local || has_gw ) {
125                         if ( ! local )
126                                 *dest = miniroute->gateway;
127                         return miniroute;
128                 }
129         }
130
131         return NULL;
132 }
133
134 /**
135  * Fragment reassembly counter timeout
136  *
137  * @v timer     Retry timer
138  * @v over      If asserted, the timer is greater than @c MAX_TIMEOUT 
139  */
140 static void ipv4_frag_expired ( struct retry_timer *timer __unused,
141                                 int over ) {
142         if ( over ) {
143                 DBG ( "Fragment reassembly timeout" );
144                 /* Free the fragment buffer */
145         }
146 }
147
148 /**
149  * Free fragment buffer
150  *
151  * @v fragbug   Fragment buffer
152  */
153 static void free_fragbuf ( struct frag_buffer *fragbuf ) {
154         free ( fragbuf );
155 }
156
157 /**
158  * Fragment reassembler
159  *
160  * @v iobuf             I/O buffer, fragment of the datagram
161  * @ret frag_iob        Reassembled packet, or NULL
162  */
163 static struct io_buffer * ipv4_reassemble ( struct io_buffer * iobuf ) {
164         struct iphdr *iphdr = iobuf->data;
165         struct frag_buffer *fragbuf;
166         
167         /**
168          * Check if the fragment belongs to any fragment series
169          */
170         list_for_each_entry ( fragbuf, &frag_buffers, list ) {
171                 if ( fragbuf->ident == iphdr->ident &&
172                      fragbuf->src.s_addr == iphdr->src.s_addr ) {
173                         /**
174                          * Check if the packet is the expected fragment
175                          * 
176                          * The offset of the new packet must be equal to the
177                          * length of the data accumulated so far (the length of
178                          * the reassembled I/O buffer
179                          */
180                         if ( iob_len ( fragbuf->frag_iob ) == 
181                               ( iphdr->frags & IP_MASK_OFFSET ) ) {
182                                 /**
183                                  * Append the contents of the fragment to the
184                                  * reassembled I/O buffer
185                                  */
186                                 iob_pull ( iobuf, sizeof ( *iphdr ) );
187                                 memcpy ( iob_put ( fragbuf->frag_iob,
188                                                         iob_len ( iobuf ) ),
189                                          iobuf->data, iob_len ( iobuf ) );
190                                 free_iob ( iobuf );
191
192                                 /** Check if the fragment series is over */
193                                 if ( ! ( iphdr->frags & IP_MASK_MOREFRAGS ) ) {
194                                         iobuf = fragbuf->frag_iob;
195                                         free_fragbuf ( fragbuf );
196                                         return iobuf;
197                                 }
198
199                         } else {
200                                 /* Discard the fragment series */
201                                 free_fragbuf ( fragbuf );
202                                 free_iob ( iobuf );
203                         }
204                         return NULL;
205                 }
206         }
207         
208         /** Check if the fragment is the first in the fragment series */
209         if ( iphdr->frags & IP_MASK_MOREFRAGS &&
210                         ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
211         
212                 /** Create a new fragment buffer */
213                 fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
214                 fragbuf->ident = iphdr->ident;
215                 fragbuf->src = iphdr->src;
216
217                 /* Set up the reassembly I/O buffer */
218                 fragbuf->frag_iob = alloc_iob ( IP_FRAG_IOB_SIZE );
219                 iob_pull ( iobuf, sizeof ( *iphdr ) );
220                 memcpy ( iob_put ( fragbuf->frag_iob, iob_len ( iobuf ) ),
221                          iobuf->data, iob_len ( iobuf ) );
222                 free_iob ( iobuf );
223
224                 /* Set the reassembly timer */
225                 fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
226                 fragbuf->frag_timer.expired = ipv4_frag_expired;
227                 start_timer ( &fragbuf->frag_timer );
228
229                 /* Add the fragment buffer to the list of fragment buffers */
230                 list_add ( &fragbuf->list, &frag_buffers );
231         }
232         
233         return NULL;
234 }
235
236 /**
237  * Add IPv4 pseudo-header checksum to existing checksum
238  *
239  * @v iobuf             I/O buffer
240  * @v csum              Existing checksum
241  * @ret csum            Updated checksum
242  */
243 static uint16_t ipv4_pshdr_chksum ( struct io_buffer *iobuf, uint16_t csum ) {
244         struct ipv4_pseudo_header pshdr;
245         struct iphdr *iphdr = iobuf->data;
246         size_t hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
247
248         /* Build pseudo-header */
249         pshdr.src = iphdr->src;
250         pshdr.dest = iphdr->dest;
251         pshdr.zero_padding = 0x00;
252         pshdr.protocol = iphdr->protocol;
253         pshdr.len = htons ( iob_len ( iobuf ) - hdrlen );
254
255         /* Update the checksum value */
256         return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
257 }
258
259 /**
260  * Determine link-layer address
261  *
262  * @v dest              IPv4 destination address
263  * @v src               IPv4 source address
264  * @v netdev            Network device
265  * @v ll_dest           Link-layer destination address buffer
266  * @ret rc              Return status code
267  */
268 static int ipv4_ll_addr ( struct in_addr dest, struct in_addr src,
269                           struct net_device *netdev, uint8_t *ll_dest ) {
270         struct ll_protocol *ll_protocol = netdev->ll_protocol;
271
272         if ( dest.s_addr == INADDR_BROADCAST ) {
273                 /* Broadcast address */
274                 memcpy ( ll_dest, netdev->ll_broadcast,
275                          ll_protocol->ll_addr_len );
276                 return 0;
277         } else if ( IN_MULTICAST ( ntohl ( dest.s_addr ) ) ) {
278                 return ll_protocol->mc_hash ( AF_INET, &dest, ll_dest );
279         } else {
280                 /* Unicast address: resolve via ARP */
281                 return arp_resolve ( netdev, &ipv4_protocol, &dest,
282                                      &src, ll_dest );
283         }
284 }
285
286 /**
287  * Transmit IP packet
288  *
289  * @v iobuf             I/O buffer
290  * @v tcpip             Transport-layer protocol
291  * @v st_src            Source network-layer address
292  * @v st_dest           Destination network-layer address
293  * @v netdev            Network device to use if no route found, or NULL
294  * @v trans_csum        Transport-layer checksum to complete, or NULL
295  * @ret rc              Status
296  *
297  * This function expects a transport-layer segment and prepends the IP header
298  */
299 static int ipv4_tx ( struct io_buffer *iobuf,
300                      struct tcpip_protocol *tcpip_protocol,
301                      struct sockaddr_tcpip *st_src,
302                      struct sockaddr_tcpip *st_dest,
303                      struct net_device *netdev,
304                      uint16_t *trans_csum ) {
305         struct iphdr *iphdr = iob_push ( iobuf, sizeof ( *iphdr ) );
306         struct sockaddr_in *sin_src = ( ( struct sockaddr_in * ) st_src );
307         struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
308         struct ipv4_miniroute *miniroute;
309         struct in_addr next_hop;
310         uint8_t ll_dest[MAX_LL_ADDR_LEN];
311         int rc;
312
313         /* Fill up the IP header, except source address */
314         memset ( iphdr, 0, sizeof ( *iphdr ) );
315         iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
316         iphdr->service = IP_TOS;
317         iphdr->len = htons ( iob_len ( iobuf ) );       
318         iphdr->ident = htons ( ++next_ident );
319         iphdr->ttl = IP_TTL;
320         iphdr->protocol = tcpip_protocol->tcpip_proto;
321         iphdr->dest = sin_dest->sin_addr;
322
323         /* Use routing table to identify next hop and transmitting netdev */
324         next_hop = iphdr->dest;
325         if ( sin_src )
326                 iphdr->src = sin_src->sin_addr;
327         if ( ( next_hop.s_addr != INADDR_BROADCAST ) &&
328              ( ! IN_MULTICAST ( ntohl ( next_hop.s_addr ) ) ) &&
329              ( ( miniroute = ipv4_route ( &next_hop ) ) != NULL ) ) {
330                 iphdr->src = miniroute->address;
331                 netdev = miniroute->netdev;
332         }
333         if ( ! netdev ) {
334                 DBG ( "IPv4 has no route to %s\n", inet_ntoa ( iphdr->dest ) );
335                 rc = -ENETUNREACH;
336                 goto err;
337         }
338
339         /* Determine link-layer destination address */
340         if ( ( rc = ipv4_ll_addr ( next_hop, iphdr->src, netdev,
341                                    ll_dest ) ) != 0 ) {
342                 DBG ( "IPv4 has no link-layer address for %s: %s\n",
343                       inet_ntoa ( next_hop ), strerror ( rc ) );
344                 goto err;
345         }
346
347         /* Fix up checksums */
348         if ( trans_csum )
349                 *trans_csum = ipv4_pshdr_chksum ( iobuf, *trans_csum );
350         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
351
352         /* Print IP4 header for debugging */
353         DBG ( "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
354         DBG ( "%s len %d proto %d id %04x csum %04x\n",
355               inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ), iphdr->protocol,
356               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
357
358         /* Hand off to link layer */
359         if ( ( rc = net_tx ( iobuf, netdev, &ipv4_protocol, ll_dest ) ) != 0 ) {
360                 DBG ( "IPv4 could not transmit packet via %s: %s\n",
361                       netdev->name, strerror ( rc ) );
362                 return rc;
363         }
364
365         return 0;
366
367  err:
368         free_iob ( iobuf );
369         return rc;
370 }
371
372 /**
373  * Process incoming packets
374  *
375  * @v iobuf     I/O buffer
376  * @v netdev    Network device
377  * @v ll_source Link-layer destination source
378  *
379  * This function expects an IP4 network datagram. It processes the headers 
380  * and sends it to the transport layer.
381  */
382 static int ipv4_rx ( struct io_buffer *iobuf, struct net_device *netdev __unused,
383                      const void *ll_source __unused ) {
384         struct iphdr *iphdr = iobuf->data;
385         size_t hdrlen;
386         size_t len;
387         union {
388                 struct sockaddr_in sin;
389                 struct sockaddr_tcpip st;
390         } src, dest;
391         uint16_t csum;
392         uint16_t pshdr_csum;
393         int rc;
394
395         /* Sanity check the IPv4 header */
396         if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
397                 DBG ( "IPv4 packet too short at %zd bytes (min %zd bytes)\n",
398                       iob_len ( iobuf ), sizeof ( *iphdr ) );
399                 goto err;
400         }
401         if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
402                 DBG ( "IPv4 version %#02x not supported\n", iphdr->verhdrlen );
403                 goto err;
404         }
405         hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
406         if ( hdrlen < sizeof ( *iphdr ) ) {
407                 DBG ( "IPv4 header too short at %zd bytes (min %zd bytes)\n",
408                       hdrlen, sizeof ( *iphdr ) );
409                 goto err;
410         }
411         if ( hdrlen > iob_len ( iobuf ) ) {
412                 DBG ( "IPv4 header too long at %zd bytes "
413                       "(packet is %zd bytes)\n", hdrlen, iob_len ( iobuf ) );
414                 goto err;
415         }
416         if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
417                 DBG ( "IPv4 checksum incorrect (is %04x including checksum "
418                       "field, should be 0000)\n", csum );
419                 goto err;
420         }
421         len = ntohs ( iphdr->len );
422         if ( len < hdrlen ) {
423                 DBG ( "IPv4 length too short at %zd bytes "
424                       "(header is %zd bytes)\n", len, hdrlen );
425                 goto err;
426         }
427         if ( len > iob_len ( iobuf ) ) {
428                 DBG ( "IPv4 length too long at %zd bytes "
429                       "(packet is %zd bytes)\n", len, iob_len ( iobuf ) );
430                 goto err;
431         }
432
433         /* Print IPv4 header for debugging */
434         DBG ( "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
435         DBG ( "%s len %d proto %d id %04x csum %04x\n",
436               inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
437               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
438
439         /* Truncate packet to correct length, calculate pseudo-header
440          * checksum and then strip off the IPv4 header.
441          */
442         iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
443         pshdr_csum = ipv4_pshdr_chksum ( iobuf, TCPIP_EMPTY_CSUM );
444         iob_pull ( iobuf, hdrlen );
445
446         /* Fragment reassembly */
447         if ( ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) ) || 
448              ( ( iphdr->frags & htons ( IP_MASK_OFFSET ) ) != 0 ) ) {
449                 /* Pass the fragment to ipv4_reassemble() which either
450                  * returns a fully reassembled I/O buffer or NULL.
451                  */
452                 iobuf = ipv4_reassemble ( iobuf );
453                 if ( ! iobuf )
454                         return 0;
455         }
456
457         /* Construct socket addresses and hand off to transport layer */
458         memset ( &src, 0, sizeof ( src ) );
459         src.sin.sin_family = AF_INET;
460         src.sin.sin_addr = iphdr->src;
461         memset ( &dest, 0, sizeof ( dest ) );
462         dest.sin.sin_family = AF_INET;
463         dest.sin.sin_addr = iphdr->dest;
464         if ( ( rc = tcpip_rx ( iobuf, iphdr->protocol, &src.st,
465                                &dest.st, pshdr_csum ) ) != 0 ) {
466                 DBG ( "IPv4 received packet rejected by stack: %s\n",
467                       strerror ( rc ) );
468                 return rc;
469         }
470
471         return 0;
472
473  err:
474         free_iob ( iobuf );
475         return -EINVAL;
476 }
477
478 /** 
479  * Check existence of IPv4 address for ARP
480  *
481  * @v netdev            Network device
482  * @v net_addr          Network-layer address
483  * @ret rc              Return status code
484  */
485 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
486         const struct in_addr *address = net_addr;
487         struct ipv4_miniroute *miniroute;
488
489         list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
490                 if ( ( miniroute->netdev == netdev ) &&
491                      ( miniroute->address.s_addr == address->s_addr ) ) {
492                         /* Found matching address */
493                         return 0;
494                 }
495         }
496         return -ENOENT;
497 }
498
499 /**
500  * Convert IPv4 address to dotted-quad notation
501  *
502  * @v in        IP address
503  * @ret string  IP address in dotted-quad notation
504  */
505 char * inet_ntoa ( struct in_addr in ) {
506         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
507         uint8_t *bytes = ( uint8_t * ) &in;
508         
509         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
510         return buf;
511 }
512
513 /**
514  * Transcribe IP address
515  *
516  * @v net_addr  IP address
517  * @ret string  IP address in dotted-quad notation
518  *
519  */
520 static const char * ipv4_ntoa ( const void *net_addr ) {
521         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
522 }
523
524 /** IPv4 protocol */
525 struct net_protocol ipv4_protocol __net_protocol = {
526         .name = "IP",
527         .net_proto = htons ( ETH_P_IP ),
528         .net_addr_len = sizeof ( struct in_addr ),
529         .rx = ipv4_rx,
530         .ntoa = ipv4_ntoa,
531 };
532
533 /** IPv4 TCPIP net protocol */
534 struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol = {
535         .name = "IPv4",
536         .sa_family = AF_INET,
537         .tx = ipv4_tx,
538 };
539
540 /** IPv4 ARP protocol */
541 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
542         .net_protocol = &ipv4_protocol,
543         .check = ipv4_arp_check,
544 };
545
546 /******************************************************************************
547  *
548  * Settings
549  *
550  ******************************************************************************
551  */
552
553 /** IPv4 address setting */
554 struct setting ip_setting __setting = {
555         .name = "ip",
556         .description = "IPv4 address",
557         .tag = DHCP_EB_YIADDR,
558         .type = &setting_type_ipv4,
559 };
560
561 /** IPv4 subnet mask setting */
562 struct setting netmask_setting __setting = {
563         .name = "netmask",
564         .description = "IPv4 subnet mask",
565         .tag = DHCP_SUBNET_MASK,
566         .type = &setting_type_ipv4,
567 };
568
569 /** Default gateway setting */
570 struct setting gateway_setting __setting = {
571         .name = "gateway",
572         .description = "Default gateway",
573         .tag = DHCP_ROUTERS,
574         .type = &setting_type_ipv4,
575 };
576
577 /**
578  * Create IPv4 routing table based on configured settings
579  *
580  * @ret rc              Return status code
581  */
582 static int ipv4_create_routes ( void ) {
583         struct ipv4_miniroute *miniroute;
584         struct ipv4_miniroute *tmp;
585         struct net_device *netdev;
586         struct settings *settings;
587         struct in_addr address = { 0 };
588         struct in_addr netmask = { 0 };
589         struct in_addr gateway = { 0 };
590
591         /* Delete all existing routes */
592         list_for_each_entry_safe ( miniroute, tmp, &ipv4_miniroutes, list )
593                 del_ipv4_miniroute ( miniroute );
594
595         /* Create a route for each configured network device */
596         for_each_netdev ( netdev ) {
597                 settings = netdev_settings ( netdev );
598                 /* Get IPv4 address */
599                 address.s_addr = 0;
600                 fetch_ipv4_setting ( settings, &ip_setting, &address );
601                 if ( ! address.s_addr )
602                         continue;
603                 /* Calculate default netmask */
604                 if ( IN_CLASSA ( ntohl ( address.s_addr ) ) ) {
605                         netmask.s_addr = htonl ( IN_CLASSA_NET );
606                 } else if ( IN_CLASSB ( ntohl ( address.s_addr ) ) ) {
607                         netmask.s_addr = htonl ( IN_CLASSB_NET );
608                 } else if ( IN_CLASSC ( ntohl ( address.s_addr ) ) ) {
609                         netmask.s_addr = htonl ( IN_CLASSC_NET );
610                 } else {
611                         netmask.s_addr = 0;
612                 }
613                 /* Override with subnet mask, if present */
614                 fetch_ipv4_setting ( settings, &netmask_setting, &netmask );
615                 /* Get default gateway, if present */
616                 fetch_ipv4_setting ( settings, &gateway_setting, &gateway );
617                 /* Configure route */
618                 miniroute = add_ipv4_miniroute ( netdev, address,
619                                                  netmask, gateway );
620                 if ( ! miniroute )
621                         return -ENOMEM;
622         }
623
624         return 0;
625 }
626
627 /** IPv4 settings applicator */
628 struct settings_applicator ipv4_settings_applicator __settings_applicator = {
629         .apply = ipv4_create_routes,
630 };
631
632 /* Drag in ICMP */
633 REQUIRE_OBJECT ( icmp );