![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ifconfig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / ifconfig|
Return to ifconfig.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / ifconfig |
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.