Return to ifconfig.c CVS log

Up to [CSRG BSD Unix] / 43BSD / etc

Annotation of 43BSD/etc/ifconfig.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: char copyright[] =
        !             9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
        !            10:  All rights reserved.\n";
        !            11: #endif not lint
        !            12: 
        !            13: #ifndef lint
        !            14: static char sccsid[] = "@(#)ifconfig.c 4.18 (Berkeley) 5/22/86";
        !            15: #endif not lint
        !            16: 
        !            17: #include <sys/types.h>
        !            18: #include <sys/socket.h>
        !            19: #include <sys/ioctl.h>
        !            20: 
        !            21: #include <net/if.h>
        !            22: #include <netinet/in.h>
        !            23: 
        !            24: #define        NSIP
        !            25: #include <netns/ns.h>
        !            26: #include <netns/ns_if.h>
        !            27: 
        !            28: #include <stdio.h>
        !            29: #include <errno.h>
        !            30: #include <ctype.h>
        !            31: #include <netdb.h>
        !            32: 
        !            33: extern int errno;
        !            34: struct ifreq ifr;
        !            35: struct sockaddr_in sin = { AF_INET };
        !            36: struct sockaddr_in broadaddr;
        !            37: struct sockaddr_in netmask = { AF_INET };
        !            38: struct sockaddr_in ipdst = { AF_INET };
        !            39: char   name[30];
        !            40: int    flags;
        !            41: int    metric;
        !            42: int    setaddr;
        !            43: int    setmask;
        !            44: int    setbroadaddr;
        !            45: int    setipdst;
        !            46: int    s;
        !            47: extern int errno;
        !            48: 
        !            49: int    setifflags(), setifaddr(), setifdstaddr(), setifnetmask();
        !            50: int    setifmetric(), setifbroadaddr(), setifipdst();
        !            51: 
        !            52: #define        NEXTARG         0xffffff
        !            53: 
        !            54: struct cmd {
        !            55:        char    *c_name;
        !            56:        int     c_parameter;            /* NEXTARG means next argv */
        !            57:        int     (*c_func)();
        !            58: } cmds[] = {
        !            59:        { "up",         IFF_UP,         setifflags } ,
        !            60:        { "down",       -IFF_UP,        setifflags },
        !            61:        { "trailers",   -IFF_NOTRAILERS,setifflags },
        !            62:        { "-trailers",  IFF_NOTRAILERS, setifflags },
        !            63:        { "arp",        -IFF_NOARP,     setifflags },
        !            64:        { "-arp",       IFF_NOARP,      setifflags },
        !            65:        { "debug",      IFF_DEBUG,      setifflags },
        !            66:        { "-debug",     -IFF_DEBUG,     setifflags },
        !            67: #ifdef notdef
        !            68: #define        EN_SWABIPS      0x1000
        !            69:        { "swabips",    EN_SWABIPS,     setifflags },
        !            70:        { "-swabips",   -EN_SWABIPS,    setifflags },
        !            71: #endif
        !            72:        { "netmask",    NEXTARG,        setifnetmask },
        !            73:        { "metric",     NEXTARG,        setifmetric },
        !            74:        { "broadcast",  NEXTARG,        setifbroadaddr },
        !            75:        { "ipdst",      NEXTARG,        setifipdst },
        !            76:        { 0,            0,              setifaddr },
        !            77:        { 0,            0,              setifdstaddr },
        !            78: };
        !            79: 
        !            80: /*
        !            81:  * XNS support liberally adapted from
        !            82:  * code written at the University of Maryland
        !            83:  * principally by James O'Toole and Chris Torek.
        !            84:  */
        !            85: 
        !            86: int    in_status(), in_getaddr();
        !            87: int    xns_status(), xns_getaddr();
        !            88: 
        !            89: /* Known address families */
        !            90: struct afswtch {
        !            91:        char *af_name;
        !            92:        short af_af;
        !            93:        int (*af_status)();
        !            94:        int (*af_getaddr)();
        !            95: } afs[] = {
        !            96:        { "inet",       AF_INET,        in_status,      in_getaddr },
        !            97:        { "ns",         AF_NS,          xns_status,     xns_getaddr },
        !            98:        { 0,            0,              0,              0 }
        !            99: };
        !           100: 
        !           101: struct afswtch *afp;   /*the address family being set or asked about*/
        !           102: 
        !           103: main(argc, argv)
        !           104:        int argc;
        !           105:        char *argv[];
        !           106: {
        !           107:        int af = AF_INET;
        !           108: 
        !           109:        if (argc < 2) {
        !           110:                fprintf(stderr, "usage: ifconfig interface\n%s%s%s%s",
        !           111:                    "\t[ af [ address [ dest_addr ] ] [ up ] [ down ]",
        !           112:                            "[ netmask mask ] ]\n",
        !           113:                    "\t[ metric n ]\n",
        !           114:                    "\t[ trailers | -trailers ]\n",
        !           115:                    "\t[ arp | -arp ]\n");
        !           116:                exit(1);
        !           117:        }
        !           118:        argc--, argv++;
        !           119:        strncpy(name, *argv, sizeof(name));
        !           120:        strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
        !           121:        argc--, argv++;
        !           122:        if (argc > 0) {
        !           123:                struct afswtch *myafp;
        !           124:                
        !           125:                for (myafp = afp = afs; myafp->af_name; myafp++)
        !           126:                        if (strcmp(myafp->af_name, *argv) == 0) {
        !           127:                                afp = myafp; argc--; argv++;
        !           128:                                break;
        !           129:                        }
        !           130:                af = ifr.ifr_addr.sa_family = afp->af_af;
        !           131:        }
        !           132:        s = socket(af, SOCK_DGRAM, 0);
        !           133:        if (s < 0) {
        !           134:                perror("ifconfig: socket");
        !           135:                exit(1);
        !           136:        }
        !           137:        if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
        !           138:                Perror("ioctl (SIOCGIFFLAGS)");
        !           139:                exit(1);
        !           140:        }
        !           141:        strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
        !           142:        flags = ifr.ifr_flags;
        !           143:        if (ioctl(s, SIOCGIFMETRIC, (caddr_t)&ifr) < 0)
        !           144:                perror("ioctl (SIOCGIFMETRIC)");
        !           145:        else
        !           146:                metric = ifr.ifr_metric;
        !           147:        if (argc == 0) {
        !           148:                status();
        !           149:                exit(0);
        !           150:        }
        !           151:        while (argc > 0) {
        !           152:                register struct cmd *p;
        !           153: 
        !           154:                for (p = cmds; p->c_name; p++)
        !           155:                        if (strcmp(*argv, p->c_name) == 0)
        !           156:                                break;
        !           157:                if (p->c_name == 0 && setaddr)
        !           158:                        p++;    /* got src, do dst */
        !           159:                if (p->c_func) {
        !           160:                        if (p->c_parameter == NEXTARG) {
        !           161:                                (*p->c_func)(argv[1]);
        !           162:                                argc--, argv++;
        !           163:                        } else
        !           164:                                (*p->c_func)(*argv, p->c_parameter);
        !           165:                }
        !           166:                argc--, argv++;
        !           167:        }
        !           168:        if ((setmask || setaddr) && (af == AF_INET)) {
        !           169:                /*
        !           170:                 * If setting the address and not the mask,
        !           171:                 * clear any existing mask and the kernel will then
        !           172:                 * assign the default.  If setting both,
        !           173:                 * set the mask first, so the address will be
        !           174:                 * interpreted correctly.
        !           175:                 */
        !           176:                ifr.ifr_addr = *(struct sockaddr *)&netmask;
        !           177:                if (ioctl(s, SIOCSIFNETMASK, (caddr_t)&ifr) < 0)
        !           178:                        Perror("ioctl (SIOCSIFNETMASK)");
        !           179:        }
        !           180:        if (setipdst && af==AF_NS) {
        !           181:                struct nsip_req rq;
        !           182:                int size = sizeof(rq);
        !           183: 
        !           184:                rq.rq_ns = *(struct sockaddr *) &sin;
        !           185:                rq.rq_ip = *(struct sockaddr *) &ipdst;
        !           186: 
        !           187:                if (setsockopt(s, 0, SO_NSIP_ROUTE, &rq, size) < 0)
        !           188:                        Perror("Encapsulation Routing");
        !           189:                setaddr = 0;
        !           190:        }
        !           191:        if (setaddr) {
        !           192:                ifr.ifr_addr = *(struct sockaddr *) &sin;
        !           193:                if (ioctl(s, SIOCSIFADDR, (caddr_t)&ifr) < 0)
        !           194:                        Perror("ioctl (SIOCSIFADDR)");
        !           195:        }
        !           196:        if (setbroadaddr) {
        !           197:                ifr.ifr_addr = *(struct sockaddr *)&broadaddr;
        !           198:                if (ioctl(s, SIOCSIFBRDADDR, (caddr_t)&ifr) < 0)
        !           199:                        Perror("ioctl (SIOCSIFBRDADDR)");
        !           200:        }
        !           201:        exit(0);
        !           202: }
        !           203: 
        !           204: /*ARGSUSED*/
        !           205: setifaddr(addr, param)
        !           206:        char *addr;
        !           207:        short param;
        !           208: {
        !           209:        /*
        !           210:         * Delay the ioctl to set the interface addr until flags are all set.
        !           211:         * The address interpretation may depend on the flags,
        !           212:         * and the flags may change when the address is set.
        !           213:         */
        !           214:        setaddr++;
        !           215:        (*afp->af_getaddr)(addr, &sin);
        !           216: }
        !           217: 
        !           218: setifnetmask(addr)
        !           219:        char *addr;
        !           220: {
        !           221:        in_getaddr(addr, &netmask);
        !           222:        setmask++;
        !           223: }
        !           224: 
        !           225: setifbroadaddr(addr)
        !           226:        char *addr;
        !           227: {
        !           228:        (*afp->af_getaddr)(addr, &broadaddr);
        !           229:        setbroadaddr++;
        !           230: }
        !           231: 
        !           232: setifipdst(addr)
        !           233:        char *addr;
        !           234: {
        !           235:        in_getaddr(addr, &ipdst);
        !           236:        setipdst++;
        !           237: }
        !           238: 
        !           239: /*ARGSUSED*/
        !           240: setifdstaddr(addr, param)
        !           241:        char *addr;
        !           242:        int param;
        !           243: {
        !           244: 
        !           245:        (*afp->af_getaddr)(addr, &ifr.ifr_addr);
        !           246:        if (ioctl(s, SIOCSIFDSTADDR, (caddr_t)&ifr) < 0)
        !           247:                Perror("ioctl (SIOCSIFDSTADDR)");
        !           248: }
        !           249: 
        !           250: setifflags(vname, value)
        !           251:        char *vname;
        !           252:        short value;
        !           253: {
        !           254:        if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
        !           255:                Perror("ioctl (SIOCGIFFLAGS)");
        !           256:                exit(1);
        !           257:        }
        !           258:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           259:        flags = ifr.ifr_flags;
        !           260: 
        !           261:        if (value < 0) {
        !           262:                value = -value;
        !           263:                flags &= ~value;
        !           264:        } else
        !           265:                flags |= value;
        !           266:        ifr.ifr_flags = flags;
        !           267:        if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0)
        !           268:                Perror(vname);
        !           269: }
        !           270: 
        !           271: setifmetric(val)
        !           272:        char *val;
        !           273: {
        !           274:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           275:        ifr.ifr_metric = atoi(val);
        !           276:        if (ioctl(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0)
        !           277:                perror("ioctl (set metric)");
        !           278: }
        !           279: 
        !           280: #define        IFFBITS \
        !           281: "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6NOTRAILERS\7RUNNING\10NOARP\
        !           282: "
        !           283: 
        !           284: /*
        !           285:  * Print the status of the interface.  If an address family was
        !           286:  * specified, show it and it only; otherwise, show them all.
        !           287:  */
        !           288: status()
        !           289: {
        !           290:        register struct afswtch *p = afp;
        !           291:        short af = ifr.ifr_addr.sa_family;
        !           292: 
        !           293:        printf("%s: ", name);
        !           294:        printb("flags", flags, IFFBITS);
        !           295:        if (metric)
        !           296:                printf(" metric %d", metric);
        !           297:        putchar('\n');
        !           298:        if ((p = afp) != NULL) {
        !           299:                (*p->af_status)(1);
        !           300:        } else for (p = afs; p->af_name; p++) {
        !           301:                ifr.ifr_addr.sa_family = p->af_af;
        !           302:                (*p->af_status)(0);
        !           303:        }
        !           304: }
        !           305: 
        !           306: in_status(force)
        !           307:        int force;
        !           308: {
        !           309:        struct sockaddr_in *sin;
        !           310:        char *inet_ntoa();
        !           311: 
        !           312:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           313:        if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
        !           314:                if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
        !           315:                        if (!force)
        !           316:                                return;
        !           317:                        bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           318:                } else
        !           319:                        perror("ioctl (SIOCGIFADDR)");
        !           320:        }
        !           321:        sin = (struct sockaddr_in *)&ifr.ifr_addr;
        !           322:        printf("\tinet %s ", inet_ntoa(sin->sin_addr));
        !           323:        strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           324:        if (ioctl(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
        !           325:                if (errno != EADDRNOTAVAIL)
        !           326:                        perror("ioctl (SIOCGIFNETMASK)");
        !           327:                bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           328:        } else
        !           329:                netmask.sin_addr =
        !           330:                    ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
        !           331:        if (flags & IFF_POINTOPOINT) {
        !           332:                if (ioctl(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
        !           333:                        if (errno == EADDRNOTAVAIL)
        !           334:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           335:                        else
        !           336:                            perror("ioctl (SIOCGIFDSTADDR)");
        !           337:                }
        !           338:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           339:                sin = (struct sockaddr_in *)&ifr.ifr_dstaddr;
        !           340:                printf("--> %s ", inet_ntoa(sin->sin_addr));
        !           341:        }
        !           342:        printf("netmask %x ", ntohl(netmask.sin_addr.s_addr));
        !           343:        if (flags & IFF_BROADCAST) {
        !           344:                if (ioctl(s, SIOCGIFBRDADDR, (caddr_t)&ifr) < 0) {
        !           345:                        if (errno == EADDRNOTAVAIL)
        !           346:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           347:                        else
        !           348:                            perror("ioctl (SIOCGIFADDR)");
        !           349:                }
        !           350:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           351:                sin = (struct sockaddr_in *)&ifr.ifr_addr;
        !           352:                if (sin->sin_addr.s_addr != 0)
        !           353:                        printf("broadcast %s", inet_ntoa(sin->sin_addr));
        !           354:        }
        !           355:        putchar('\n');
        !           356: }
        !           357: 
        !           358: 
        !           359: xns_status(force)
        !           360:        int force;
        !           361: {
        !           362:        struct sockaddr_ns *sns;
        !           363: 
        !           364:        close(s);
        !           365:        s = socket(AF_NS, SOCK_DGRAM, 0);
        !           366:        if (s < 0) {
        !           367:                if (errno == EAFNOSUPPORT)
        !           368:                        return;
        !           369:                perror("ifconfig: socket");
        !           370:                exit(1);
        !           371:        }
        !           372:        if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
        !           373:                if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT) {
        !           374:                        if (!force)
        !           375:                                return;
        !           376:                        bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           377:                } else
        !           378:                        perror("ioctl (SIOCGIFADDR)");
        !           379:        }
        !           380:        strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
        !           381:        sns = (struct sockaddr_ns *)&ifr.ifr_addr;
        !           382:        printf("\tns %s ", ns_ntoa(sns->sns_addr));
        !           383:        if (flags & IFF_POINTOPOINT) { /* by W. Nesheim@Cornell */
        !           384:                if (ioctl(s, SIOCGIFDSTADDR, (caddr_t)&ifr) < 0) {
        !           385:                        if (errno == EADDRNOTAVAIL)
        !           386:                            bzero((char *)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
        !           387:                        else
        !           388:                            Perror("ioctl (SIOCGIFDSTADDR)");
        !           389:                }
        !           390:                strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
        !           391:                sns = (struct sockaddr_ns *)&ifr.ifr_dstaddr;
        !           392:                printf("--> %s ", ns_ntoa(sns->sns_addr));
        !           393:        }
        !           394:        putchar('\n');
        !           395: }
        !           396: 
        !           397: Perror(cmd)
        !           398:        char *cmd;
        !           399: {
        !           400:        extern int errno;
        !           401: 
        !           402:        fprintf(stderr, "ifconfig: ");
        !           403:        switch (errno) {
        !           404: 
        !           405:        case ENXIO:
        !           406:                fprintf(stderr, "%s: no such interface\n", cmd);
        !           407:                break;
        !           408: 
        !           409:        case EPERM:
        !           410:                fprintf(stderr, "%s: permission denied\n", cmd);
        !           411:                break;
        !           412: 
        !           413:        default:
        !           414:                perror(cmd);
        !           415:        }
        !           416:        exit(1);
        !           417: }
        !           418: 
        !           419: struct in_addr inet_makeaddr();
        !           420: 
        !           421: in_getaddr(s, saddr)
        !           422:        char *s;
        !           423:        struct sockaddr *saddr;
        !           424: {
        !           425:        register struct sockaddr_in *sin = (struct sockaddr_in *)saddr;
        !           426:        struct hostent *hp;
        !           427:        struct netent *np;
        !           428:        int val;
        !           429: 
        !           430:        sin->sin_family = AF_INET;
        !           431:        val = inet_addr(s);
        !           432:        if (val != -1) {
        !           433:                sin->sin_addr.s_addr = val;
        !           434:                return;
        !           435:        }
        !           436:        hp = gethostbyname(s);
        !           437:        if (hp) {
        !           438:                sin->sin_family = hp->h_addrtype;
        !           439:                bcopy(hp->h_addr, (char *)&sin->sin_addr, hp->h_length);
        !           440:                return;
        !           441:        }
        !           442:        np = getnetbyname(s);
        !           443:        if (np) {
        !           444:                sin->sin_family = np->n_addrtype;
        !           445:                sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
        !           446:                return;
        !           447:        }
        !           448:        fprintf(stderr, "%s: bad value\n", s);
        !           449:        exit(1);
        !           450: }
        !           451: 
        !           452: /*
        !           453:  * Print a value a la the %b format of the kernel's printf
        !           454:  */
        !           455: printb(s, v, bits)
        !           456:        char *s;
        !           457:        register char *bits;
        !           458:        register unsigned short v;
        !           459: {
        !           460:        register int i, any = 0;
        !           461:        register char c;
        !           462: 
        !           463:        if (bits && *bits == 8)
        !           464:                printf("%s=%o", s, v);
        !           465:        else
        !           466:                printf("%s=%x", s, v);
        !           467:        bits++;
        !           468:        if (bits) {
        !           469:                putchar('<');
        !           470:                while (i = *bits++) {
        !           471:                        if (v & (1 << (i-1))) {
        !           472:                                if (any)
        !           473:                                        putchar(',');
        !           474:                                any = 1;
        !           475:                                for (; (c = *bits) > 32; bits++)
        !           476:                                        putchar(c);
        !           477:                        } else
        !           478:                                for (; *bits > 32; bits++)
        !           479:                                        ;
        !           480:                }
        !           481:                putchar('>');
        !           482:        }
        !           483: }
        !           484: 
        !           485: xns_getaddr(addr, saddr)
        !           486: char *addr;
        !           487: struct sockaddr *saddr;
        !           488: {
        !           489:        struct sockaddr_ns *sns = (struct sockaddr_ns *)saddr;
        !           490:        struct ns_addr ns_addr();
        !           491:        sns->sns_family = AF_NS;
        !           492:        sns->sns_addr = ns_addr(addr);
        !           493: }

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