xref: /freebsd/sbin/ifconfig/ifconfig.c (revision c0020399a650364d0134f79f3fa319f84064372d) 
1 /*
2  * Copyright (c) 1983, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #ifndef lint
31 static const char copyright[] =
32 "@(#) Copyright (c) 1983, 1993\n\
33 	The Regents of the University of California.  All rights reserved.\n";
34 #endif /* not lint */
35 
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)ifconfig.c	8.2 (Berkeley) 2/16/94";
39 #endif
40 static const char rcsid[] =
41   "$FreeBSD$";
42 #endif /* not lint */
43 
44 #include <sys/param.h>
45 #include <sys/ioctl.h>
46 #include <sys/socket.h>
47 #include <sys/sysctl.h>
48 #include <sys/time.h>
49 #include <sys/module.h>
50 #include <sys/linker.h>
51 
52 #include <net/ethernet.h>
53 #include <net/if.h>
54 #include <net/if_var.h>
55 #include <net/if_dl.h>
56 #include <net/if_types.h>
57 #include <net/route.h>
58 
59 /* IP */
60 #include <netinet/in.h>
61 #include <netinet/in_var.h>
62 #include <arpa/inet.h>
63 #include <netdb.h>
64 
65 #include <ifaddrs.h>
66 #include <ctype.h>
67 #include <err.h>
68 #include <errno.h>
69 #include <fcntl.h>
70 #include <stdio.h>
71 #include <stdlib.h>
72 #include <string.h>
73 #include <unistd.h>
74 
75 #include "ifconfig.h"
76 
77 /*
78  * Since "struct ifreq" is composed of various union members, callers
79  * should pay special attention to interprete the value.
80  * (.e.g. little/big endian difference in the structure.)
81  */
82 struct	ifreq ifr;
83 
84 char	name[IFNAMSIZ];
85 int	setaddr;
86 int	setmask;
87 int	doalias;
88 int	clearaddr;
89 int	newaddr = 1;
90 int	verbose;
91 int	noload;
92 
93 int	supmedia = 0;
94 int	printkeys = 0;		/* Print keying material for interfaces. */
95 
96 static	int ifconfig(int argc, char *const *argv, int iscreate,
97 		const struct afswtch *afp);
98 static	void status(const struct afswtch *afp, const struct sockaddr_dl *sdl,
99 		struct ifaddrs *ifa);
100 static	void tunnel_status(int s);
101 static	void usage(void);
102 
103 static struct afswtch *af_getbyname(const char *name);
104 static struct afswtch *af_getbyfamily(int af);
105 static void af_other_status(int);
106 
107 static struct option *opts = NULL;
108 
109 void
110 opt_register(struct option *p)
111 {
112 	p->next = opts;
113 	opts = p;
114 }
115 
116 static void
117 usage(void)
118 {
119 	char options[1024];
120 	struct option *p;
121 
122 	/* XXX not right but close enough for now */
123 	options[0] = '\0';
124 	for (p = opts; p != NULL; p = p->next) {
125 		strlcat(options, p->opt_usage, sizeof(options));
126 		strlcat(options, " ", sizeof(options));
127 	}
128 
129 	fprintf(stderr,
130 	"usage: ifconfig %sinterface address_family [address [dest_address]]\n"
131 	"                [parameters]\n"
132 	"       ifconfig interface create\n"
133 	"       ifconfig -a %s[-d] [-m] [-u] [-v] [address_family]\n"
134 	"       ifconfig -l [-d] [-u] [address_family]\n"
135 	"       ifconfig %s[-d] [-m] [-u] [-v]\n",
136 		options, options, options);
137 	exit(1);
138 }
139 
140 int
141 main(int argc, char *argv[])
142 {
143 	int c, all, namesonly, downonly, uponly;
144 	const struct afswtch *afp = NULL;
145 	int ifindex;
146 	struct ifaddrs *ifap, *ifa;
147 	struct ifreq paifr;
148 	const struct sockaddr_dl *sdl;
149 	char options[1024], *cp;
150 	const char *ifname;
151 	struct option *p;
152 	size_t iflen;
153 
154 	all = downonly = uponly = namesonly = noload = verbose = 0;
155 
156 	/* Parse leading line options */
157 	strlcpy(options, "adklmnuv", sizeof(options));
158 	for (p = opts; p != NULL; p = p->next)
159 		strlcat(options, p->opt, sizeof(options));
160 	while ((c = getopt(argc, argv, options)) != -1) {
161 		switch (c) {
162 		case 'a':	/* scan all interfaces */
163 			all++;
164 			break;
165 		case 'd':	/* restrict scan to "down" interfaces */
166 			downonly++;
167 			break;
168 		case 'k':
169 			printkeys++;
170 			break;
171 		case 'l':	/* scan interface names only */
172 			namesonly++;
173 			break;
174 		case 'm':	/* show media choices in status */
175 			supmedia = 1;
176 			break;
177 		case 'n':	/* suppress module loading */
178 			noload++;
179 			break;
180 		case 'u':	/* restrict scan to "up" interfaces */
181 			uponly++;
182 			break;
183 		case 'v':
184 			verbose++;
185 			break;
186 		default:
187 			for (p = opts; p != NULL; p = p->next)
188 				if (p->opt[0] == c) {
189 					p->cb(optarg);
190 					break;
191 				}
192 			if (p == NULL)
193 				usage();
194 			break;
195 		}
196 	}
197 	argc -= optind;
198 	argv += optind;
199 
200 	/* -l cannot be used with -a or -m */
201 	if (namesonly && (all || supmedia))
202 		usage();
203 
204 	/* nonsense.. */
205 	if (uponly && downonly)
206 		usage();
207 
208 	/* no arguments is equivalent to '-a' */
209 	if (!namesonly && argc < 1)
210 		all = 1;
211 
212 	/* -a and -l allow an address family arg to limit the output */
213 	if (all || namesonly) {
214 		if (argc > 1)
215 			usage();
216 
217 		ifname = NULL;
218 		ifindex = 0;
219 		if (argc == 1) {
220 			afp = af_getbyname(*argv);
221 			if (afp == NULL)
222 				usage();
223 			if (afp->af_name != NULL)
224 				argc--, argv++;
225 			/* leave with afp non-zero */
226 		}
227 	} else {
228 		/* not listing, need an argument */
229 		if (argc < 1)
230 			usage();
231 
232 		ifname = *argv;
233 		argc--, argv++;
234 
235 		/* check and maybe load support for this interface */
236 		ifmaybeload(ifname);
237 
238 		ifindex = if_nametoindex(ifname);
239 		if (ifindex == 0) {
240 			/*
241 			 * NOTE:  We must special-case the `create' command
242 			 * right here as we would otherwise fail when trying
243 			 * to find the interface.
244 			 */
245 			if (argc > 0 && (strcmp(argv[0], "create") == 0 ||
246 			    strcmp(argv[0], "plumb") == 0)) {
247 				iflen = strlcpy(name, ifname, sizeof(name));
248 				if (iflen >= sizeof(name))
249 					errx(1, "%s: cloning name too long",
250 					    ifname);
251 				ifconfig(argc, argv, 1, NULL);
252 				exit(0);
253 			}
254 			errx(1, "interface %s does not exist", ifname);
255 		}
256 	}
257 
258 	/* Check for address family */
259 	if (argc > 0) {
260 		afp = af_getbyname(*argv);
261 		if (afp != NULL)
262 			argc--, argv++;
263 	}
264 
265 	if (getifaddrs(&ifap) != 0)
266 		err(EXIT_FAILURE, "getifaddrs");
267 	cp = NULL;
268 	ifindex = 0;
269 	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
270 		memset(&paifr, 0, sizeof(paifr));
271 		strncpy(paifr.ifr_name, ifa->ifa_name, sizeof(paifr.ifr_name));
272 		if (sizeof(paifr.ifr_addr) >= ifa->ifa_addr->sa_len) {
273 			memcpy(&paifr.ifr_addr, ifa->ifa_addr,
274 			    ifa->ifa_addr->sa_len);
275 		}
276 
277 		if (ifname != NULL && strcmp(ifname, ifa->ifa_name) != 0)
278 			continue;
279 		if (ifa->ifa_addr->sa_family == AF_LINK)
280 			sdl = (const struct sockaddr_dl *) ifa->ifa_addr;
281 		else
282 			sdl = NULL;
283 		if (cp != NULL && strcmp(cp, ifa->ifa_name) == 0)
284 			continue;
285 		iflen = strlcpy(name, ifa->ifa_name, sizeof(name));
286 		if (iflen >= sizeof(name)) {
287 			warnx("%s: interface name too long, skipping",
288 			    ifa->ifa_name);
289 			continue;
290 		}
291 		cp = ifa->ifa_name;
292 
293 		if (downonly && (ifa->ifa_flags & IFF_UP) != 0)
294 			continue;
295 		if (uponly && (ifa->ifa_flags & IFF_UP) == 0)
296 			continue;
297 		ifindex++;
298 		/*
299 		 * Are we just listing the interfaces?
300 		 */
301 		if (namesonly) {
302 			if (ifindex > 1)
303 				printf(" ");
304 			fputs(name, stdout);
305 			continue;
306 		}
307 
308 		if (argc > 0)
309 			ifconfig(argc, argv, 0, afp);
310 		else
311 			status(afp, sdl, ifa);
312 	}
313 	if (namesonly)
314 		printf("\n");
315 	freeifaddrs(ifap);
316 
317 	exit(0);
318 }
319 
320 static struct afswtch *afs = NULL;
321 
322 void
323 af_register(struct afswtch *p)
324 {
325 	p->af_next = afs;
326 	afs = p;
327 }
328 
329 static struct afswtch *
330 af_getbyname(const char *name)
331 {
332 	struct afswtch *afp;
333 
334 	for (afp = afs; afp !=  NULL; afp = afp->af_next)
335 		if (strcmp(afp->af_name, name) == 0)
336 			return afp;
337 	return NULL;
338 }
339 
340 static struct afswtch *
341 af_getbyfamily(int af)
342 {
343 	struct afswtch *afp;
344 
345 	for (afp = afs; afp != NULL; afp = afp->af_next)
346 		if (afp->af_af == af)
347 			return afp;
348 	return NULL;
349 }
350 
351 static void
352 af_other_status(int s)
353 {
354 	struct afswtch *afp;
355 	uint8_t afmask[howmany(AF_MAX, NBBY)];
356 
357 	memset(afmask, 0, sizeof(afmask));
358 	for (afp = afs; afp != NULL; afp = afp->af_next) {
359 		if (afp->af_other_status == NULL)
360 			continue;
361 		if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af))
362 			continue;
363 		afp->af_other_status(s);
364 		setbit(afmask, afp->af_af);
365 	}
366 }
367 
368 static void
369 af_all_tunnel_status(int s)
370 {
371 	struct afswtch *afp;
372 	uint8_t afmask[howmany(AF_MAX, NBBY)];
373 
374 	memset(afmask, 0, sizeof(afmask));
375 	for (afp = afs; afp != NULL; afp = afp->af_next) {
376 		if (afp->af_status_tunnel == NULL)
377 			continue;
378 		if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af))
379 			continue;
380 		afp->af_status_tunnel(s);
381 		setbit(afmask, afp->af_af);
382 	}
383 }
384 
385 static struct cmd *cmds = NULL;
386 
387 void
388 cmd_register(struct cmd *p)
389 {
390 	p->c_next = cmds;
391 	cmds = p;
392 }
393 
394 static const struct cmd *
395 cmd_lookup(const char *name, int iscreate)
396 {
397 #define	N(a)	(sizeof(a)/sizeof(a[0]))
398 	const struct cmd *p;
399 
400 	for (p = cmds; p != NULL; p = p->c_next)
401 		if (strcmp(name, p->c_name) == 0) {
402 			if (iscreate) {
403 				if (p->c_iscloneop)
404 					return p;
405 			} else {
406 				if (!p->c_iscloneop)
407 					return p;
408 			}
409 		}
410 	return NULL;
411 #undef N
412 }
413 
414 struct callback {
415 	callback_func *cb_func;
416 	void	*cb_arg;
417 	struct callback *cb_next;
418 };
419 static struct callback *callbacks = NULL;
420 
421 void
422 callback_register(callback_func *func, void *arg)
423 {
424 	struct callback *cb;
425 
426 	cb = malloc(sizeof(struct callback));
427 	if (cb == NULL)
428 		errx(1, "unable to allocate memory for callback");
429 	cb->cb_func = func;
430 	cb->cb_arg = arg;
431 	cb->cb_next = callbacks;
432 	callbacks = cb;
433 }
434 
435 /* specially-handled commands */
436 static void setifaddr(const char *, int, int, const struct afswtch *);
437 static const struct cmd setifaddr_cmd = DEF_CMD("ifaddr", 0, setifaddr);
438 
439 static void setifdstaddr(const char *, int, int, const struct afswtch *);
440 static const struct cmd setifdstaddr_cmd =
441 	DEF_CMD("ifdstaddr", 0, setifdstaddr);
442 
443 static int
444 ifconfig(int argc, char *const *argv, int iscreate, const struct afswtch *uafp)
445 {
446 	const struct afswtch *afp, *nafp;
447 	const struct cmd *p;
448 	struct callback *cb;
449 	int s;
450 
451 	strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
452 	afp = uafp != NULL ? uafp : af_getbyname("inet");
453 top:
454 	ifr.ifr_addr.sa_family =
455 		afp->af_af == AF_LINK || afp->af_af == AF_UNSPEC ?
456 		AF_LOCAL : afp->af_af;
457 
458 	if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0 &&
459 	    (uafp != NULL || errno != EPROTONOSUPPORT ||
460 	     (s = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0))
461 		err(1, "socket(family %u,SOCK_DGRAM", ifr.ifr_addr.sa_family);
462 
463 	while (argc > 0) {
464 		p = cmd_lookup(*argv, iscreate);
465 		if (iscreate && p == NULL) {
466 			/*
467 			 * Push the clone create callback so the new
468 			 * device is created and can be used for any
469 			 * remaining arguments.
470 			 */
471 			cb = callbacks;
472 			if (cb == NULL)
473 				errx(1, "internal error, no callback");
474 			callbacks = cb->cb_next;
475 			cb->cb_func(s, cb->cb_arg);
476 			iscreate = 0;
477 			/*
478 			 * Handle any address family spec that
479 			 * immediately follows and potentially
480 			 * recreate the socket.
481 			 */
482 			nafp = af_getbyname(*argv);
483 			if (nafp != NULL) {
484 				argc--, argv++;
485 				if (nafp != afp) {
486 					close(s);
487 					afp = nafp;
488 					goto top;
489 				}
490 			}
491 			/*
492 			 * Look for a normal parameter.
493 			 */
494 			continue;
495 		}
496 		if (p == NULL) {
497 			/*
498 			 * Not a recognized command, choose between setting
499 			 * the interface address and the dst address.
500 			 */
501 			p = (setaddr ? &setifdstaddr_cmd : &setifaddr_cmd);
502 		}
503 		if (p->c_u.c_func || p->c_u.c_func2) {
504 			if (p->c_parameter == NEXTARG) {
505 				if (argv[1] == NULL)
506 					errx(1, "'%s' requires argument",
507 					    p->c_name);
508 				p->c_u.c_func(argv[1], 0, s, afp);
509 				argc--, argv++;
510 			} else if (p->c_parameter == OPTARG) {
511 				p->c_u.c_func(argv[1], 0, s, afp);
512 				if (argv[1] != NULL)
513 					argc--, argv++;
514 			} else if (p->c_parameter == NEXTARG2) {
515 				if (argc < 3)
516 					errx(1, "'%s' requires 2 arguments",
517 					    p->c_name);
518 				p->c_u.c_func2(argv[1], argv[2], s, afp);
519 				argc -= 2, argv += 2;
520 			} else
521 				p->c_u.c_func(*argv, p->c_parameter, s, afp);
522 		}
523 		argc--, argv++;
524 	}
525 
526 	/*
527 	 * Do any post argument processing required by the address family.
528 	 */
529 	if (afp->af_postproc != NULL)
530 		afp->af_postproc(s, afp);
531 	/*
532 	 * Do deferred callbacks registered while processing
533 	 * command-line arguments.
534 	 */
535 	for (cb = callbacks; cb != NULL; cb = cb->cb_next)
536 		cb->cb_func(s, cb->cb_arg);
537 	/*
538 	 * Do deferred operations.
539 	 */
540 	if (clearaddr) {
541 		if (afp->af_ridreq == NULL || afp->af_difaddr == 0) {
542 			warnx("interface %s cannot change %s addresses!",
543 			      name, afp->af_name);
544 			clearaddr = 0;
545 		}
546 	}
547 	if (clearaddr) {
548 		int ret;
549 		strncpy(afp->af_ridreq, name, sizeof ifr.ifr_name);
550 		ret = ioctl(s, afp->af_difaddr, afp->af_ridreq);
551 		if (ret < 0) {
552 			if (errno == EADDRNOTAVAIL && (doalias >= 0)) {
553 				/* means no previous address for interface */
554 			} else
555 				Perror("ioctl (SIOCDIFADDR)");
556 		}
557 	}
558 	if (newaddr) {
559 		if (afp->af_addreq == NULL || afp->af_aifaddr == 0) {
560 			warnx("interface %s cannot change %s addresses!",
561 			      name, afp->af_name);
562 			newaddr = 0;
563 		}
564 	}
565 	if (newaddr && (setaddr || setmask)) {
566 		strncpy(afp->af_addreq, name, sizeof ifr.ifr_name);
567 		if (ioctl(s, afp->af_aifaddr, afp->af_addreq) < 0)
568 			Perror("ioctl (SIOCAIFADDR)");
569 	}
570 
571 	close(s);
572 	return(0);
573 }
574 
575 /*ARGSUSED*/
576 static void
577 setifaddr(const char *addr, int param, int s, const struct afswtch *afp)
578 {
579 	if (afp->af_getaddr == NULL)
580 		return;
581 	/*
582 	 * Delay the ioctl to set the interface addr until flags are all set.
583 	 * The address interpretation may depend on the flags,
584 	 * and the flags may change when the address is set.
585 	 */
586 	setaddr++;
587 	if (doalias == 0 && afp->af_af != AF_LINK)
588 		clearaddr = 1;
589 	afp->af_getaddr(addr, (doalias >= 0 ? ADDR : RIDADDR));
590 }
591 
592 static void
593 settunnel(const char *src, const char *dst, int s, const struct afswtch *afp)
594 {
595 	struct addrinfo *srcres, *dstres;
596 	int ecode;
597 
598 	if (afp->af_settunnel == NULL) {
599 		warn("address family %s does not support tunnel setup",
600 			afp->af_name);
601 		return;
602 	}
603 
604 	if ((ecode = getaddrinfo(src, NULL, NULL, &srcres)) != 0)
605 		errx(1, "error in parsing address string: %s",
606 		    gai_strerror(ecode));
607 
608 	if ((ecode = getaddrinfo(dst, NULL, NULL, &dstres)) != 0)
609 		errx(1, "error in parsing address string: %s",
610 		    gai_strerror(ecode));
611 
612 	if (srcres->ai_addr->sa_family != dstres->ai_addr->sa_family)
613 		errx(1,
614 		    "source and destination address families do not match");
615 
616 	afp->af_settunnel(s, srcres, dstres);
617 
618 	freeaddrinfo(srcres);
619 	freeaddrinfo(dstres);
620 }
621 
622 /* ARGSUSED */
623 static void
624 deletetunnel(const char *vname, int param, int s, const struct afswtch *afp)
625 {
626 
627 	if (ioctl(s, SIOCDIFPHYADDR, &ifr) < 0)
628 		err(1, "SIOCDIFPHYADDR");
629 }
630 
631 static void
632 setifnetmask(const char *addr, int dummy __unused, int s,
633     const struct afswtch *afp)
634 {
635 	if (afp->af_getaddr != NULL) {
636 		setmask++;
637 		afp->af_getaddr(addr, MASK);
638 	}
639 }
640 
641 static void
642 setifbroadaddr(const char *addr, int dummy __unused, int s,
643     const struct afswtch *afp)
644 {
645 	if (afp->af_getaddr != NULL)
646 		afp->af_getaddr(addr, DSTADDR);
647 }
648 
649 static void
650 setifipdst(const char *addr, int dummy __unused, int s,
651     const struct afswtch *afp)
652 {
653 	const struct afswtch *inet;
654 
655 	inet = af_getbyname("inet");
656 	if (inet == NULL)
657 		return;
658 	inet->af_getaddr(addr, DSTADDR);
659 	clearaddr = 0;
660 	newaddr = 0;
661 }
662 
663 static void
664 notealias(const char *addr, int param, int s, const struct afswtch *afp)
665 {
666 #define rqtosa(x) (&(((struct ifreq *)(afp->x))->ifr_addr))
667 	if (setaddr && doalias == 0 && param < 0)
668 		if (afp->af_addreq != NULL && afp->af_ridreq != NULL)
669 			bcopy((caddr_t)rqtosa(af_addreq),
670 			      (caddr_t)rqtosa(af_ridreq),
671 			      rqtosa(af_addreq)->sa_len);
672 	doalias = param;
673 	if (param < 0) {
674 		clearaddr = 1;
675 		newaddr = 0;
676 	} else
677 		clearaddr = 0;
678 #undef rqtosa
679 }
680 
681 /*ARGSUSED*/
682 static void
683 setifdstaddr(const char *addr, int param __unused, int s,
684     const struct afswtch *afp)
685 {
686 	if (afp->af_getaddr != NULL)
687 		afp->af_getaddr(addr, DSTADDR);
688 }
689 
690 /*
691  * Note: doing an SIOCIGIFFLAGS scribbles on the union portion
692  * of the ifreq structure, which may confuse other parts of ifconfig.
693  * Make a private copy so we can avoid that.
694  */
695 static void
696 setifflags(const char *vname, int value, int s, const struct afswtch *afp)
697 {
698 	struct ifreq		my_ifr;
699 	int flags;
700 
701 	memset(&my_ifr, 0, sizeof(my_ifr));
702 	(void) strlcpy(my_ifr.ifr_name, name, sizeof(my_ifr.ifr_name));
703 
704  	if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&my_ifr) < 0) {
705  		Perror("ioctl (SIOCGIFFLAGS)");
706  		exit(1);
707  	}
708 	flags = (my_ifr.ifr_flags & 0xffff) | (my_ifr.ifr_flagshigh << 16);
709 
710 	if (value < 0) {
711 		value = -value;
712 		flags &= ~value;
713 	} else
714 		flags |= value;
715 	my_ifr.ifr_flags = flags & 0xffff;
716 	my_ifr.ifr_flagshigh = flags >> 16;
717 	if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&my_ifr) < 0)
718 		Perror(vname);
719 }
720 
721 void
722 setifcap(const char *vname, int value, int s, const struct afswtch *afp)
723 {
724 	int flags;
725 
726  	if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) < 0) {
727  		Perror("ioctl (SIOCGIFCAP)");
728  		exit(1);
729  	}
730 	flags = ifr.ifr_curcap;
731 	if (value < 0) {
732 		value = -value;
733 		flags &= ~value;
734 	} else
735 		flags |= value;
736 	flags &= ifr.ifr_reqcap;
737 	ifr.ifr_reqcap = flags;
738 	if (ioctl(s, SIOCSIFCAP, (caddr_t)&ifr) < 0)
739 		Perror(vname);
740 }
741 
742 static void
743 setifmetric(const char *val, int dummy __unused, int s,
744     const struct afswtch *afp)
745 {
746 	strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
747 	ifr.ifr_metric = atoi(val);
748 	if (ioctl(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0)
749 		warn("ioctl (set metric)");
750 }
751 
752 static void
753 setifmtu(const char *val, int dummy __unused, int s,
754     const struct afswtch *afp)
755 {
756 	strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name));
757 	ifr.ifr_mtu = atoi(val);
758 	if (ioctl(s, SIOCSIFMTU, (caddr_t)&ifr) < 0)
759 		warn("ioctl (set mtu)");
760 }
761 
762 static void
763 setifname(const char *val, int dummy __unused, int s,
764     const struct afswtch *afp)
765 {
766 	char *newname;
767 
768 	newname = strdup(val);
769 	if (newname == NULL) {
770 		warn("no memory to set ifname");
771 		return;
772 	}
773 	ifr.ifr_data = newname;
774 	if (ioctl(s, SIOCSIFNAME, (caddr_t)&ifr) < 0) {
775 		warn("ioctl (set name)");
776 		free(newname);
777 		return;
778 	}
779 	strlcpy(name, newname, sizeof(name));
780 	free(newname);
781 }
782 
783 #define	IFFBITS \
784 "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6SMART\7RUNNING" \
785 "\10NOARP\11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2" \
786 "\20MULTICAST\22PPROMISC\23MONITOR\24STATICARP"
787 
788 #define	IFCAPBITS \
789 "\020\1RXCSUM\2TXCSUM\3NETCONS\4VLAN_MTU\5VLAN_HWTAGGING\6JUMBO_MTU\7POLLING" \
790 "\10VLAN_HWCSUM\11TSO4\12TSO6\13LRO\14WOL_UCAST\15WOL_MCAST\16WOL_MAGIC" \
791 "\21VLAN_HWFILTER"
792 
793 /*
794  * Print the status of the interface.  If an address family was
795  * specified, show only it; otherwise, show them all.
796  */
797 static void
798 status(const struct afswtch *afp, const struct sockaddr_dl *sdl,
799 	struct ifaddrs *ifa)
800 {
801 	struct ifaddrs *ift;
802 	int allfamilies, s;
803 	struct ifstat ifs;
804 
805 	if (afp == NULL) {
806 		allfamilies = 1;
807 		ifr.ifr_addr.sa_family = AF_LOCAL;
808 	} else {
809 		allfamilies = 0;
810 		ifr.ifr_addr.sa_family =
811 		    afp->af_af == AF_LINK ? AF_LOCAL : afp->af_af;
812 	}
813 	strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
814 
815 	s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0);
816 	if (s < 0)
817 		err(1, "socket(family %u,SOCK_DGRAM)", ifr.ifr_addr.sa_family);
818 
819 	printf("%s: ", name);
820 	printb("flags", ifa->ifa_flags, IFFBITS);
821 	if (ioctl(s, SIOCGIFMETRIC, &ifr) != -1)
822 		printf(" metric %d", ifr.ifr_metric);
823 	if (ioctl(s, SIOCGIFMTU, &ifr) != -1)
824 		printf(" mtu %d", ifr.ifr_mtu);
825 	putchar('\n');
826 
827 	if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) == 0) {
828 		if (ifr.ifr_curcap != 0) {
829 			printb("\toptions", ifr.ifr_curcap, IFCAPBITS);
830 			putchar('\n');
831 		}
832 		if (supmedia && ifr.ifr_reqcap != 0) {
833 			printb("\tcapabilities", ifr.ifr_reqcap, IFCAPBITS);
834 			putchar('\n');
835 		}
836 	}
837 
838 	tunnel_status(s);
839 
840 	for (ift = ifa; ift != NULL; ift = ift->ifa_next) {
841 		if (ift->ifa_addr == NULL)
842 			continue;
843 		if (strcmp(ifa->ifa_name, ift->ifa_name) != 0)
844 			continue;
845 		if (allfamilies) {
846 			const struct afswtch *p;
847 			p = af_getbyfamily(ift->ifa_addr->sa_family);
848 			if (p != NULL && p->af_status != NULL)
849 				p->af_status(s, ift);
850 		} else if (afp->af_af == ift->ifa_addr->sa_family)
851 			afp->af_status(s, ift);
852 	}
853 #if 0
854 	if (allfamilies || afp->af_af == AF_LINK) {
855 		const struct afswtch *lafp;
856 
857 		/*
858 		 * Hack; the link level address is received separately
859 		 * from the routing information so any address is not
860 		 * handled above.  Cobble together an entry and invoke
861 		 * the status method specially.
862 		 */
863 		lafp = af_getbyname("lladdr");
864 		if (lafp != NULL) {
865 			info.rti_info[RTAX_IFA] = (struct sockaddr *)sdl;
866 			lafp->af_status(s, &info);
867 		}
868 	}
869 #endif
870 	if (allfamilies)
871 		af_other_status(s);
872 	else if (afp->af_other_status != NULL)
873 		afp->af_other_status(s);
874 
875 	strncpy(ifs.ifs_name, name, sizeof ifs.ifs_name);
876 	if (ioctl(s, SIOCGIFSTATUS, &ifs) == 0)
877 		printf("%s", ifs.ascii);
878 
879 	close(s);
880 	return;
881 }
882 
883 static void
884 tunnel_status(int s)
885 {
886 	af_all_tunnel_status(s);
887 }
888 
889 void
890 Perror(const char *cmd)
891 {
892 	switch (errno) {
893 
894 	case ENXIO:
895 		errx(1, "%s: no such interface", cmd);
896 		break;
897 
898 	case EPERM:
899 		errx(1, "%s: permission denied", cmd);
900 		break;
901 
902 	default:
903 		err(1, "%s", cmd);
904 	}
905 }
906 
907 /*
908  * Print a value a la the %b format of the kernel's printf
909  */
910 void
911 printb(const char *s, unsigned v, const char *bits)
912 {
913 	int i, any = 0;
914 	char c;
915 
916 	if (bits && *bits == 8)
917 		printf("%s=%o", s, v);
918 	else
919 		printf("%s=%x", s, v);
920 	bits++;
921 	if (bits) {
922 		putchar('<');
923 		while ((i = *bits++) != '\0') {
924 			if (v & (1 << (i-1))) {
925 				if (any)
926 					putchar(',');
927 				any = 1;
928 				for (; (c = *bits) > 32; bits++)
929 					putchar(c);
930 			} else
931 				for (; *bits > 32; bits++)
932 					;
933 		}
934 		putchar('>');
935 	}
936 }
937 
938 void
939 ifmaybeload(const char *name)
940 {
941 #define MOD_PREFIX_LEN		3	/* "if_" */
942 	struct module_stat mstat;
943 	int fileid, modid;
944 	char ifkind[IFNAMSIZ + MOD_PREFIX_LEN], ifname[IFNAMSIZ], *dp;
945 	const char *cp;
946 
947 	/* loading suppressed by the user */
948 	if (noload)
949 		return;
950 
951 	/* trim the interface number off the end */
952 	strlcpy(ifname, name, sizeof(ifname));
953 	for (dp = ifname; *dp != 0; dp++)
954 		if (isdigit(*dp)) {
955 			*dp = 0;
956 			break;
957 		}
958 
959 	/* turn interface and unit into module name */
960 	strcpy(ifkind, "if_");
961 	strlcpy(ifkind + MOD_PREFIX_LEN, ifname,
962 	    sizeof(ifkind) - MOD_PREFIX_LEN);
963 
964 	/* scan files in kernel */
965 	mstat.version = sizeof(struct module_stat);
966 	for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) {
967 		/* scan modules in file */
968 		for (modid = kldfirstmod(fileid); modid > 0;
969 		     modid = modfnext(modid)) {
970 			if (modstat(modid, &mstat) < 0)
971 				continue;
972 			/* strip bus name if present */
973 			if ((cp = strchr(mstat.name, '/')) != NULL) {
974 				cp++;
975 			} else {
976 				cp = mstat.name;
977 			}
978 			/* already loaded? */
979 			if (strncmp(ifname, cp, strlen(ifname) + 1) == 0 ||
980 			    strncmp(ifkind, cp, strlen(ifkind) + 1) == 0)
981 				return;
982 		}
983 	}
984 
985 	/* not present, we should try to load it */
986 	kldload(ifkind);
987 }
988 
989 static struct cmd basic_cmds[] = {
990 	DEF_CMD("up",		IFF_UP,		setifflags),
991 	DEF_CMD("down",		-IFF_UP,	setifflags),
992 	DEF_CMD("arp",		-IFF_NOARP,	setifflags),
993 	DEF_CMD("-arp",		IFF_NOARP,	setifflags),
994 	DEF_CMD("debug",	IFF_DEBUG,	setifflags),
995 	DEF_CMD("-debug",	-IFF_DEBUG,	setifflags),
996 	DEF_CMD("promisc",	IFF_PPROMISC,	setifflags),
997 	DEF_CMD("-promisc",	-IFF_PPROMISC,	setifflags),
998 	DEF_CMD("add",		IFF_UP,		notealias),
999 	DEF_CMD("alias",	IFF_UP,		notealias),
1000 	DEF_CMD("-alias",	-IFF_UP,	notealias),
1001 	DEF_CMD("delete",	-IFF_UP,	notealias),
1002 	DEF_CMD("remove",	-IFF_UP,	notealias),
1003 #ifdef notdef
1004 #define	EN_SWABIPS	0x1000
1005 	DEF_CMD("swabips",	EN_SWABIPS,	setifflags),
1006 	DEF_CMD("-swabips",	-EN_SWABIPS,	setifflags),
1007 #endif
1008 	DEF_CMD_ARG("netmask",			setifnetmask),
1009 	DEF_CMD_ARG("metric",			setifmetric),
1010 	DEF_CMD_ARG("broadcast",		setifbroadaddr),
1011 	DEF_CMD_ARG("ipdst",			setifipdst),
1012 	DEF_CMD_ARG2("tunnel",			settunnel),
1013 	DEF_CMD("-tunnel", 0,			deletetunnel),
1014 	DEF_CMD("deletetunnel", 0,		deletetunnel),
1015 	DEF_CMD("link0",	IFF_LINK0,	setifflags),
1016 	DEF_CMD("-link0",	-IFF_LINK0,	setifflags),
1017 	DEF_CMD("link1",	IFF_LINK1,	setifflags),
1018 	DEF_CMD("-link1",	-IFF_LINK1,	setifflags),
1019 	DEF_CMD("link2",	IFF_LINK2,	setifflags),
1020 	DEF_CMD("-link2",	-IFF_LINK2,	setifflags),
1021 	DEF_CMD("monitor",	IFF_MONITOR,	setifflags),
1022 	DEF_CMD("-monitor",	-IFF_MONITOR,	setifflags),
1023 	DEF_CMD("staticarp",	IFF_STATICARP,	setifflags),
1024 	DEF_CMD("-staticarp",	-IFF_STATICARP,	setifflags),
1025 	DEF_CMD("rxcsum",	IFCAP_RXCSUM,	setifcap),
1026 	DEF_CMD("-rxcsum",	-IFCAP_RXCSUM,	setifcap),
1027 	DEF_CMD("txcsum",	IFCAP_TXCSUM,	setifcap),
1028 	DEF_CMD("-txcsum",	-IFCAP_TXCSUM,	setifcap),
1029 	DEF_CMD("netcons",	IFCAP_NETCONS,	setifcap),
1030 	DEF_CMD("-netcons",	-IFCAP_NETCONS,	setifcap),
1031 	DEF_CMD("polling",	IFCAP_POLLING,	setifcap),
1032 	DEF_CMD("-polling",	-IFCAP_POLLING,	setifcap),
1033 	DEF_CMD("tso",		IFCAP_TSO,	setifcap),
1034 	DEF_CMD("-tso",		-IFCAP_TSO,	setifcap),
1035 	DEF_CMD("lro",		IFCAP_LRO,	setifcap),
1036 	DEF_CMD("-lro",		-IFCAP_LRO,	setifcap),
1037 	DEF_CMD("wol",		IFCAP_WOL,	setifcap),
1038 	DEF_CMD("-wol",		-IFCAP_WOL,	setifcap),
1039 	DEF_CMD("wol_ucast",	IFCAP_WOL_UCAST,	setifcap),
1040 	DEF_CMD("-wol_ucast",	-IFCAP_WOL_UCAST,	setifcap),
1041 	DEF_CMD("wol_mcast",	IFCAP_WOL_MCAST,	setifcap),
1042 	DEF_CMD("-wol_mcast",	-IFCAP_WOL_MCAST,	setifcap),
1043 	DEF_CMD("wol_magic",	IFCAP_WOL_MAGIC,	setifcap),
1044 	DEF_CMD("-wol_magic",	-IFCAP_WOL_MAGIC,	setifcap),
1045 	DEF_CMD("normal",	-IFF_LINK0,	setifflags),
1046 	DEF_CMD("compress",	IFF_LINK0,	setifflags),
1047 	DEF_CMD("noicmp",	IFF_LINK1,	setifflags),
1048 	DEF_CMD_ARG("mtu",			setifmtu),
1049 	DEF_CMD_ARG("name",			setifname),
1050 };
1051 
1052 static __constructor void
1053 ifconfig_ctor(void)
1054 {
1055 #define	N(a)	(sizeof(a) / sizeof(a[0]))
1056 	int i;
1057 
1058 	for (i = 0; i < N(basic_cmds);  i++)
1059 		cmd_register(&basic_cmds[i]);
1060 #undef N
1061 }
1062