[tcpip] Allow supported address families to be detected at runtime
[ipxe.git] / src / net / ipv4.c
1 /*
2 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3 * Copyright (C) 2006 Nikhil Chandru Rao
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 *
20 * You can also choose to distribute this program under the terms of
21 * the Unmodified Binary Distribution Licence (as given in the file
22 * COPYING.UBDL), provided that you have satisfied its requirements.
23 */
24
25 #include <string.h>
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <errno.h>
30 #include <byteswap.h>
31 #include <ipxe/list.h>
32 #include <ipxe/in.h>
33 #include <ipxe/arp.h>
34 #include <ipxe/if_ether.h>
35 #include <ipxe/iobuf.h>
36 #include <ipxe/netdevice.h>
37 #include <ipxe/ip.h>
38 #include <ipxe/tcpip.h>
39 #include <ipxe/dhcp.h>
40 #include <ipxe/settings.h>
41 #include <ipxe/fragment.h>
42 #include <ipxe/ipstat.h>
43 #include <ipxe/profile.h>
44
45 /** @file
46 *
47 * IPv4 protocol
48 *
49 */
50
51 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
52
53 /* Unique IP datagram identification number (high byte) */
54 static uint8_t next_ident_high = 0;
55
56 /** List of IPv4 miniroutes */
57 struct list_head ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes );
58
59 /** IPv4 statistics */
60 static struct ip_statistics ipv4_stats;
61
62 /** IPv4 statistics family */
63 struct ip_statistics_family
64 ipv4_stats_family __ip_statistics_family ( IP_STATISTICS_IPV4 ) = {
65 .version = 4,
66 .stats = &ipv4_stats,
67 };
68
69 /** Transmit profiler */
70 static struct profiler ipv4_tx_profiler __profiler = { .name = "ipv4.tx" };
71
72 /** Receive profiler */
73 static struct profiler ipv4_rx_profiler __profiler = { .name = "ipv4.rx" };
74
75 /**
76 * Add IPv4 minirouting table entry
77 *
78 * @v netdev Network device
79 * @v address IPv4 address
80 * @v netmask Subnet mask
81 * @v gateway Gateway address (if any)
82 * @ret miniroute Routing table entry, or NULL
83 */
84 static struct ipv4_miniroute * __malloc
85 add_ipv4_miniroute ( struct net_device *netdev, struct in_addr address,
86 struct in_addr netmask, struct in_addr gateway ) {
87 struct ipv4_miniroute *miniroute;
88
89 DBGC ( netdev, "IPv4 add %s", inet_ntoa ( address ) );
90 DBGC ( netdev, "/%s ", inet_ntoa ( netmask ) );
91 if ( gateway.s_addr )
92 DBGC ( netdev, "gw %s ", inet_ntoa ( gateway ) );
93 DBGC ( netdev, "via %s\n", netdev->name );
94
95 /* Allocate and populate miniroute structure */
96 miniroute = malloc ( sizeof ( *miniroute ) );
97 if ( ! miniroute ) {
98 DBGC ( netdev, "IPv4 could not add miniroute\n" );
99 return NULL;
100 }
101
102 /* Record routing information */
103 miniroute->netdev = netdev_get ( netdev );
104 miniroute->address = address;
105 miniroute->netmask = netmask;
106 miniroute->gateway = gateway;
107
108 /* Add to end of list if we have a gateway, otherwise
109 * to start of list.
110 */
111 if ( gateway.s_addr ) {
112 list_add_tail ( &miniroute->list, &ipv4_miniroutes );
113 } else {
114 list_add ( &miniroute->list, &ipv4_miniroutes );
115 }
116
117 return miniroute;
118 }
119
120 /**
121 * Delete IPv4 minirouting table entry
122 *
123 * @v miniroute Routing table entry
124 */
125 static void del_ipv4_miniroute ( struct ipv4_miniroute *miniroute ) {
126 struct net_device *netdev = miniroute->netdev;
127
128 DBGC ( netdev, "IPv4 del %s", inet_ntoa ( miniroute->address ) );
129 DBGC ( netdev, "/%s ", inet_ntoa ( miniroute->netmask ) );
130 if ( miniroute->gateway.s_addr )
131 DBGC ( netdev, "gw %s ", inet_ntoa ( miniroute->gateway ) );
132 DBGC ( netdev, "via %s\n", miniroute->netdev->name );
133
134 netdev_put ( miniroute->netdev );
135 list_del ( &miniroute->list );
136 free ( miniroute );
137 }
138
139 /**
140 * Perform IPv4 routing
141 *
142 * @v scope_id Destination address scope ID
143 * @v dest Final destination address
144 * @ret dest Next hop destination address
145 * @ret miniroute Routing table entry to use, or NULL if no route
146 *
147 * If the route requires use of a gateway, the next hop destination
148 * address will be overwritten with the gateway address.
149 */
150 static struct ipv4_miniroute * ipv4_route ( unsigned int scope_id,
151 struct in_addr *dest ) {
152 struct ipv4_miniroute *miniroute;
153
154 /* Find first usable route in routing table */
155 list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
156
157 /* Skip closed network devices */
158 if ( ! netdev_is_open ( miniroute->netdev ) )
159 continue;
160
161 if ( IN_IS_MULTICAST ( dest->s_addr ) ) {
162
163 /* If destination is non-global, and the scope ID
164 * matches this network device, then use this route.
165 */
166 if ( miniroute->netdev->index == scope_id )
167 return miniroute;
168
169 } else {
170
171 /* If destination is an on-link global
172 * address, then use this route.
173 */
174 if ( ( ( dest->s_addr ^ miniroute->address.s_addr )
175 & miniroute->netmask.s_addr ) == 0 )
176 return miniroute;
177
178 /* If destination is an off-link global
179 * address, and we have a default gateway,
180 * then use this route.
181 */
182 if ( miniroute->gateway.s_addr ) {
183 *dest = miniroute->gateway;
184 return miniroute;
185 }
186 }
187 }
188
189 return NULL;
190 }
191
192 /**
193 * Determine transmitting network device
194 *
195 * @v st_dest Destination network-layer address
196 * @ret netdev Transmitting network device, or NULL
197 */
198 static struct net_device * ipv4_netdev ( struct sockaddr_tcpip *st_dest ) {
199 struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
200 struct in_addr dest = sin_dest->sin_addr;
201 struct ipv4_miniroute *miniroute;
202
203 /* Find routing table entry */
204 miniroute = ipv4_route ( sin_dest->sin_scope_id, &dest );
205 if ( ! miniroute )
206 return NULL;
207
208 return miniroute->netdev;
209 }
210
211 /**
212 * Check if IPv4 fragment matches fragment reassembly buffer
213 *
214 * @v fragment Fragment reassembly buffer
215 * @v iobuf I/O buffer
216 * @v hdrlen Length of non-fragmentable potion of I/O buffer
217 * @ret is_fragment Fragment matches this reassembly buffer
218 */
219 static int ipv4_is_fragment ( struct fragment *fragment,
220 struct io_buffer *iobuf,
221 size_t hdrlen __unused ) {
222 struct iphdr *frag_iphdr = fragment->iobuf->data;
223 struct iphdr *iphdr = iobuf->data;
224
225 return ( ( iphdr->src.s_addr == frag_iphdr->src.s_addr ) &&
226 ( iphdr->ident == frag_iphdr->ident ) );
227 }
228
229 /**
230 * Get IPv4 fragment offset
231 *
232 * @v iobuf I/O buffer
233 * @v hdrlen Length of non-fragmentable potion of I/O buffer
234 * @ret offset Offset
235 */
236 static size_t ipv4_fragment_offset ( struct io_buffer *iobuf,
237 size_t hdrlen __unused ) {
238 struct iphdr *iphdr = iobuf->data;
239
240 return ( ( ntohs ( iphdr->frags ) & IP_MASK_OFFSET ) << 3 );
241 }
242
243 /**
244 * Check if more fragments exist
245 *
246 * @v iobuf I/O buffer
247 * @v hdrlen Length of non-fragmentable potion of I/O buffer
248 * @ret more_frags More fragments exist
249 */
250 static int ipv4_more_fragments ( struct io_buffer *iobuf,
251 size_t hdrlen __unused ) {
252 struct iphdr *iphdr = iobuf->data;
253
254 return ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) );
255 }
256
257 /** IPv4 fragment reassembler */
258 static struct fragment_reassembler ipv4_reassembler = {
259 .list = LIST_HEAD_INIT ( ipv4_reassembler.list ),
260 .is_fragment = ipv4_is_fragment,
261 .fragment_offset = ipv4_fragment_offset,
262 .more_fragments = ipv4_more_fragments,
263 .stats = &ipv4_stats,
264 };
265
266 /**
267 * Add IPv4 pseudo-header checksum to existing checksum
268 *
269 * @v iobuf I/O buffer
270 * @v csum Existing checksum
271 * @ret csum Updated checksum
272 */
273 static uint16_t ipv4_pshdr_chksum ( struct io_buffer *iobuf, uint16_t csum ) {
274 struct ipv4_pseudo_header pshdr;
275 struct iphdr *iphdr = iobuf->data;
276 size_t hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
277
278 /* Build pseudo-header */
279 pshdr.src = iphdr->src;
280 pshdr.dest = iphdr->dest;
281 pshdr.zero_padding = 0x00;
282 pshdr.protocol = iphdr->protocol;
283 pshdr.len = htons ( iob_len ( iobuf ) - hdrlen );
284
285 /* Update the checksum value */
286 return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
287 }
288
289 /**
290 * Transmit IP packet
291 *
292 * @v iobuf I/O buffer
293 * @v tcpip Transport-layer protocol
294 * @v st_src Source network-layer address
295 * @v st_dest Destination network-layer address
296 * @v netdev Network device to use if no route found, or NULL
297 * @v trans_csum Transport-layer checksum to complete, or NULL
298 * @ret rc Status
299 *
300 * This function expects a transport-layer segment and prepends the IP header
301 */
302 static int ipv4_tx ( struct io_buffer *iobuf,
303 struct tcpip_protocol *tcpip_protocol,
304 struct sockaddr_tcpip *st_src,
305 struct sockaddr_tcpip *st_dest,
306 struct net_device *netdev,
307 uint16_t *trans_csum ) {
308 struct iphdr *iphdr = iob_push ( iobuf, sizeof ( *iphdr ) );
309 struct sockaddr_in *sin_src = ( ( struct sockaddr_in * ) st_src );
310 struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
311 struct ipv4_miniroute *miniroute;
312 struct in_addr next_hop;
313 struct in_addr netmask = { .s_addr = 0 };
314 uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
315 const void *ll_dest;
316 int rc;
317
318 /* Start profiling */
319 profile_start ( &ipv4_tx_profiler );
320
321 /* Update statistics */
322 ipv4_stats.out_requests++;
323
324 /* Fill up the IP header, except source address */
325 memset ( iphdr, 0, sizeof ( *iphdr ) );
326 iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
327 iphdr->service = IP_TOS;
328 iphdr->len = htons ( iob_len ( iobuf ) );
329 iphdr->ttl = IP_TTL;
330 iphdr->protocol = tcpip_protocol->tcpip_proto;
331 iphdr->dest = sin_dest->sin_addr;
332
333 /* Use routing table to identify next hop and transmitting netdev */
334 next_hop = iphdr->dest;
335 if ( sin_src )
336 iphdr->src = sin_src->sin_addr;
337 if ( ( next_hop.s_addr != INADDR_BROADCAST ) &&
338 ( ( miniroute = ipv4_route ( sin_dest->sin_scope_id,
339 &next_hop ) ) != NULL ) ) {
340 iphdr->src = miniroute->address;
341 netmask = miniroute->netmask;
342 netdev = miniroute->netdev;
343 }
344 if ( ! netdev ) {
345 DBGC ( sin_dest->sin_addr, "IPv4 has no route to %s\n",
346 inet_ntoa ( iphdr->dest ) );
347 ipv4_stats.out_no_routes++;
348 rc = -ENETUNREACH;
349 goto err;
350 }
351
352 /* (Ab)use the "ident" field to convey metadata about the
353 * network device statistics into packet traces. Useful for
354 * extracting debug information from non-debug builds.
355 */
356 iphdr->ident = htons ( ( (++next_ident_high) << 8 ) |
357 ( ( netdev->rx_stats.bad & 0xf ) << 4 ) |
358 ( ( netdev->rx_stats.good & 0xf ) << 0 ) );
359
360 /* Fix up checksums */
361 if ( trans_csum )
362 *trans_csum = ipv4_pshdr_chksum ( iobuf, *trans_csum );
363 iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
364
365 /* Print IP4 header for debugging */
366 DBGC2 ( sin_dest->sin_addr, "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
367 DBGC2 ( sin_dest->sin_addr, "%s len %d proto %d id %04x csum %04x\n",
368 inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ),
369 iphdr->protocol, ntohs ( iphdr->ident ),
370 ntohs ( iphdr->chksum ) );
371
372 /* Calculate link-layer destination address, if possible */
373 if ( ( ( next_hop.s_addr ^ INADDR_BROADCAST ) & ~netmask.s_addr ) == 0){
374 /* Broadcast address */
375 ipv4_stats.out_bcast_pkts++;
376 ll_dest = netdev->ll_broadcast;
377 } else if ( IN_IS_MULTICAST ( next_hop.s_addr ) ) {
378 /* Multicast address */
379 ipv4_stats.out_mcast_pkts++;
380 if ( ( rc = netdev->ll_protocol->mc_hash ( AF_INET, &next_hop,
381 ll_dest_buf ) ) !=0){
382 DBGC ( sin_dest->sin_addr, "IPv4 could not hash "
383 "multicast %s: %s\n",
384 inet_ntoa ( next_hop ), strerror ( rc ) );
385 goto err;
386 }
387 ll_dest = ll_dest_buf;
388 } else {
389 /* Unicast address */
390 ll_dest = NULL;
391 }
392
393 /* Update statistics */
394 ipv4_stats.out_transmits++;
395 ipv4_stats.out_octets += iob_len ( iobuf );
396
397 /* Hand off to link layer (via ARP if applicable) */
398 if ( ll_dest ) {
399 if ( ( rc = net_tx ( iobuf, netdev, &ipv4_protocol, ll_dest,
400 netdev->ll_addr ) ) != 0 ) {
401 DBGC ( sin_dest->sin_addr, "IPv4 could not transmit "
402 "packet via %s: %s\n",
403 netdev->name, strerror ( rc ) );
404 return rc;
405 }
406 } else {
407 if ( ( rc = arp_tx ( iobuf, netdev, &ipv4_protocol, &next_hop,
408 &iphdr->src, netdev->ll_addr ) ) != 0 ) {
409 DBGC ( sin_dest->sin_addr, "IPv4 could not transmit "
410 "packet via %s: %s\n",
411 netdev->name, strerror ( rc ) );
412 return rc;
413 }
414 }
415
416 profile_stop ( &ipv4_tx_profiler );
417 return 0;
418
419 err:
420 free_iob ( iobuf );
421 return rc;
422 }
423
424 /**
425 * Check if network device has any IPv4 address
426 *
427 * @v netdev Network device
428 * @ret has_any_addr Network device has any IPv4 address
429 */
430 int ipv4_has_any_addr ( struct net_device *netdev ) {
431 struct ipv4_miniroute *miniroute;
432
433 list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
434 if ( miniroute->netdev == netdev )
435 return 1;
436 }
437 return 0;
438 }
439
440 /**
441 * Check if network device has a specific IPv4 address
442 *
443 * @v netdev Network device
444 * @v addr IPv4 address
445 * @ret has_addr Network device has this IPv4 address
446 */
447 static int ipv4_has_addr ( struct net_device *netdev, struct in_addr addr ) {
448 struct ipv4_miniroute *miniroute;
449
450 list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
451 if ( ( miniroute->netdev == netdev ) &&
452 ( miniroute->address.s_addr == addr.s_addr ) ) {
453 /* Found matching address */
454 return 1;
455 }
456 }
457 return 0;
458 }
459
460 /**
461 * Process incoming packets
462 *
463 * @v iobuf I/O buffer
464 * @v netdev Network device
465 * @v ll_dest Link-layer destination address
466 * @v ll_source Link-layer destination source
467 * @v flags Packet flags
468 * @ret rc Return status code
469 *
470 * This function expects an IP4 network datagram. It processes the headers
471 * and sends it to the transport layer.
472 */
473 static int ipv4_rx ( struct io_buffer *iobuf,
474 struct net_device *netdev,
475 const void *ll_dest __unused,
476 const void *ll_source __unused,
477 unsigned int flags ) {
478 struct iphdr *iphdr = iobuf->data;
479 size_t hdrlen;
480 size_t len;
481 union {
482 struct sockaddr_in sin;
483 struct sockaddr_tcpip st;
484 } src, dest;
485 uint16_t csum;
486 uint16_t pshdr_csum;
487 int rc;
488
489 /* Start profiling */
490 profile_start ( &ipv4_rx_profiler );
491
492 /* Update statistics */
493 ipv4_stats.in_receives++;
494 ipv4_stats.in_octets += iob_len ( iobuf );
495 if ( flags & LL_BROADCAST ) {
496 ipv4_stats.in_bcast_pkts++;
497 } else if ( flags & LL_MULTICAST ) {
498 ipv4_stats.in_mcast_pkts++;
499 }
500
501 /* Sanity check the IPv4 header */
502 if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
503 DBGC ( iphdr->src, "IPv4 packet too short at %zd bytes (min "
504 "%zd bytes)\n", iob_len ( iobuf ), sizeof ( *iphdr ) );
505 goto err_header;
506 }
507 if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
508 DBGC ( iphdr->src, "IPv4 version %#02x not supported\n",
509 iphdr->verhdrlen );
510 goto err_header;
511 }
512 hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
513 if ( hdrlen < sizeof ( *iphdr ) ) {
514 DBGC ( iphdr->src, "IPv4 header too short at %zd bytes (min "
515 "%zd bytes)\n", hdrlen, sizeof ( *iphdr ) );
516 goto err_header;
517 }
518 if ( hdrlen > iob_len ( iobuf ) ) {
519 DBGC ( iphdr->src, "IPv4 header too long at %zd bytes "
520 "(packet is %zd bytes)\n", hdrlen, iob_len ( iobuf ) );
521 goto err_header;
522 }
523 if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
524 DBGC ( iphdr->src, "IPv4 checksum incorrect (is %04x "
525 "including checksum field, should be 0000)\n", csum );
526 goto err_header;
527 }
528 len = ntohs ( iphdr->len );
529 if ( len < hdrlen ) {
530 DBGC ( iphdr->src, "IPv4 length too short at %zd bytes "
531 "(header is %zd bytes)\n", len, hdrlen );
532 goto err_header;
533 }
534 if ( len > iob_len ( iobuf ) ) {
535 DBGC ( iphdr->src, "IPv4 length too long at %zd bytes "
536 "(packet is %zd bytes)\n", len, iob_len ( iobuf ) );
537 ipv4_stats.in_truncated_pkts++;
538 goto err_other;
539 }
540
541 /* Truncate packet to correct length */
542 iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
543
544 /* Print IPv4 header for debugging */
545 DBGC2 ( iphdr->src, "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
546 DBGC2 ( iphdr->src, "%s len %d proto %d id %04x csum %04x\n",
547 inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
548 ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
549
550 /* Discard unicast packets not destined for us */
551 if ( ( ! ( flags & LL_MULTICAST ) ) &&
552 ipv4_has_any_addr ( netdev ) &&
553 ( ! ipv4_has_addr ( netdev, iphdr->dest ) ) ) {
554 DBGC ( iphdr->src, "IPv4 discarding non-local unicast packet "
555 "for %s\n", inet_ntoa ( iphdr->dest ) );
556 ipv4_stats.in_addr_errors++;
557 goto err_other;
558 }
559
560 /* Perform fragment reassembly if applicable */
561 if ( iphdr->frags & htons ( IP_MASK_OFFSET | IP_MASK_MOREFRAGS ) ) {
562 /* Pass the fragment to fragment_reassemble() which returns
563 * either a fully reassembled I/O buffer or NULL.
564 */
565 iobuf = fragment_reassemble ( &ipv4_reassembler, iobuf,
566 &hdrlen );
567 if ( ! iobuf )
568 return 0;
569 iphdr = iobuf->data;
570 }
571
572 /* Construct socket addresses, calculate pseudo-header
573 * checksum, and hand off to transport layer
574 */
575 memset ( &src, 0, sizeof ( src ) );
576 src.sin.sin_family = AF_INET;
577 src.sin.sin_addr = iphdr->src;
578 memset ( &dest, 0, sizeof ( dest ) );
579 dest.sin.sin_family = AF_INET;
580 dest.sin.sin_addr = iphdr->dest;
581 pshdr_csum = ipv4_pshdr_chksum ( iobuf, TCPIP_EMPTY_CSUM );
582 iob_pull ( iobuf, hdrlen );
583 if ( ( rc = tcpip_rx ( iobuf, netdev, iphdr->protocol, &src.st,
584 &dest.st, pshdr_csum, &ipv4_stats ) ) != 0 ) {
585 DBGC ( src.sin.sin_addr, "IPv4 received packet rejected by "
586 "stack: %s\n", strerror ( rc ) );
587 return rc;
588 }
589
590 profile_stop ( &ipv4_rx_profiler );
591 return 0;
592
593 err_header:
594 ipv4_stats.in_hdr_errors++;
595 err_other:
596 free_iob ( iobuf );
597 return -EINVAL;
598 }
599
600 /**
601 * Check existence of IPv4 address for ARP
602 *
603 * @v netdev Network device
604 * @v net_addr Network-layer address
605 * @ret rc Return status code
606 */
607 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
608 const struct in_addr *address = net_addr;
609
610 if ( ipv4_has_addr ( netdev, *address ) )
611 return 0;
612
613 return -ENOENT;
614 }
615
616 /**
617 * Parse IPv4 address
618 *
619 * @v string IPv4 address string
620 * @ret in IPv4 address to fill in
621 * @ret ok IPv4 address is valid
622 *
623 * Note that this function returns nonzero iff the address is valid,
624 * to match the standard BSD API function of the same name. Unlike
625 * most other iPXE functions, a zero therefore indicates failure.
626 */
627 int inet_aton ( const char *string, struct in_addr *in ) {
628 const char *separator = "...";
629 uint8_t *byte = ( ( uint8_t * ) in );
630 char *endp;
631 unsigned long value;
632
633 while ( 1 ) {
634 value = strtoul ( string, &endp, 0 );
635 if ( string == endp )
636 return 0;
637 if ( value > 0xff )
638 return 0;
639 *(byte++) = value;
640 if ( *endp != *separator )
641 return 0;
642 if ( ! *(separator++) )
643 return 1;
644 string = ( endp + 1 );
645 }
646 }
647
648 /**
649 * Convert IPv4 address to dotted-quad notation
650 *
651 * @v in IPv4 address
652 * @ret string IPv4 address in dotted-quad notation
653 */
654 char * inet_ntoa ( struct in_addr in ) {
655 static char buf[16]; /* "xxx.xxx.xxx.xxx" */
656 uint8_t *bytes = ( uint8_t * ) &in;
657
658 sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
659 return buf;
660 }
661
662 /**
663 * Transcribe IPv4 address
664 *
665 * @v net_addr IPv4 address
666 * @ret string IPv4 address in dotted-quad notation
667 *
668 */
669 static const char * ipv4_ntoa ( const void *net_addr ) {
670 return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
671 }
672
673 /**
674 * Transcribe IPv4 socket address
675 *
676 * @v sa Socket address
677 * @ret string Socket address in standard notation
678 */
679 static const char * ipv4_sock_ntoa ( struct sockaddr *sa ) {
680 struct sockaddr_in *sin = ( ( struct sockaddr_in * ) sa );
681
682 return inet_ntoa ( sin->sin_addr );
683 }
684
685 /**
686 * Parse IPv4 socket address
687 *
688 * @v string Socket address string
689 * @v sa Socket address to fill in
690 * @ret rc Return status code
691 */
692 static int ipv4_sock_aton ( const char *string, struct sockaddr *sa ) {
693 struct sockaddr_in *sin = ( ( struct sockaddr_in * ) sa );
694 struct in_addr in;
695
696 if ( inet_aton ( string, &in ) ) {
697 sin->sin_addr = in;
698 return 0;
699 }
700 return -EINVAL;
701 }
702
703 /** IPv4 protocol */
704 struct net_protocol ipv4_protocol __net_protocol = {
705 .name = "IP",
706 .net_proto = htons ( ETH_P_IP ),
707 .net_addr_len = sizeof ( struct in_addr ),
708 .rx = ipv4_rx,
709 .ntoa = ipv4_ntoa,
710 };
711
712 /** IPv4 TCPIP net protocol */
713 struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol = {
714 .name = "IPv4",
715 .sa_family = AF_INET,
716 .header_len = sizeof ( struct iphdr ),
717 .net_protocol = &ipv4_protocol,
718 .tx = ipv4_tx,
719 .netdev = ipv4_netdev,
720 };
721
722 /** IPv4 ARP protocol */
723 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
724 .net_protocol = &ipv4_protocol,
725 .check = ipv4_arp_check,
726 };
727
728 /** IPv4 socket address converter */
729 struct sockaddr_converter ipv4_sockaddr_converter __sockaddr_converter = {
730 .family = AF_INET,
731 .ntoa = ipv4_sock_ntoa,
732 .aton = ipv4_sock_aton,
733 };
734
735 /******************************************************************************
736 *
737 * Settings
738 *
739 ******************************************************************************
740 */
741
742 /**
743 * Parse IPv4 address setting value
744 *
745 * @v type Setting type
746 * @v value Formatted setting value
747 * @v buf Buffer to contain raw value
748 * @v len Length of buffer
749 * @ret len Length of raw value, or negative error
750 */
751 int parse_ipv4_setting ( const struct setting_type *type __unused,
752 const char *value, void *buf, size_t len ) {
753 struct in_addr ipv4;
754
755 /* Parse IPv4 address */
756 if ( inet_aton ( value, &ipv4 ) == 0 )
757 return -EINVAL;
758
759 /* Copy to buffer */
760 if ( len > sizeof ( ipv4 ) )
761 len = sizeof ( ipv4 );
762 memcpy ( buf, &ipv4, len );
763
764 return ( sizeof ( ipv4 ) );
765 }
766
767 /**
768 * Format IPv4 address setting value
769 *
770 * @v type Setting type
771 * @v raw Raw setting value
772 * @v raw_len Length of raw setting value
773 * @v buf Buffer to contain formatted value
774 * @v len Length of buffer
775 * @ret len Length of formatted value, or negative error
776 */
777 int format_ipv4_setting ( const struct setting_type *type __unused,
778 const void *raw, size_t raw_len, char *buf,
779 size_t len ) {
780 const struct in_addr *ipv4 = raw;
781
782 if ( raw_len < sizeof ( *ipv4 ) )
783 return -EINVAL;
784 return snprintf ( buf, len, "%s", inet_ntoa ( *ipv4 ) );
785 }
786
787 /** IPv4 address setting */
788 const struct setting ip_setting __setting ( SETTING_IP, ip ) = {
789 .name = "ip",
790 .description = "IP address",
791 .tag = DHCP_EB_YIADDR,
792 .type = &setting_type_ipv4,
793 };
794
795 /** IPv4 subnet mask setting */
796 const struct setting netmask_setting __setting ( SETTING_IP, netmask ) = {
797 .name = "netmask",
798 .description = "Subnet mask",
799 .tag = DHCP_SUBNET_MASK,
800 .type = &setting_type_ipv4,
801 };
802
803 /** Default gateway setting */
804 const struct setting gateway_setting __setting ( SETTING_IP, gateway ) = {
805 .name = "gateway",
806 .description = "Default gateway",
807 .tag = DHCP_ROUTERS,
808 .type = &setting_type_ipv4,
809 };
810
811 /**
812 * Create IPv4 routing table based on configured settings
813 *
814 * @ret rc Return status code
815 */
816 static int ipv4_create_routes ( void ) {
817 struct ipv4_miniroute *miniroute;
818 struct ipv4_miniroute *tmp;
819 struct net_device *netdev;
820 struct settings *settings;
821 struct in_addr address = { 0 };
822 struct in_addr netmask = { 0 };
823 struct in_addr gateway = { 0 };
824
825 /* Delete all existing routes */
826 list_for_each_entry_safe ( miniroute, tmp, &ipv4_miniroutes, list )
827 del_ipv4_miniroute ( miniroute );
828
829 /* Create a route for each configured network device */
830 for_each_netdev ( netdev ) {
831 settings = netdev_settings ( netdev );
832 /* Get IPv4 address */
833 address.s_addr = 0;
834 fetch_ipv4_setting ( settings, &ip_setting, &address );
835 if ( ! address.s_addr )
836 continue;
837 /* Get subnet mask */
838 fetch_ipv4_setting ( settings, &netmask_setting, &netmask );
839 /* Calculate default netmask, if necessary */
840 if ( ! netmask.s_addr ) {
841 if ( IN_IS_CLASSA ( address.s_addr ) ) {
842 netmask.s_addr = INADDR_NET_CLASSA;
843 } else if ( IN_IS_CLASSB ( address.s_addr ) ) {
844 netmask.s_addr = INADDR_NET_CLASSB;
845 } else if ( IN_IS_CLASSC ( address.s_addr ) ) {
846 netmask.s_addr = INADDR_NET_CLASSC;
847 }
848 }
849 /* Get default gateway, if present */
850 fetch_ipv4_setting ( settings, &gateway_setting, &gateway );
851 /* Configure route */
852 miniroute = add_ipv4_miniroute ( netdev, address,
853 netmask, gateway );
854 if ( ! miniroute )
855 return -ENOMEM;
856 }
857
858 return 0;
859 }
860
861 /** IPv4 settings applicator */
862 struct settings_applicator ipv4_settings_applicator __settings_applicator = {
863 .apply = ipv4_create_routes,
864 };
865
866 /* Drag in objects via ipv4_protocol */
867 REQUIRING_SYMBOL ( ipv4_protocol );
868
869 /* Drag in ICMPv4 */
870 REQUIRE_OBJECT ( icmpv4 );