usr.sbin/gifconfig/gifconfig.c

   1 /*      $FreeBSD: src/usr.sbin/gifconfig/gifconfig.c,v 1.2.2.4 2002/08/30 14:23:39 sobomax Exp $        */
   2 /*      $KAME: gifconfig.c,v 1.14 2001/01/01 04:04:56 jinmei Exp $      */
   3
   4 /*
   5  * Copyright (c) 1983, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * gifconfig, derived from ifconfig
  35  *
  36  * @(#) Copyright (c) 1983, 1993\n\
  37  *      The Regents of the University of California.  All rights reserved.\n
  38  *
  39  * @(#)ifconfig.c       8.2 (Berkeley) 2/16/94
  40  */
  41
  42 /*
  43  *  951109 - Andrew@pubnix.net - Changed to iterative buffer growing mechanism
  44  *                               for ifconfig -a so all interfaces are queried.
  45  *
  46  *  960101 - peter@freebsd.org - Blow away the SIOCGIFCONF code and use
  47  *                               sysctl() to get the structured interface conf
  48  *                               and parse the messages in there. REALLY UGLY!
  49  */
  50
  51 #include <sys/param.h>
  52 #include <sys/socket.h>
  53 #include <sys/ioctl.h>
  54 #include <sys/sysctl.h>
  55
  56 #include <net/if.h>
  57 #if defined(__DragonFly__)
  58 #include <net/if_var.h>
  59 #endif /* __DragonFly__ */
  60 #include <net/if_dl.h>
  61 #include <net/if_types.h>
  62 #include <net/route.h>
  63 #include <netinet/in.h>
  64 #include <netinet/in_var.h>
  65 #include <arpa/inet.h>
  66 #include <netdb.h>
  67
  68 #include <sys/protosw.h>
  69
  70 #include <ctype.h>
  71 #include <err.h>
  72 #include <errno.h>
  73 #include <stdio.h>
  74 #include <stdlib.h>
  75 #include <string.h>
  76 #include <unistd.h>
  77 #include <nlist.h>
  78 #include <kvm.h>
  79 #include <fcntl.h>
  80
  81 struct  ifreq           ifr;
  82 struct  ifaliasreq      addreq;
  83 #ifdef INET6
  84 struct  in6_ifreq       in6_ifr;
  85 struct  in6_aliasreq    in6_addreq;
  86 #endif
  87
  88 char    name[32];
  89 int     flags;
  90 int     metric;
  91 int     mtu;
  92 int     setpsrc = 0;
  93 int     newaddr = 0;
  94 int     s;
  95 kvm_t   *kvmd;
  96
  97 #ifdef INET6
  98 char ntop_buf[INET6_ADDRSTRLEN];        /*inet_ntop()*/
  99 #endif
 100
 101 void setifpsrc(char *, int);
 102 void setifpdst(char *, int);
 103 void setifflags(char *, int);
 104 #ifdef SIOCDIFPHYADDR
 105 void delifaddrs(char *, int);
 106 #endif
 107
 108 #define NEXTARG         0xffffff
 109
 110 static struct   cmd {
 111         char    *c_name;
 112         int     c_parameter;            /* NEXTARG means next argv */
 113         void    (*c_func)(char *, int);
 114 } cmds[] = {
 115         { "up",         IFF_UP,         setifflags } ,
 116         { "down",       -IFF_UP,        setifflags },
 117 #ifdef SIOCDIFPHYADDR
 118         { "delete",     0,              delifaddrs },
 119 #endif
 120         { 0,            0,              setifpsrc },
 121         { 0,            0,              setifpdst },
 122 };
 123
 124 /*
 125  * XNS support liberally adapted from code written at the University of
 126  * Maryland principally by James O'Toole and Chris Torek.
 127  */
 128 void status(void);
 129 void phys_status(int);
 130 void in_status(int);
 131 #ifdef INET6
 132 void in6_status(int);
 133 #endif
 134 void ether_status(int);
 135 void Perror(char *);
 136 void in_getaddr(char *, int);
 137 #ifdef INET6
 138 void in6_getaddr(char *, int);
 139 void in6_getprefix(char *, int);
 140 #endif
 141 void printb(char *, unsigned int, char *);
 142 int prefix(void *, int);
 143
 144 char ntop_buf[INET6_ADDRSTRLEN];
 145
 146 /* Known address families */
 147 struct afswtch {
 148         char *af_name;
 149         short af_af;
 150         void (*af_status)(int);
 151         void (*af_getaddr)(char *, int);
 152         void (*af_getprefix)(char *, int);
 153         u_long af_pifaddr;
 154         caddr_t af_addreq;
 155         caddr_t af_req;
 156 } afs[] = {
 157 #define C(x) ((caddr_t) &x)
 158         { "inet", AF_INET, in_status, in_getaddr, 0,
 159              SIOCSIFPHYADDR, C(addreq), C(ifr) },
 160 #ifdef INET6
 161         { "inet6", AF_INET6, in6_status, in6_getaddr, in6_getprefix,
 162              SIOCSIFPHYADDR_IN6, C(in6_addreq), C(in6_ifr) },
 163 #endif
 164         { "ether", AF_INET, ether_status, NULL, NULL }, /* XXX not real!! */
 165         { 0,    0,          0,          0,      0 }
 166 };
 167
 168 struct afswtch *afp = NULL;     /*the address family being set or asked about*/
 169
 170 void    rt_xaddrs(caddr_t, caddr_t, struct rt_addrinfo *);
 171 int     ifconfig(int argc, char *argv[], int af, struct afswtch *rafp);
 172
 173 void
 174 rt_xaddrs(caddr_t cp, caddr_t cplim, struct rt_addrinfo *rtinfo)
 175 {
 176         struct sockaddr *sa;
 177         int i;
 178
 179         memset(rtinfo->rti_info, 0, sizeof(rtinfo->rti_info));
 180         for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
 181                 if ((rtinfo->rti_addrs & (1 << i)) == 0)
 182                         continue;
 183                 rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
 184                 RT_ADVANCE(cp, sa);
 185         }
 186 }
 187
 188
 189 /*
 190  * Grunge for new-style sysctl() decoding.. :-(
 191  * Apologies to the world for committing gross things like this in 1996..
 192  */
 193 struct if_msghdr *ifm;
 194 struct ifa_msghdr *ifam;
 195 struct sockaddr_dl *sdl;
 196 struct rt_addrinfo info;
 197 char *buf, *lim, *next;
 198
 199
 200 int
 201 main(int argc, char **argv)
 202 {
 203         int af = AF_INET;
 204         struct afswtch *rafp = NULL;
 205         size_t needed;
 206         int mib[6];
 207         int all;
 208
 209         if (argc < 2) {
 210                 fprintf(stderr,
 211                     "usage: gifconfig interface [af] [physsrc physdst]\n");
 212 #ifdef SIOCDIFPHYADDR
 213                 fprintf(stderr,
 214                     "       gifconfig interface delete\n");
 215 #endif
 216                 fprintf(stderr,
 217                     "       gifconfig -a\n");
 218                 exit(1);
 219         }
 220         argc--, argv++;
 221         strncpy(name, *argv, sizeof(name));
 222         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 223         argc--, argv++;
 224         if (argc > 0) {
 225                 for (afp = rafp = afs; rafp->af_name; rafp++)
 226                         if (strcmp(rafp->af_name, *argv) == 0) {
 227                                 afp = rafp; argc--; argv++;
 228                                 break;
 229                         }
 230                 rafp = afp;
 231                 af = ifr.ifr_addr.sa_family = rafp->af_af;
 232         }
 233
 234         mib[0] = CTL_NET;
 235         mib[1] = PF_ROUTE;
 236         mib[2] = 0;
 237         mib[3] = 0;     /* address family */
 238         mib[4] = NET_RT_IFLIST;
 239         mib[5] = 0;
 240
 241         /* if particular family specified, only ask about it */
 242         if (afp) {
 243                 mib[3] = afp->af_af;
 244         }
 245
 246         if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
 247                 errx(1, "iflist-sysctl-estimate");
 248         if ((buf = malloc(needed)) == NULL)
 249                 errx(1, "malloc");
 250         if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
 251                 errx(1, "actual retrieval of interface table");
 252         lim = buf + needed;
 253
 254         all = 0;
 255         if (strcmp(name, "-a") == 0)
 256                 all = 1;        /* All interfaces */
 257         else if (strcmp(name, "-au") == 0)
 258                 all = 2;        /* All IFF_UPinterfaces */
 259         else if (strcmp(name, "-ad") == 0)
 260                 all = 3;        /* All !IFF_UP interfaces */
 261
 262         for (next = buf; next < lim; next += ifm->ifm_msglen) {
 263
 264                 ifm = (struct if_msghdr *)next;
 265
 266                 /* XXX: Swallow up leftover NEWADDR messages */
 267                 if (ifm->ifm_type == RTM_NEWADDR)
 268                         continue;
 269
 270                 if (ifm->ifm_type == RTM_IFINFO) {
 271                         sdl = (struct sockaddr_dl *)(ifm + 1);
 272                         flags = ifm->ifm_flags;
 273                 } else {
 274                         errx(1, "out of sync parsing NET_RT_IFLIST");
 275                 }
 276
 277                 switch(all) {
 278                 case -1:
 279                 case 0:
 280                         if (strlen(name) != sdl->sdl_nlen)
 281                                 continue; /* not same len */
 282                         if (strncmp(name, sdl->sdl_data, sdl->sdl_nlen) != 0)
 283                                 continue; /* not same name */
 284                         break;
 285                 case 1:
 286                         break;  /* always do it */
 287                 case 2:
 288                         if ((flags & IFF_UP) == 0)
 289                                 continue; /* not up */
 290                         break;
 291                 case 3:
 292                         if (flags & IFF_UP)
 293                                 continue; /* not down */
 294                         break;
 295                 }
 296
 297                 /*
 298                  * Let's just do it for gif only
 299                  */
 300                 if (sdl->sdl_type != IFT_GIF) {
 301                         if (all != 0)
 302                                 continue;
 303
 304                         fprintf(stderr, "gifconfig: %s is not gif.\n",
 305                                 ifr.ifr_name);
 306                         exit(1);
 307                 }
 308
 309                 if (all > 0) {
 310                         strncpy(name, sdl->sdl_data, sdl->sdl_nlen);
 311                         name[sdl->sdl_nlen] = '\0';
 312                 }
 313
 314                 if ((s = socket(af, SOCK_DGRAM, 0)) < 0) {
 315                         perror("gifconfig: socket");
 316                         exit(1);
 317                 }
 318
 319                 ifconfig(argc,argv,af,rafp);
 320
 321                 close(s);
 322
 323                 if (all == 0) {
 324                         all = -1; /* flag it as 'done' */
 325                         break;
 326                 }
 327         }
 328         free(buf);
 329
 330         if (all == 0)
 331                 errx(1, "interface %s does not exist", name);
 332
 333
 334         exit (0);
 335 }
 336
 337
 338 int
 339 ifconfig(int argc, char **argv, int af, struct afswtch *rafp)
 340 {
 341
 342         af = 0;         /*fool gcc*/
 343
 344         strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
 345 #ifdef INET6
 346         strncpy(in6_ifr.ifr_name, name, sizeof in6_ifr.ifr_name);
 347 #endif /* INET6 */
 348
 349         if (ioctl(s, SIOCGIFMETRIC, (caddr_t)&ifr) < 0)
 350                 perror("ioctl (SIOCGIFMETRIC)");
 351         else
 352                 metric = ifr.ifr_metric;
 353
 354 #if defined(SIOCGIFMTU) && !defined(__OpenBSD__)
 355         if (ioctl(s, SIOCGIFMTU, (caddr_t)&ifr) < 0)
 356                 perror("ioctl (SIOCGIFMTU)");
 357         else
 358                 mtu = ifr.ifr_mtu;
 359 #else
 360         mtu = 0;
 361 #endif
 362
 363         if (argc == 0) {
 364                 status();
 365                 return(0);
 366         }
 367
 368         while (argc > 0) {
 369                 struct cmd *p;
 370
 371                 for (p = cmds; p->c_name; p++)
 372                         if (strcmp(*argv, p->c_name) == 0)
 373                                 break;
 374                 if (p->c_name == NULL && setpsrc)
 375                         p++;    /* got src, do dst */
 376                 if (p->c_func) {
 377                         if (p->c_parameter == NEXTARG) {
 378                                 if (argv[1] == NULL)
 379                                         errx(1, "'%s' requires argument",
 380                                             p->c_name);
 381                                 (*p->c_func)(argv[1], 0);
 382                                 argc--, argv++;
 383                         } else
 384                                 (*p->c_func)(*argv, p->c_parameter);
 385                 }
 386                 argc--, argv++;
 387         }
 388         if (newaddr) {
 389                 strncpy(rafp->af_addreq, name, sizeof ifr.ifr_name);
 390                 if (ioctl(s, rafp->af_pifaddr, rafp->af_addreq) < 0)
 391                         Perror("ioctl (SIOCSIFPHYADDR)");
 392         }
 393         else if (setpsrc) {
 394                 errx(1, "destination is not specified");
 395         }
 396         return(0);
 397 }
 398 #define PSRC    0
 399 #define PDST    1
 400
 401 /*ARGSUSED*/
 402 void
 403 setifpsrc(char *addr, int param)
 404 {
 405         param = 0;      /*fool gcc*/
 406         (*afp->af_getaddr)(addr, PSRC);
 407         setpsrc = 1;
 408 }
 409
 410 /*ARGSUSED*/
 411 void
 412 setifpdst(char *addr, int param)
 413 {
 414         param = 0;      /*fool gcc*/
 415         (*afp->af_getaddr)(addr, PDST);
 416         newaddr = 1;
 417 }
 418
 419 void
 420 setifflags(char *vname, int value)
 421 {
 422         if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
 423                 Perror("ioctl (SIOCGIFFLAGS)");
 424                 exit(1);
 425         }
 426         strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
 427         flags = (ifr.ifr_flags & 0xffff) | (ifr.ifr_flagshigh << 16);
 428
 429         if (value < 0) {
 430                 value = -value;
 431                 flags &= ~value;
 432         } else
 433                 flags |= value;
 434         ifr.ifr_flags = flags & 0xffff;
 435         ifr.ifr_flagshigh = flags >> 16;
 436         if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
 437                 Perror(vname);
 438 }
 439
 440 #ifdef SIOCDIFPHYADDR
 441 /* ARGSUSED */
 442 void
 443 delifaddrs(char *vname, int param)
 444 {
 445         param = 0;              /* fool gcc */
 446         vname = NULL;           /* ditto */
 447
 448         if (ioctl(s, SIOCDIFPHYADDR, (caddr_t)&ifr) < 0)
 449                 err(1, "ioctl(SIOCDIFPHYADDR)");
 450 }
 451 #endif
 452
 453 #define IFFBITS \
 454 "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6NOTRAILERS\7RUNNING\10NOARP\
 455 \11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2\20MULTICAST"
 456
 457 /*
 458  * Print the status of the interface.  If an address family was
 459  * specified, show it and it only; otherwise, show them all.
 460  */
 461 void
 462 status(void)
 463 {
 464         struct afswtch *p = NULL;
 465         char *mynext;
 466         struct if_msghdr *myifm;
 467
 468         printf("%s: ", name);
 469         printb("flags", flags, IFFBITS);
 470         if (metric)
 471                 printf(" metric %d", metric);
 472         if (mtu)
 473                 printf(" mtu %d", mtu);
 474         putchar('\n');
 475
 476         /*
 477          * XXX: Sigh. This is bad, I know.  At this point, we may have
 478          * *zero* RTM_NEWADDR's, so we have to "feel the water" before
 479          * incrementing the loop.  One day, I might feel inspired enough
 480          * to get the top level loop to pass a count down here so we
 481          * dont have to mess with this.  -Peter
 482          */
 483         myifm = ifm;
 484
 485         while (1) {
 486
 487                 mynext = next + ifm->ifm_msglen;
 488
 489                 if (mynext >= lim)
 490                         break;
 491
 492                 myifm = (struct if_msghdr *)mynext;
 493
 494                 if (myifm->ifm_type != RTM_NEWADDR)
 495                         break;
 496
 497                 next = mynext;
 498
 499                 ifm = (struct if_msghdr *)next;
 500
 501                 ifam = (struct ifa_msghdr *)myifm;
 502                 info.rti_addrs = ifam->ifam_addrs;
 503
 504                 /* Expand the compacted addresses */
 505                 rt_xaddrs((char *)(ifam + 1), ifam->ifam_msglen + (char *)ifam,
 506                           &info);
 507
 508                 if (afp) {
 509                         if (afp->af_af == info.rti_info[RTAX_IFA]->sa_family &&
 510                             afp->af_status != ether_status) {
 511                                 p = afp;
 512                                 if (p->af_status != ether_status)
 513                                         (*p->af_status)(1);
 514                         }
 515                 } else for (p = afs; p->af_name; p++) {
 516                         if (p->af_af == info.rti_info[RTAX_IFA]->sa_family &&
 517                             p->af_status != ether_status)
 518                                 (*p->af_status)(0);
 519                 }
 520         }
 521         if (afp == NULL || afp->af_status == ether_status)
 522                 ether_status(0);
 523         else if (afp && !p) {
 524                 warnx("%s has no %s IFA address!", name, afp->af_name);
 525         }
 526
 527         phys_status(0);
 528 }
 529
 530 void
 531 phys_status(int force)
 532 {
 533         char psrcaddr[256];
 534         char pdstaddr[256];
 535         int flags = NI_NUMERICHOST;
 536         char *af;
 537 #ifndef SIOCGLIFPHYADDR
 538         u_long srccmd, dstcmd;
 539         struct ifreq *ifrp;
 540 #ifdef INET6
 541         int s6;
 542 #endif
 543
 544         force = 0;      /*fool gcc*/
 545
 546         psrcaddr[0] = pdstaddr[0] = '\0';
 547
 548 #ifdef INET6
 549         s6 = socket(AF_INET6, SOCK_DGRAM, 0);
 550         if (s6 < 0) {
 551                 ifrp = &ifr;
 552                 srccmd = SIOCGIFPSRCADDR;
 553                 dstcmd = SIOCGIFPDSTADDR;
 554         } else {
 555                 close(s6);
 556                 srccmd = SIOCGIFPSRCADDR_IN6;
 557                 dstcmd = SIOCGIFPDSTADDR_IN6;
 558                 ifrp = (struct ifreq *)&in6_ifr;
 559         }
 560 #else /* INET6 */
 561         ifrp = &ifr;
 562         srccmd = SIOCGIFPSRCADDR;
 563         dstcmd = SIOCGIFPDSTADDR;
 564 #endif /* INET6 */
 565
 566         if (0 <= ioctl(s, srccmd, (caddr_t)ifrp)) {
 567 #ifdef INET6
 568                 if (ifrp->ifr_addr.sa_family == AF_INET6)
 569                         af = "inet6";
 570                 else
 571                         af = "inet";
 572 #else
 573                 af = "inet";
 574 #endif /* INET6 */
 575                 if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
 576                     psrcaddr, sizeof(psrcaddr), 0, 0, flags) != 0)
 577                         psrcaddr[0] = '\0';
 578         }
 579         if (0 <= ioctl(s, dstcmd, (caddr_t)ifrp)) {
 580                 if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
 581                     pdstaddr, sizeof(pdstaddr), 0, 0, flags) != 0)
 582                         pdstaddr[0] = '\0';
 583         }
 584         printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);
 585 #else
 586         struct if_laddrreq iflr;
 587
 588         force = 0;      /*fool gcc*/
 589
 590         psrcaddr[0] = pdstaddr[0] = '\0';
 591
 592         memset(&iflr, 0, sizeof(iflr));
 593         memcpy(iflr.iflr_name, ifr.ifr_name, sizeof(iflr.iflr_name));
 594
 595         if (0 <= ioctl(s, SIOCGLIFPHYADDR, (caddr_t)&iflr)) {
 596                 switch (iflr.addr.ss_family) {
 597                 case AF_INET:
 598                         af = "inet";
 599                         break;
 600 #ifdef INET6
 601                 case AF_INET6:
 602                         af = "inet6";
 603                         break;
 604 #endif /* INET6 */
 605                 }
 606                 if (getnameinfo((struct sockaddr *)&iflr.addr, iflr.addr.ss_len,
 607                     psrcaddr, sizeof(psrcaddr), 0, 0, flags) != 0)
 608                         psrcaddr[0] = '\0';
 609                 if (getnameinfo((struct sockaddr *)&iflr.dstaddr,
 610                     iflr.dstaddr.ss_len, pdstaddr, sizeof(pdstaddr), 0, 0,
 611                     flags) != 0)
 612                         pdstaddr[0] = '\0';
 613         }
 614         printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);
 615 #endif
 616 }
 617
 618 void
 619 in_status(int force)
 620 {
 621         struct sockaddr_in *sin, null_sin;
 622 #if 0
 623         char *inet_ntoa();
 624 #endif
 625
 626         memset(&null_sin, 0, sizeof(null_sin));
 627
 628         sin = (struct sockaddr_in *)info.rti_info[RTAX_IFA];
 629         if (!sin || sin->sin_family != AF_INET) {
 630                 if (!force)
 631                         return;
 632                 /* warnx("%s has no AF_INET IFA address!", name); */
 633                 sin = &null_sin;
 634         }
 635         printf("\tinet %s ", inet_ntoa(sin->sin_addr));
 636
 637         if (flags & IFF_POINTOPOINT) {
 638                 /* note RTAX_BRD overlap with IFF_BROADCAST */
 639                 sin = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
 640                 if (!sin)
 641                         sin = &null_sin;
 642                 printf("--> %s ", inet_ntoa(sin->sin_addr));
 643         }
 644
 645         sin = (struct sockaddr_in *)info.rti_info[RTAX_NETMASK];
 646         if (!sin)
 647                 sin = &null_sin;
 648         printf("netmask 0x%x ", (u_int32_t)ntohl(sin->sin_addr.s_addr));
 649
 650         if (flags & IFF_BROADCAST) {
 651                 /* note RTAX_BRD overlap with IFF_POINTOPOINT */
 652                 sin = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
 653                 if (sin && sin->sin_addr.s_addr != 0)
 654                         printf("broadcast %s", inet_ntoa(sin->sin_addr));
 655         }
 656         putchar('\n');
 657 }
 658
 659 #ifdef INET6
 660 void
 661 in6_status(int force)
 662 {
 663         struct sockaddr_in6 *sin, null_sin;
 664         char hostname[NI_MAXHOST];
 665         int niflags = NI_NUMERICHOST;
 666
 667         memset(&null_sin, 0, sizeof(null_sin));
 668 #ifdef NI_WITHSCOPEID
 669         niflags |= NI_WITHSCOPEID;
 670 #endif
 671
 672         sin = (struct sockaddr_in6 *)info.rti_info[RTAX_IFA];
 673         if (!sin || sin->sin6_family != AF_INET6) {
 674                 if (!force)
 675                         return;
 676                 /* warnx("%s has no AF_INET6 IFA address!", name); */
 677                 sin = &null_sin;
 678         }
 679 #ifdef __KAME__
 680         if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {
 681                 sin->sin6_scope_id =
 682                         ntohs(*(u_int16_t *)&sin->sin6_addr.s6_addr[2]);
 683                 sin->sin6_addr.s6_addr[2] = 0;
 684                 sin->sin6_addr.s6_addr[3] = 0;
 685         }
 686 #endif
 687         getnameinfo((struct sockaddr *)sin, sin->sin6_len,
 688                     hostname, sizeof(hostname), 0, 0, niflags);
 689         printf("\tinet6 %s ", hostname);
 690
 691         if (flags & IFF_POINTOPOINT) {
 692                 /* note RTAX_BRD overlap with IFF_BROADCAST */
 693                 sin = (struct sockaddr_in6 *)info.rti_info[RTAX_BRD];
 694                 /*
 695                  * some of ther interfaces do not have valid destination
 696                  * address.
 697                  */
 698                 if (sin->sin6_family == AF_INET6) {
 699 #ifdef __KAME__
 700                         if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {
 701                                 sin->sin6_scope_id =
 702                                         ntohs(*(u_int16_t *)&sin->sin6_addr.s6_addr[2]);
 703                                 sin->sin6_addr.s6_addr[2] = 0;
 704                                 sin->sin6_addr.s6_addr[3] = 0;
 705                         }
 706 #endif
 707                         getnameinfo((struct sockaddr *)sin, sin->sin6_len,
 708                                     hostname, sizeof(hostname), 0, 0, niflags);
 709                         printf("--> %s ", hostname);
 710                 }
 711         }
 712
 713         sin = (struct sockaddr_in6 *)info.rti_info[RTAX_NETMASK];
 714         if (!sin)
 715                 sin = &null_sin;
 716         printf(" prefixlen %d ", prefix(&sin->sin6_addr,
 717                 sizeof(struct in6_addr)));
 718
 719         putchar('\n');
 720 }
 721 #endif /*INET6*/
 722
 723 /*ARGSUSED*/
 724 void
 725 ether_status(int dummy)
 726 {
 727         char *cp;
 728         int n;
 729
 730         dummy = 0;      /*fool gcc*/
 731
 732         cp = (char *)LLADDR(sdl);
 733         if ((n = sdl->sdl_alen) > 0) {
 734                 if (sdl->sdl_type == IFT_ETHER)
 735                         printf ("\tether ");
 736                 else
 737                         printf ("\tlladdr ");
 738                 while (--n >= 0)
 739                         printf("%02x%c",*cp++ & 0xff, n>0? ':' : ' ');
 740                 putchar('\n');
 741         }
 742 }
 743
 744 void
 745 Perror(char *cmd)
 746 {
 747         switch (errno) {
 748
 749         case ENXIO:
 750                 errx(1, "%s: no such interface", cmd);
 751                 break;
 752
 753         case EPERM:
 754                 errx(1, "%s: permission denied", cmd);
 755                 break;
 756
 757         default:
 758                 err(1, "%s", cmd);
 759         }
 760 }
 761
 762 #define SIN(x) ((struct sockaddr_in *) &(x))
 763 struct sockaddr_in *sintab[] = {
 764 SIN(addreq.ifra_addr), SIN(addreq.ifra_dstaddr)};
 765
 766 void
 767 in_getaddr(char *s, int which)
 768 {
 769         struct sockaddr_in *sin = sintab[which];
 770         struct hostent *hp;
 771         struct netent *np;
 772
 773         sin->sin_len = sizeof(*sin);
 774         sin->sin_family = AF_INET;
 775
 776         if (inet_aton(s, &sin->sin_addr))
 777                 ;
 778         else if ((hp = gethostbyname(s)) != NULL)
 779                 bcopy(hp->h_addr, (char *)&sin->sin_addr, hp->h_length);
 780         else if ((np = getnetbyname(s)) != NULL)
 781                 sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
 782         else
 783                 errx(1, "%s: bad value", s);
 784 }
 785
 786 #ifdef INET6
 787 #define SIN6(x) ((struct sockaddr_in6 *) &(x))
 788 struct sockaddr_in6 *sin6tab[] = {
 789 SIN6(in6_addreq.ifra_addr), SIN6(in6_addreq.ifra_dstaddr)};
 790
 791 void
 792 in6_getaddr(char *s, int which)
 793 {
 794         struct sockaddr_in6 *sin = sin6tab[which];
 795
 796         sin->sin6_len = sizeof(*sin);
 797         sin->sin6_family = AF_INET6;
 798
 799         if (inet_pton(AF_INET6, s, &sin->sin6_addr) != 1)
 800                 errx(1, "%s: bad value", s);
 801 }
 802
 803 void
 804 in6_getprefix(char *plen, int which)
 805 {
 806         struct sockaddr_in6 *sin = sin6tab[which];
 807         u_char *cp;
 808         int len = atoi(plen);
 809
 810         if ((len < 0) || (len > 128))
 811                 errx(1, "%s: bad value", plen);
 812         sin->sin6_len = sizeof(*sin);
 813         sin->sin6_family = AF_INET6;
 814         if ((len == 0) || (len == 128)) {
 815                 memset(&sin->sin6_addr, -1, sizeof(struct in6_addr));
 816                 return;
 817         }
 818         for (cp = (u_char *)&sin->sin6_addr; len > 7; len -= 8)
 819                 *cp++ = -1;
 820         *cp = (-1) << (8 - len);
 821 }
 822 #endif
 823
 824 /*
 825  * Print a value a la the %b format of the kernel's printf
 826  */
 827 void
 828 printb(char *s, unsigned int v, char *bits)
 829 {
 830         int i, any = 0;
 831         char c;
 832
 833         if (bits && *bits == 8)
 834                 printf("%s=%o", s, v & 0xffff);
 835         else
 836                 printf("%s=%x", s, v & 0xffff);
 837         bits++;
 838         if (bits) {
 839                 putchar('<');
 840                 while ((i = *bits++) != 0) {
 841                         if ((v & (1 << (i-1))) != 0) {
 842                                 if (any)
 843                                         putchar(',');
 844                                 any = 1;
 845                                 for (; (c = *bits) > 32; bits++)
 846                                         putchar(c);
 847                         } else
 848                                 for (; *bits > 32; bits++)
 849                                         ;
 850                 }
 851                 putchar('>');
 852         }
 853 }
 854
 855 #ifdef INET6
 856 int
 857 prefix(void *val, int size)
 858 {
 859         u_char *name = (u_char *)val;
 860         int byte, bit, plen = 0;
 861
 862         for (byte = 0; byte < size; byte++, plen += 8)
 863                 if (name[byte] != 0xff)
 864                         break;
 865         if (byte == size)
 866                 return (plen);
 867         for (bit = 7; bit != 0; bit--, plen++)
 868                 if (!(name[byte] & (1 << bit)))
 869                         break;
 870         for (; bit != 0; bit--)
 871                 if (name[byte] & (1 << bit))
 872                         return(0);
 873         byte++;
 874         for (; byte < size; byte++)
 875                 if (name[byte])
 876                         return(0);
 877         return (plen);
 878 }
 879 #endif /*INET6*/