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