Merge branch 'vendor/BIND' into bind_vendor2
[dragonfly.git] / usr.sbin / ppp / iface.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
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 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: src/usr.sbin/ppp/iface.c,v 1.13.2.9 2003/04/29 16:04:41 ume Exp $
3bdde06f 27 * $DragonFly: src/usr.sbin/ppp/iface.c,v 1.3 2004/02/03 07:11:47 dillon Exp $
984263bc
MD
28 */
29
30#include <sys/param.h>
31#include <sys/socket.h>
32#include <netinet/in.h>
33#include <net/if.h>
34#include <net/if_dl.h>
3bdde06f 35#ifdef __DragonFly__
984263bc
MD
36#include <net/if_var.h>
37#endif
38#include <net/route.h>
39#include <netinet/in_systm.h>
40#include <netinet/in_var.h>
41#include <netinet/ip.h>
42#ifndef NOINET6
43#include <netinet6/nd6.h>
44#endif
45#include <sys/un.h>
46
47#include <errno.h>
48#include <string.h>
49#include <stdarg.h>
50#include <stdio.h>
51#include <stdlib.h>
52#include <sys/ioctl.h>
53#include <sys/sysctl.h>
54#include <termios.h>
55#include <unistd.h>
56
57#include "layer.h"
58#include "defs.h"
59#include "command.h"
60#include "mbuf.h"
61#include "log.h"
62#include "id.h"
63#include "timer.h"
64#include "fsm.h"
65#include "iplist.h"
66#include "lqr.h"
67#include "hdlc.h"
68#include "throughput.h"
69#include "slcompress.h"
70#include "descriptor.h"
71#include "ncpaddr.h"
72#include "ipcp.h"
73#include "filter.h"
74#include "lcp.h"
75#include "ccp.h"
76#include "link.h"
77#include "mp.h"
78#ifndef NORADIUS
79#include "radius.h"
80#endif
81#include "ipv6cp.h"
82#include "ncp.h"
83#include "bundle.h"
84#include "prompt.h"
85#include "iface.h"
86
87#define IN6MASK128 {{{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, \
88 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}}
89static const struct in6_addr in6mask128 = IN6MASK128;
90
91
92struct iface *
93iface_Create(const char *name)
94{
95 int mib[6], maxtries, err;
96 size_t needed, namelen;
97 char *buf, *ptr, *end;
98 struct if_msghdr *ifm;
99 struct ifa_msghdr *ifam;
100 struct sockaddr_dl *dl;
101 struct sockaddr *sa[RTAX_MAX];
102 struct iface *iface;
103 struct iface_addr *addr;
104
105 mib[0] = CTL_NET;
106 mib[1] = PF_ROUTE;
107 mib[2] = 0;
108 mib[3] = 0;
109 mib[4] = NET_RT_IFLIST;
110 mib[5] = 0;
111
112 maxtries = 20;
113 err = 0;
114 do {
115 if (maxtries-- == 0 || (err && err != ENOMEM)) {
116 fprintf(stderr, "iface_Create: sysctl: %s\n", strerror(err));
117 return NULL;
118 }
119
120 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
121 fprintf(stderr, "iface_Create: sysctl: estimate: %s\n",
122 strerror(errno));
123 return NULL;
124 }
125
126 if ((buf = (char *)malloc(needed)) == NULL) {
127 fprintf(stderr, "iface_Create: malloc failed: %s\n", strerror(errno));
128 return NULL;
129 }
130
131 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
132 err = errno;
133 free(buf);
134 buf = NULL;
135 }
136 } while (buf == NULL);
137
138 ptr = buf;
139 end = buf + needed;
140 iface = NULL;
141 namelen = strlen(name);
142
143 while (ptr < end && iface == NULL) {
144 ifm = (struct if_msghdr *)ptr; /* On if_msghdr */
145 if (ifm->ifm_type != RTM_IFINFO)
146 break;
147 dl = (struct sockaddr_dl *)(ifm + 1); /* Single _dl at end */
148 if (dl->sdl_nlen == namelen && !strncmp(name, dl->sdl_data, namelen)) {
149 iface = (struct iface *)malloc(sizeof *iface);
150 if (iface == NULL) {
151 fprintf(stderr, "iface_Create: malloc: %s\n", strerror(errno));
152 return NULL;
153 }
154 iface->name = strdup(name);
155 iface->index = ifm->ifm_index;
156 iface->flags = ifm->ifm_flags;
157 iface->mtu = 0;
158 iface->addrs = 0;
159 iface->addr = NULL;
160 }
161 ptr += ifm->ifm_msglen; /* First ifa_msghdr */
162 for (; ptr < end; ptr += ifam->ifam_msglen) {
163 ifam = (struct ifa_msghdr *)ptr; /* Next if address */
164
165 if (ifam->ifam_type != RTM_NEWADDR) /* finished this if */
166 break;
167
168 if (iface != NULL && ifam->ifam_addrs & RTA_IFA) {
169 /* Found a configured interface ! */
170 iface_ParseHdr(ifam, sa);
171
172 if (sa[RTAX_IFA] && (sa[RTAX_IFA]->sa_family == AF_INET
173#ifndef NOINET6
174 || sa[RTAX_IFA]->sa_family == AF_INET6
175#endif
176 )) {
177 /* Record the address */
178
179 addr = (struct iface_addr *)
180 realloc(iface->addr, (iface->addrs + 1) * sizeof iface->addr[0]);
181 if (addr == NULL)
182 break;
183 iface->addr = addr;
184
185 addr += iface->addrs;
186 iface->addrs++;
187
188 ncprange_setsa(&addr->ifa, sa[RTAX_IFA], sa[RTAX_NETMASK]);
189 if (sa[RTAX_BRD])
190 ncpaddr_setsa(&addr->peer, sa[RTAX_BRD]);
191 else
192 ncpaddr_init(&addr->peer);
193 }
194 }
195 }
196 }
197
198 free(buf);
199
200 return iface;
201}
202
203static int
204iface_addr_Zap(const char *name, struct iface_addr *addr, int s)
205{
206 struct ifaliasreq ifra;
207#ifndef NOINET6
208 struct in6_aliasreq ifra6;
209#endif
210 struct sockaddr_in *me4, *msk4, *peer4;
211 struct sockaddr_storage ssme, sspeer, ssmsk;
212 int res;
213
214 ncprange_getsa(&addr->ifa, &ssme, &ssmsk);
215 ncpaddr_getsa(&addr->peer, &sspeer);
216 res = 0;
217
218 switch (ncprange_family(&addr->ifa)) {
219 case AF_INET:
220 memset(&ifra, '\0', sizeof ifra);
221 strncpy(ifra.ifra_name, name, sizeof ifra.ifra_name - 1);
222
223 me4 = (struct sockaddr_in *)&ifra.ifra_addr;
224 memcpy(me4, &ssme, sizeof *me4);
225
226 msk4 = (struct sockaddr_in *)&ifra.ifra_mask;
227 memcpy(msk4, &ssmsk, sizeof *msk4);
228
229 peer4 = (struct sockaddr_in *)&ifra.ifra_broadaddr;
230 if (ncpaddr_family(&addr->peer) == AF_UNSPEC) {
231 peer4->sin_family = AF_INET;
232 peer4->sin_len = sizeof(*peer4);
233 peer4->sin_addr.s_addr = INADDR_NONE;
234 } else
235 memcpy(peer4, &sspeer, sizeof *peer4);
236
237 res = ID0ioctl(s, SIOCDIFADDR, &ifra);
238 if (log_IsKept(LogDEBUG)) {
239 char buf[100];
240
241 snprintf(buf, sizeof buf, "%s", ncprange_ntoa(&addr->ifa));
242 log_Printf(LogWARN, "%s: DIFADDR %s -> %s returns %d\n",
243 ifra.ifra_name, buf, ncpaddr_ntoa(&addr->peer), res);
244 }
245 break;
246
247#ifndef NOINET6
248 case AF_INET6:
249 memset(&ifra6, '\0', sizeof ifra6);
250 strncpy(ifra6.ifra_name, name, sizeof ifra6.ifra_name - 1);
251
252 memcpy(&ifra6.ifra_addr, &ssme, sizeof ifra6.ifra_addr);
253 memcpy(&ifra6.ifra_prefixmask, &ssmsk, sizeof ifra6.ifra_prefixmask);
254 ifra6.ifra_prefixmask.sin6_family = AF_UNSPEC;
255 if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
256 ifra6.ifra_dstaddr.sin6_family = AF_UNSPEC;
257 else
258 memcpy(&ifra6.ifra_dstaddr, &sspeer, sizeof ifra6.ifra_dstaddr);
259 ifra6.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
260 ifra6.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
261
262 res = ID0ioctl(s, SIOCDIFADDR_IN6, &ifra6);
263 break;
264#endif
265 }
266
267 if (res == -1) {
268 char dst[40];
269 const char *end =
270#ifndef NOINET6
271 ncprange_family(&addr->ifa) == AF_INET6 ? "_IN6" :
272#endif
273 "";
274
275 if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
276 log_Printf(LogWARN, "iface rm: ioctl(SIOCDIFADDR%s, %s): %s\n",
277 end, ncprange_ntoa(&addr->ifa), strerror(errno));
278 else {
279 snprintf(dst, sizeof dst, "%s", ncpaddr_ntoa(&addr->peer));
280 log_Printf(LogWARN, "iface rm: ioctl(SIOCDIFADDR%s, %s -> %s): %s\n",
281 end, ncprange_ntoa(&addr->ifa), dst, strerror(errno));
282 }
283 }
284
285 return res != -1;
286}
287
288static int
289iface_addr_Add(const char *name, struct iface_addr *addr, int s)
290{
291 struct ifaliasreq ifra;
292#ifndef NOINET6
293 struct in6_aliasreq ifra6;
294#endif
295 struct sockaddr_in *me4, *msk4, *peer4;
296 struct sockaddr_storage ssme, sspeer, ssmsk;
297 int res;
298
299 ncprange_getsa(&addr->ifa, &ssme, &ssmsk);
300 ncpaddr_getsa(&addr->peer, &sspeer);
301 res = 0;
302
303 switch (ncprange_family(&addr->ifa)) {
304 case AF_INET:
305 memset(&ifra, '\0', sizeof ifra);
306 strncpy(ifra.ifra_name, name, sizeof ifra.ifra_name - 1);
307
308 me4 = (struct sockaddr_in *)&ifra.ifra_addr;
309 memcpy(me4, &ssme, sizeof *me4);
310
311 msk4 = (struct sockaddr_in *)&ifra.ifra_mask;
312 memcpy(msk4, &ssmsk, sizeof *msk4);
313
314 peer4 = (struct sockaddr_in *)&ifra.ifra_broadaddr;
315 if (ncpaddr_family(&addr->peer) == AF_UNSPEC) {
316 peer4->sin_family = AF_INET;
317 peer4->sin_len = sizeof(*peer4);
318 peer4->sin_addr.s_addr = INADDR_NONE;
319 } else
320 memcpy(peer4, &sspeer, sizeof *peer4);
321
322 res = ID0ioctl(s, SIOCAIFADDR, &ifra);
323 if (log_IsKept(LogDEBUG)) {
324 char buf[100];
325
326 snprintf(buf, sizeof buf, "%s", ncprange_ntoa(&addr->ifa));
327 log_Printf(LogWARN, "%s: AIFADDR %s -> %s returns %d\n",
328 ifra.ifra_name, buf, ncpaddr_ntoa(&addr->peer), res);
329 }
330 break;
331
332#ifndef NOINET6
333 case AF_INET6:
334 memset(&ifra6, '\0', sizeof ifra6);
335 strncpy(ifra6.ifra_name, name, sizeof ifra6.ifra_name - 1);
336
337 memcpy(&ifra6.ifra_addr, &ssme, sizeof ifra6.ifra_addr);
338 memcpy(&ifra6.ifra_prefixmask, &ssmsk, sizeof ifra6.ifra_prefixmask);
339 if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
340 ifra6.ifra_dstaddr.sin6_family = AF_UNSPEC;
341 else if (memcmp(&((struct sockaddr_in6 *)&ssmsk)->sin6_addr, &in6mask128,
342 sizeof in6mask128) == 0)
343 memcpy(&ifra6.ifra_dstaddr, &sspeer, sizeof ifra6.ifra_dstaddr);
344 ifra6.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
345 ifra6.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
346
347 res = ID0ioctl(s, SIOCAIFADDR_IN6, &ifra6);
348 break;
349#endif
350 }
351
352 if (res == -1) {
353 char dst[40];
354 const char *end =
355#ifndef NOINET6
356 ncprange_family(&addr->ifa) == AF_INET6 ? "_IN6" :
357#endif
358 "";
359
360 if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
361 log_Printf(LogWARN, "iface add: ioctl(SIOCAIFADDR%s, %s): %s\n",
362 end, ncprange_ntoa(&addr->ifa), strerror(errno));
363 else {
364 snprintf(dst, sizeof dst, "%s", ncpaddr_ntoa(&addr->peer));
365 log_Printf(LogWARN, "iface add: ioctl(SIOCAIFADDR%s, %s -> %s): %s\n",
366 end, ncprange_ntoa(&addr->ifa), dst, strerror(errno));
367 }
368 }
369
370 return res != -1;
371}
372
373
374void
375iface_Clear(struct iface *iface, struct ncp *ncp, int family, int how)
376{
377 int addrs, af, inskip, in6skip, n, s4 = -1, s6 = -1, *s;
378
379 if (iface->addrs) {
380 inskip = in6skip = how == IFACE_CLEAR_ALL ? 0 : 1;
381 addrs = 0;
382
383 for (n = 0; n < iface->addrs; n++) {
384 af = ncprange_family(&iface->addr[n].ifa);
385 if (family == 0 || family == af) {
386 if (!iface->addr[n].system && (how & IFACE_SYSTEM))
387 continue;
388 switch (af) {
389 case AF_INET:
390 if (inskip) {
391 inskip = 0;
392 continue;
393 }
394 s = &s4;
395 break;
396
397#ifndef NOINET6
398 case AF_INET6:
399 if (in6skip) {
400 in6skip = 0;
401 continue;
402 }
403 s = &s6;
404 break;
405#endif
406 default:
407 continue;
408 }
409
410 if (*s == -1 && (*s = ID0socket(af, SOCK_DGRAM, 0)) == -1)
411 log_Printf(LogERROR, "iface_Clear: socket(): %s\n", strerror(errno));
412 else if (iface_addr_Zap(iface->name, iface->addr + n, *s)) {
413 ncp_IfaceAddrDeleted(ncp, iface->addr + n);
414 bcopy(iface->addr + n + 1, iface->addr + n,
415 (iface->addrs - n - 1) * sizeof *iface->addr);
416 iface->addrs--;
417 n--;
418 }
419 }
420 }
421
422 /* Don't bother realloc()ing - we have little to gain */
423
424 if (s4)
425 close(s4);
426 if (s6)
427 close(s6);
428 }
429}
430
431int
432iface_Add(struct iface *iface, struct ncp *ncp, const struct ncprange *ifa,
433 const struct ncpaddr *peer, int how)
434{
435 int af, n, removed, s;
436 struct ncpaddr ncplocal;
437 struct iface_addr *addr, newaddr;
438
439 af = ncprange_family(ifa);
440 if ((s = ID0socket(af, SOCK_DGRAM, 0)) == -1) {
441 log_Printf(LogERROR, "iface_Add: socket(): %s\n", strerror(errno));
442 return 0;
443 }
444 ncprange_getaddr(ifa, &ncplocal);
445
446 for (n = 0; n < iface->addrs; n++) {
447 if (ncprange_contains(&iface->addr[n].ifa, &ncplocal) ||
448 ncpaddr_equal(&iface->addr[n].peer, peer)) {
449 /* Replace this sockaddr */
450 if (!(how & IFACE_FORCE_ADD)) {
451 close(s);
452 return 0; /* errno = EEXIST; */
453 }
454
455 if (ncprange_equal(&iface->addr[n].ifa, ifa) &&
456 ncpaddr_equal(&iface->addr[n].peer, peer)) {
457 close(s);
458 return 1; /* Already there */
459 }
460
461 removed = iface_addr_Zap(iface->name, iface->addr + n, s);
462 if (removed)
463 ncp_IfaceAddrDeleted(ncp, iface->addr + n);
464 ncprange_copy(&iface->addr[n].ifa, ifa);
465 ncpaddr_copy(&iface->addr[n].peer, peer);
466 if (!iface_addr_Add(iface->name, iface->addr + n, s)) {
467 if (removed) {
468 bcopy(iface->addr + n + 1, iface->addr + n,
469 (iface->addrs - n - 1) * sizeof *iface->addr);
470 iface->addrs--;
471 n--;
472 }
473 close(s);
474 return 0;
475 }
476 close(s);
477 ncp_IfaceAddrAdded(ncp, iface->addr + n);
478 return 1;
479 }
480 }
481
482 addr = (struct iface_addr *)realloc
483 (iface->addr, (iface->addrs + 1) * sizeof iface->addr[0]);
484 if (addr == NULL) {
485 log_Printf(LogERROR, "iface_inAdd: realloc: %s\n", strerror(errno));
486 close(s);
487 return 0;
488 }
489 iface->addr = addr;
490
491 ncprange_copy(&newaddr.ifa, ifa);
492 ncpaddr_copy(&newaddr.peer, peer);
493 newaddr.system = !!(how & IFACE_SYSTEM);
494 if (!iface_addr_Add(iface->name, &newaddr, s)) {
495 close(s);
496 return 0;
497 }
498
499 if (how & IFACE_ADD_FIRST) {
500 /* Stuff it at the start of our list */
501 n = 0;
502 bcopy(iface->addr, iface->addr + 1, iface->addrs * sizeof *iface->addr);
503 } else
504 n = iface->addrs;
505
506 iface->addrs++;
507 memcpy(iface->addr + n, &newaddr, sizeof(*iface->addr));
508
509 close(s);
510 ncp_IfaceAddrAdded(ncp, iface->addr + n);
511
512 return 1;
513}
514
515int
516iface_Delete(struct iface *iface, struct ncp *ncp, const struct ncpaddr *del)
517{
518 struct ncpaddr found;
519 int n, res, s;
520
521 if ((s = ID0socket(ncpaddr_family(del), SOCK_DGRAM, 0)) == -1) {
522 log_Printf(LogERROR, "iface_Delete: socket(): %s\n", strerror(errno));
523 return 0;
524 }
525
526 for (n = res = 0; n < iface->addrs; n++) {
527 ncprange_getaddr(&iface->addr[n].ifa, &found);
528 if (ncpaddr_equal(&found, del)) {
529 if (iface_addr_Zap(iface->name, iface->addr + n, s)) {
530 ncp_IfaceAddrDeleted(ncp, iface->addr + n);
531 bcopy(iface->addr + n + 1, iface->addr + n,
532 (iface->addrs - n - 1) * sizeof *iface->addr);
533 iface->addrs--;
534 res = 1;
535 }
536 break;
537 }
538 }
539
540 close(s);
541
542 return res;
543}
544
545#define IFACE_ADDFLAGS 1
546#define IFACE_DELFLAGS 2
547
548static int
549iface_ChangeFlags(const char *ifname, int flags, int how)
550{
551 struct ifreq ifrq;
552 int s;
553
554 s = ID0socket(PF_INET, SOCK_DGRAM, 0);
555 if (s < 0) {
556 log_Printf(LogERROR, "iface_ChangeFlags: socket: %s\n", strerror(errno));
557 return 0;
558 }
559
560 memset(&ifrq, '\0', sizeof ifrq);
561 strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1);
562 ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
563 if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
564 log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCGIFFLAGS): %s\n",
565 strerror(errno));
566 close(s);
567 return 0;
568 }
569
570 if (how == IFACE_ADDFLAGS)
571 ifrq.ifr_flags |= flags;
572 else
573 ifrq.ifr_flags &= ~flags;
574
575 if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
576 log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCSIFFLAGS): %s\n",
577 strerror(errno));
578 close(s);
579 return 0;
580 }
581 close(s);
582
583 return 1; /* Success */
584}
585
586int
587iface_SetFlags(const char *ifname, int flags)
588{
589 return iface_ChangeFlags(ifname, flags, IFACE_ADDFLAGS);
590}
591
592int
593iface_ClearFlags(const char *ifname, int flags)
594{
595 return iface_ChangeFlags(ifname, flags, IFACE_DELFLAGS);
596}
597
598void
599iface_Destroy(struct iface *iface)
600{
601 /*
602 * iface_Clear(iface, IFACE_CLEAR_ALL) must be called manually
603 * if that's what the user wants. It's better to leave the interface
604 * allocated so that existing connections can continue to work.
605 */
606
607 if (iface != NULL) {
608 free(iface->name);
609 free(iface->addr);
610 free(iface);
611 }
612}
613
614#define if_entry(x) { IFF_##x, #x }
615
616struct {
617 int flag;
618 const char *value;
619} if_flags[] = {
620 if_entry(UP),
621 if_entry(BROADCAST),
622 if_entry(DEBUG),
623 if_entry(LOOPBACK),
624 if_entry(POINTOPOINT),
625 if_entry(RUNNING),
626 if_entry(NOARP),
627 if_entry(PROMISC),
628 if_entry(ALLMULTI),
629 if_entry(OACTIVE),
630 if_entry(SIMPLEX),
631 if_entry(LINK0),
632 if_entry(LINK1),
633 if_entry(LINK2),
634 if_entry(MULTICAST),
635 { 0, "???" }
636};
637
638int
639iface_Show(struct cmdargs const *arg)
640{
641 struct ncpaddr ncpaddr;
642 struct iface *iface = arg->bundle->iface, *current;
643 int f, flags;
644#ifndef NOINET6
645 int scopeid, width;
646#endif
647 struct in_addr mask;
648
649 current = iface_Create(iface->name);
650 flags = iface->flags = current->flags;
651 iface_Destroy(current);
652
653 prompt_Printf(arg->prompt, "%s (idx %d) <", iface->name, iface->index);
654 for (f = 0; f < sizeof if_flags / sizeof if_flags[0]; f++)
655 if ((if_flags[f].flag & flags)) {
656 prompt_Printf(arg->prompt, "%s%s", flags == iface->flags ? "" : ",",
657 if_flags[f].value);
658 flags &= ~if_flags[f].flag;
659 }
660
661#if 0
662 if (flags)
663 prompt_Printf(arg->prompt, "%s0x%x", flags == iface->flags ? "" : ",",
664 flags);
665#endif
666
667 prompt_Printf(arg->prompt, "> mtu %d has %d address%s:\n", iface->mtu,
668 iface->addrs, iface->addrs == 1 ? "" : "es");
669
670 for (f = 0; f < iface->addrs; f++) {
671 ncprange_getaddr(&iface->addr[f].ifa, &ncpaddr);
672 switch (ncprange_family(&iface->addr[f].ifa)) {
673 case AF_INET:
674 prompt_Printf(arg->prompt, " inet %s --> ", ncpaddr_ntoa(&ncpaddr));
675 if (ncpaddr_family(&iface->addr[f].peer) == AF_UNSPEC)
676 prompt_Printf(arg->prompt, "255.255.255.255");
677 else
678 prompt_Printf(arg->prompt, "%s", ncpaddr_ntoa(&iface->addr[f].peer));
679 ncprange_getip4mask(&iface->addr[f].ifa, &mask);
680 prompt_Printf(arg->prompt, " netmask 0x%08lx", (long)ntohl(mask.s_addr));
681 break;
682
683#ifndef NOINET6
684 case AF_INET6:
685 prompt_Printf(arg->prompt, " inet6 %s", ncpaddr_ntoa(&ncpaddr));
686 if (ncpaddr_family(&iface->addr[f].peer) != AF_UNSPEC)
687 prompt_Printf(arg->prompt, " --> %s",
688 ncpaddr_ntoa(&iface->addr[f].peer));
689 ncprange_getwidth(&iface->addr[f].ifa, &width);
690 if (ncpaddr_family(&iface->addr[f].peer) == AF_UNSPEC)
691 prompt_Printf(arg->prompt, " prefixlen %d", width);
692 if ((scopeid = ncprange_scopeid(&iface->addr[f].ifa)) != -1)
693 prompt_Printf(arg->prompt, " scopeid 0x%x", (unsigned)scopeid);
694 break;
695#endif
696 }
697 prompt_Printf(arg->prompt, "\n");
698 }
699
700 return 0;
701}
702
703void
704iface_ParseHdr(struct ifa_msghdr *ifam, struct sockaddr *sa[RTAX_MAX])
705{
706 char *wp;
707 int rtax;
708
709 wp = (char *)(ifam + 1);
710
711 for (rtax = 0; rtax < RTAX_MAX; rtax++)
712 if (ifam->ifam_addrs & (1 << rtax)) {
713 sa[rtax] = (struct sockaddr *)wp;
714 wp += ROUNDUP(sa[rtax]->sa_len);
715 } else
716 sa[rtax] = NULL;
717}