source: mainline/uspace/srv/net/inetsrv/inetcfg.c@ 59ff52d

Last change on this file since 59ff52d was 59ff52d, checked in by Jakub Jermar <jakub@…>, 7 years ago

Add async_accept_0() for accepting connections
  • Property mode set to 100644
File size: 17.3 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 inet
30 * @{
31 */
32/**
33 * @file
34 * @brief
35 */
36
37#include <async.h>
38#include <errno.h>
39#include <macros.h>
40#include <io/log.h>
41#include <ipc/inet.h>
42#include <loc.h>
43#include <stdlib.h>
44#include <str.h>
45#include <stddef.h>
46#include <types/inetcfg.h>
47
48#include "addrobj.h"
49#include "inetsrv.h"
50#include "inet_link.h"
51#include "inetcfg.h"
52#include "sroute.h"
53
54static errno_t inetcfg_addr_create_static(char *name, inet_naddr_t *naddr,
55 sysarg_t link_id, sysarg_t *addr_id)
56{
57 inet_link_t *ilink;
58 inet_addrobj_t *addr;
59 inet_addr_t iaddr;
60 errno_t rc;
61
62 ilink = inet_link_get_by_id(link_id);
63 if (ilink == NULL) {
64 log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %lu not found.",
65 (unsigned long) link_id);
66 return ENOENT;
67 }
68
69 addr = inet_addrobj_new();
70 if (addr == NULL) {
71 *addr_id = 0;
72 return ENOMEM;
73 }
74
75 addr->naddr = *naddr;
76 addr->ilink = ilink;
77 addr->name = str_dup(name);
78 rc = inet_addrobj_add(addr);
79 if (rc != EOK) {
80 log_msg(LOG_DEFAULT, LVL_DEBUG, "Duplicate address name '%s'.", addr->name);
81 inet_addrobj_delete(addr);
82 return rc;
83 }
84
85 inet_naddr_addr(&addr->naddr, &iaddr);
86 rc = iplink_addr_add(ilink->iplink, &iaddr);
87 if (rc != EOK) {
88 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
89 inet_addrobj_remove(addr);
90 inet_addrobj_delete(addr);
91 return rc;
92 }
93
94 return EOK;
95}
96
97static errno_t inetcfg_addr_delete(sysarg_t addr_id)
98{
99 inet_addrobj_t *addr;
100
101 addr = inet_addrobj_get_by_id(addr_id);
102 if (addr == NULL)
103 return ENOENT;
104
105 inet_addrobj_remove(addr);
106 inet_addrobj_delete(addr);
107
108 return EOK;
109}
110
111static errno_t inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
112{
113 inet_addrobj_t *addr;
114
115 addr = inet_addrobj_get_by_id(addr_id);
116 if (addr == NULL)
117 return ENOENT;
118
119 ainfo->naddr = addr->naddr;
120 ainfo->ilink = addr->ilink->svc_id;
121 ainfo->name = str_dup(addr->name);
122
123 return EOK;
124}
125
126static errno_t inetcfg_addr_get_id(char *name, sysarg_t link_id, sysarg_t *addr_id)
127{
128 inet_link_t *ilink;
129 inet_addrobj_t *addr;
130
131 ilink = inet_link_get_by_id(link_id);
132 if (ilink == NULL) {
133 log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %zu not found.", (size_t) link_id);
134 return ENOENT;
135 }
136
137 addr = inet_addrobj_find_by_name(name, ilink);
138 if (addr == NULL) {
139 log_msg(LOG_DEFAULT, LVL_DEBUG, "Address '%s' not found.", name);
140 return ENOENT;
141 }
142
143 *addr_id = addr->id;
144 return EOK;
145}
146
147static errno_t inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
148{
149 return inet_addrobj_get_id_list(addrs, count);
150}
151
152static errno_t inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
153{
154 return inet_link_get_id_list(addrs, count);
155}
156
157static errno_t inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
158{
159 return inet_sroute_get_id_list(sroutes, count);
160}
161
162static errno_t inetcfg_link_add(sysarg_t link_id)
163{
164 return inet_link_open(link_id);
165}
166
167static errno_t inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
168{
169 inet_link_t *ilink;
170
171 ilink = inet_link_get_by_id(link_id);
172 if (ilink == NULL) {
173 return ENOENT;
174 }
175
176 linfo->name = str_dup(ilink->svc_name);
177 linfo->def_mtu = ilink->def_mtu;
178 if (ilink->mac_valid) {
179 addr48(ilink->mac, linfo->mac_addr);
180 } else {
181 memset(linfo->mac_addr, 0, sizeof(linfo->mac_addr));
182 }
183
184 return EOK;
185}
186
187static errno_t inetcfg_link_remove(sysarg_t link_id)
188{
189 return ENOTSUP;
190}
191
192static errno_t inetcfg_sroute_create(char *name, inet_naddr_t *dest,
193 inet_addr_t *router, sysarg_t *sroute_id)
194{
195 inet_sroute_t *sroute;
196
197 sroute = inet_sroute_new();
198 if (sroute == NULL) {
199 *sroute_id = 0;
200 return ENOMEM;
201 }
202
203 sroute->dest = *dest;
204 sroute->router = *router;
205 sroute->name = str_dup(name);
206 inet_sroute_add(sroute);
207
208 *sroute_id = sroute->id;
209 return EOK;
210}
211
212static errno_t inetcfg_sroute_delete(sysarg_t sroute_id)
213{
214 inet_sroute_t *sroute;
215
216 sroute = inet_sroute_get_by_id(sroute_id);
217 if (sroute == NULL)
218 return ENOENT;
219
220 inet_sroute_remove(sroute);
221 inet_sroute_delete(sroute);
222
223 return EOK;
224}
225
226static errno_t inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
227{
228 inet_sroute_t *sroute;
229
230 sroute = inet_sroute_get_by_id(sroute_id);
231 if (sroute == NULL)
232 return ENOENT;
233
234 srinfo->dest = sroute->dest;
235 srinfo->router = sroute->router;
236 srinfo->name = str_dup(sroute->name);
237
238 return EOK;
239}
240
241static errno_t inetcfg_sroute_get_id(char *name, sysarg_t *sroute_id)
242{
243 inet_sroute_t *sroute;
244
245 sroute = inet_sroute_find_by_name(name);
246 if (sroute == NULL) {
247 log_msg(LOG_DEFAULT, LVL_DEBUG, "Static route '%s' not found.", name);
248 return ENOENT;
249 }
250
251 *sroute_id = sroute->id;
252 return EOK;
253}
254
255static void inetcfg_addr_create_static_srv(ipc_call_t *icall)
256{
257 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
258
259 sysarg_t link_id = IPC_GET_ARG1(*icall);
260
261 ipc_call_t call;
262 size_t size;
263 if (!async_data_write_receive(&call, &size)) {
264 async_answer_0(&call, EINVAL);
265 async_answer_0(icall, EINVAL);
266 return;
267 }
268
269 if (size != sizeof(inet_naddr_t)) {
270 async_answer_0(&call, EINVAL);
271 async_answer_0(icall, EINVAL);
272 return;
273 }
274
275 inet_naddr_t naddr;
276 errno_t rc = async_data_write_finalize(&call, &naddr, size);
277 if (rc != EOK) {
278 async_answer_0(&call, rc);
279 async_answer_0(icall, rc);
280 return;
281 }
282
283 char *name;
284 rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
285 0, NULL);
286 if (rc != EOK) {
287 async_answer_0(icall, rc);
288 return;
289 }
290
291 sysarg_t addr_id = 0;
292 rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
293 free(name);
294 async_answer_1(icall, rc, addr_id);
295}
296
297static void inetcfg_addr_delete_srv(ipc_call_t *call)
298{
299 sysarg_t addr_id;
300 errno_t rc;
301
302 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_delete_srv()");
303
304 addr_id = IPC_GET_ARG1(*call);
305
306 rc = inetcfg_addr_delete(addr_id);
307 async_answer_0(call, rc);
308}
309
310static void inetcfg_addr_get_srv(ipc_call_t *icall)
311{
312 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
313
314 sysarg_t addr_id = IPC_GET_ARG1(*icall);
315
316 inet_addr_info_t ainfo;
317
318 inet_naddr_any(&ainfo.naddr);
319 ainfo.ilink = 0;
320 ainfo.name = NULL;
321
322 errno_t rc = inetcfg_addr_get(addr_id, &ainfo);
323 if (rc != EOK) {
324 async_answer_0(icall, rc);
325 return;
326 }
327
328 ipc_call_t call;
329 size_t size;
330 if (!async_data_read_receive(&call, &size)) {
331 async_answer_0(&call, EREFUSED);
332 async_answer_0(icall, EREFUSED);
333 return;
334 }
335
336 if (size != sizeof(inet_naddr_t)) {
337 async_answer_0(&call, EINVAL);
338 async_answer_0(icall, EINVAL);
339 return;
340 }
341
342 rc = async_data_read_finalize(&call, &ainfo.naddr, size);
343 if (rc != EOK) {
344 async_answer_0(&call, rc);
345 async_answer_0(icall, rc);
346 return;
347 }
348
349 if (!async_data_read_receive(&call, &size)) {
350 async_answer_0(&call, EREFUSED);
351 async_answer_0(icall, EREFUSED);
352 return;
353 }
354
355 rc = async_data_read_finalize(&call, ainfo.name,
356 min(size, str_size(ainfo.name)));
357 free(ainfo.name);
358
359 if (rc != EOK) {
360 async_answer_0(&call, rc);
361 async_answer_0(icall, rc);
362 return;
363 }
364
365 async_answer_1(icall, rc, ainfo.ilink);
366}
367
368static void inetcfg_addr_get_id_srv(ipc_call_t *call)
369{
370 char *name;
371 sysarg_t link_id;
372 sysarg_t addr_id;
373 errno_t rc;
374
375 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_id_srv()");
376
377 link_id = IPC_GET_ARG1(*call);
378
379 rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
380 0, NULL);
381 if (rc != EOK) {
382 async_answer_0(call, rc);
383 return;
384 }
385
386 addr_id = 0;
387 rc = inetcfg_addr_get_id(name, link_id, &addr_id);
388 free(name);
389 async_answer_1(call, rc, addr_id);
390}
391
392static void inetcfg_get_addr_list_srv(ipc_call_t *call)
393{
394 ipc_call_t rcall;
395 size_t count;
396 size_t max_size;
397 size_t act_size;
398 size_t size;
399 sysarg_t *id_buf;
400 errno_t rc;
401
402 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
403
404 if (!async_data_read_receive(&rcall, &max_size)) {
405 async_answer_0(&rcall, EREFUSED);
406 async_answer_0(call, EREFUSED);
407 return;
408 }
409
410 rc = inetcfg_get_addr_list(&id_buf, &count);
411 if (rc != EOK) {
412 async_answer_0(&rcall, rc);
413 async_answer_0(call, rc);
414 return;
415 }
416
417 act_size = count * sizeof(sysarg_t);
418 size = min(act_size, max_size);
419
420 errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
421 free(id_buf);
422
423 async_answer_1(call, retval, act_size);
424}
425
426static void inetcfg_get_link_list_srv(ipc_call_t *call)
427{
428 ipc_call_t rcall;
429 size_t count;
430 size_t max_size;
431 size_t act_size;
432 size_t size;
433 sysarg_t *id_buf;
434 errno_t rc;
435
436 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()");
437
438 if (!async_data_read_receive(&rcall, &max_size)) {
439 async_answer_0(&rcall, EREFUSED);
440 async_answer_0(call, EREFUSED);
441 return;
442 }
443
444 rc = inetcfg_get_link_list(&id_buf, &count);
445 if (rc != EOK) {
446 async_answer_0(&rcall, rc);
447 async_answer_0(call, rc);
448 return;
449 }
450
451 act_size = count * sizeof(sysarg_t);
452 size = min(act_size, max_size);
453
454 errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
455 free(id_buf);
456
457 async_answer_1(call, retval, act_size);
458}
459
460static void inetcfg_get_sroute_list_srv(ipc_call_t *call)
461{
462 ipc_call_t rcall;
463 size_t count;
464 size_t max_size;
465 size_t act_size;
466 size_t size;
467 sysarg_t *id_buf;
468 errno_t rc;
469
470 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()");
471
472 if (!async_data_read_receive(&rcall, &max_size)) {
473 async_answer_0(&rcall, EREFUSED);
474 async_answer_0(call, EREFUSED);
475 return;
476 }
477
478 rc = inetcfg_get_sroute_list(&id_buf, &count);
479 if (rc != EOK) {
480 async_answer_0(&rcall, rc);
481 async_answer_0(call, rc);
482 return;
483 }
484
485 act_size = count * sizeof(sysarg_t);
486 size = min(act_size, max_size);
487
488 errno_t retval = async_data_read_finalize(&rcall, id_buf, size);
489 free(id_buf);
490
491 async_answer_1(call, retval, act_size);
492}
493
494static void inetcfg_link_add_srv(ipc_call_t *call)
495{
496 sysarg_t link_id;
497 errno_t rc;
498
499 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_add_srv()");
500
501 link_id = IPC_GET_ARG1(*call);
502
503 rc = inetcfg_link_add(link_id);
504 async_answer_0(call, rc);
505}
506
507static void inetcfg_link_get_srv(ipc_call_t *call)
508{
509 ipc_call_t name;
510 ipc_call_t laddr;
511 size_t name_max_size;
512 size_t laddr_max_size;
513
514 sysarg_t link_id;
515 inet_link_info_t linfo;
516 errno_t rc;
517
518 link_id = IPC_GET_ARG1(*call);
519 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_get_srv()");
520
521 linfo.name = NULL;
522
523 if (!async_data_read_receive(&name, &name_max_size)) {
524 async_answer_0(&name, EREFUSED);
525 async_answer_0(call, EREFUSED);
526 return;
527 }
528
529 if (!async_data_read_receive(&laddr, &laddr_max_size)) {
530 async_answer_0(&laddr, EREFUSED);
531 async_answer_0(&name, EREFUSED);
532 async_answer_0(call, EREFUSED);
533 return;
534 }
535
536 rc = inetcfg_link_get(link_id, &linfo);
537 if (rc != EOK) {
538 async_answer_0(&laddr, rc);
539 async_answer_0(&name, rc);
540 async_answer_0(call, rc);
541 return;
542 }
543
544 errno_t retval = async_data_read_finalize(&name, linfo.name,
545 min(name_max_size, str_size(linfo.name)));
546 if (retval != EOK) {
547 free(linfo.name);
548 async_answer_0(&laddr, retval);
549 async_answer_0(call, retval);
550 return;
551 }
552
553 retval = async_data_read_finalize(&laddr, &linfo.mac_addr,
554 min(laddr_max_size, sizeof(linfo.mac_addr)));
555
556 free(linfo.name);
557
558 async_answer_1(call, retval, linfo.def_mtu);
559}
560
561static void inetcfg_link_remove_srv(ipc_call_t *call)
562{
563 sysarg_t link_id;
564 errno_t rc;
565
566 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_remove_srv()");
567
568 link_id = IPC_GET_ARG1(*call);
569
570 rc = inetcfg_link_remove(link_id);
571 async_answer_0(call, rc);
572}
573
574static void inetcfg_sroute_create_srv(ipc_call_t *icall)
575{
576 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
577
578 ipc_call_t call;
579 size_t size;
580 if (!async_data_write_receive(&call, &size)) {
581 async_answer_0(&call, EINVAL);
582 async_answer_0(icall, EINVAL);
583 return;
584 }
585
586 if (size != sizeof(inet_naddr_t)) {
587 async_answer_0(&call, EINVAL);
588 async_answer_0(icall, EINVAL);
589 return;
590 }
591
592 inet_naddr_t dest;
593 errno_t rc = async_data_write_finalize(&call, &dest, size);
594 if (rc != EOK) {
595 async_answer_0(&call, rc);
596 async_answer_0(icall, rc);
597 return;
598 }
599
600 if (!async_data_write_receive(&call, &size)) {
601 async_answer_0(&call, EINVAL);
602 async_answer_0(icall, EINVAL);
603 return;
604 }
605
606 if (size != sizeof(inet_addr_t)) {
607 async_answer_0(&call, EINVAL);
608 async_answer_0(icall, EINVAL);
609 return;
610 }
611
612 inet_addr_t router;
613 rc = async_data_write_finalize(&call, &router, size);
614 if (rc != EOK) {
615 async_answer_0(&call, rc);
616 async_answer_0(icall, rc);
617 return;
618 }
619
620 char *name;
621 rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
622 0, NULL);
623 if (rc != EOK) {
624 async_answer_0(icall, rc);
625 return;
626 }
627
628 sysarg_t sroute_id = 0;
629 rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
630 free(name);
631 async_answer_1(icall, rc, sroute_id);
632}
633
634static void inetcfg_sroute_delete_srv(ipc_call_t *call)
635{
636 sysarg_t sroute_id;
637 errno_t rc;
638
639 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_delete_srv()");
640
641 sroute_id = IPC_GET_ARG1(*call);
642
643 rc = inetcfg_sroute_delete(sroute_id);
644 async_answer_0(call, rc);
645}
646
647static void inetcfg_sroute_get_srv(ipc_call_t *icall)
648{
649 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
650
651 sysarg_t sroute_id = IPC_GET_ARG1(*icall);
652
653 inet_sroute_info_t srinfo;
654
655 inet_naddr_any(&srinfo.dest);
656 inet_addr_any(&srinfo.router);
657 srinfo.name = NULL;
658
659 errno_t rc = inetcfg_sroute_get(sroute_id, &srinfo);
660 if (rc != EOK) {
661 async_answer_0(icall, rc);
662 return;
663 }
664
665 ipc_call_t call;
666 size_t size;
667 if (!async_data_read_receive(&call, &size)) {
668 async_answer_0(&call, EREFUSED);
669 async_answer_0(icall, EREFUSED);
670 return;
671 }
672
673 if (size != sizeof(inet_naddr_t)) {
674 async_answer_0(&call, EINVAL);
675 async_answer_0(icall, EINVAL);
676 return;
677 }
678
679 rc = async_data_read_finalize(&call, &srinfo.dest, size);
680 if (rc != EOK) {
681 async_answer_0(&call, rc);
682 async_answer_0(icall, rc);
683 return;
684 }
685
686 if (!async_data_read_receive(&call, &size)) {
687 async_answer_0(&call, EREFUSED);
688 async_answer_0(icall, EREFUSED);
689 return;
690 }
691
692 if (size != sizeof(inet_addr_t)) {
693 async_answer_0(&call, EINVAL);
694 async_answer_0(icall, EINVAL);
695 return;
696 }
697
698 rc = async_data_read_finalize(&call, &srinfo.router, size);
699 if (rc != EOK) {
700 async_answer_0(&call, rc);
701 async_answer_0(icall, rc);
702 return;
703 }
704
705 if (!async_data_read_receive(&call, &size)) {
706 async_answer_0(&call, EREFUSED);
707 async_answer_0(icall, EREFUSED);
708 return;
709 }
710
711 rc = async_data_read_finalize(&call, srinfo.name,
712 min(size, str_size(srinfo.name)));
713 free(srinfo.name);
714
715 async_answer_0(icall, rc);
716}
717
718static void inetcfg_sroute_get_id_srv(ipc_call_t *call)
719{
720 char *name;
721 sysarg_t sroute_id;
722 errno_t rc;
723
724 log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_id_srv()");
725
726 rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
727 0, NULL);
728 if (rc != EOK) {
729 async_answer_0(call, rc);
730 return;
731 }
732
733 sroute_id = 0;
734 rc = inetcfg_sroute_get_id(name, &sroute_id);
735 free(name);
736 async_answer_1(call, rc, sroute_id);
737}
738
739void inet_cfg_conn(ipc_call_t *icall, void *arg)
740{
741 log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()");
742
743 /* Accept the connection */
744 async_accept_0(icall);
745
746 while (true) {
747 ipc_call_t call;
748 async_get_call(&call);
749 sysarg_t method = IPC_GET_IMETHOD(call);
750
751 log_msg(LOG_DEFAULT, LVL_DEBUG, "method %d", (int)method);
752 if (!method) {
753 /* The other side has hung up */
754 async_answer_0(&call, EOK);
755 return;
756 }
757
758 switch (method) {
759 case INETCFG_ADDR_CREATE_STATIC:
760 inetcfg_addr_create_static_srv(&call);
761 break;
762 case INETCFG_ADDR_DELETE:
763 inetcfg_addr_delete_srv(&call);
764 break;
765 case INETCFG_ADDR_GET:
766 inetcfg_addr_get_srv(&call);
767 break;
768 case INETCFG_ADDR_GET_ID:
769 inetcfg_addr_get_id_srv(&call);
770 break;
771 case INETCFG_GET_ADDR_LIST:
772 inetcfg_get_addr_list_srv(&call);
773 break;
774 case INETCFG_GET_LINK_LIST:
775 inetcfg_get_link_list_srv(&call);
776 break;
777 case INETCFG_GET_SROUTE_LIST:
778 inetcfg_get_sroute_list_srv(&call);
779 break;
780 case INETCFG_LINK_ADD:
781 inetcfg_link_add_srv(&call);
782 break;
783 case INETCFG_LINK_GET:
784 inetcfg_link_get_srv(&call);
785 break;
786 case INETCFG_LINK_REMOVE:
787 inetcfg_link_remove_srv(&call);
788 break;
789 case INETCFG_SROUTE_CREATE:
790 inetcfg_sroute_create_srv(&call);
791 break;
792 case INETCFG_SROUTE_DELETE:
793 inetcfg_sroute_delete_srv(&call);
794 break;
795 case INETCFG_SROUTE_GET:
796 inetcfg_sroute_get_srv(&call);
797 break;
798 case INETCFG_SROUTE_GET_ID:
799 inetcfg_sroute_get_id_srv(&call);
800 break;
801 default:
802 async_answer_0(&call, EINVAL);
803 }
804 }
805}
806
807/** @}
808 */
Note: See TracBrowser for help on using the repository browser.