workbench/network/common/C/ifconfig.c

   1 /*
   2  * Copyright (C) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
   3  *                    Helsinki University of Technology, Finland.
   4  *                    All rights reserved.
   5  * Copyright (C) 2005 Neil Cafferkey
   6  * Copyright (c) 2005 Pavel Fedin
   7  * Copyright (c) 2006-2019 The AROS Dev Team
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  21  * MA 02111-1307, USA.
  22  *
  23  */
  24
  25 /*
  26  * Copyright (c) 1983, 1993
  27  *      The Regents of the University of California.  All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  */
  57
  58 #define INET_ONLY
  59
  60 #include <dos/dos.h>
  61
  62 #include <proto/exec.h>
  63
  64 #include <sys/cdefs.h>
  65 #include <sys/param.h>
  66 #include <sys/socket.h>
  67 #include <sys/sockio.h>
  68
  69 #include <net/if.h>
  70 #include <net/if_dl.h>
  71 #ifdef ENABLE_MEDIA_IOCTL
  72 #include <net/if_media.h>
  73 #endif
  74 #include <netinet/in.h>
  75 #include <arpa/inet.h>
  76 #ifdef ENABLE_APPLETALK
  77 #include <netatalk/at.h>
  78 #endif
  79 #ifdef NS
  80 #define NSIP
  81 #include <netns/ns.h>
  82 #include <netns/ns_if.h>
  83 #endif
  84 #include <netdb.h>
  85
  86 #define EON
  87 #ifdef ISO
  88 #include <netiso/iso.h>
  89 #include <netiso/iso_var.h>
  90 #endif
  91 #if !defined(__AROS__)
  92 #include <sys/protosw.h>
  93 #endif
  94
  95 #include <ctype.h>
  96 #if !defined(__AROS__)
  97 #include <err.h>
  98 #else
  99 #define  err(a,b)
 100 #define  errx(a,b,c)
 101 #define  warn(a)
 102 #define  inet_makeaddr(a,b) Inet_MakeAddr(a,b)
 103 #endif
 104 #include <errno.h>
 105 #include <stdio.h>
 106 #include <stdlib.h>
 107 #include <string.h>
 108 #include <unistd.h>
 109 #include <proto/miami.h>
 110 #include <proto/socket.h>
 111
 112 #if defined(__AROS__)
 113 struct Library *SocketBase;
 114 struct Library *MiamiBase;
 115 #endif
 116
 117 #define SOCKET_VERSION 3
 118 const TEXT version[] = "$VER: ifconfig 5.0 (04.12.2005)";
 119 const TEXT socket_name[] = "bsdsocket.library";
 120
 121 struct  ifreq           ifr, ridreq;
 122 struct  ifaliasreq      addreq __attribute__((aligned(4)));
 123 #ifdef ISO
 124 struct  iso_aliasreq    iso_addreq;
 125 #endif
 126 struct  sockaddr_in     netmask;
 127 #ifdef ENABLE_APPLETALK
 128 struct  netrange        at_nr;          /* AppleTalk net range */
 129 #endif
 130 char    name[30];
 131 int     flags, metric, mtu, setaddr, setipdst, doalias;
 132 int     clearaddr, s;
 133 int     newaddr = -1;
 134 int     nsellength = 1;
 135 int     af;
 136 int     dflag, mflag, lflag, uflag;
 137 int     reset_if_flags;
 138
 139 void    notealias __P((char *, int));
 140 void    notrailers __P((char *, int));
 141 void    setifaddr __P((char *, int));
 142 void    setifdstaddr __P((char *, int));
 143 void    setifflags __P((char *, int));
 144 void    setifbroadaddr __P((char *, int));
 145 void    setifipdst __P((char *, int));
 146 void    setifmetric __P((char *, int));
 147 void    setifmtu __P((char *, int));
 148 void    setifnetmask __P((char *, int));
 149 void    setnsellength __P((char *, int));
 150 void    setsnpaoffset __P((char *, int));
 151 void    setatrange __P((char *, int));
 152 void    setatphase __P((char *, int));
 153 #ifdef ENABLE_APPLETALK
 154 void    checkatrange __P ((struct sockaddr_at *));
 155 #endif
 156 void    setmedia __P((char *, int));
 157 void    setmediaopt __P((char *, int));
 158 void    unsetmediaopt __P((char *, int));
 159 #ifdef ISO
 160 void    fixnsel __P((struct sockaddr_iso *));
 161 #endif
 162 int     main __P((int, char *[]));
 163
 164 #define NEXTARG         0xffffff
 165
 166 struct  cmd {
 167         char    *c_name;
 168         int     c_parameter;            /* NEXTARG means next argv */
 169         void    (*c_func) __P((char *, int));
 170 } cmds[] = {
 171         { "up",         IFF_UP,         setifflags } ,
 172         { "down",       -IFF_UP,        setifflags },
 173         { "trailers",   -1,             notrailers },
 174         { "-trailers",  1,              notrailers },
 175         { "arp",        -IFF_NOARP,     setifflags },
 176         { "-arp",       IFF_NOARP,      setifflags },
 177         { "debug",      IFF_DEBUG,      setifflags },
 178         { "-debug",     -IFF_DEBUG,     setifflags },
 179         { "alias",      IFF_UP,         notealias },
 180         { "-alias",     -IFF_UP,        notealias },
 181         { "delete",     -IFF_UP,        notealias },
 182 #ifdef notdef
 183 #define EN_SWABIPS      0x1000
 184         { "swabips",    EN_SWABIPS,     setifflags },
 185         { "-swabips",   -EN_SWABIPS,    setifflags },
 186 #endif
 187         { "netmask",    NEXTARG,        setifnetmask },
 188         { "metric",     NEXTARG,        setifmetric },
 189         { "mtu",        NEXTARG,        setifmtu },
 190         { "broadcast",  NEXTARG,        setifbroadaddr },
 191         { "ipdst",      NEXTARG,        setifipdst },
 192 #ifndef INET_ONLY
 193         { "range",      NEXTARG,        setatrange },
 194         { "phase",      NEXTARG,        setatphase },
 195         { "snpaoffset", NEXTARG,        setsnpaoffset },
 196         { "nsellength", NEXTARG,        setnsellength },
 197 #endif  /* INET_ONLY */
 198         { "link0",      IFF_LINK0,      setifflags } ,
 199         { "-link0",     -IFF_LINK0,     setifflags } ,
 200         { "link1",      IFF_LINK1,      setifflags } ,
 201         { "-link1",     -IFF_LINK1,     setifflags } ,
 202         { "link2",      IFF_LINK2,      setifflags } ,
 203         { "-link2",     -IFF_LINK2,     setifflags } ,
 204 #ifdef ENABLE_MEDIA_IOCTL
 205         { "media",      NEXTARG,        setmedia },
 206         { "mediaopt",   NEXTARG,        setmediaopt },
 207         { "-mediaopt",  NEXTARG,        unsetmediaopt },
 208 #endif
 209         { 0,            0,              setifaddr },
 210         { 0,            0,              setifdstaddr },
 211 };
 212
 213 void    adjust_nsellength __P((void));
 214 int     getinfo __P((struct ifreq *));
 215 void    getsock __P((int));
 216 void    printall __P((void));
 217 void    printb __P((char *, unsigned short, char *));
 218 void    status __P((const u_int8_t *, int));
 219 void    usage __P((void));
 220 #ifdef ENABLE_MEDIA_IOCTL
 221 void    domediaopt __P((char *, int));
 222 int     get_media_subtype __P((int, char *));
 223 int     get_media_options __P((int, char *));
 224 int     lookup_media_word __P((struct ifmedia_description *, char *));
 225 void    print_media_word __P((int));
 226 #endif
 227 /*
 228  * XNS support liberally adapted from code written at the University of
 229  * Maryland principally by James O'Toole and Chris Torek.
 230  */
 231 void    in_status __P((int));
 232 void    in_getaddr __P((char *, int));
 233 void    at_status __P((int));
 234 void    at_getaddr __P((char *, int));
 235 void    xns_status __P((int));
 236 void    xns_getaddr __P((char *, int));
 237 void    iso_status __P((int));
 238 void    iso_getaddr __P((char *, int));
 239
 240 /* Known address families */
 241 struct afswtch {
 242         char *af_name;
 243         short af_af;
 244         void (*af_status) __P((int));
 245         void (*af_getaddr) __P((char *, int));
 246         u_long af_difaddr;
 247         u_long af_aifaddr;
 248         caddr_t af_ridreq;
 249         caddr_t af_addreq;
 250 } afs[] = {
 251 #define C(x) ((caddr_t) &x)
 252         { "inet", AF_INET, in_status, in_getaddr,
 253              SIOCDIFADDR, SIOCAIFADDR, C(ridreq), C(addreq) },
 254 #ifndef INET_ONLY       /* small version, for boot media */
 255         { "atalk", AF_APPLETALK, at_status, at_getaddr,
 256              SIOCDIFADDR, SIOCAIFADDR, C(addreq), C(addreq) },
 257         { "ns", AF_NS, xns_status, xns_getaddr,
 258              SIOCDIFADDR, SIOCAIFADDR, C(ridreq), C(addreq) },
 259         { "iso", AF_ISO, iso_status, iso_getaddr,
 260              SIOCDIFADDR, SIOCAIFADDR, C(ridreq), C(iso_addreq) },
 261 #endif  /* INET_ONLY */
 262         { 0,    0,          0,          0 }
 263 };
 264
 265 struct afswtch *afp;    /*the address family being set or asked about*/
 266
 267 struct afswtch *lookup_af __P((const char *));
 268
 269 static void __close_bsdsocket()
 270 {
 271         if (MiamiBase != NULL)
 272         {
 273                 CloseLibrary(MiamiBase);
 274                 MiamiBase = NULL;
 275         }
 276         if (SocketBase != NULL)
 277         {
 278                 CloseLibrary(SocketBase);
 279                 SocketBase = NULL;
 280         }
 281 }
 282
 283 int
 284 main(argc, argv)
 285         int argc;
 286         char *argv[];
 287 {
 288         int ch, aflag;
 289
 290 #if defined(__AROS__)
 291    if (!(SocketBase = OpenLibrary(socket_name, SOCKET_VERSION)))
 292    {
 293       return RETURN_FAIL;
 294    }
 295    if (!(MiamiBase = OpenLibrary("miami.library", 0)))
 296    {
 297       return RETURN_FAIL;
 298    }
 299         atexit(__close_bsdsocket);
 300 #endif
 301
 302         /* Parse command-line options */
 303         aflag = mflag = 0;
 304         while ((ch = getopt(argc, argv, "adlmu")) != -1) {
 305                 switch (ch) {
 306                 case 'a':
 307                         aflag = 1;
 308                         break;
 309
 310                 case 'd':
 311                         dflag = 1;
 312                         break;
 313
 314                 case 'l':
 315                         lflag = 1;
 316                         break;
 317
 318                 case 'm':
 319                         mflag = 1;
 320                         break;
 321
 322                 case 'u':
 323                         uflag = 1;
 324                         break;
 325
 326                 default:
 327                         usage();
 328                         /* NOTREACHED */
 329                 }
 330         }
 331         argc -= optind;
 332         argv += optind;
 333
 334         /*
 335          * -l means "list all interfaces", and is mutally exclusive with
 336          * all other flags/commands.
 337          *
 338          * -a means "print status of all interfaces".
 339          */
 340         if (lflag && (aflag || mflag || argc))
 341                 usage();
 342         if (aflag || lflag) {
 343                 if (argc > 1)
 344                         usage();
 345                 else if (argc == 1) {
 346                         afp = lookup_af(argv[0]);
 347                         if (afp == NULL)
 348                                 usage();
 349                 }
 350                 if (afp)
 351                         af = ifr.ifr_addr.sa_family = afp->af_af;
 352                 else
 353                         af = ifr.ifr_addr.sa_family = afs[0].af_af;
 354                 printall();
 355                 exit(0);
 356         }
 357
 358         /* Make sure there's an interface name. */
 359         if (argc < 1)
 360                 usage();
 361         (void) strncpy(name, argv[0], sizeof(name) - 1);
 362         argc--; argv++;
 363
 364         /* Check for address family. */
 365         afp = NULL;
 366         if (argc > 0) {
 367                 afp = lookup_af(argv[0]);
 368                 if (afp != NULL) {
 369                         argv++;
 370                         argc--;
 371                 }
 372         }
 373
 374         if (afp == NULL)
 375                 afp = afs;
 376         af = ifr.ifr_addr.sa_family = afp->af_af;
 377
 378         /* Get information about the interface. */
 379         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
 380         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 381         if (getinfo(&ifr) < 0)
 382                 exit(1);
 383
 384         /* No more arguments means interface status. */
 385         if (argc == 0) {
 386                 status(NULL, 0);
 387                 exit(0);
 388         }
 389
 390         /* Process commands. */
 391         while (argc > 0) {
 392                 struct cmd *p;
 393
 394                 for (p = cmds; p->c_name; p++)
 395                         if (strcmp(argv[0], p->c_name) == 0)
 396                                 break;
 397                 if (p->c_name == 0 && setaddr)
 398                         p++;    /* got src, do dst */
 399                 if (p->c_func) {
 400                         if (p->c_parameter == NEXTARG) {
 401                                 if (argc < 2)
 402                                         errx(1, "'%s' requires argument",
 403                                             p->c_name);
 404                                 (*p->c_func)(argv[1], 0);
 405                                 argc--, argv++;
 406                         } else
 407                                 (*p->c_func)(argv[0], p->c_parameter);
 408                 }
 409                 argc--, argv++;
 410         }
 411
 412 #ifndef INET_ONLY
 413
 414         if (af == AF_ISO)
 415                 adjust_nsellength();
 416
 417         if (af == AF_APPLETALK)
 418                 checkatrange((struct sockaddr_at *) &addreq.ifra_addr);
 419
 420         if (setipdst && af==AF_NS) {
 421                 struct nsip_req rq;
 422                 int size = sizeof(rq);
 423
 424                 rq.rq_ns = addreq.ifra_addr;
 425                 rq.rq_ip = addreq.ifra_dstaddr;
 426
 427                 if (setsockopt(s, 0, SO_NSIP_ROUTE, &rq, size) < 0)
 428                         warn("encapsulation routing");
 429         }
 430
 431 #endif  /* INET_ONLY */
 432
 433         if (clearaddr) {
 434                 int ret;
 435                 CopyMem(name, afp->af_ridreq, sizeof (ifr.ifr_name));
 436                 afp->af_ridreq[sizeof(ifr.ifr_name) - 1] = '\0';
 437                 if ((ret = IoctlSocket(s, afp->af_difaddr, afp->af_ridreq)) < 0) {
 438                         if (errno == EADDRNOTAVAIL && (doalias >= 0)) {
 439                                 /* means no previous address for interface */
 440                         } else
 441                                 warn("SIOCDIFADDR");
 442                 }
 443         }
 444         if (newaddr > 0) {
 445                 CopyMem(name, afp->af_addreq, sizeof (ifr.ifr_name));
 446                 afp->af_addreq[sizeof(ifr.ifr_name) - 1] = '\0';
 447                 if (IoctlSocket(s, afp->af_aifaddr, afp->af_addreq) < 0)
 448                         warn("SIOCAIFADDR");
 449         }
 450         if (reset_if_flags && IoctlSocket(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
 451                 err(1, "SIOCSIFFLAGS");
 452         exit(0);
 453 }
 454
 455 struct afswtch *
 456 lookup_af(cp)
 457         const char *cp;
 458 {
 459         struct afswtch *a;
 460
 461         for (a = afs; a->af_name != NULL; a++)
 462                 if (strcmp(a->af_name, cp) == 0)
 463                         return (a);
 464         return (NULL);
 465 }
 466
 467 void
 468 getsock(naf)
 469         int naf;
 470 {
 471         static int oaf = -1;
 472
 473         if (oaf == naf)
 474                 return;
 475         if (oaf != -1)
 476                 CloseSocket(s);
 477         s = socket(naf, SOCK_DGRAM, 0);
 478         if (s < 0)
 479                 oaf = -1;
 480         else
 481                 oaf = naf;
 482 }
 483
 484 int
 485 getinfo(ifr)
 486         struct ifreq *ifr;
 487 {
 488
 489         getsock(af);
 490         if (s < 0)
 491                 err(1, "socket");
 492         if (IoctlSocket(s, SIOCGIFFLAGS, (caddr_t)ifr) < 0) {
 493 #if !defined(__AROS__)
 494                 warn("SIOCGIFFLAGS %s", ifr->ifr_name);
 495 #endif
 496                 return (-1);
 497         }
 498         flags = ifr->ifr_flags;
 499         if (IoctlSocket(s, SIOCGIFMETRIC, (caddr_t)ifr) < 0) {
 500 #if !defined(__AROS__)
 501                 warn("SIOCGIFMETRIC %s", ifr->ifr_name);
 502 #endif
 503                 metric = 0;
 504         } else
 505                 metric = ifr->ifr_metric;
 506         if (IoctlSocket(s, SIOCGIFMTU, (caddr_t)ifr) < 0)
 507                 mtu = 0;
 508         else
 509                 mtu = ifr->ifr_mtu;
 510         return (0);
 511 }
 512
 513 void
 514 printall()
 515 {
 516         char inbuf[8192];
 517         const struct sockaddr_dl *sdl = NULL;
 518         struct ifconf ifc;
 519         struct ifreq ifreq, *ifr;
 520         int i, idx;
 521
 522         ifc.ifc_len = sizeof(inbuf);
 523         ifc.ifc_buf = inbuf;
 524         getsock(af);
 525         if (s < 0)
 526                 err(1, "socket");
 527         if (IoctlSocket(s, SIOCGIFCONF, (char *)&ifc) < 0)
 528                 err(1, "SIOCGIFCONF");
 529         ifr = ifc.ifc_req;
 530         ifreq.ifr_name[0] = '\0';
 531         for (i = 0, idx = 0; i < ifc.ifc_len; ) {
 532                 ifr = (struct ifreq *)((caddr_t)ifc.ifc_req + i);
 533                 i += sizeof(ifr->ifr_name) +
 534                         (ifr->ifr_addr.sa_len > sizeof(struct sockaddr)
 535                                 ? ifr->ifr_addr.sa_len
 536                                 : sizeof(struct sockaddr));
 537                 if (ifr->ifr_addr.sa_family == AF_LINK)
 538                         sdl = (const struct sockaddr_dl *) &ifr->ifr_addr;
 539                 if (!strncmp(ifreq.ifr_name, ifr->ifr_name,
 540                              sizeof(ifr->ifr_name)))
 541                         continue;
 542                 (void) strncpy(name, ifr->ifr_name, sizeof(name));
 543                 ifreq = *ifr;
 544
 545                 if (getinfo(&ifreq) < 0)
 546                         continue;
 547                 if (dflag && (flags & IFF_UP) != 0)
 548                         continue;
 549                 if (uflag && (flags & IFF_UP) == 0)
 550                         continue;
 551
 552                 idx++;
 553                 /*
 554                  * Are we just listing the interfaces?
 555                  */
 556                 if (lflag) {
 557                         if (idx > 1)
 558                                 putchar(' ');
 559                         fputs(name, stdout);
 560                         continue;
 561                 }
 562
 563                 if (sdl == NULL) {
 564                         status(NULL, 0);
 565                 } else {
 566                         status(LLADDR(sdl), sdl->sdl_alen);
 567                         sdl = NULL;
 568                 }
 569         }
 570         if (lflag)
 571                 putchar('\n');
 572 }
 573
 574 #define RIDADDR 0
 575 #define ADDR    1
 576 #define MASK    2
 577 #define DSTADDR 3
 578
 579 /*ARGSUSED*/
 580 void
 581 setifaddr(addr, param)
 582         char *addr;
 583         int param;
 584 {
 585         /*
 586          * Delay the IoctlSocket to set the interface addr until flags are all set.
 587          * The address interpretation may depend on the flags,
 588          * and the flags may change when the address is set.
 589          */
 590         setaddr++;
 591         if (newaddr == -1)
 592                 newaddr = 1;
 593         if (doalias == 0)
 594                 clearaddr = 1;
 595         (*afp->af_getaddr)(addr, (doalias >= 0 ? ADDR : RIDADDR));
 596 }
 597
 598 void
 599 setifnetmask(addr, d)
 600         char *addr;
 601         int d;
 602 {
 603         (*afp->af_getaddr)(addr, MASK);
 604 }
 605
 606 void
 607 setifbroadaddr(addr, d)
 608         char *addr;
 609         int d;
 610 {
 611         (*afp->af_getaddr)(addr, DSTADDR);
 612 }
 613
 614 void
 615 setifipdst(addr, d)
 616         char *addr;
 617         int d;
 618 {
 619         in_getaddr(addr, DSTADDR);
 620         setipdst++;
 621         clearaddr = 0;
 622         newaddr = 0;
 623 }
 624
 625 #define rqtosa(x) (&(((struct ifreq *)(afp->x))->ifr_addr))
 626 /*ARGSUSED*/
 627 void
 628 notealias(addr, param)
 629         char *addr;
 630         int param;
 631 {
 632         if (setaddr && doalias == 0 && param < 0)
 633                 (void) memcpy(rqtosa(af_ridreq), rqtosa(af_addreq),
 634                     rqtosa(af_addreq)->sa_len);
 635         doalias = param;
 636         if (param < 0) {
 637                 clearaddr = 1;
 638                 newaddr = 0;
 639         } else
 640                 clearaddr = 0;
 641 }
 642
 643 /*ARGSUSED*/
 644 void
 645 notrailers(vname, value)
 646         char *vname;
 647         int value;
 648 {
 649         puts("Note: trailers are no longer sent, but always received");
 650 }
 651
 652 /*ARGSUSED*/
 653 void
 654 setifdstaddr(addr, param)
 655         char *addr;
 656         int param;
 657 {
 658         (*afp->af_getaddr)(addr, DSTADDR);
 659 }
 660
 661 void
 662 setifflags(vname, value)
 663         char *vname;
 664         int value;
 665 {
 666         if (IoctlSocket(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0)
 667                 err(1, "SIOCGIFFLAGS");
 668         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
 669         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 670         flags = ifr.ifr_flags;
 671
 672         if (value < 0) {
 673                 value = -value;
 674                 flags &= ~value;
 675         } else
 676                 flags |= value;
 677         ifr.ifr_flags = flags;
 678 /*      if (IoctlSocket(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
 679                 err(1, "SIOCSIFFLAGS");*/
 680
 681         reset_if_flags = 1;
 682 }
 683
 684 void
 685 setifmetric(val, d)
 686         char *val;
 687         int d;
 688 {
 689         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
 690         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 691         ifr.ifr_metric = atoi(val);
 692         if (IoctlSocket(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0)
 693                 warn("SIOCSIFMETRIC");
 694 }
 695
 696 void
 697 setifmtu(val, d)
 698         char *val;
 699         int d;
 700 {
 701         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
 702         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 703         ifr.ifr_mtu = atoi(val);
 704         if (IoctlSocket(s, SIOCSIFMTU, (caddr_t)&ifr) < 0)
 705                 warn("SIOCSIFMTU");
 706 }
 707 #ifdef ENABLE_MEDIA_IOCTL
 708 void
 709 setmedia(val, d)
 710         char *val;
 711         int d;
 712 {
 713         struct ifmediareq ifmr;
 714         int first_type, subtype;
 715
 716         (void) memset(&ifmr, 0, sizeof(ifmr));
 717         CopyMem(name, ifmr.ifm_name, sizeof (ifmr.ifm_name));
 718         ifr.ifr_name[sizeof(ifmr.ifm_name) - 1] = '\0';
 719
 720         ifmr.ifm_count = 1;
 721         ifmr.ifm_ulist = &first_type;
 722         if (IoctlSocket(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
 723                 /*
 724                  * If we get E2BIG, the kernel is telling us
 725                  * that there are more, so we can ignore it.
 726                  */
 727                 if (errno != E2BIG)
 728                         err(1, "SIOCGIFMEDIA");
 729         }
 730
 731         if (ifmr.ifm_count == 0)
 732                 errx(1, "%s: no media types?", name);
 733
 734         /*
 735          * We are primarily concerned with the top-level type.
 736          * However, "current" may be only IFM_NONE, so we just look
 737          * for the top-level type in the first "supported type"
 738          * entry.
 739          *
 740          * (I'm assuming that all supported media types for a given
 741          * interface will be the same top-level type..)
 742          */
 743         subtype = get_media_subtype(IFM_TYPE(first_type), val);
 744
 745         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 746         ifr.ifr_media = (ifmr.ifm_current & ~(IFM_NMASK|IFM_TMASK)) |
 747             IFM_TYPE(first_type) | subtype;
 748
 749         if (IoctlSocket(s, SIOCSIFMEDIA, (caddr_t)&ifr) < 0)
 750                 err(1, "SIOCSIFMEDIA");
 751 }
 752
 753 void
 754 setmediaopt(val, d)
 755         char *val;
 756         int d;
 757 {
 758
 759         domediaopt(val, 0);
 760 }
 761
 762 void
 763 unsetmediaopt(val, d)
 764         int d;
 765         char *val;
 766 {
 767
 768         domediaopt(val, 1);
 769 }
 770
 771 void
 772 domediaopt(val, clear)
 773         char *val;
 774         int clear;
 775 {
 776         struct ifmediareq ifmr;
 777         int *mwords, options;
 778
 779         (void) memset(&ifmr, 0, sizeof(ifmr));
 780         (void) strncpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name));
 781
 782         /*
 783          * We must go through the motions of reading all
 784          * supported media because we need to know both
 785          * the current media type and the top-level type.
 786          */
 787
 788         if (IoctlSocket(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
 789                 err(1, "SIOCGIFMEDIA");
 790
 791         if (ifmr.ifm_count == 0)
 792                 errx(1, "%s: no media types?", name);
 793
 794         mwords = (int *)malloc(ifmr.ifm_count * sizeof(int));
 795         if (mwords == NULL)
 796                 err(1, "malloc");
 797
 798         ifmr.ifm_ulist = mwords;
 799         if (IoctlSocket(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
 800                 err(1, "SIOCGIFMEDIA");
 801
 802         options = get_media_options(IFM_TYPE(mwords[0]), val);
 803
 804         free(mwords);
 805
 806         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 807         ifr.ifr_media = ifmr.ifm_current;
 808         if (clear)
 809                 ifr.ifr_media &= ~options;
 810         else
 811                 ifr.ifr_media |= options;
 812
 813         if (IoctlSocket(s, SIOCSIFMEDIA, (caddr_t)&ifr) < 0)
 814                 err(1, "SIOCSIFMEDIA");
 815 }
 816
 817 /**********************************************************************
 818  * A good chunk of this is duplicated from sys/net/ifmedia.c
 819  **********************************************************************/
 820
 821 struct ifmedia_description ifm_type_descriptions[] =
 822     IFM_TYPE_DESCRIPTIONS;
 823
 824 struct ifmedia_description ifm_subtype_ethernet_descriptions[] =
 825     IFM_SUBTYPE_ETHERNET_DESCRIPTIONS;
 826
 827 struct ifmedia_description ifm_subtype_ethernet_aliases[] =
 828     IFM_SUBTYPE_ETHERNET_ALIASES;
 829
 830 struct ifmedia_description ifm_subtype_ethernet_option_descriptions[] =
 831     IFM_SUBTYPE_ETHERNET_OPTION_DESCRIPTIONS;
 832
 833 struct ifmedia_description ifm_subtype_tokenring_descriptions[] =
 834     IFM_SUBTYPE_TOKENRING_DESCRIPTIONS;
 835
 836 struct ifmedia_description ifm_subtype_tokenring_aliases[] =
 837     IFM_SUBTYPE_TOKENRING_ALIASES;
 838
 839 struct ifmedia_description ifm_subtype_tokenring_option_descriptions[] =
 840     IFM_SUBTYPE_TOKENRING_OPTION_DESCRIPTIONS;
 841
 842 struct ifmedia_description ifm_subtype_fddi_descriptions[] =
 843     IFM_SUBTYPE_FDDI_DESCRIPTIONS;
 844
 845 struct ifmedia_description ifm_subtype_fddi_aliases[] =
 846     IFM_SUBTYPE_FDDI_ALIASES;
 847
 848 struct ifmedia_description ifm_subtype_fddi_option_descriptions[] =
 849     IFM_SUBTYPE_FDDI_OPTION_DESCRIPTIONS;
 850
 851 struct ifmedia_description ifm_subtype_shared_descriptions[] =
 852     IFM_SUBTYPE_SHARED_DESCRIPTIONS;
 853
 854 struct ifmedia_description ifm_subtype_shared_aliases[] =
 855     IFM_SUBTYPE_SHARED_ALIASES;
 856
 857 struct ifmedia_description ifm_shared_option_descriptions[] =
 858     IFM_SHARED_OPTION_DESCRIPTIONS;
 859
 860 struct ifmedia_type_to_subtype {
 861         struct {
 862                 struct ifmedia_description *desc;
 863                 int alias;
 864         } subtypes[5];
 865         struct {
 866                 struct ifmedia_description *desc;
 867                 int alias;
 868         } options[3];
 869 };
 870
 871 /* must be in the same order as IFM_TYPE_DESCRIPTIONS */
 872 struct ifmedia_type_to_subtype ifmedia_types_to_subtypes[] = {
 873         {
 874                 {
 875                         { &ifm_subtype_shared_descriptions[0], 0 },
 876                         { &ifm_subtype_shared_aliases[0], 1 },
 877                         { &ifm_subtype_ethernet_descriptions[0], 0 },
 878                         { &ifm_subtype_ethernet_aliases[0], 1 },
 879                         { NULL, 0 },
 880                 },
 881                 {
 882                         { &ifm_shared_option_descriptions[0], 0 },
 883                         { &ifm_subtype_ethernet_option_descriptions[0], 1 },
 884                         { NULL, 0 },
 885                 },
 886         },
 887         {
 888                 {
 889                         { &ifm_subtype_shared_descriptions[0], 0 },
 890                         { &ifm_subtype_shared_aliases[0], 1 },
 891                         { &ifm_subtype_tokenring_descriptions[0], 0 },
 892                         { &ifm_subtype_tokenring_aliases[0], 1 },
 893                         { NULL, 0 },
 894                 },
 895                 {
 896                         { &ifm_shared_option_descriptions[0], 0 },
 897                         { &ifm_subtype_tokenring_option_descriptions[0], 1 },
 898                         { NULL, 0 },
 899                 },
 900         },
 901         {
 902                 {
 903                         { &ifm_subtype_shared_descriptions[0], 0 },
 904                         { &ifm_subtype_shared_aliases[0], 1 },
 905                         { &ifm_subtype_fddi_descriptions[0], 0 },
 906                         { &ifm_subtype_fddi_aliases[0], 1 },
 907                         { NULL, 0 },
 908                 },
 909                 {
 910                         { &ifm_shared_option_descriptions[0], 0 },
 911                         { &ifm_subtype_fddi_option_descriptions[0], 1 },
 912                         { NULL, 0 },
 913                 },
 914         },
 915 };
 916
 917 int
 918 get_media_subtype(type, val)
 919         int type;
 920         char *val;
 921 {
 922         struct ifmedia_description *desc;
 923         struct ifmedia_type_to_subtype *ttos;
 924         int rval, i;
 925
 926         /* Find the top-level interface type. */
 927         for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes;
 928             desc->ifmt_string != NULL; desc++, ttos++)
 929                 if (type == desc->ifmt_word)
 930                         break;
 931         if (desc->ifmt_string == NULL)
 932                 errx(1, "unknown media type 0x%x", type);
 933
 934         for (i = 0; ttos->subtypes[i].desc != NULL; i++) {
 935                 rval = lookup_media_word(ttos->subtypes[i].desc, val);
 936                 if (rval != -1)
 937                         return (rval);
 938         }
 939         errx(1, "unknown media subtype: %s", val);
 940         /* NOTREACHED */
 941 }
 942
 943 int
 944 get_media_options(type, val)
 945         int type;
 946         char *val;
 947 {
 948         struct ifmedia_description *desc;
 949         struct ifmedia_type_to_subtype *ttos;
 950         char *optlist;
 951         int option = 0, i, rval = 0;
 952
 953         /* We muck with the string, so copy it. */
 954         optlist = strdup(val);
 955         if (optlist == NULL)
 956                 err(1, "strdup");
 957         val = optlist;
 958
 959         /* Find the top-level interface type. */
 960         for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes;
 961             desc->ifmt_string != NULL; desc++, ttos++)
 962                 if (type == desc->ifmt_word)
 963                         break;
 964         if (desc->ifmt_string == NULL)
 965                 errx(1, "unknown media type 0x%x", type);
 966
 967         /*
 968          * Look up the options in the user-provided comma-separated
 969          * list.
 970          */
 971         for (; (val = strtok(val, ",")) != NULL; val = NULL) {
 972                 for (i = 0; ttos->options[i].desc != NULL; i++) {
 973                         option = lookup_media_word(ttos->options[i].desc, val);
 974                         if (option != -1)
 975                                 break;
 976                 }
 977                 if (option == 0)
 978                         errx(1, "unknown option: %s", val);
 979                 rval |= option;
 980         }
 981
 982         free(optlist);
 983         return (rval);
 984 }
 985
 986 int
 987 lookup_media_word(desc, val)
 988         struct ifmedia_description *desc;
 989         char *val;
 990 {
 991
 992         for (; desc->ifmt_string != NULL; desc++)
 993                 if (strcasecmp(desc->ifmt_string, val) == 0)
 994                         return (desc->ifmt_word);
 995
 996         return (-1);
 997 }
 998
 999 void
1000 print_media_word(ifmw)
1001         int ifmw;
1002 {
1003         struct ifmedia_description *desc;
1004         struct ifmedia_type_to_subtype *ttos;
1005         int seen_option = 0, i;
1006
1007         /* Find the top-level interface type. */
1008         for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes;
1009             desc->ifmt_string != NULL; desc++, ttos++)
1010                 if (IFM_TYPE(ifmw) == desc->ifmt_word)
1011                         break;
1012         if (desc->ifmt_string == NULL) {
1013                 printf("<unknown type>");
1014                 return;
1015         }
1016
1017         /*
1018          * Don't print the top-level type; it's not like we can
1019          * change it, or anything.
1020          */
1021
1022         /* Find subtype. */
1023         for (i = 0; ttos->subtypes[i].desc != NULL; i++) {
1024                 if (ttos->subtypes[i].alias)
1025                         continue;
1026                 for (desc = ttos->subtypes[i].desc;
1027                     desc->ifmt_string != NULL; desc++) {
1028                         if (IFM_SUBTYPE(ifmw) == desc->ifmt_word)
1029                                 goto got_subtype;
1030                 }
1031         }
1032
1033         /* Falling to here means unknown subtype. */
1034         printf("<unknown subtype>");
1035         return;
1036
1037  got_subtype:
1038         printf("%s", desc->ifmt_string);
1039
1040         /* Find options. */
1041         for (i = 0; ttos->options[i].desc != NULL; i++) {
1042                 if (ttos->options[i].alias)
1043                         continue;
1044                 for (desc = ttos->options[i].desc;
1045                     desc->ifmt_string != NULL; desc++) {
1046                         if (ifmw & desc->ifmt_word) {
1047                                 if (seen_option == 0)
1048                                         printf(" <");
1049                                 printf("%s%s", seen_option++ ? "," : "",
1050                                     desc->ifmt_string);
1051                         }
1052                 }
1053         }
1054         printf("%s", seen_option ? ">" : "");
1055 }
1056 #endif
1057 /**********************************************************************
1058  * ...until here.
1059  **********************************************************************/
1060
1061 #define IFFBITS \
1062 "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6NOTRAILERS\7RUNNING\10NOARP\
1063 \11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2\20MULTICAST"
1064
1065 /*
1066  * Print the status of the interface.  If an address family was
1067  * specified, show it and it only; otherwise, show them all.
1068  */
1069 void
1070 status(ap, alen)
1071         const u_int8_t *ap;
1072         int alen;
1073 {
1074         struct afswtch *p = afp;
1075 #ifdef ENABLE_MEDIA_IOCTL
1076         struct ifmediareq ifmr;
1077         int *media_list;
1078 #endif
1079         int i;
1080
1081         printf("%s: ", name);
1082         printb("flags", flags, IFFBITS);
1083         if (metric)
1084                 printf(" metric %d", metric);
1085         if (mtu)
1086                 printf(" mtu %d", mtu);
1087         putchar('\n');
1088         if (ap && alen > 0) {
1089                 printf("\taddress:");
1090                 for (i = 0; i < alen; i++, ap++)
1091                         printf("%c%02x", i > 0 ? ':' : ' ', *ap);
1092                 putchar('\n');
1093         }
1094 #ifdef ENABLE_MEDIA_IOCTL
1095         (void) memset(&ifmr, 0, sizeof(ifmr));
1096         (void) strncpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name));
1097
1098         if (IoctlSocket(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
1099                 /*
1100                  * Interface doesn't support SIOC{G,S}IFMEDIA.
1101                  */
1102                 goto proto_status;
1103         }
1104
1105         if (ifmr.ifm_count == 0) {
1106                 warnx("%s: no media types?", name);
1107                 goto proto_status;
1108         }
1109
1110         media_list = (int *)malloc(ifmr.ifm_count * sizeof(int));
1111         if (media_list == NULL)
1112                 err(1, "malloc");
1113         ifmr.ifm_ulist = media_list;
1114
1115         if (IoctlSocket(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
1116                 err(1, "SIOCGIFMEDIA");
1117
1118         printf("\tmedia: ");
1119         print_media_word(ifmr.ifm_current);
1120         if (ifmr.ifm_active != ifmr.ifm_current) {
1121                 putchar(' ');
1122                 putchar('(');
1123                 print_media_word(ifmr.ifm_active);
1124                 putchar(')');
1125         }
1126
1127         if (ifmr.ifm_status & IFM_AVALID) {
1128                 printf(" status: ");
1129                 switch (IFM_TYPE(ifmr.ifm_active)) {
1130                 case IFM_ETHER:
1131                         if (ifmr.ifm_status & IFM_ACTIVE)
1132                                 printf("active");
1133                         else
1134                                 printf("no carrier");
1135                         break;
1136
1137                 case IFM_FDDI:
1138                 case IFM_TOKEN:
1139                         if (ifmr.ifm_status & IFM_ACTIVE)
1140                                 printf("inserted");
1141                         else
1142                                 printf("no ring");
1143                         break;
1144                 }
1145         }
1146
1147         putchar('\n');
1148
1149         if (mflag) {
1150                 printf("\tsupported media:");
1151                 for (i = 0; i < ifmr.ifm_count; i++) {
1152                         putchar(' ');
1153                         print_media_word(media_list[i]);
1154                 }
1155                 putchar('\n');
1156         }
1157
1158         free(media_list);
1159  proto_status:
1160 #endif
1161         if ((p = afp) != NULL) {
1162                 (*p->af_status)(1);
1163         } else for (p = afs; p->af_name; p++) {
1164                 ifr.ifr_addr.sa_family = p->af_af;
1165                 (*p->af_status)(0);
1166         }
1167 }
1168
1169 void
1170 in_status(force)
1171         int force;
1172 {
1173         struct sockaddr_in *sin;
1174
1175         getsock(AF_INET);
1176         if (s < 0) {
1177                 if (errno == EPROTONOSUPPORT)
1178                         return;
1179                 err(1, "socket");
1180         }
1181         (void) memset(&ifr, 0, sizeof(ifr));
1182         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
1183         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
1184         if (IoctlSocket(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
1185                 if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
1186                         if (!force)
1187                                 return;
1188                         (void) memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1189                 } else
1190                         warn("SIOCGIFADDR");
1191         }
1192         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
1193         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
1194         sin = (struct sockaddr_in *)&ifr.ifr_addr;
1195         printf("\tinet %s ", inet_ntoa(sin->sin_addr));
1196         CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
1197         ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
1198         if (IoctlSocket(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
1199                 if (errno != EADDRNOTAVAIL)
1200                         warn("SIOCGIFNETMASK");
1201                 (void) memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1202         } else {
1203                 struct sockaddr_in *nm_sin = (struct sockaddr_in *)&ifr.ifr_addr;
1204                 netmask.sin_addr = nm_sin->sin_addr;
1205         }
1206         if (flags & IFF_POINTOPOINT) {
1207                 if (IoctlSocket(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
1208                         if (errno == EADDRNOTAVAIL)
1209                             (void) memset(&ifr.ifr_addr, 0,
1210                                 sizeof(ifr.ifr_addr));
1211                         else
1212                             warn("SIOCGIFDSTADDR");
1213                 }
1214                 CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
1215                 ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
1216                 sin = (struct sockaddr_in *)&ifr.ifr_dstaddr;
1217                 printf("--> %s ", inet_ntoa(sin->sin_addr));
1218         }
1219         printf("netmask 0x%x ", (unsigned int)ntohl(netmask.sin_addr.s_addr));
1220         if (flags & IFF_BROADCAST) {
1221                 if (IoctlSocket(s, SIOCGIFBRDADDR, (caddr_t)&ifr) < 0) {
1222                         if (errno == EADDRNOTAVAIL)
1223                                 (void) memset(&ifr.ifr_addr, 0,
1224                                     sizeof(ifr.ifr_addr));
1225                         else
1226                             warn("SIOCGIFBRDADDR");
1227                 }
1228                 CopyMem(name, ifr.ifr_name, sizeof (ifr.ifr_name));
1229                 ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
1230                 sin = (struct sockaddr_in *)&ifr.ifr_addr;
1231                 if (sin->sin_addr.s_addr != 0)
1232                         printf("broadcast %s", inet_ntoa(sin->sin_addr));
1233         }
1234         putchar('\n');
1235 }
1236
1237 #ifndef INET_ONLY
1238
1239 void
1240 at_status(force)
1241         int force;
1242 {
1243         struct sockaddr_at *sat, null_sat;
1244         struct netrange *nr;
1245
1246         getsock(AF_APPLETALK);
1247         if (s < 0) {
1248                 if (errno == EPROTONOSUPPORT)
1249                         return;
1250                 err(1, "socket");
1251         }
1252         (void) memset(&ifr, 0, sizeof(ifr));
1253         (void) strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
1254         if (IoctlSocket(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
1255                 if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
1256                         if (!force)
1257                                 return;
1258                         (void) memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1259                 } else
1260                         warn("SIOCGIFADDR");
1261         }
1262         (void) strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
1263         sat = (struct sockaddr_at *)&ifr.ifr_addr;
1264
1265         (void) memset(&null_sat, 0, sizeof(null_sat));
1266
1267         nr = (struct netrange *) &sat->sat_zero;
1268         printf("\tatalk %d.%d range %d-%d phase %d",
1269             ntohs(sat->sat_addr.s_net), sat->sat_addr.s_node,
1270             ntohs(nr->nr_firstnet), ntohs(nr->nr_lastnet), nr->nr_phase);
1271         if (flags & IFF_POINTOPOINT) {
1272                 if (IoctlSocket(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
1273                         if (errno == EADDRNOTAVAIL)
1274                             (void) memset(&ifr.ifr_addr, 0,
1275                                 sizeof(ifr.ifr_addr));
1276                         else
1277                             warn("SIOCGIFDSTADDR");
1278                 }
1279                 (void) strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
1280                 sat = (struct sockaddr_at *)&ifr.ifr_dstaddr;
1281                 if (!sat)
1282                         sat = &null_sat;
1283                 printf("--> %d.%d",
1284                     ntohs(sat->sat_addr.s_net), sat->sat_addr.s_node);
1285         }
1286         if (flags & IFF_BROADCAST) {
1287                 /* note RTAX_BRD overlap with IFF_POINTOPOINT */
1288                 sat = (struct sockaddr_at *)&ifr.ifr_broadaddr;
1289                 if (sat)
1290                         printf(" broadcast %d.%d", ntohs(sat->sat_addr.s_net),
1291                             sat->sat_addr.s_node);
1292         }
1293         putchar('\n');
1294 }
1295
1296 void
1297 xns_status(force)
1298         int force;
1299 {
1300         struct sockaddr_ns *sns;
1301
1302         getsock(AF_NS);
1303         if (s < 0) {
1304                 if (errno == EPROTONOSUPPORT)
1305                         return;
1306                 err(1, "socket");
1307         }
1308         (void) memset(&ifr, 0, sizeof(ifr));
1309         (void) strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
1310         if (IoctlSocket(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
1311                 if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
1312                         if (!force)
1313                                 return;
1314                         memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1315                 } else
1316                         warn("SIOCGIFADDR");
1317         }
1318         (void) strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
1319         sns = (struct sockaddr_ns *)&ifr.ifr_addr;
1320         printf("\tns %s ", ns_ntoa(sns->sns_addr));
1321         if (flags & IFF_POINTOPOINT) { /* by W. Nesheim@Cornell */
1322                 if (IoctlSocket(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
1323                         if (errno == EADDRNOTAVAIL)
1324                             memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1325                         else
1326                             warn("SIOCGIFDSTADDR");
1327                 }
1328                 (void) strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
1329                 sns = (struct sockaddr_ns *)&ifr.ifr_dstaddr;
1330                 printf("--> %s ", ns_ntoa(sns->sns_addr));
1331         }
1332         putchar('\n');
1333 }
1334
1335 void
1336 iso_status(force)
1337         int force;
1338 {
1339         struct sockaddr_iso *siso;
1340
1341         getsock(AF_ISO);
1342         if (s < 0) {
1343                 if (errno == EPROTONOSUPPORT)
1344                         return;
1345                 err(1, "socket");
1346         }
1347         (void) memset(&ifr, 0, sizeof(ifr));
1348         (void) strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
1349         if (IoctlSocket(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
1350                 if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
1351                         if (!force)
1352                                 return;
1353                         (void) memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1354                 } else
1355                         warn("SIOCGIFADDR");
1356         }
1357         (void) strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
1358         siso = (struct sockaddr_iso *)&ifr.ifr_addr;
1359         printf("\tiso %s ", iso_ntoa(&siso->siso_addr));
1360         if (IoctlSocket(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
1361                 if (errno == EADDRNOTAVAIL)
1362                         memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1363                 else
1364                         warn("SIOCGIFNETMASK");
1365         } else {
1366                 printf(" netmask %s ", iso_ntoa(&siso->siso_addr));
1367         }
1368         if (flags & IFF_POINTOPOINT) {
1369                 if (IoctlSocket(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
1370                         if (errno == EADDRNOTAVAIL)
1371                             memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
1372                         else
1373                             warn("SIOCGIFDSTADDR");
1374                 }
1375                 (void) strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
1376                 siso = (struct sockaddr_iso *)&ifr.ifr_addr;
1377                 printf("--> %s ", iso_ntoa(&siso->siso_addr));
1378         }
1379         putchar('\n');
1380 }
1381
1382 #endif  /* INET_ONLY */
1383
1384 #define SIN(x) ((struct sockaddr_in *) &(x))
1385 struct sockaddr_in *sintab[] = {
1386 SIN(ridreq.ifr_addr), SIN(addreq.ifra_addr),
1387 SIN(addreq.ifra_mask), SIN(addreq.ifra_broadaddr)};
1388
1389 void
1390 in_getaddr(s, which)
1391         char *s;
1392         int which;
1393 {
1394         struct sockaddr_in *sin = sintab[which];
1395         struct hostent *hp;
1396         struct netent *np;
1397
1398         sin->sin_len = sizeof(*sin);
1399         if (which != MASK)
1400                 sin->sin_family = AF_INET;
1401
1402         if (inet_aton(s, &sin->sin_addr) == 0) {
1403                 if ((hp = gethostbyname(s)) != NULL)
1404                         (void) memcpy(&sin->sin_addr, hp->h_addr, hp->h_length);
1405                 else if ((np = getnetbyname(s)) != NULL)
1406                 {
1407                         sin->sin_addr.s_addr = inet_makeaddr(np->n_net, INADDR_ANY);
1408                 }
1409                 else
1410                         errx(1, "%s: bad value", s);
1411         }
1412 }
1413
1414 /*
1415  * Print a value a la the %b format of the kernel's printf
1416  */
1417 void
1418 printb(s, v, bits)
1419         char *s;
1420         char *bits;
1421         unsigned short v;
1422 {
1423         int i, any = 0;
1424         char c;
1425
1426         if (bits && *bits == 8)
1427                 printf("%s=%o", s, v);
1428         else
1429                 printf("%s=%x", s, v);
1430         bits++;
1431         if (bits) {
1432                 putchar('<');
1433                 while ((i = *bits++) != 0) {
1434                         if (v & (1 << (i-1))) {
1435                                 if (any)
1436                                         putchar(',');
1437                                 any = 1;
1438                                 for (; (c = *bits) > 32; bits++)
1439                                         putchar(c);
1440                         } else
1441                                 for (; *bits > 32; bits++)
1442                                         ;
1443                 }
1444                 putchar('>');
1445         }
1446 }
1447
1448 #ifndef INET_ONLY
1449
1450 void
1451 at_getaddr(addr, which)
1452         char *addr;
1453         int which;
1454 {
1455         struct sockaddr_at *sat = (struct sockaddr_at *) &addreq.ifra_addr;
1456         u_int net, node;
1457
1458         sat->sat_family = AF_APPLETALK;
1459         sat->sat_len = sizeof(*sat);
1460         if (which == MASK)
1461                 errx(1, "AppleTalk does not use netmasks\n");
1462         if (sscanf(addr, "%u.%u", &net, &node) != 2
1463             || net == 0 || net > 0xffff || node == 0 || node > 0xfe)
1464                 errx(1, "%s: illegal address", addr);
1465         sat->sat_addr.s_net = htons(net);
1466         sat->sat_addr.s_node = node;
1467 }
1468
1469 void
1470 setatrange(range, d)
1471         char *range;
1472         int d;
1473 {
1474         u_short first = 123, last = 123;
1475
1476         if (sscanf(range, "%hu-%hu", &first, &last) != 2
1477             || first == 0 || first > 0xffff
1478             || last == 0 || last > 0xffff || first > last)
1479                 errx(1, "%s: illegal net range: %u-%u", range, first, last);
1480         at_nr.nr_firstnet = htons(first);
1481         at_nr.nr_lastnet = htons(last);
1482 }
1483
1484 void
1485 setatphase(phase, d)
1486         char *phase;
1487         int d;
1488 {
1489         if (!strcmp(phase, "1"))
1490                 at_nr.nr_phase = 1;
1491         else if (!strcmp(phase, "2"))
1492                 at_nr.nr_phase = 2;
1493         else
1494                 errx(1, "%s: illegal phase", phase);
1495 }
1496
1497 void
1498 checkatrange(sat)
1499         struct sockaddr_at *sat;
1500 {
1501         if (at_nr.nr_phase == 0)
1502                 at_nr.nr_phase = 2;     /* Default phase 2 */
1503         if (at_nr.nr_firstnet == 0)
1504                 at_nr.nr_firstnet =     /* Default range of one */
1505                 at_nr.nr_lastnet = sat->sat_addr.s_net;
1506         printf("\tatalk %d.%d range %d-%d phase %d\n",
1507         ntohs(sat->sat_addr.s_net), sat->sat_addr.s_node,
1508         ntohs(at_nr.nr_firstnet), ntohs(at_nr.nr_lastnet), at_nr.nr_phase);
1509         if ((u_short) ntohs(at_nr.nr_firstnet) >
1510                         (u_short) ntohs(sat->sat_addr.s_net)
1511                     || (u_short) ntohs(at_nr.nr_lastnet) <
1512                         (u_short) ntohs(sat->sat_addr.s_net))
1513                 errx(1, "AppleTalk address is not in range");
1514         *((struct netrange *) &sat->sat_zero) = at_nr;
1515 }
1516
1517 #define SNS(x) ((struct sockaddr_ns *) &(x))
1518 struct sockaddr_ns *snstab[] = {
1519 SNS(ridreq.ifr_addr), SNS(addreq.ifra_addr),
1520 SNS(addreq.ifra_mask), SNS(addreq.ifra_broadaddr)};
1521
1522 void
1523 xns_getaddr(addr, which)
1524         char *addr;
1525         int which;
1526 {
1527         struct sockaddr_ns *sns = snstab[which];
1528
1529         sns->sns_family = AF_NS;
1530         sns->sns_len = sizeof(*sns);
1531         sns->sns_addr = ns_addr(addr);
1532         if (which == MASK)
1533                 puts("Attempt to set XNS netmask will be ineffectual");
1534 }
1535
1536 #define SISO(x) ((struct sockaddr_iso *) &(x))
1537 struct sockaddr_iso *sisotab[] = {
1538 SISO(ridreq.ifr_addr), SISO(iso_addreq.ifra_addr),
1539 SISO(iso_addreq.ifra_mask), SISO(iso_addreq.ifra_dstaddr)};
1540
1541 void
1542 iso_getaddr(addr, which)
1543         char *addr;
1544         int which;
1545 {
1546         struct sockaddr_iso *siso = sisotab[which];
1547         siso->siso_addr = *iso_addr(addr);
1548
1549         if (which == MASK) {
1550                 siso->siso_len = TSEL(siso) - (caddr_t)(siso);
1551                 siso->siso_nlen = 0;
1552         } else {
1553                 siso->siso_len = sizeof(*siso);
1554                 siso->siso_family = AF_ISO;
1555         }
1556 }
1557
1558 void
1559 setsnpaoffset(val, d)
1560         char *val;
1561         int d;
1562 {
1563         iso_addreq.ifra_snpaoffset = atoi(val);
1564 }
1565
1566 void
1567 setnsellength(val, d)
1568         char *val;
1569         int d;
1570 {
1571         nsellength = atoi(val);
1572         if (nsellength < 0)
1573                 errx(1, "Negative NSEL length is absurd");
1574         if (afp == 0 || afp->af_af != AF_ISO)
1575                 errx(1, "Setting NSEL length valid only for iso");
1576 }
1577
1578 void
1579 fixnsel(s)
1580         struct sockaddr_iso *s;
1581 {
1582         if (s->siso_family == 0)
1583                 return;
1584         s->siso_tlen = nsellength;
1585 }
1586
1587 void
1588 adjust_nsellength()
1589 {
1590         fixnsel(sisotab[RIDADDR]);
1591         fixnsel(sisotab[ADDR]);
1592         fixnsel(sisotab[DSTADDR]);
1593 }
1594
1595 #endif  /* INET_ONLY */
1596
1597 void
1598 usage()
1599 {
1600         fprintf(stderr,
1601             "usage: ifconfig [ -m ] interface\n%s%s%s%s%s%s%s%s%s%s%s",
1602                 "\t[ af [alias | -alias | delete] [ address [ dest_addr ] ] [ up ] [ down ] ",
1603                 "[ netmask mask ] ]\n",
1604                 "\t[ metric n ]\n",
1605                 "\t[ mtu n ]\n",
1606                 "\t[ arp | -arp ]\n",
1607 #ifdef ENABLE_MEDIA_IOCTL
1608                 "\t[ media mtype ]\n",
1609                 "\t[ mediaopt mopts ]\n",
1610                 "\t[ -mediaopt mopts ]\n",
1611 #else
1612                 "","","",
1613 #endif
1614                 "\t[ link0 | -link0 ] [ link1 | -link1 ] [ link2 | -link2 ]\n",
1615                 "       ifconfig -a [ -m ] [ -d ] [ -u ] [ af ]\n",
1616                 "       ifconfig -l [ -d ] [ -u ]\n");
1617         exit(1);
1618 }