source: mainline/uspace/srv/net/dhcp/dhcp.c@ b7fd2a0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b7fd2a0 was b7fd2a0, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 8 years ago

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.
  • Property mode set to 100644
File size: 15.2 KB
Line 
1/*
2 * Copyright (c) 2013 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup dhcp
30 * @{
31 */
32/**
33 * @file
34 * @brief DHCP client
35 */
36
37#include <adt/list.h>
38#include <bitops.h>
39#include <byteorder.h>
40#include <errno.h>
41#include <str_error.h>
42#include <fibril_synch.h>
43#include <inet/addr.h>
44#include <inet/dnsr.h>
45#include <inet/inetcfg.h>
46#include <io/log.h>
47#include <loc.h>
48#include <stdio.h>
49#include <stdlib.h>
50
51#include "dhcp.h"
52#include "dhcp_std.h"
53#include "transport.h"
54
55enum {
56 /** In microseconds */
57 dhcp_discover_timeout_val = 5 * 1000 * 1000,
58 /** In microseconds */
59 dhcp_request_timeout_val = 1 * 1000 * 1000,
60 dhcp_discover_retries = 5,
61 dhcp_request_retries = 3
62};
63
64#define MAX_MSG_SIZE 1024
65static uint8_t msgbuf[MAX_MSG_SIZE];
66
67/** List of registered links (of dhcp_link_t) */
68static list_t dhcp_links;
69
70static void dhcpsrv_discover_timeout(void *);
71static void dhcpsrv_request_timeout(void *);
72
73typedef enum {
74 ds_bound,
75 ds_fail,
76 ds_init,
77 ds_init_reboot,
78 ds_rebinding,
79 ds_renewing,
80 ds_requesting,
81 ds_selecting
82} dhcp_state_t;
83
84typedef struct {
85 /** Message type */
86 enum dhcp_msg_type msg_type;
87 /** Offered address */
88 inet_naddr_t oaddr;
89 /** Server address */
90 inet_addr_t srv_addr;
91 /** Router address */
92 inet_addr_t router;
93 /** DNS server */
94 inet_addr_t dns_server;
95} dhcp_offer_t;
96
97typedef struct {
98 /** Link to dhcp_links list */
99 link_t links;
100 /** Link service ID */
101 service_id_t link_id;
102 /** Link info */
103 inet_link_info_t link_info;
104 /** Transport */
105 dhcp_transport_t dt;
106 /** Transport timeout */
107 fibril_timer_t *timeout;
108 /** Number of retries */
109 int retries_left;
110 /** Link state */
111 dhcp_state_t state;
112 /** Last received offer */
113 dhcp_offer_t offer;
114} dhcp_link_t;
115
116static void dhcpsrv_recv(void *, void *, size_t);
117
118/** Decode subnet mask into subnet prefix length. */
119static errno_t subnet_mask_decode(uint32_t mask, int *bits)
120{
121 int zbits;
122 uint32_t nmask;
123
124 if (mask == 0xffffffff) {
125 *bits = 32;
126 return EOK;
127 }
128
129 zbits = 1 + fnzb32(mask ^ 0xffffffff);
130 nmask = BIT_RRANGE(uint32_t, zbits);
131
132 if ((mask ^ nmask) != 0xffffffff) {
133 /* The mask is not in the form 1**n,0**m */
134 return EINVAL;
135 }
136
137 *bits = 32 - zbits;
138 return EOK;
139}
140
141static uint32_t dhcp_uint32_decode(uint8_t *data)
142{
143 return
144 ((uint32_t)data[0] << 24) |
145 ((uint32_t)data[1] << 16) |
146 ((uint32_t)data[2] << 8) |
147 ((uint32_t)data[3]);
148}
149
150static errno_t dhcp_send_discover(dhcp_link_t *dlink)
151{
152 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
153 uint8_t *opt = msgbuf + sizeof(dhcp_hdr_t);
154
155 memset(msgbuf, 0, MAX_MSG_SIZE);
156 hdr->op = op_bootrequest;
157 hdr->htype = 1; /* AHRD_ETHERNET */
158 hdr->hlen = sizeof(addr48_t);
159 hdr->xid = host2uint32_t_be(42);
160 hdr->flags = flag_broadcast;
161
162 addr48(dlink->link_info.mac_addr, hdr->chaddr);
163 hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
164
165 opt[0] = opt_msg_type;
166 opt[1] = 1;
167 opt[2] = msg_dhcpdiscover;
168 opt[3] = opt_end;
169
170 return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + 4);
171}
172
173static errno_t dhcp_send_request(dhcp_link_t *dlink, dhcp_offer_t *offer)
174{
175 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
176 uint8_t *opt = msgbuf + sizeof(dhcp_hdr_t);
177 size_t i;
178
179 memset(msgbuf, 0, MAX_MSG_SIZE);
180 hdr->op = op_bootrequest;
181 hdr->htype = 1; /* AHRD_ETHERNET */
182 hdr->hlen = 6;
183 hdr->xid = host2uint32_t_be(42);
184 hdr->flags = flag_broadcast;
185 hdr->ciaddr = host2uint32_t_be(offer->oaddr.addr);
186 addr48(dlink->link_info.mac_addr, hdr->chaddr);
187 hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
188
189 i = 0;
190
191 opt[i++] = opt_msg_type;
192 opt[i++] = 1;
193 opt[i++] = msg_dhcprequest;
194
195 opt[i++] = opt_req_ip_addr;
196 opt[i++] = 4;
197 opt[i++] = offer->oaddr.addr >> 24;
198 opt[i++] = (offer->oaddr.addr >> 16) & 0xff;
199 opt[i++] = (offer->oaddr.addr >> 8) & 0xff;
200 opt[i++] = offer->oaddr.addr & 0xff;
201
202 opt[i++] = opt_server_id;
203 opt[i++] = 4;
204 opt[i++] = offer->srv_addr.addr >> 24;
205 opt[i++] = (offer->srv_addr.addr >> 16) & 0xff;
206 opt[i++] = (offer->srv_addr.addr >> 8) & 0xff;
207 opt[i++] = offer->srv_addr.addr & 0xff;
208
209 opt[i++] = opt_end;
210
211 return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + i);
212}
213
214static errno_t dhcp_parse_reply(void *msg, size_t size, dhcp_offer_t *offer)
215{
216 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msg;
217 inet_addr_t yiaddr;
218 inet_addr_t siaddr;
219 inet_addr_t giaddr;
220 uint32_t subnet_mask;
221 bool have_subnet_mask = false;
222 bool have_server_id = false;
223 int subnet_bits;
224 char *saddr;
225 uint8_t opt_type, opt_len;
226 uint8_t *msgb;
227 errno_t rc;
228 size_t i;
229
230 log_msg(LOG_DEFAULT, LVL_DEBUG, "Receive reply");
231 memset(offer, 0, sizeof(*offer));
232
233 inet_addr_set(uint32_t_be2host(hdr->yiaddr), &yiaddr);
234 rc = inet_addr_format(&yiaddr, &saddr);
235 if (rc != EOK)
236 return rc;
237
238 log_msg(LOG_DEFAULT, LVL_DEBUG, "Your IP address: %s", saddr);
239 free(saddr);
240
241 inet_addr_set(uint32_t_be2host(hdr->siaddr), &siaddr);
242 rc = inet_addr_format(&siaddr, &saddr);
243 if (rc != EOK)
244 return rc;
245
246 log_msg(LOG_DEFAULT, LVL_DEBUG, "Next server IP address: %s", saddr);
247 free(saddr);
248
249 inet_addr_set(uint32_t_be2host(hdr->giaddr), &giaddr);
250 rc = inet_addr_format(&giaddr, &saddr);
251 if (rc != EOK)
252 return rc;
253
254 log_msg(LOG_DEFAULT, LVL_DEBUG, "Relay agent IP address: %s", saddr);
255 free(saddr);
256
257 inet_naddr_set(yiaddr.addr, 0, &offer->oaddr);
258
259 msgb = (uint8_t *)msg;
260
261 i = sizeof(dhcp_hdr_t);
262 while (i < size) {
263 opt_type = msgb[i++];
264
265 if (opt_type == opt_pad)
266 continue;
267 if (opt_type == opt_end)
268 break;
269
270 if (i >= size)
271 return EINVAL;
272
273 opt_len = msgb[i++];
274
275 if (i + opt_len > size)
276 return EINVAL;
277
278 switch (opt_type) {
279 case opt_subnet_mask:
280 if (opt_len != 4)
281 return EINVAL;
282 subnet_mask = dhcp_uint32_decode(&msgb[i]);
283 rc = subnet_mask_decode(subnet_mask, &subnet_bits);
284 if (rc != EOK)
285 return EINVAL;
286 offer->oaddr.prefix = subnet_bits;
287 have_subnet_mask = true;
288 break;
289 case opt_msg_type:
290 if (opt_len != 1)
291 return EINVAL;
292 offer->msg_type = msgb[i];
293 break;
294 case opt_server_id:
295 if (opt_len != 4)
296 return EINVAL;
297 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
298 &offer->srv_addr);
299 have_server_id = true;
300 break;
301 case opt_router:
302 if (opt_len != 4)
303 return EINVAL;
304 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
305 &offer->router);
306 break;
307 case opt_dns_server:
308 if (opt_len < 4 || opt_len % 4 != 0)
309 return EINVAL;
310 /* XXX Handle multiple DNS servers properly */
311 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
312 &offer->dns_server);
313 break;
314 case opt_end:
315 break;
316 default:
317 break;
318 }
319
320 /* Advance to the next option */
321 i = i + opt_len;
322 }
323
324 if (!have_server_id) {
325 log_msg(LOG_DEFAULT, LVL_ERROR, "Missing server ID option.");
326 return rc;
327 }
328
329 if (!have_subnet_mask) {
330 log_msg(LOG_DEFAULT, LVL_ERROR, "Missing subnet mask option.");
331 return rc;
332 }
333
334 rc = inet_naddr_format(&offer->oaddr, &saddr);
335 if (rc != EOK)
336 return rc;
337
338 log_msg(LOG_DEFAULT, LVL_DEBUG, "Offered network address: %s", saddr);
339 free(saddr);
340
341 if (offer->router.addr != 0) {
342 rc = inet_addr_format(&offer->router, &saddr);
343 if (rc != EOK)
344 return rc;
345
346 log_msg(LOG_DEFAULT, LVL_DEBUG, "Router address: %s", saddr);
347 free(saddr);
348 }
349
350 if (offer->dns_server.addr != 0) {
351 rc = inet_addr_format(&offer->dns_server, &saddr);
352 if (rc != EOK)
353 return rc;
354
355 log_msg(LOG_DEFAULT, LVL_DEBUG, "DNS server: %s", saddr);
356 free(saddr);
357 }
358
359 return EOK;
360}
361
362static errno_t dhcp_cfg_create(service_id_t iplink, dhcp_offer_t *offer)
363{
364 errno_t rc;
365 service_id_t addr_id;
366 service_id_t sroute_id;
367 inet_naddr_t defr;
368
369 rc = inetcfg_addr_create_static("dhcp4a", &offer->oaddr, iplink,
370 &addr_id);
371 if (rc != EOK) {
372 log_msg(LOG_DEFAULT, LVL_ERROR,
373 "Error creating IP address %s: %s", "dhcp4a", str_error(rc));
374 return rc;
375 }
376
377 if (offer->router.addr != 0) {
378 inet_naddr_set(0, 0, &defr);
379
380 rc = inetcfg_sroute_create("dhcpdef", &defr, &offer->router, &sroute_id);
381 if (rc != EOK) {
382 log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating "
383 "default route %s: %s.", "dhcpdef", str_error(rc));
384 return rc;
385 }
386 }
387
388 if (offer->dns_server.addr != 0) {
389 rc = dnsr_set_srvaddr(&offer->dns_server);
390 if (rc != EOK) {
391 log_msg(LOG_DEFAULT, LVL_ERROR, "Error setting "
392 "nameserver address: %s)", str_error(rc));
393 return rc;
394 }
395 }
396
397 return EOK;
398}
399
400void dhcpsrv_links_init(void)
401{
402 list_initialize(&dhcp_links);
403}
404
405static dhcp_link_t *dhcpsrv_link_find(service_id_t link_id)
406{
407 list_foreach(dhcp_links, links, dhcp_link_t, dlink) {
408 if (dlink->link_id == link_id)
409 return dlink;
410 }
411
412 return NULL;
413}
414
415static void dhcp_link_set_failed(dhcp_link_t *dlink)
416{
417 log_msg(LOG_DEFAULT, LVL_NOTE, "Giving up on link %s",
418 dlink->link_info.name);
419 dlink->state = ds_fail;
420}
421
422static errno_t dhcp_discover_proc(dhcp_link_t *dlink)
423{
424 dlink->state = ds_selecting;
425
426 errno_t rc = dhcp_send_discover(dlink);
427 if (rc != EOK)
428 return EIO;
429
430 dlink->retries_left = dhcp_discover_retries;
431
432 if ((dlink->timeout->state == fts_not_set) ||
433 (dlink->timeout->state == fts_fired))
434 fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
435 dhcpsrv_discover_timeout, dlink);
436
437 return rc;
438}
439
440errno_t dhcpsrv_link_add(service_id_t link_id)
441{
442 dhcp_link_t *dlink;
443 errno_t rc;
444
445 log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
446
447 if (dhcpsrv_link_find(link_id) != NULL) {
448 log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu already added",
449 link_id);
450 return EEXIST;
451 }
452
453 dlink = calloc(1, sizeof(dhcp_link_t));
454 if (dlink == NULL)
455 return ENOMEM;
456
457 dlink->link_id = link_id;
458 dlink->timeout = fibril_timer_create(NULL);
459 if (dlink->timeout == NULL) {
460 rc = ENOMEM;
461 goto error;
462 }
463
464 /* Get link hardware address */
465 rc = inetcfg_link_get(link_id, &dlink->link_info);
466 if (rc != EOK) {
467 log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting properties "
468 "for link %zu.", link_id);
469 rc = EIO;
470 goto error;
471 }
472
473 rc = dhcp_transport_init(&dlink->dt, link_id, dhcpsrv_recv, dlink);
474 if (rc != EOK) {
475 log_msg(LOG_DEFAULT, LVL_ERROR, "Error initializing DHCP "
476 "transport for link %s.", dlink->link_info.name);
477 rc = EIO;
478 goto error;
479 }
480
481 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
482 rc = dhcp_discover_proc(dlink);
483 if (rc != EOK) {
484 log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER.");
485 dhcp_link_set_failed(dlink);
486 rc = EIO;
487 goto error;
488 }
489
490 list_append(&dlink->links, &dhcp_links);
491
492 return EOK;
493error:
494 if (dlink != NULL && dlink->timeout != NULL)
495 fibril_timer_destroy(dlink->timeout);
496 free(dlink);
497 return rc;
498}
499
500errno_t dhcpsrv_link_remove(service_id_t link_id)
501{
502 return ENOTSUP;
503}
504
505errno_t dhcpsrv_discover(service_id_t link_id)
506{
507 log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
508
509 dhcp_link_t *dlink = dhcpsrv_link_find(link_id);
510
511 if (dlink == NULL) {
512 log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu doesn't exist",
513 link_id);
514 return EINVAL;
515 }
516
517 return dhcp_discover_proc(dlink);
518}
519
520static void dhcpsrv_recv_offer(dhcp_link_t *dlink, dhcp_offer_t *offer)
521{
522 errno_t rc;
523
524 if (dlink->state != ds_selecting) {
525 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received offer in state "
526 " %d, ignoring.", (int)dlink->state);
527 return;
528 }
529
530 fibril_timer_clear(dlink->timeout);
531 dlink->offer = *offer;
532 dlink->state = ds_requesting;
533
534 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
535 rc = dhcp_send_request(dlink, offer);
536 if (rc != EOK) {
537 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
538 return;
539 }
540
541 dlink->retries_left = dhcp_request_retries;
542 fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
543 dhcpsrv_request_timeout, dlink);
544}
545
546static void dhcpsrv_recv_ack(dhcp_link_t *dlink, dhcp_offer_t *offer)
547{
548 errno_t rc;
549
550 if (dlink->state != ds_requesting) {
551 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received ack in state "
552 " %d, ignoring.", (int)dlink->state);
553 return;
554 }
555
556 fibril_timer_clear(dlink->timeout);
557 dlink->offer = *offer;
558 dlink->state = ds_bound;
559
560 rc = dhcp_cfg_create(dlink->link_id, offer);
561 if (rc != EOK) {
562 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error creating configuration.");
563 return;
564 }
565
566 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: Successfully configured.",
567 dlink->link_info.name);
568}
569
570static void dhcpsrv_recv(void *arg, void *msg, size_t size)
571{
572 dhcp_link_t *dlink = (dhcp_link_t *)arg;
573 dhcp_offer_t offer;
574 errno_t rc;
575
576 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: dhcpsrv_recv() %zu bytes",
577 dlink->link_info.name, size);
578
579 rc = dhcp_parse_reply(msg, size, &offer);
580 if (rc != EOK) {
581 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error parsing reply");
582 return;
583 }
584
585 switch (offer.msg_type) {
586 case msg_dhcpoffer:
587 dhcpsrv_recv_offer(dlink, &offer);
588 break;
589 case msg_dhcpack:
590 dhcpsrv_recv_ack(dlink, &offer);
591 break;
592 default:
593 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received unexpected "
594 "message type. %d", (int)offer.msg_type);
595 break;
596 }
597}
598
599static void dhcpsrv_discover_timeout(void *arg)
600{
601 dhcp_link_t *dlink = (dhcp_link_t *)arg;
602 errno_t rc;
603
604 assert(dlink->state == ds_selecting);
605 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dcpsrv_discover_timeout",
606 dlink->link_info.name);
607
608 if (dlink->retries_left == 0) {
609 log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
610 dhcp_link_set_failed(dlink);
611 return;
612 }
613 --dlink->retries_left;
614
615 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
616 rc = dhcp_send_discover(dlink);
617 if (rc != EOK) {
618 log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER");
619 dhcp_link_set_failed(dlink);
620 return;
621 }
622
623 fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
624 dhcpsrv_discover_timeout, dlink);
625}
626
627static void dhcpsrv_request_timeout(void *arg)
628{
629 dhcp_link_t *dlink = (dhcp_link_t *)arg;
630 errno_t rc;
631
632 assert(dlink->state == ds_requesting);
633 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dcpsrv_request_timeout",
634 dlink->link_info.name);
635
636 if (dlink->retries_left == 0) {
637 log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
638 dhcp_link_set_failed(dlink);
639 return;
640 }
641 --dlink->retries_left;
642
643 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
644 rc = dhcp_send_request(dlink, &dlink->offer);
645 if (rc != EOK) {
646 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
647 dhcp_link_set_failed(dlink);
648 return;
649 }
650
651 fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
652 dhcpsrv_request_timeout, dlink);
653}
654
655/** @}
656 */
Note: See TracBrowser for help on using the repository browser.