Return to ifconfig.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sbin / ifconfig

Annotation of 43BSDReno/sbin/ifconfig/ifconfig.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted provided
        !             6:  * that: (1) source distributions retain this entire copyright notice and
        !             7:  * comment, and (2) distributions including binaries display the following
        !             8:  * acknowledgement:  ``This product includes software developed by the
        !             9:  * University of California, Berkeley and its contributors'' in the
        !            10:  * documentation or other materials provided with the distribution and in
        !            11:  * all advertising materials mentioning features or use of this software.
        !            12:  * Neither the name of the University nor the names of its contributors may
        !            13:  * be used to endorse or promote products derived from this software without
        !            14:  * specific prior written permission.
        !            15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
        !            16:  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
        !            17:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            18:  */
        !            19: 
        !            20: #ifndef lint
        !            21: char copyright[] =
        !            22: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
        !            23:  All rights reserved.\n";
        !            24: #endif /* not lint */
        !            25: 
        !            26: #ifndef lint
        !            27: static char sccsid[] = "@(#)ifconfig.c 4.30 (Berkeley) 6/14/90";
        !            28: #endif /* not lint */
        !            29: 
        !            30: #include <sys/types.h>
        !            31: #include <sys/socket.h>
        !            32: #include <sys/ioctl.h>
        !            33: 
        !            34: #include <net/if.h>
        !            35: #include <netinet/in.h>
        !            36: 
        !            37: #define        NSIP
        !            38: #include <netns/ns.h>
        !            39: #include <netns/ns_if.h>
        !            40: 
        !            41: #define EON
        !            42: #include <netiso/iso.h>
        !            43: #include <netiso/iso_var.h>
        !            44: #include <sys/protosw.h>
        !            45: 
        !            46: #include <stdio.h>
        !            47: #include <errno.h>
        !            48: #include <ctype.h>
        !            49: #include <netdb.h>
        !            50: 
        !            51: extern int errno;
        !            52: struct ifreq           ifr, ridreq;
        !            53: struct ifaliasreq      addreq;
        !            54: struct iso_ifreq       iso_ridreq;
        !            55: struct iso_aliasreq    iso_addreq;
        !            56: struct sockaddr_in     netmask;
        !            57: 
        !            58: char   name[30];
        !            59: int    flags;
        !            60: int    metric;
        !            61: int    nsellength = 1;
        !            62: int    setaddr;
        !            63: int    setipdst;
        !            64: int    doalias;
        !            65: int    clearaddr;
        !            66: int    newaddr = 1;
        !            67: int    s;
        !            68: extern int errno;
        !            69: 
        !            70: int    setifflags(), setifaddr(), setifdstaddr(), setifnetmask();
        !            71: int    setifmetric(), setifbroadaddr(), setifipdst();
        !            72: int    notealias(), setsnpaoffset(), setnsellength();
        !            73: 
        !            74: #define        NEXTARG         0xffffff
        !            75: 
        !            76: struct cmd {
        !            77:        char    *c_name;
        !            78:        int     c_parameter;            /* NEXTARG means next argv */
        !            79:        int     (*c_func)();
        !            80: } cmds[] = {
        !            81:        { "up",         IFF_UP,         setifflags } ,
        !            82:        { "down",       -IFF_UP,        setifflags },
        !            83:        { "trailers",   -IFF_NOTRAILERS,setifflags },
        !            84:        { "-trailers",  IFF_NOTRAILERS, setifflags },
        !            85:        { "arp",        -IFF_NOARP,     setifflags },
        !            86:        { "-arp",       IFF_NOARP,      setifflags },
        !            87:        { "debug",      IFF_DEBUG,      setifflags },
        !            88:        { "-debug",     -IFF_DEBUG,     setifflags },
        !            89:        { "alias",      IFF_UP,         notealias },
        !            90:        { "-alias",     -IFF_UP,        notealias },
        !            91:        { "delete",     -IFF_UP,        notealias },
        !            92: #ifdef notdef
        !            93: #define        EN_SWABIPS      0x1000
        !            94:        { "swabips",    EN_SWABIPS,     setifflags },
        !            95:        { "-swabips",   -EN_SWABIPS,    setifflags },
        !            96: #endif
        !            97:        { "netmask",    NEXTARG,        setifnetmask },
        !            98:        { "metric",     NEXTARG,        setifmetric },
        !            99:        { "broadcast",  NEXTARG,        setifbroadaddr },
        !           100:        { "ipdst",      NEXTARG,        setifipdst },
        !           101:        { "snpaoffset", NEXTARG,        setsnpaoffset },
        !           102:        { "nsellength", NEXTARG,        setnsellength },
        !           103:        { 0,            0,              setifaddr },
        !           104:        { 0,            0,              setifdstaddr },
        !           105: };
        !           106: 
        !           107: /*
        !           108:  * XNS support liberally adapted from
        !           109:  * code written at the University of Maryland
        !           110:  * principally by James O'Toole and Chris Torek.
        !           111:  */
        !           112: int    in_status(), in_getaddr();
        !           113: int    xns_status(), xns_getaddr();
        !           114: int    iso_status(), iso_getaddr();
        !           115: 
        !           116: /* Known address families */
        !           117: struct afswtch {
        !           118:        char *af_name;
        !           119:        short af_af;
        !           120:        int (*af_status)();
        !           121:        int (*af_getaddr)();
        !           122:        int af_difaddr;
        !           123:        int af_aifaddr;
        !           124:        caddr_t af_ridreq;
        !           125:        caddr_t af_addreq;
        !           126: } afs[] = {
        !           127: #define C(x) ((caddr_t) &x)
        !           128:        { "inet", AF_INET, in_status, in_getaddr,
        !           129:             SIOCDIFADDR, SIOCAIFADDR, C(ridreq), C(addreq) },
        !           130:        { "ns", AF_NS, xns_status, xns_getaddr,
        !           131:             SIOCDIFADDR, SIOCAIFADDR, C(ridreq), C(addreq) },
        !           132:        { "iso", AF_ISO, iso_status, iso_getaddr,
        !           133:             SIOCDIFADDR_ISO, SIOCAIFADDR_ISO, C(iso_ridreq), C(iso_addreq) },
        !           134:        { 0,    0,          0,          0 }
        !           135: };
        !           136: 
        !           137: struct afswtch *afp;   /*the address family being set or asked about*/
        !           138: 
        !           139: main(argc, argv)
        !           140:        int argc;
        !           141:        char *argv[];
        !           142: {
        !           143:        int af = AF_INET;
        !           144:        register struct afswtch *rafp;
        !           145: 
        !           146:        if (argc < 2) {
        !           147:                fprintf(stderr, "usage: ifconfig interface\n%s%s%s%s%s",
        !           148:                    "\t[ af [ address [ dest_addr ] ] [ up ] [ down ]",
        !           149:                            "[ netmask mask ] ]\n",
        !           150:                    "\t[ metric n ]\n",
        !           151:                    "\t[ trailers | -trailers ]\n",
        !           152:                    "\t[ arp | -arp ]\n");
        !           153:                exit(1);
        !           154:        }
        !           155:        argc--, argv++;
        !           156:        strncpy(name, *argv, sizeof(name));
        !           157:        strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
        !           158:        argc--, argv++;
        !           159:        if (argc > 0) {
        !           160:                for (afp = rafp = afs; rafp->af_name; rafp++)
        !           161:                        if (strcmp(rafp->af_name, *argv) == 0) {
        !           162:                                afp = rafp; argc--; argv++;
        !           163:                                break;
        !           164:                        }
        !           165:                rafp = afp;
        !           166:                af = ifr.ifr_addr.sa_family = rafp->af_af;
        !           167:        }
        !           168:        s = socket(af, SOCK_DGRAM, 0);
        !           169:        if (s < 0) {
        !           170:                perror("ifconfig: socket");
        !           171:                exit(1);
        !           172:        }
        !           173:        if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
        !           174:                Perror("ioctl (SIOCGIFFLAGS)");
        !           175:                exit(1);
        !           176:        }
        !           177:        strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
        !           178:        flags = ifr.ifr_flags;
        !           179:        if (ioctl(s, SIOCGIFMETRIC, (caddr_t)&ifr) < 0)
        !           180:                perror("ioctl (SIOCGIFMETRIC)");
        !           181:        else
        !           182:                metric = ifr.ifr_metric;
        !           183:        if (argc == 0) {
        !           184:                status();
        !           185:                exit(0);
        !           186:        }
        !           187:        while (argc > 0) {
        !           188:                register struct cmd *p;
        !           189: 
        !           190:                for (p = cmds; p->c_name; p++)
        !           191:                        if (strcmp(*argv, p->c_name) == 0)
        !           192:                                break;
        !           193:                if (p->c_name == 0 && setaddr)
        !           194:                        p++;    /* got src, do dst */
        !           195:                if (p->c_func) {
        !           196:                        if (p->c_parameter == NEXTARG) {
        !           197:                                (*p->c_func)(argv[1]);
        !           198:                                argc--, argv++;
        !           199:                        } else
        !           200:                                (*p->c_func)(*argv, p->c_parameter);
        !           201:                }
        !           202:                argc--, argv++;
        !           203:        }
        !           204:        if (af == AF_ISO)
        !           205:                adjust_nsellength();
        !           206:        if (setipdst && af==AF_NS) {
        !           207:                struct nsip_req rq;
        !           208:                int size = sizeof(rq);
        !           209: 
        !           210:                rq.rq_ns = addreq.ifra_addr;
        !           211:                rq.rq_ip = addreq.ifra_dstaddr;
        !           212: 
        !           213:                if (setsockopt(s, 0, SO_NSIP_ROUTE, &rq, size) < 0)
        !           214:                        Perror("Encapsulation Routing");
        !           215:        }
        !           216:        if (clearaddr) {
        !           217:                int ret;
        !           218:                strncpy(rafp->af_ridreq, name, sizeof ifr.ifr_name);
        !           219:                if ((ret = ioctl(s, rafp->af_difaddr, rafp->af_ridreq)) < 0) {
        !           220:                        if (errno == EADDRNOTAVAIL && (doalias >= 0)) {
        !           221:                                /* means no previous address for interface */
        !           222:                        } else
        !           223:                                Perror("ioctl (SIOCDIFADDR)");
        !           224:                }
        !           225:        }
        !           226:        if (newaddr) {
        !           227:                strncpy(rafp->af_addreq, name, sizeof ifr.ifr_name);
        !           228:                if (ioctl(s, rafp->af_aifaddr, rafp->af_addreq) < 0)
        !           229:                        Perror("ioctl (SIOCAIFADDR)");
        !           230:        }
        !           231:        exit(0);
        !           232: }
        !           233: #define RIDADDR 0
        !           234: #define ADDR   1
        !           235: #define MASK   2
        !           236: #define DSTADDR        3
        !           237: 
        !           238: /*ARGSUSED*/
        !           239: setifaddr(addr, param)
        !           240:        char *addr;
        !           241:        short param;
        !           242: {
        !           243:        /*
        !           244:         * Delay the ioctl to set the interface addr until flags are all set.
        !           245:         * The address interpretation may depend on the flags,
        !           246:         * and the flags may change when the address is set.
        !           247:         */
        !           248:        setaddr++;
        !           249:        if (doalias == 0)
        !           250:                clearaddr = 1;
        !           251:        (*afp->af_getaddr)(addr, (doalias >= 0 ? ADDR : RIDADDR));
        !           252: }
        !           253: 
        !           254: setifnetmask(addr)
        !           255:        char *addr;
        !           256: {
        !           257:        (*afp->af_getaddr)(addr, MASK);
        !           258: }
        !           259: 
        !           260: setifbroadaddr(addr)
        !           261:        char *addr;
        !           262: {
        !           263:        (*afp->af_getaddr)(addr, DSTADDR);
        !           264: }
        !           265: 
        !           266: setifipdst(addr)
        !           267:        char *addr;
        !           268: {
        !           269:        in_getaddr(addr, DSTADDR);
        !           270:        setipdst++;
        !           271:        clearaddr = 0;
        !           272:        newaddr = 0;
        !           273: }
        !           274: #define rqtosa(x) (&(((struct ifreq *)(afp->x))->ifr_addr))
        !           275: /*ARGSUSED*/
        !           276: notealias(addr, param)
        !           277:        char *addr;
        !           278: {
        !           279:        if (setaddr && doalias == 0 && param < 0)
        !           280:                bcopy((caddr_t)rqtosa(af_addreq),
        !           281:                      (caddr_t)rqtosa(af_ridreq),
        !           282:                      rqtosa(af_addreq)->sa_len);
        !           283:        doalias = param;
        !           284:        if (param < 0) {
        !           285:                clearaddr = 1;
        !           286:                newaddr = 0;
        !           287:        } else
        !           288:                clearaddr = 0;
        !           289: }
        !           290: 
        !           291: /*ARGSUSED*/
        !           292: setifdstaddr(addr, param)
        !           293:        char *addr;
        !           294:        int param;
        !           295: {
        !           296:        (*afp->af_getaddr)(addr, DSTADDR);
        !           297: }
        !           298: 
        !           299: setifflags(vname, value)
        !           300:        char *vname;
        !           301:        short value;
        !           302: {
        !           303:        if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
        !           304:                Perror("ioctl (SIOCGIFFLAGS)");
        !           305:                exit(1);
        !           306:        }
        !           307:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           308:        flags = ifr.ifr_flags;
        !           309: 
        !           310:        if (value < 0) {
        !           311:                value = -value;
        !           312:                flags &= ~value;
        !           313:        } else
        !           314:                flags |= value;
        !           315:        ifr.ifr_flags = flags;
        !           316:        if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
        !           317:                Perror(vname);
        !           318: }
        !           319: 
        !           320: setifmetric(val)
        !           321:        char *val;
        !           322: {
        !           323:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           324:        ifr.ifr_metric = atoi(val);
        !           325:        if (ioctl(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0)
        !           326:                perror("ioctl (set metric)");
        !           327: }
        !           328: 
        !           329: setsnpaoffset(val)
        !           330:        char *val;
        !           331: {
        !           332:        iso_addreq.ifra_snpaoffset = atoi(val);
        !           333: }
        !           334: 
        !           335: #define        IFFBITS \
        !           336: "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6NOTRAILERS\7RUNNING\10NOARP\
        !           337: "
        !           338: 
        !           339: /*
        !           340:  * Print the status of the interface.  If an address family was
        !           341:  * specified, show it and it only; otherwise, show them all.
        !           342:  */
        !           343: status()
        !           344: {
        !           345:        register struct afswtch *p = afp;
        !           346:        short af = ifr.ifr_addr.sa_family;
        !           347: 
        !           348:        printf("%s: ", name);
        !           349:        printb("flags", flags, IFFBITS);
        !           350:        if (metric)
        !           351:                printf(" metric %d", metric);
        !           352:        putchar('\n');
        !           353:        if ((p = afp) != NULL) {
        !           354:                (*p->af_status)(1);
        !           355:        } else for (p = afs; p->af_name; p++) {
        !           356:                ifr.ifr_addr.sa_family = p->af_af;
        !           357:                (*p->af_status)(0);
        !           358:        }
        !           359: }
        !           360: 
        !           361: in_status(force)
        !           362:        int force;
        !           363: {
        !           364:        struct sockaddr_in *sin;
        !           365:        char *inet_ntoa();
        !           366: 
        !           367:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           368:        if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
        !           369:                if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
        !           370:                        if (!force)
        !           371:                                return;
        !           372:                        bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           373:                } else
        !           374:                        perror("ioctl (SIOCGIFADDR)");
        !           375:        }
        !           376:        sin = (struct sockaddr_in *)&ifr.ifr_addr;
        !           377:        printf("\tinet %s ", inet_ntoa(sin->sin_addr));
        !           378:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           379:        if (ioctl(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
        !           380:                if (errno != EADDRNOTAVAIL)
        !           381:                        perror("ioctl (SIOCGIFNETMASK)");
        !           382:                bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           383:        } else
        !           384:                netmask.sin_addr =
        !           385:                    ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
        !           386:        if (flags & IFF_POINTOPOINT) {
        !           387:                if (ioctl(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
        !           388:                        if (errno == EADDRNOTAVAIL)
        !           389:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           390:                        else
        !           391:                            perror("ioctl (SIOCGIFDSTADDR)");
        !           392:                }
        !           393:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           394:                sin = (struct sockaddr_in *)&ifr.ifr_dstaddr;
        !           395:                printf("--> %s ", inet_ntoa(sin->sin_addr));
        !           396:        }
        !           397:        printf("netmask %x ", ntohl(netmask.sin_addr.s_addr));
        !           398:        if (flags & IFF_BROADCAST) {
        !           399:                if (ioctl(s, SIOCGIFBRDADDR, (caddr_t)&ifr) < 0) {
        !           400:                        if (errno == EADDRNOTAVAIL)
        !           401:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           402:                        else
        !           403:                            perror("ioctl (SIOCGIFADDR)");
        !           404:                }
        !           405:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           406:                sin = (struct sockaddr_in *)&ifr.ifr_addr;
        !           407:                if (sin->sin_addr.s_addr != 0)
        !           408:                        printf("broadcast %s", inet_ntoa(sin->sin_addr));
        !           409:        }
        !           410:        putchar('\n');
        !           411: }
        !           412: 
        !           413: 
        !           414: xns_status(force)
        !           415:        int force;
        !           416: {
        !           417:        struct sockaddr_ns *sns;
        !           418: 
        !           419:        close(s);
        !           420:        s = socket(AF_NS, SOCK_DGRAM, 0);
        !           421:        if (s < 0) {
        !           422:                if (errno == EPROTONOSUPPORT)
        !           423:                        return;
        !           424:                perror("ifconfig: socket");
        !           425:                exit(1);
        !           426:        }
        !           427:        if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
        !           428:                if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
        !           429:                        if (!force)
        !           430:                                return;
        !           431:                        bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           432:                } else
        !           433:                        perror("ioctl (SIOCGIFADDR)");
        !           434:        }
        !           435:        strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
        !           436:        sns = (struct sockaddr_ns *)&ifr.ifr_addr;
        !           437:        printf("\tns %s ", ns_ntoa(sns->sns_addr));
        !           438:        if (flags & IFF_POINTOPOINT) { /* by W. Nesheim@Cornell */
        !           439:                if (ioctl(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
        !           440:                        if (errno == EADDRNOTAVAIL)
        !           441:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           442:                        else
        !           443:                            Perror("ioctl (SIOCGIFDSTADDR)");
        !           444:                }
        !           445:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           446:                sns = (struct sockaddr_ns *)&ifr.ifr_dstaddr;
        !           447:                printf("--> %s ", ns_ntoa(sns->sns_addr));
        !           448:        }
        !           449:        putchar('\n');
        !           450: }
        !           451: 
        !           452: iso_status(force)
        !           453:        int force;
        !           454: {
        !           455:        struct sockaddr_iso *siso;
        !           456:        struct iso_ifreq ifr;
        !           457: 
        !           458:        close(s);
        !           459:        s = socket(AF_ISO, SOCK_DGRAM, 0);
        !           460:        if (s < 0) {
        !           461:                if (errno == EPROTONOSUPPORT)
        !           462:                        return;
        !           463:                perror("ifconfig: socket");
        !           464:                exit(1);
        !           465:        }
        !           466:        bzero((caddr_t)&ifr, sizeof(ifr));
        !           467:        strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
        !           468:        if (ioctl(s, SIOCGIFADDR_ISO, (caddr_t)&ifr) < 0) {
        !           469:                if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
        !           470:                        if (!force)
        !           471:                                return;
        !           472:                        bzero((char *)&ifr.ifr_Addr, sizeof(ifr.ifr_Addr));
        !           473:                } else {
        !           474:                        perror("ioctl (SIOCGIFADDR_ISO)");
        !           475:                        exit(1);
        !           476:                }
        !           477:        }
        !           478:        strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
        !           479:        siso = &ifr.ifr_Addr;
        !           480:        printf("\tiso %s ", iso_ntoa(&siso->siso_addr));
        !           481:        if (ioctl(s, SIOCGIFNETMASK_ISO, (caddr_t)&ifr) < 0) {
        !           482:                if (errno != EADDRNOTAVAIL)
        !           483:                        perror("ioctl (SIOCGIFNETMASK_ISO)");
        !           484:        } else {
        !           485:                printf(" netmask %s ", iso_ntoa(&siso->siso_addr));
        !           486:        }
        !           487:        if (flags & IFF_POINTOPOINT) {
        !           488:                if (ioctl(s, SIOCGIFDSTADDR_ISO, (caddr_t)&ifr) < 0) {
        !           489:                        if (errno == EADDRNOTAVAIL)
        !           490:                            bzero((char *)&ifr.ifr_Addr, sizeof(ifr.ifr_Addr));
        !           491:                        else
        !           492:                            Perror("ioctl (SIOCGIFDSTADDR_ISO)");
        !           493:                }
        !           494:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           495:                siso = &ifr.ifr_Addr;
        !           496:                printf("--> %s ", iso_ntoa(&siso->siso_addr));
        !           497:        }
        !           498:        putchar('\n');
        !           499: }
        !           500: 
        !           501: Perror(cmd)
        !           502:        char *cmd;
        !           503: {
        !           504:        extern int errno;
        !           505: 
        !           506:        fprintf(stderr, "ifconfig: ");
        !           507:        switch (errno) {
        !           508: 
        !           509:        case ENXIO:
        !           510:                fprintf(stderr, "%s: no such interface\n", cmd);
        !           511:                break;
        !           512: 
        !           513:        case EPERM:
        !           514:                fprintf(stderr, "%s: permission denied\n", cmd);
        !           515:                break;
        !           516: 
        !           517:        default:
        !           518:                perror(cmd);
        !           519:        }
        !           520:        exit(1);
        !           521: }
        !           522: 
        !           523: struct in_addr inet_makeaddr();
        !           524: 
        !           525: #define SIN(x) ((struct sockaddr_in *) &(x))
        !           526: struct sockaddr_in *sintab[] = {
        !           527: SIN(ridreq.ifr_addr), SIN(addreq.ifra_addr),
        !           528: SIN(addreq.ifra_mask), SIN(addreq.ifra_broadaddr)};
        !           529: 
        !           530: in_getaddr(s, which)
        !           531:        char *s;
        !           532: {
        !           533:        register struct sockaddr_in *sin = sintab[which];
        !           534:        struct hostent *hp;
        !           535:        struct netent *np;
        !           536:        int val;
        !           537: 
        !           538:        sin->sin_len = sizeof(*sin);
        !           539:        if (which != MASK)
        !           540:                sin->sin_family = AF_INET;
        !           541: 
        !           542:        if ((val = inet_addr(s)) != -1)
        !           543:                sin->sin_addr.s_addr = val;
        !           544:        else if (hp = gethostbyname(s))
        !           545:                bcopy(hp->h_addr, (char *)&sin->sin_addr, hp->h_length);
        !           546:        else if (np = getnetbyname(s))
        !           547:                sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
        !           548:        else {
        !           549:                fprintf(stderr, "%s: bad value\n", s);
        !           550:                exit(1);
        !           551:        }
        !           552: }
        !           553: 
        !           554: /*
        !           555:  * Print a value a la the %b format of the kernel's printf
        !           556:  */
        !           557: printb(s, v, bits)
        !           558:        char *s;
        !           559:        register char *bits;
        !           560:        register unsigned short v;
        !           561: {
        !           562:        register int i, any = 0;
        !           563:        register char c;
        !           564: 
        !           565:        if (bits && *bits == 8)
        !           566:                printf("%s=%o", s, v);
        !           567:        else
        !           568:                printf("%s=%x", s, v);
        !           569:        bits++;
        !           570:        if (bits) {
        !           571:                putchar('<');
        !           572:                while (i = *bits++) {
        !           573:                        if (v & (1 << (i-1))) {
        !           574:                                if (any)
        !           575:                                        putchar(',');
        !           576:                                any = 1;
        !           577:                                for (; (c = *bits) > 32; bits++)
        !           578:                                        putchar(c);
        !           579:                        } else
        !           580:                                for (; *bits > 32; bits++)
        !           581:                                        ;
        !           582:                }
        !           583:                putchar('>');
        !           584:        }
        !           585: }
        !           586: 
        !           587: #define SNS(x) ((struct sockaddr_ns *) &(x))
        !           588: struct sockaddr_ns *snstab[] = {
        !           589: SNS(ridreq.ifr_addr), SNS(addreq.ifra_addr),
        !           590: SNS(addreq.ifra_mask), SNS(addreq.ifra_broadaddr)};
        !           591: 
        !           592: xns_getaddr(addr, which)
        !           593: char *addr;
        !           594: {
        !           595:        struct sockaddr_ns *sns = snstab[which];
        !           596:        struct ns_addr ns_addr();
        !           597: 
        !           598:        sns->sns_family = AF_NS;
        !           599:        sns->sns_len = sizeof(*sns);
        !           600:        sns->sns_addr = ns_addr(addr);
        !           601:        if (which == MASK)
        !           602:                printf("Attempt to set XNS netmask will be ineffectual\n");
        !           603: }
        !           604: 
        !           605: #define SISO(x) ((struct sockaddr_iso *) &(x))
        !           606: struct sockaddr_iso *sisotab[] = {
        !           607: SISO(iso_ridreq.ifr_Addr), SISO(iso_addreq.ifra_addr),
        !           608: SISO(iso_addreq.ifra_mask), SISO(iso_addreq.ifra_dstaddr)};
        !           609: 
        !           610: iso_getaddr(addr, which)
        !           611: char *addr;
        !           612: {
        !           613:        register struct sockaddr_iso *siso = sisotab[which];
        !           614:        struct iso_addr *iso_addr();
        !           615:        siso->siso_addr = *iso_addr(addr);
        !           616: 
        !           617:        if (which == MASK) {
        !           618:                siso->siso_len = TSEL(siso) - (caddr_t)(siso);
        !           619:                siso->siso_nlen = 0;
        !           620:        } else {
        !           621:                siso->siso_len = sizeof(*siso);
        !           622:                siso->siso_family = AF_ISO;
        !           623:        }
        !           624: }
        !           625: 
        !           626: setnsellength(val)
        !           627:        char *val;
        !           628: {
        !           629:        nsellength = atoi(val);
        !           630:        if (nsellength < 0) {
        !           631:                fprintf(stderr, "Negative NSEL length is absurd\n");
        !           632:                exit (1);
        !           633:        }
        !           634:        if (afp == 0 || afp->af_af != AF_ISO) {
        !           635:                fprintf(stderr, "Setting NSEL length valid only for iso\n");
        !           636:                exit (1);
        !           637:        }
        !           638: }
        !           639: 
        !           640: fixnsel(s)
        !           641: register struct sockaddr_iso *s;
        !           642: {
        !           643:        if (s->siso_family == 0)
        !           644:                return;
        !           645:        s->siso_tlen = nsellength;
        !           646: }
        !           647: 
        !           648: adjust_nsellength()
        !           649: {
        !           650:        fixnsel(sisotab[RIDADDR]);
        !           651:        fixnsel(sisotab[ADDR]);
        !           652:        fixnsel(sisotab[DSTADDR]);
        !           653: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.