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