Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

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