source: mainline/uspace/srv/net/dhcp/dhcp.c@ 9aa51406

Last change on this file since 9aa51406 was 1bbc6dc, checked in by Jiri Svoboda <jiri@…>, 9 months ago

Network configuration persistence.

nconfsrv is folded into inetsrv
DHCP is disabled when a static address is configured on a link
  • Property mode set to 100644
File size: 16.1 KB
Line 
1/*
2 * Copyright (c) 2024 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/eth_addr.h>
45#include <inet/dnsr.h>
46#include <inet/inetcfg.h>
47#include <io/log.h>
48#include <loc.h>
49#include <rndgen.h>
50#include <stdio.h>
51#include <stdlib.h>
52#include <str.h>
53
54#include "dhcp.h"
55#include "dhcp_std.h"
56#include "transport.h"
57
58enum {
59 /** In microseconds */
60 dhcp_discover_timeout_val = 5 * 1000 * 1000,
61 /** In microseconds */
62 dhcp_request_timeout_val = 1 * 1000 * 1000,
63 dhcp_discover_retries = 5,
64 dhcp_request_retries = 3
65};
66
67#define MAX_MSG_SIZE 1024
68static uint8_t msgbuf[MAX_MSG_SIZE];
69
70/** List of registered links (of dhcp_link_t) */
71static list_t dhcp_links;
72
73bool inetcfg_inited = false;
74
75static void dhcpsrv_discover_timeout(void *);
76static void dhcpsrv_request_timeout(void *);
77
78typedef enum {
79 ds_bound,
80 ds_fail,
81 ds_init,
82 ds_init_reboot,
83 ds_rebinding,
84 ds_renewing,
85 ds_requesting,
86 ds_selecting
87} dhcp_state_t;
88
89typedef struct {
90 /** Message type */
91 enum dhcp_msg_type msg_type;
92 /** Offered address */
93 inet_naddr_t oaddr;
94 /** Server address */
95 inet_addr_t srv_addr;
96 /** Router address */
97 inet_addr_t router;
98 /** DNS server */
99 inet_addr_t dns_server;
100 /** Transaction ID */
101 uint32_t xid;
102} dhcp_offer_t;
103
104typedef struct {
105 /** Link to dhcp_links list */
106 link_t links;
107 /** Link service ID */
108 service_id_t link_id;
109 /** Link info */
110 inet_link_info_t link_info;
111 /** Transport */
112 dhcp_transport_t dt;
113 /** Transport timeout */
114 fibril_timer_t *timeout;
115 /** Number of retries */
116 int retries_left;
117 /** Link state */
118 dhcp_state_t state;
119 /** Last received offer */
120 dhcp_offer_t offer;
121 /** Random number generator */
122 rndgen_t *rndgen;
123} dhcp_link_t;
124
125static void dhcpsrv_recv(void *, void *, size_t);
126
127/** Decode subnet mask into subnet prefix length. */
128static errno_t subnet_mask_decode(uint32_t mask, int *bits)
129{
130 int zbits;
131 uint32_t nmask;
132
133 if (mask == 0xffffffff) {
134 *bits = 32;
135 return EOK;
136 }
137
138 zbits = 1 + fnzb32(mask ^ 0xffffffff);
139 nmask = BIT_RRANGE(uint32_t, zbits);
140
141 if ((mask ^ nmask) != 0xffffffff) {
142 /* The mask is not in the form 1**n,0**m */
143 return EINVAL;
144 }
145
146 *bits = 32 - zbits;
147 return EOK;
148}
149
150static uint32_t dhcp_uint32_decode(uint8_t *data)
151{
152 return
153 ((uint32_t)data[0] << 24) |
154 ((uint32_t)data[1] << 16) |
155 ((uint32_t)data[2] << 8) |
156 ((uint32_t)data[3]);
157}
158
159static errno_t dhcp_send_discover(dhcp_link_t *dlink)
160{
161 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
162 uint8_t *opt = msgbuf + sizeof(dhcp_hdr_t);
163 uint32_t xid;
164 errno_t rc;
165 size_t i;
166
167 rc = rndgen_uint32(dlink->rndgen, &xid);
168 if (rc != EOK)
169 return rc;
170
171 memset(msgbuf, 0, MAX_MSG_SIZE);
172 hdr->op = op_bootrequest;
173 hdr->htype = 1; /* AHRD_ETHERNET */
174 hdr->hlen = ETH_ADDR_SIZE;
175 hdr->xid = host2uint32_t_be(xid);
176 hdr->flags = host2uint16_t_be(flag_broadcast);
177
178 eth_addr_encode(&dlink->link_info.mac_addr, hdr->chaddr);
179 hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
180
181 i = 0;
182
183 opt[i++] = opt_msg_type;
184 opt[i++] = 1;
185 opt[i++] = msg_dhcpdiscover;
186
187 opt[i++] = opt_param_req_list;
188 opt[i++] = 3;
189 opt[i++] = 1; /* subnet mask */
190 opt[i++] = 6; /* DNS server */
191 opt[i++] = 3; /* router */
192
193 opt[i++] = opt_end;
194
195 return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + i);
196}
197
198static errno_t dhcp_send_request(dhcp_link_t *dlink, dhcp_offer_t *offer)
199{
200 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
201 uint8_t *opt = msgbuf + sizeof(dhcp_hdr_t);
202 size_t i;
203
204 memset(msgbuf, 0, MAX_MSG_SIZE);
205 hdr->op = op_bootrequest;
206 hdr->htype = 1; /* AHRD_ETHERNET */
207 hdr->hlen = 6;
208 hdr->xid = host2uint32_t_be(offer->xid);
209 hdr->flags = host2uint16_t_be(flag_broadcast);
210 eth_addr_encode(&dlink->link_info.mac_addr, hdr->chaddr);
211 hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
212
213 i = 0;
214
215 opt[i++] = opt_msg_type;
216 opt[i++] = 1;
217 opt[i++] = msg_dhcprequest;
218
219 opt[i++] = opt_req_ip_addr;
220 opt[i++] = 4;
221 opt[i++] = offer->oaddr.addr >> 24;
222 opt[i++] = (offer->oaddr.addr >> 16) & 0xff;
223 opt[i++] = (offer->oaddr.addr >> 8) & 0xff;
224 opt[i++] = offer->oaddr.addr & 0xff;
225
226 opt[i++] = opt_server_id;
227 opt[i++] = 4;
228 opt[i++] = offer->srv_addr.addr >> 24;
229 opt[i++] = (offer->srv_addr.addr >> 16) & 0xff;
230 opt[i++] = (offer->srv_addr.addr >> 8) & 0xff;
231 opt[i++] = offer->srv_addr.addr & 0xff;
232
233 opt[i++] = opt_end;
234
235 return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + i);
236}
237
238static errno_t dhcp_parse_reply(void *msg, size_t size, dhcp_offer_t *offer)
239{
240 dhcp_hdr_t *hdr = (dhcp_hdr_t *)msg;
241 inet_addr_t yiaddr;
242 inet_addr_t siaddr;
243 inet_addr_t giaddr;
244 uint32_t subnet_mask;
245 bool have_subnet_mask = false;
246 bool have_server_id = false;
247 int subnet_bits;
248 char *saddr;
249 uint8_t opt_type, opt_len;
250 uint8_t *msgb;
251 errno_t rc;
252 size_t i;
253
254 log_msg(LOG_DEFAULT, LVL_DEBUG, "Receive reply");
255 memset(offer, 0, sizeof(*offer));
256
257 inet_addr_set(uint32_t_be2host(hdr->yiaddr), &yiaddr);
258 rc = inet_addr_format(&yiaddr, &saddr);
259 if (rc != EOK)
260 return rc;
261
262 log_msg(LOG_DEFAULT, LVL_DEBUG, "Your IP address: %s", saddr);
263 free(saddr);
264
265 inet_addr_set(uint32_t_be2host(hdr->siaddr), &siaddr);
266 rc = inet_addr_format(&siaddr, &saddr);
267 if (rc != EOK)
268 return rc;
269
270 log_msg(LOG_DEFAULT, LVL_DEBUG, "Next server IP address: %s", saddr);
271 free(saddr);
272
273 inet_addr_set(uint32_t_be2host(hdr->giaddr), &giaddr);
274 rc = inet_addr_format(&giaddr, &saddr);
275 if (rc != EOK)
276 return rc;
277
278 log_msg(LOG_DEFAULT, LVL_DEBUG, "Relay agent IP address: %s", saddr);
279 free(saddr);
280
281 inet_naddr_set(yiaddr.addr, 0, &offer->oaddr);
282 offer->xid = uint32_t_be2host(hdr->xid);
283
284 msgb = (uint8_t *)msg;
285
286 i = sizeof(dhcp_hdr_t);
287 while (i < size) {
288 opt_type = msgb[i++];
289
290 if (opt_type == opt_pad)
291 continue;
292 if (opt_type == opt_end)
293 break;
294
295 if (i >= size)
296 return EINVAL;
297
298 opt_len = msgb[i++];
299
300 if (i + opt_len > size)
301 return EINVAL;
302
303 switch (opt_type) {
304 case opt_subnet_mask:
305 if (opt_len != 4)
306 return EINVAL;
307 subnet_mask = dhcp_uint32_decode(&msgb[i]);
308 rc = subnet_mask_decode(subnet_mask, &subnet_bits);
309 if (rc != EOK)
310 return EINVAL;
311 offer->oaddr.prefix = subnet_bits;
312 have_subnet_mask = true;
313 break;
314 case opt_msg_type:
315 if (opt_len != 1)
316 return EINVAL;
317 offer->msg_type = msgb[i];
318 break;
319 case opt_server_id:
320 if (opt_len != 4)
321 return EINVAL;
322 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
323 &offer->srv_addr);
324 have_server_id = true;
325 break;
326 case opt_router:
327 if (opt_len != 4)
328 return EINVAL;
329 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
330 &offer->router);
331 break;
332 case opt_dns_server:
333 if (opt_len < 4 || opt_len % 4 != 0)
334 return EINVAL;
335 /* XXX Handle multiple DNS servers properly */
336 inet_addr_set(dhcp_uint32_decode(&msgb[i]),
337 &offer->dns_server);
338 break;
339 case opt_end:
340 break;
341 default:
342 break;
343 }
344
345 /* Advance to the next option */
346 i = i + opt_len;
347 }
348
349 if (!have_server_id) {
350 log_msg(LOG_DEFAULT, LVL_ERROR, "Missing server ID option.");
351 return rc;
352 }
353
354 if (!have_subnet_mask) {
355 log_msg(LOG_DEFAULT, LVL_ERROR, "Missing subnet mask option.");
356 return rc;
357 }
358
359 rc = inet_naddr_format(&offer->oaddr, &saddr);
360 if (rc != EOK)
361 return rc;
362
363 log_msg(LOG_DEFAULT, LVL_DEBUG, "Offered network address: %s", saddr);
364 free(saddr);
365
366 if (offer->router.addr != 0) {
367 rc = inet_addr_format(&offer->router, &saddr);
368 if (rc != EOK)
369 return rc;
370
371 log_msg(LOG_DEFAULT, LVL_DEBUG, "Router address: %s", saddr);
372 free(saddr);
373 }
374
375 if (offer->dns_server.addr != 0) {
376 rc = inet_addr_format(&offer->dns_server, &saddr);
377 if (rc != EOK)
378 return rc;
379
380 log_msg(LOG_DEFAULT, LVL_DEBUG, "DNS server: %s", saddr);
381 free(saddr);
382 }
383
384 return EOK;
385}
386
387static errno_t dhcp_cfg_create(service_id_t iplink, dhcp_offer_t *offer)
388{
389 errno_t rc;
390 service_id_t addr_id;
391 service_id_t sroute_id;
392 inet_naddr_t defr;
393
394 rc = inetcfg_addr_create_static("dhcp4a", &offer->oaddr, iplink,
395 &addr_id);
396 if (rc != EOK) {
397 log_msg(LOG_DEFAULT, LVL_ERROR,
398 "Error creating IP address %s: %s", "dhcp4a", str_error(rc));
399 return rc;
400 }
401
402 if (offer->router.addr != 0) {
403 inet_naddr_set(0, 0, &defr);
404
405 rc = inetcfg_sroute_create("dhcpdef", &defr, &offer->router, &sroute_id);
406 if (rc != EOK) {
407 log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating "
408 "default route %s: %s.", "dhcpdef", str_error(rc));
409 return rc;
410 }
411 }
412
413 if (offer->dns_server.addr != 0) {
414 rc = dnsr_set_srvaddr(&offer->dns_server);
415 if (rc != EOK) {
416 log_msg(LOG_DEFAULT, LVL_ERROR, "Error setting "
417 "nameserver address: %s)", str_error(rc));
418 return rc;
419 }
420 }
421
422 return EOK;
423}
424
425void dhcpsrv_links_init(void)
426{
427 list_initialize(&dhcp_links);
428}
429
430static dhcp_link_t *dhcpsrv_link_find(service_id_t link_id)
431{
432 list_foreach(dhcp_links, links, dhcp_link_t, dlink) {
433 if (dlink->link_id == link_id)
434 return dlink;
435 }
436
437 return NULL;
438}
439
440static void dhcp_link_set_failed(dhcp_link_t *dlink)
441{
442 log_msg(LOG_DEFAULT, LVL_NOTE, "Giving up on link %s",
443 dlink->link_info.name);
444 dlink->state = ds_fail;
445}
446
447static errno_t dhcp_discover_proc(dhcp_link_t *dlink)
448{
449 dlink->state = ds_selecting;
450
451 errno_t rc = dhcp_send_discover(dlink);
452 if (rc != EOK)
453 return EIO;
454
455 dlink->retries_left = dhcp_discover_retries;
456
457 if ((dlink->timeout->state == fts_not_set) ||
458 (dlink->timeout->state == fts_fired))
459 fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
460 dhcpsrv_discover_timeout, dlink);
461
462 return rc;
463}
464
465errno_t dhcpsrv_link_add(service_id_t link_id)
466{
467 dhcp_link_t *dlink;
468 errno_t rc;
469
470 log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
471
472 if (!inetcfg_inited) {
473 rc = inetcfg_init();
474 if (rc != EOK) {
475 log_msg(LOG_DEFAULT, LVL_ERROR, "Error contacting "
476 "inet configuration service.\n");
477 return EIO;
478 }
479
480 inetcfg_inited = true;
481 }
482
483 if (dhcpsrv_link_find(link_id) != NULL) {
484 log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu already added",
485 link_id);
486 return EEXIST;
487 }
488
489 dlink = calloc(1, sizeof(dhcp_link_t));
490 if (dlink == NULL)
491 return ENOMEM;
492
493 rc = rndgen_create(&dlink->rndgen);
494 if (rc != EOK)
495 goto error;
496
497 dlink->link_id = link_id;
498 dlink->timeout = fibril_timer_create(NULL);
499 if (dlink->timeout == NULL) {
500 rc = ENOMEM;
501 goto error;
502 }
503
504 /* Get link hardware address */
505 rc = inetcfg_link_get(link_id, &dlink->link_info);
506 if (rc != EOK) {
507 log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting properties "
508 "for link %zu.", link_id);
509 rc = EIO;
510 goto error;
511 }
512
513 rc = dhcp_transport_init(&dlink->dt, link_id, dhcpsrv_recv, dlink);
514 if (rc != EOK) {
515 log_msg(LOG_DEFAULT, LVL_ERROR, "Error initializing DHCP "
516 "transport for link %s.", dlink->link_info.name);
517 rc = EIO;
518 goto error;
519 }
520
521 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
522 rc = dhcp_discover_proc(dlink);
523 if (rc != EOK) {
524 log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER.");
525 dhcp_link_set_failed(dlink);
526 rc = EIO;
527 goto error;
528 }
529
530 list_append(&dlink->links, &dhcp_links);
531
532 return EOK;
533error:
534 if (dlink != NULL && dlink->rndgen != NULL)
535 rndgen_destroy(dlink->rndgen);
536 if (dlink != NULL && dlink->timeout != NULL)
537 fibril_timer_destroy(dlink->timeout);
538 free(dlink);
539 return rc;
540}
541
542errno_t dhcpsrv_link_remove(service_id_t link_id)
543{
544 return ENOTSUP;
545}
546
547errno_t dhcpsrv_discover(service_id_t link_id)
548{
549 log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
550
551 dhcp_link_t *dlink = dhcpsrv_link_find(link_id);
552
553 if (dlink == NULL) {
554 log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu doesn't exist",
555 link_id);
556 return EINVAL;
557 }
558
559 return dhcp_discover_proc(dlink);
560}
561
562static void dhcpsrv_recv_offer(dhcp_link_t *dlink, dhcp_offer_t *offer)
563{
564 errno_t rc;
565
566 if (dlink->state != ds_selecting) {
567 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received offer in state "
568 " %d, ignoring.", (int)dlink->state);
569 return;
570 }
571
572 fibril_timer_clear(dlink->timeout);
573 dlink->offer = *offer;
574 dlink->state = ds_requesting;
575
576 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
577 rc = dhcp_send_request(dlink, offer);
578 if (rc != EOK) {
579 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
580 return;
581 }
582
583 dlink->retries_left = dhcp_request_retries;
584 fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
585 dhcpsrv_request_timeout, dlink);
586}
587
588static void dhcpsrv_recv_ack(dhcp_link_t *dlink, dhcp_offer_t *offer)
589{
590 errno_t rc;
591
592 if (dlink->state != ds_requesting) {
593 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received ack in state "
594 " %d, ignoring.", (int)dlink->state);
595 return;
596 }
597
598 fibril_timer_clear(dlink->timeout);
599 dlink->offer = *offer;
600 dlink->state = ds_bound;
601
602 rc = dhcp_cfg_create(dlink->link_id, offer);
603 if (rc != EOK) {
604 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error creating configuration.");
605 return;
606 }
607
608 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: Successfully configured.",
609 dlink->link_info.name);
610}
611
612static void dhcpsrv_recv(void *arg, void *msg, size_t size)
613{
614 dhcp_link_t *dlink = (dhcp_link_t *)arg;
615 dhcp_offer_t offer;
616 errno_t rc;
617
618 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: dhcpsrv_recv() %zu bytes",
619 dlink->link_info.name, size);
620
621 rc = dhcp_parse_reply(msg, size, &offer);
622 if (rc != EOK) {
623 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error parsing reply");
624 return;
625 }
626
627 switch (offer.msg_type) {
628 case msg_dhcpoffer:
629 dhcpsrv_recv_offer(dlink, &offer);
630 break;
631 case msg_dhcpack:
632 dhcpsrv_recv_ack(dlink, &offer);
633 break;
634 default:
635 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received unexpected "
636 "message type. %d", (int)offer.msg_type);
637 break;
638 }
639}
640
641static void dhcpsrv_discover_timeout(void *arg)
642{
643 dhcp_link_t *dlink = (dhcp_link_t *)arg;
644 errno_t rc;
645
646 assert(dlink->state == ds_selecting);
647 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dhcpsrv_discover_timeout",
648 dlink->link_info.name);
649
650 if (dlink->retries_left == 0) {
651 log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
652 dhcp_link_set_failed(dlink);
653 return;
654 }
655 --dlink->retries_left;
656
657 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
658 rc = dhcp_send_discover(dlink);
659 if (rc != EOK) {
660 log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER");
661 dhcp_link_set_failed(dlink);
662 return;
663 }
664
665 fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
666 dhcpsrv_discover_timeout, dlink);
667}
668
669static void dhcpsrv_request_timeout(void *arg)
670{
671 dhcp_link_t *dlink = (dhcp_link_t *)arg;
672 errno_t rc;
673
674 assert(dlink->state == ds_requesting);
675 log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dhcpsrv_request_timeout",
676 dlink->link_info.name);
677
678 if (dlink->retries_left == 0) {
679 log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
680 dhcp_link_set_failed(dlink);
681 return;
682 }
683 --dlink->retries_left;
684
685 log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
686 rc = dhcp_send_request(dlink, &dlink->offer);
687 if (rc != EOK) {
688 log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
689 dhcp_link_set_failed(dlink);
690 return;
691 }
692
693 fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
694 dhcpsrv_request_timeout, dlink);
695}
696
697/** @}
698 */
Note: See TracBrowser for help on using the repository browser.