Context Navigation

route.c @ 21abaef

55-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 21abaef was 21abaef, checked in by Christian Mauderer <Christian.Mauderer@…>, on 07/15/16 at 05:32:56

freebsd: Don't use new wrappers for old ports.

Some of the commands have been adapted manually. So the wrapper
currently don't necessarily work as expected. For example ifconfig calls
malloc outside of the program call.

Property mode set to 100644

File size: 48.9 KB

Line
1	#include <machine/rtems-bsd-user-space.h>
2
3	/*
4	* Copyright (c) 1983, 1989, 1991, 1993
5	* The Regents of the University of California. All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.
15	* 4. Neither the name of the University nor the names of its contributors
16	* may be used to endorse or promote products derived from this software
17	* without specific prior written permission.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31
32	#ifndef lint
33	static const char copyright[] =
34	"@(#) Copyright (c) 1983, 1989, 1991, 1993\n\
35	The Regents of the University of California. All rights reserved.\n";
36	#endif /* not lint */
37
38	#ifndef lint
39	#if 0
40	static char sccsid[] = "@(#)route.c 8.6 (Berkeley) 4/28/95";
41	#endif
42	#endif /* not lint */
43
44	#ifdef __rtems__
45	#define __need_getopt_newlib
46	#include <getopt.h>
47	#define RTEMS_BSD_PROGRAM_NO_OPEN_WRAP
48	#define RTEMS_BSD_PROGRAM_NO_SOCKET_WRAP
49	#define RTEMS_BSD_PROGRAM_NO_CLOSE_WRAP
50	#define RTEMS_BSD_PROGRAM_NO_FOPEN_WRAP
51	#define RTEMS_BSD_PROGRAM_NO_FCLOSE_WRAP
52	#define RTEMS_BSD_PROGRAM_NO_MALLOC_WRAP
53	#define RTEMS_BSD_PROGRAM_NO_CALLOC_WRAP
54	#define RTEMS_BSD_PROGRAM_NO_REALLOC_WRAP
55	#define RTEMS_BSD_PROGRAM_NO_FREE_WRAP
56	#include <machine/rtems-bsd-program.h>
57	#include <machine/rtems-bsd-commands.h>
58	#endif
59	#include <sys/cdefs.h>
60	__FBSDID("$FreeBSD$");
61
62	#include <rtems/bsd/sys/param.h>
63	#include <sys/file.h>
64	#include <sys/socket.h>
65	#include <sys/ioctl.h>
66	#include <sys/sysctl.h>
67	#include <sys/types.h>
68	#include <sys/queue.h>
69
70	#include <net/if.h>
71	#include <net/route.h>
72	#include <net/if_dl.h>
73	#include <netinet/in.h>
74	#include <netinet/if_ether.h>
75	#include <netatalk/at.h>
76	#include <arpa/inet.h>
77	#include <netdb.h>
78
79	#include <ctype.h>
80	#include <err.h>
81	#include <errno.h>
82	#include <paths.h>
83	#include <stdio.h>
84	#include <stdlib.h>
85	#include <string.h>
86	#include <sysexits.h>
87	#include <unistd.h>
88	#include <ifaddrs.h>
89
90	static const struct keytab {
91	const char *kt_cp;
92	int kt_i;
93	} keywords[] = {
94	#include "keywords.h"
95	{0, 0}
96	};
97
98	struct fibl {
99	TAILQ_ENTRY(fibl) fl_next;
100
101	int fl_num;
102	int fl_error;
103	int fl_errno;
104	};
105
106	struct rt_ctx {
107	union sockunion {
108	struct sockaddr sa;
109	struct sockaddr_in sin;
110	#ifdef INET6
111	struct sockaddr_in6 sin6;
112	#endif
113	struct sockaddr_at sat;
114	struct sockaddr_dl sdl;
115	struct sockaddr_inarp sinarp;
116	struct sockaddr_storage ss; /* added to avoid memory overrun */
117	} so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp;
118
119	int pid, rtm_addrs;
120	int s;
121	int forcehost, forcenet, nflag, af, qflag, tflag;
122	int verbose, aflen;
123	int locking, lockrest, debugonly;
124	struct rt_metrics rt_metrics;
125	u_long rtm_inits;
126	uid_t uid;
127	int defaultfib;
128	int numfibs;
129	char domain[MAXHOSTNAMELEN + 1];
130	int domain_initialized;
131	int rtm_seq;
132	char rt_line[MAXHOSTNAMELEN + 1];
133	char net_line[MAXHOSTNAMELEN + 1];
134	struct {
135	struct rt_msghdr m_rtm;
136	char m_space[512];
137	} m_rtmsg;
138	TAILQ_HEAD(fibl_head_t, fibl) fibl_head;
139	};
140
141	#ifndef __rtems__
142	struct rt_ctx rt_ctx;
143	#endif /* __rtems__ */
144
145	typedef union sockunion *sup;
146
147	static int atalk_aton(const char , struct at_addr );
148	static char *atalk_ntoa(struct at_addr, char [20]);
149	static void bprintf(FILE , int, const char );
150	static void flushroutes(struct rt_ctx , int argc, char argv[]);
151	static int flushroutes_fib(struct rt_ctx *, int);
152	static int getaddr(struct rt_ctx , int, char , struct hostent **, int);
153	static int keyword(const char *);
154	static void inet_makenetandmask(struct rt_ctx , u_long, struct sockaddr_in , u_long);
155	#ifdef INET6
156	static int inet6_makenetandmask(struct rt_ctx , struct sockaddr_in6 , const char *);
157	#endif
158	static void interfaces(struct rt_ctx *);
159	static void mask_addr(struct rt_ctx *);
160	static void monitor(struct rt_ctx , int, char []);
161	static const char netname(struct rt_ctx , struct sockaddr *);
162	static void newroute(struct rt_ctx , int, char *);
163	static int newroute_fib(struct rt_ctx , int, char , int);
164	static void pmsg_addrs(struct rt_ctx , char , int, size_t);
165	static void pmsg_common(struct rt_ctx , struct rt_msghdr , size_t);
166	static int prefixlen(struct rt_ctx , const char );
167	static void print_getmsg(struct rt_ctx , struct rt_msghdr , int, int);
168	static void print_rtmsg(struct rt_ctx , struct rt_msghdr , size_t);
169	static const char routename(struct rt_ctx , struct sockaddr *);
170	static int rtmsg(struct rt_ctx *, int, int, int);
171	static void set_metric(struct rt_ctx , char , int);
172	static int set_sofib(struct rt_ctx *, int);
173	static int set_procfib(int);
174	static void sockaddr(char , struct sockaddr );
175	static void sodump(sup, const char *);
176	extern char *iso_ntoa(void);
177
178	static int fiboptlist_csv(struct rt_ctx , const char , struct fibl_head_t *);
179	static int fiboptlist_range(struct rt_ctx , const char , struct fibl_head_t *);
180
181	static void usage(const char *) __dead2;
182
183	void
184	usage(const char *cp)
185	{
186	if (cp != NULL)
187	warnx("bad keyword: %s", cp);
188	(void) fprintf(stderr,
189	"usage: route [-46dnqtv] command [[modifiers] args]\n");
190	exit(EX_USAGE);
191	/* NOTREACHED */
192	}
193
194	#ifdef __rtems__
195	static int main(int argc, char *argv, struct rt_ctx c);
196
197	struct main_ctx {
198	int argc;
199	char **argv;
200	struct rt_ctx *c;
201	};
202
203	static int
204	call_main(void *ctx)
205	{
206	const struct main_ctx *mc = ctx;
207
208	return main(mc->argc, mc->argv, mc->c);
209	}
210
211	int rtems_bsd_command_route(int argc, char *argv[])
212	{
213	struct rt_ctx *c;
214	int exit_code;
215
216	c = calloc(1, sizeof(*c));
217	if (c != NULL) {
218	struct main_ctx mc;
219	struct fibl *fl;
220	struct fibl *tfl;
221
222	mc.argc = argc;
223	mc.argv = argv;
224	mc.c = c;
225
226	c->s = -1;
227	c->aflen = sizeof(struct sockaddr_in);
228	TAILQ_INIT(&c->fibl_head);
229
230	exit_code = rtems_bsd_program_call("route", call_main, &mc);
231
232	close(c->s);
233
234	TAILQ_FOREACH_SAFE(fl, &c->fibl_head, fl_next, tfl) {
235	free(fl);
236	}
237
238	free(c);
239	} else {
240	exit_code = EXIT_FAILURE;
241	}
242
243	return exit_code;
244	}
245
246	int
247	main(int argc, char *argv, struct rt_ctx c)
248	{
249	#else /* __rtems__ */
250	int
251	main(int argc, char **argv)
252	{
253	struct rt_ctx *c;
254	#endif /* __rtems__ */
255	int ch;
256	size_t len;
257	#ifdef __rtems__
258	struct getopt_data getopt_data;
259	memset(&getopt_data, 0, sizeof(getopt_data));
260	#define optind getopt_data.optind
261	#define optarg getopt_data.optarg
262	#define opterr getopt_data.opterr
263	#define optopt getopt_data.optopt
264	#define getopt(argc, argv, opt) getopt_r(argc, argv, "+" opt, &getopt_data)
265	#endif /* __rtems__ */
266
267	#ifndef __rtems__
268	c = &rt_ctx;
269	c->aflen = sizeof (struct sockaddr_in);
270	#endif /* __rtems__ */
271
272	if (argc < 2)
273	usage(NULL);
274
275	while ((ch = getopt(argc, argv, "46nqdtv")) != -1)
276	switch(ch) {
277	case '4':
278	#ifdef INET
279	c->af = AF_INET;
280	c->aflen = sizeof(struct sockaddr_in);
281	#else
282	errx(1, "IPv4 support is not compiled in");
283	#endif
284	break;
285	case '6':
286	#ifdef INET6
287	c->af = AF_INET6;
288	c->aflen = sizeof(struct sockaddr_in6);
289	#else
290	errx(1, "IPv6 support is not compiled in");
291	#endif
292	break;
293	case 'n':
294	c->nflag = 1;
295	break;
296	case 'q':
297	c->qflag = 1;
298	break;
299	case 'v':
300	c->verbose = 1;
301	break;
302	case 't':
303	c->tflag = 1;
304	break;
305	case 'd':
306	c->debugonly = 1;
307	break;
308	case '?':
309	default:
310	usage(NULL);
311	}
312	argc -= optind;
313	argv += optind;
314
315	c->pid = getpid();
316	c->uid = geteuid();
317	if (c->tflag)
318	c->s = open(_PATH_DEVNULL, O_WRONLY, 0);
319	else
320	c->s = socket(PF_ROUTE, SOCK_RAW, 0);
321	if (c->s < 0)
322	err(EX_OSERR, "socket");
323
324	len = sizeof(c->numfibs);
325	if (sysctlbyname("net.fibs", (void *)&c->numfibs, &len, NULL, 0) == -1)
326	c->numfibs = -1;
327
328	len = sizeof(c->defaultfib);
329	if (c->numfibs != -1 &&
330	sysctlbyname("net.my_fibnum", (void *)&c->defaultfib, &len, NULL,
331	0) == -1)
332	c->defaultfib = -1;
333
334	if (*argv != NULL)
335	switch (keyword(*argv)) {
336	case K_GET:
337	case K_SHOW:
338	c->uid = 0;
339	/* FALLTHROUGH */
340
341	case K_CHANGE:
342	case K_ADD:
343	case K_DEL:
344	case K_DELETE:
345	newroute(c, argc, argv);
346	/* NOTREACHED */
347
348	case K_MONITOR:
349	monitor(c, argc, argv);
350	/* NOTREACHED */
351
352	case K_FLUSH:
353	flushroutes(c, argc, argv);
354	exit(0);
355	/* NOTREACHED */
356	}
357	usage(*argv);
358	/* NOTREACHED */
359	}
360
361	static int
362	set_sofib(struct rt_ctx *c, int fib)
363	{
364
365	if (fib < 0)
366	return (0);
367	return (setsockopt(c->s, SOL_SOCKET, SO_SETFIB, (void *)&fib,
368	sizeof(fib)));
369	}
370
371	static int
372	set_procfib(int fib)
373	{
374
375	if (fib < 0)
376	return (0);
377	return (setfib(fib));
378	}
379
380	static int
381	fiboptlist_range(struct rt_ctx c, const char arg, struct fibl_head_t *flh)
382	{
383	struct fibl *fl;
384	char str0, str, token, endptr;
385	int fib[2], i, error;
386
387	str0 = str = strdup(arg);
388	error = 0;
389	i = 0;
390	while ((token = strsep(&str, "-")) != NULL) {
391	switch (i) {
392	case 0:
393	case 1:
394	errno = 0;
395	fib[i] = strtol(token, &endptr, 0);
396	if (errno == 0) {
397	if (*endptr != '\0' \|\|
398	fib[i] < 0 \|\|
399	(c->numfibs != -1 && fib[i] > c->numfibs - 1))
400	errno = EINVAL;
401	}
402	if (errno)
403	error = 1;
404	break;
405	default:
406	error = 1;
407	}
408	if (error)
409	goto fiboptlist_range_ret;
410	i++;
411	}
412	if (fib[0] >= fib[1]) {
413	error = 1;
414	goto fiboptlist_range_ret;
415	}
416	for (i = fib[0]; i <= fib[1]; i++) {
417	fl = calloc(1, sizeof(*fl));
418	if (fl == NULL) {
419	error = 1;
420	goto fiboptlist_range_ret;
421	}
422	fl->fl_num = i;
423	TAILQ_INSERT_TAIL(flh, fl, fl_next);
424	}
425	fiboptlist_range_ret:
426	free(str0);
427	return (error);
428	}
429
430	#define ALLSTRLEN 64
431	static int
432	fiboptlist_csv(struct rt_ctx c, const char arg, struct fibl_head_t *flh)
433	{
434	struct fibl *fl;
435	char str0, str, token, endptr;
436	int fib, error;
437
438	if (strcmp("all", arg) == 0) {
439	str0 = str = calloc(1, ALLSTRLEN);
440	if (str == NULL) {
441	error = 1;
442	goto fiboptlist_csv_ret;
443	}
444	if (c->numfibs > 1)
445	snprintf(str, ALLSTRLEN - 1, "%d-%d", 0, c->numfibs - 1);
446	else
447	snprintf(str, ALLSTRLEN - 1, "%d", 0);
448	} else if (strcmp("default", arg) == 0) {
449	str0 = str = calloc(1, ALLSTRLEN);
450	if (str == NULL) {
451	error = 1;
452	goto fiboptlist_csv_ret;
453	}
454	snprintf(str, ALLSTRLEN - 1, "%d", c->defaultfib);
455	} else
456	str0 = str = strdup(arg);
457
458	error = 0;
459	while ((token = strsep(&str, ",")) != NULL) {
460	if (*token != '-' && strchr(token, '-') != NULL) {
461	error = fiboptlist_range(c, token, flh);
462	if (error)
463	goto fiboptlist_csv_ret;
464	} else {
465	errno = 0;
466	fib = strtol(token, &endptr, 0);
467	if (errno == 0) {
468	if (*endptr != '\0' \|\|
469	fib < 0 \|\|
470	(c->numfibs != -1 && fib > c->numfibs - 1))
471	errno = EINVAL;
472	}
473	if (errno) {
474	error = 1;
475	goto fiboptlist_csv_ret;
476	}
477	fl = calloc(1, sizeof(*fl));
478	if (fl == NULL) {
479	error = 1;
480	goto fiboptlist_csv_ret;
481	}
482	fl->fl_num = fib;
483	TAILQ_INSERT_TAIL(flh, fl, fl_next);
484	}
485	}
486	fiboptlist_csv_ret:
487	free(str0);
488	return (error);
489	}
490
491	/*
492	* Purge all entries in the routing tables not
493	* associated with network interfaces.
494	*/
495	static void
496	flushroutes(struct rt_ctx c, int argc, char argv[])
497	{
498	struct fibl *fl;
499	int error;
500
501	if (c->uid != 0 && !c->debugonly) {
502	errx(EX_NOPERM, "must be root to alter routing table");
503	}
504	shutdown(c->s, SHUT_RD); /* Don't want to read back our messages */
505
506	TAILQ_INIT(&c->fibl_head);
507	while (argc > 1) {
508	argc--;
509	argv++;
510	if (**argv != '-')
511	usage(*argv);
512	switch (keyword(*argv + 1)) {
513	case K_4:
514	case K_INET:
515	c->af = AF_INET;
516	break;
517	#ifdef INET6
518	case K_6:
519	case K_INET6:
520	c->af = AF_INET6;
521	break;
522	#endif
523	case K_ATALK:
524	c->af = AF_APPLETALK;
525	break;
526	case K_LINK:
527	c->af = AF_LINK;
528	break;
529	case K_FIB:
530	if (!--argc)
531	usage(*argv);
532	error = fiboptlist_csv(c, *++argv, &c->fibl_head);
533	if (error)
534	errx(EX_USAGE, "invalid fib number: %s", *argv);
535	break;
536	default:
537	usage(*argv);
538	}
539	}
540	if (TAILQ_EMPTY(&c->fibl_head)) {
541	error = fiboptlist_csv(c, "default", &c->fibl_head);
542	if (error)
543	errx(EX_OSERR, "fiboptlist_csv failed.");
544	}
545	TAILQ_FOREACH(fl, &c->fibl_head, fl_next)
546	flushroutes_fib(c, fl->fl_num);
547	}
548
549	static int
550	flushroutes_fib(struct rt_ctx *c, int fib)
551	{
552	struct rt_msghdr *rtm;
553	size_t needed;
554	char buf, next, *lim;
555	int mib[6], rlen, seqno, count = 0;
556	int error;
557
558	error = set_sofib(c, fib);
559	error += set_procfib(fib);
560	if (error) {
561	warn("fib number %d is ignored", fib);
562	return (error);
563	}
564
565	retry:
566	mib[0] = CTL_NET;
567	mib[1] = PF_ROUTE;
568	mib[2] = 0; /* protocol */
569	mib[3] = 0; /* wildcard address family */
570	mib[4] = NET_RT_DUMP;
571	mib[5] = 0; /* no flags */
572	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
573	err(EX_OSERR, "route-sysctl-estimate");
574	if ((buf = malloc(needed)) == NULL && needed != 0)
575	errx(EX_OSERR, "malloc failed");
576	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
577	if (errno == ENOMEM && count++ < 10) {
578	warnx("Routing table grew, retrying");
579	sleep(1);
580	free(buf);
581	goto retry;
582	}
583	err(EX_OSERR, "route-sysctl-get");
584	}
585	lim = buf + needed;
586	if (c->verbose)
587	(void) printf("Examining routing table from sysctl\n");
588	seqno = 0; /* ??? */
589	for (next = buf; next < lim; next += rtm->rtm_msglen) {
590	rtm = (struct rt_msghdr *)next;
591	if (c->verbose)
592	print_rtmsg(c, rtm, rtm->rtm_msglen);
593	if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
594	continue;
595	if (c->af != 0) {
596	struct sockaddr sa = (struct sockaddr )(rtm + 1);
597
598	if (sa->sa_family != c->af)
599	continue;
600	}
601	if (c->debugonly)
602	continue;
603	rtm->rtm_type = RTM_DELETE;
604	rtm->rtm_seq = seqno;
605	rlen = write(c->s, next, rtm->rtm_msglen);
606	if (rlen < 0 && errno == EPERM)
607	err(1, "write to routing socket");
608	if (rlen < (int)rtm->rtm_msglen) {
609	warn("write to routing socket");
610	(void) printf("got only %d for rlen\n", rlen);
611	free(buf);
612	goto retry;
613	break;
614	}
615	seqno++;
616	if (c->qflag)
617	continue;
618	if (c->verbose)
619	print_rtmsg(c, rtm, rlen);
620	else {
621	struct sockaddr sa = (struct sockaddr )(rtm + 1);
622
623	printf("%-20.20s ", rtm->rtm_flags & RTF_HOST ?
624	routename(c, sa) : netname(c, sa));
625	sa = (struct sockaddr )(SA_SIZE(sa) + (char )sa);
626	printf("%-20.20s ", routename(c, sa));
627	if (fib >= 0)
628	printf("-fib %-3d ", fib);
629	printf("done\n");
630	}
631	}
632	free(buf);
633	return (error);
634	}
635
636	static const char *
637	routename(struct rt_ctx c, struct sockaddr sa)
638	{
639	const char *cp;
640	char atalk_buf[20];
641	struct hostent *hp;
642	int n;
643
644	if (c->domain_initialized) {
645	c->domain_initialized = 1;
646	if (gethostname(c->domain, MAXHOSTNAMELEN) == 0 &&
647	(cp = strchr(c->domain, '.'))) {
648	c->domain[MAXHOSTNAMELEN] = '\0';
649	(void) strcpy(c->domain, cp + 1);
650	} else
651	c->domain[0] = 0;
652	}
653
654	if (sa->sa_len == 0)
655	strcpy(c->rt_line, "default");
656	else switch (sa->sa_family) {
657
658	case AF_INET:
659	{ struct in_addr in;
660	in = ((struct sockaddr_in *)sa)->sin_addr;
661
662	cp = NULL;
663	if (in.s_addr == INADDR_ANY \|\| sa->sa_len < 4)
664	cp = "default";
665	if (cp == NULL && !c->nflag) {
666	hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
667	AF_INET);
668	if (hp != NULL) {
669	char *cptr;
670	cptr = strchr(hp->h_name, '.');
671	if (cptr != NULL &&
672	strcmp(cptr + 1, c->domain) == 0)
673	*cptr = '\0';
674	cp = hp->h_name;
675	}
676	}
677	if (cp != NULL) {
678	strncpy(c->rt_line, cp, sizeof(c->rt_line) - 1);
679	c->rt_line[sizeof(c->rt_line) - 1] = '\0';
680	} else
681	(void) sprintf(c->rt_line, "%s", inet_ntoa(in));
682	break;
683	}
684
685	#ifdef INET6
686	case AF_INET6:
687	{
688	struct sockaddr_in6 sin6; /* use static var for safety */
689	int niflags = 0;
690
691	memset(&sin6, 0, sizeof(sin6));
692	memcpy(&sin6, sa, sa->sa_len);
693	sin6.sin6_len = sizeof(struct sockaddr_in6);
694	sin6.sin6_family = AF_INET6;
695	#ifdef __KAME__
696	if (sa->sa_len == sizeof(struct sockaddr_in6) &&
697	(IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr) \|\|
698	IN6_IS_ADDR_MC_LINKLOCAL(&sin6.sin6_addr) \|\|
699	IN6_IS_ADDR_MC_NODELOCAL(&sin6.sin6_addr)) &&
700	sin6.sin6_scope_id == 0) {
701	sin6.sin6_scope_id =
702	ntohs((u_int16_t )&sin6.sin6_addr.s6_addr[2]);
703	sin6.sin6_addr.s6_addr[2] = 0;
704	sin6.sin6_addr.s6_addr[3] = 0;
705	}
706	#endif
707	if (c->nflag)
708	niflags \|= NI_NUMERICHOST;
709	if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
710	c->rt_line, sizeof(c->rt_line), NULL, 0, niflags) != 0)
711	strncpy(c->rt_line, "invalid", sizeof(c->rt_line));
712
713	return(c->rt_line);
714	}
715	#endif
716
717	case AF_APPLETALK:
718	(void) snprintf(c->rt_line, sizeof(c->rt_line), "atalk %s",
719	atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr, atalk_buf));
720	break;
721
722	case AF_LINK:
723	return (link_ntoa((struct sockaddr_dl *)sa));
724
725	default:
726	{
727	u_short sp = (u_short )sa;
728	u_short *splim = sp + ((sa->sa_len + 1) >> 1);
729	char *cps = c->rt_line + sprintf(c->rt_line, "(%d)", sa->sa_family);
730	char *cpe = c->rt_line + sizeof(c->rt_line);
731
732	while (++sp < splim && cps < cpe) /* start with sa->sa_data */
733	if ((n = snprintf(cps, cpe - cps, " %x", *sp)) > 0)
734	cps += n;
735	else
736	*cps = '\0';
737	break;
738	}
739	}
740	return (c->rt_line);
741	}
742
743	/*
744	* Return the name of the network whose address is given.
745	* The address is assumed to be that of a net or subnet, not a host.
746	*/
747	const char *
748	netname(struct rt_ctx c, struct sockaddr sa)
749	{
750	const char *cp = NULL;
751	char atalk_buf[20];
752	struct netent *np = NULL;
753	u_long net, mask;
754	u_long i;
755	int n, subnetshift;
756
757	switch (sa->sa_family) {
758
759	case AF_INET:
760	{ struct in_addr in;
761	in = ((struct sockaddr_in *)sa)->sin_addr;
762
763	i = in.s_addr = ntohl(in.s_addr);
764	if (in.s_addr == 0)
765	cp = "default";
766	else if (!c->nflag) {
767	if (IN_CLASSA(i)) {
768	mask = IN_CLASSA_NET;
769	subnetshift = 8;
770	} else if (IN_CLASSB(i)) {
771	mask = IN_CLASSB_NET;
772	subnetshift = 8;
773	} else {
774	mask = IN_CLASSC_NET;
775	subnetshift = 4;
776	}
777	/*
778	* If there are more bits than the standard mask
779	* would suggest, subnets must be in use.
780	* Guess at the subnet mask, assuming reasonable
781	* width subnet fields.
782	*/
783	while (in.s_addr &~ mask)
784	mask = (long)mask >> subnetshift;
785	net = in.s_addr & mask;
786	while ((mask & 1) == 0)
787	mask >>= 1, net >>= 1;
788	np = getnetbyaddr(net, AF_INET);
789	if (np != NULL)
790	cp = np->n_name;
791	}
792	#define C(x) (unsigned)((x) & 0xff)
793	if (cp != NULL)
794	strncpy(c->net_line, cp, sizeof(c->net_line));
795	else if ((in.s_addr & 0xffffff) == 0)
796	(void) sprintf(c->net_line, "%u", C(in.s_addr >> 24));
797	else if ((in.s_addr & 0xffff) == 0)
798	(void) sprintf(c->net_line, "%u.%u", C(in.s_addr >> 24),
799	C(in.s_addr >> 16));
800	else if ((in.s_addr & 0xff) == 0)
801	(void) sprintf(c->net_line, "%u.%u.%u", C(in.s_addr >> 24),
802	C(in.s_addr >> 16), C(in.s_addr >> 8));
803	else
804	(void) sprintf(c->net_line, "%u.%u.%u.%u", C(in.s_addr >> 24),
805	C(in.s_addr >> 16), C(in.s_addr >> 8),
806	C(in.s_addr));
807	#undef C
808	break;
809	}
810
811	#ifdef INET6
812	case AF_INET6:
813	{
814	struct sockaddr_in6 sin6; /* use static var for safety */
815	int niflags = 0;
816
817	memset(&sin6, 0, sizeof(sin6));
818	memcpy(&sin6, sa, sa->sa_len);
819	sin6.sin6_len = sizeof(struct sockaddr_in6);
820	sin6.sin6_family = AF_INET6;
821	#ifdef __KAME__
822	if (sa->sa_len == sizeof(struct sockaddr_in6) &&
823	(IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr) \|\|
824	IN6_IS_ADDR_MC_LINKLOCAL(&sin6.sin6_addr) \|\|
825	IN6_IS_ADDR_MC_NODELOCAL(&sin6.sin6_addr)) &&
826	sin6.sin6_scope_id == 0) {
827	sin6.sin6_scope_id =
828	ntohs((u_int16_t )&sin6.sin6_addr.s6_addr[2]);
829	sin6.sin6_addr.s6_addr[2] = 0;
830	sin6.sin6_addr.s6_addr[3] = 0;
831	}
832	#endif
833	if (c->nflag)
834	niflags \|= NI_NUMERICHOST;
835	if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
836	c->net_line, sizeof(c->net_line), NULL, 0, niflags) != 0)
837	strncpy(c->net_line, "invalid", sizeof(c->net_line));
838
839	return(c->net_line);
840	}
841	#endif
842
843	case AF_APPLETALK:
844	(void) snprintf(c->net_line, sizeof(c->net_line), "atalk %s",
845	atalk_ntoa(((struct sockaddr_at *)sa)->sat_addr, atalk_buf));
846	break;
847
848	case AF_LINK:
849	return (link_ntoa((struct sockaddr_dl *)sa));
850
851
852	default:
853	{
854	u_short sp = (u_short )sa->sa_data;
855	u_short *splim = sp + ((sa->sa_len + 1)>>1);
856	char *cps = c->net_line + sprintf(c->net_line, "af %d:", sa->sa_family);
857	char *cpe = c->net_line + sizeof(c->net_line);
858
859	while (sp < splim && cps < cpe)
860	if ((n = snprintf(cps, cpe - cps, " %x", *sp++)) > 0)
861	cps += n;
862	else
863	*cps = '\0';
864	break;
865	}
866	}
867	return (c->net_line);
868	}
869
870	static void
871	set_metric(struct rt_ctx c, char value, int key)
872	{
873	int flag = 0;
874	u_long noval, *valp = &noval;
875
876	switch (key) {
877	#define caseof(x, y, z) case x: valp = &c->rt_metrics.z; flag = y; break
878	caseof(K_MTU, RTV_MTU, rmx_mtu);
879	caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount);
880	caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire);
881	caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe);
882	caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe);
883	caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh);
884	caseof(K_RTT, RTV_RTT, rmx_rtt);
885	caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar);
886	caseof(K_WEIGHT, RTV_WEIGHT, rmx_weight);
887	}
888	c->rtm_inits \|= flag;
889	if (c->lockrest \|\| c->locking)
890	c->rt_metrics.rmx_locks \|= flag;
891	if (c->locking)
892	c->locking = 0;
893	*valp = atoi(value);
894	}
895
896	#define F_ISHOST 0x01
897	#define F_FORCENET 0x02
898	#define F_FORCEHOST 0x04
899	#define F_PROXY 0x08
900	#define F_INTERFACE 0x10
901
902	static void
903	newroute(struct rt_ctx c, int argc, char *argv)
904	{
905	struct hostent *hp;
906	struct fibl *fl;
907	char *cmd;
908	const char dest, gateway, *errmsg;
909	int key, error, flags, nrflags, fibnum;
910
911	if (c->uid != 0) {
912	errx(EX_NOPERM, "must be root to alter routing table");
913	}
914
915	dest = NULL;
916	gateway = NULL;
917	flags = RTF_STATIC;
918	nrflags = 0;
919	hp = NULL;
920	TAILQ_INIT(&c->fibl_head);
921
922	cmd = argv[0];
923	if (cmd != 'g' && cmd != 's')
924	shutdown(c->s, SHUT_RD); /* Don't want to read back our messages */
925
926	while (--argc > 0) {
927	if (**(++argv)== '-') {
928	switch (key = keyword(1 + *argv)) {
929	case K_LINK:
930	c->af = AF_LINK;
931	c->aflen = sizeof(struct sockaddr_dl);
932	break;
933	case K_4:
934	case K_INET:
935	c->af = AF_INET;
936	c->aflen = sizeof(struct sockaddr_in);
937	break;
938	#ifdef INET6
939	case K_6:
940	case K_INET6:
941	c->af = AF_INET6;
942	c->aflen = sizeof(struct sockaddr_in6);
943	break;
944	#endif
945	case K_ATALK:
946	c->af = AF_APPLETALK;
947	c->aflen = sizeof(struct sockaddr_at);
948	break;
949	case K_SA:
950	c->af = PF_ROUTE;
951	c->aflen = sizeof(union sockunion);
952	break;
953	case K_IFACE:
954	case K_INTERFACE:
955	nrflags \|= F_INTERFACE;
956	break;
957	case K_NOSTATIC:
958	flags &= ~RTF_STATIC;
959	break;
960	case K_LOCK:
961	c->locking = 1;
962	break;
963	case K_LOCKREST:
964	c->lockrest = 1;
965	break;
966	case K_HOST:
967	nrflags \|= F_FORCEHOST;
968	break;
969	case K_REJECT:
970	flags \|= RTF_REJECT;
971	break;
972	case K_BLACKHOLE:
973	flags \|= RTF_BLACKHOLE;
974	break;
975	case K_PROTO1:
976	flags \|= RTF_PROTO1;
977	break;
978	case K_PROTO2:
979	flags \|= RTF_PROTO2;
980	break;
981	case K_PROXY:
982	nrflags \|= F_PROXY;
983	break;
984	case K_XRESOLVE:
985	flags \|= RTF_XRESOLVE;
986	break;
987	case K_STATIC:
988	flags \|= RTF_STATIC;
989	break;
990	case K_STICKY:
991	flags \|= RTF_STICKY;
992	break;
993	case K_NOSTICK:
994	flags &= ~RTF_STICKY;
995	break;
996	case K_FIB:
997	if (!--argc)
998	usage(NULL);
999	error = fiboptlist_csv(c, *++argv, &c->fibl_head);
1000	if (error)
1001	errx(EX_USAGE,
1002	"invalid fib number: %s", *argv);
1003	break;
1004	case K_IFA:
1005	if (!--argc)
1006	usage(NULL);
1007	getaddr(c, RTA_IFA, *++argv, 0, nrflags);
1008	break;
1009	case K_IFP:
1010	if (!--argc)
1011	usage(NULL);
1012	getaddr(c, RTA_IFP, *++argv, 0, nrflags);
1013	break;
1014	case K_GENMASK:
1015	if (!--argc)
1016	usage(NULL);
1017	getaddr(c, RTA_GENMASK, *++argv, 0, nrflags);
1018	break;
1019	case K_GATEWAY:
1020	if (!--argc)
1021	usage(NULL);
1022	getaddr(c, RTA_GATEWAY, *++argv, 0, nrflags);
1023	gateway = *argv;
1024	break;
1025	case K_DST:
1026	if (!--argc)
1027	usage(NULL);
1028	if (getaddr(c, RTA_DST, *++argv, &hp, nrflags))
1029	nrflags \|= F_ISHOST;
1030	dest = *argv;
1031	break;
1032	case K_NETMASK:
1033	if (!--argc)
1034	usage(NULL);
1035	getaddr(c, RTA_NETMASK, *++argv, 0, nrflags);
1036	/* FALLTHROUGH */
1037	case K_NET:
1038	nrflags \|= F_FORCENET;
1039	break;
1040	case K_PREFIXLEN:
1041	if (!--argc)
1042	usage(NULL);
1043	if (prefixlen(c, *++argv) == -1) {
1044	nrflags &= ~F_FORCENET;
1045	nrflags \|= F_ISHOST;
1046	} else {
1047	nrflags \|= F_FORCENET;
1048	nrflags &= ~F_ISHOST;
1049	}
1050	break;
1051	case K_MTU:
1052	case K_HOPCOUNT:
1053	case K_EXPIRE:
1054	case K_RECVPIPE:
1055	case K_SENDPIPE:
1056	case K_SSTHRESH:
1057	case K_RTT:
1058	case K_RTTVAR:
1059	case K_WEIGHT:
1060	if (!--argc)
1061	usage(NULL);
1062	set_metric(c, *++argv, key);
1063	break;
1064	default:
1065	usage(1+*argv);
1066	}
1067	} else {
1068	if ((c->rtm_addrs & RTA_DST) == 0) {
1069	dest = *argv;
1070	if (getaddr(c, RTA_DST, *argv, &hp, nrflags))
1071	nrflags \|= F_ISHOST;
1072	} else if ((c->rtm_addrs & RTA_GATEWAY) == 0) {
1073	gateway = *argv;
1074	getaddr(c, RTA_GATEWAY, *argv, &hp, nrflags);
1075	} else {
1076	getaddr(c, RTA_NETMASK, *argv, 0, nrflags);
1077	nrflags \|= F_FORCENET;
1078	}
1079	}
1080	}
1081
1082	if (nrflags & F_FORCEHOST) {
1083	nrflags \|= F_ISHOST;
1084	#ifdef INET6
1085	if (c->af == AF_INET6) {
1086	c->rtm_addrs &= ~RTA_NETMASK;
1087	memset((void *)&c->so_mask, 0, sizeof(c->so_mask));
1088	}
1089	#endif
1090	}
1091	if (nrflags & F_FORCENET)
1092	nrflags &= ~F_ISHOST;
1093	flags \|= RTF_UP;
1094	if (nrflags & F_ISHOST)
1095	flags \|= RTF_HOST;
1096	if ((nrflags & F_INTERFACE) == 0)
1097	flags \|= RTF_GATEWAY;
1098	if (nrflags & F_PROXY) {
1099	c->so_dst.sinarp.sin_other = SIN_PROXY;
1100	flags \|= RTF_ANNOUNCE;
1101	}
1102	if (dest == NULL)
1103	dest = "";
1104	if (gateway == NULL)
1105	gateway = "";
1106
1107	if (TAILQ_EMPTY(&c->fibl_head)) {
1108	error = fiboptlist_csv(c, "default", &c->fibl_head);
1109	if (error)
1110	errx(EX_OSERR, "fiboptlist_csv failed.");
1111	}
1112	error = 0;
1113	TAILQ_FOREACH(fl, &c->fibl_head, fl_next) {
1114	fl->fl_error = newroute_fib(c, fl->fl_num, cmd, flags);
1115	if (fl->fl_error)
1116	fl->fl_errno = errno;
1117	error += fl->fl_error;
1118	}
1119	if (cmd == 'g' \|\| cmd == 's')
1120	exit(error);
1121
1122	error = 0;
1123	if (!c->qflag) {
1124	fibnum = 0;
1125	TAILQ_FOREACH(fl, &c->fibl_head, fl_next) {
1126	if (fl->fl_error == 0)
1127	fibnum++;
1128	}
1129	if (fibnum > 0) {
1130	int firstfib = 1;
1131
1132	printf("%s %s %s", cmd,
1133	(nrflags & F_ISHOST) ? "host" : "net", dest);
1134	if (*gateway)
1135	printf(": gateway %s", gateway);
1136
1137	if (c->numfibs > 1) {
1138	TAILQ_FOREACH(fl, &c->fibl_head, fl_next) {
1139	if (fl->fl_error == 0
1140	&& fl->fl_num >= 0) {
1141	if (firstfib) {
1142	printf(" fib ");
1143	firstfib = 0;
1144	}
1145	printf("%d", fl->fl_num);
1146	if (fibnum-- > 1)
1147	printf(",");
1148	}
1149	}
1150	}
1151	printf("\n");
1152	}
1153
1154	fibnum = 0;
1155	TAILQ_FOREACH(fl, &c->fibl_head, fl_next) {
1156	if (fl->fl_error != 0) {
1157	printf("%s %s %s", cmd, (nrflags & F_ISHOST)
1158	? "host" : "net", dest);
1159	if (*gateway)
1160	printf(": gateway %s", gateway);
1161
1162	if (fl->fl_num >= 0)
1163	printf(" fib %d", fl->fl_num);
1164
1165	switch (fl->fl_errno) {
1166	case ESRCH:
1167	errmsg = "not in table";
1168	break;
1169	case EBUSY:
1170	errmsg = "entry in use";
1171	break;
1172	case ENOBUFS:
1173	errmsg = "not enough memory";
1174	break;
1175	case EADDRINUSE:
1176	/*
1177	* handle recursion avoidance
1178	* in rt_setgate()
1179	*/
1180	errmsg = "gateway uses the same route";
1181	break;
1182	case EEXIST:
1183	errmsg = "route already in table";
1184	break;
1185	default:
1186	errmsg = strerror(fl->fl_errno);
1187	break;
1188	}
1189	printf(": %s\n", errmsg);
1190	error = 1;
1191	}
1192	}
1193	}
1194	exit(error);
1195	}
1196
1197	static int
1198	newroute_fib(struct rt_ctx c, int fib, char cmd, int flags)
1199	{
1200	int error;
1201
1202	error = set_sofib(c, fib);
1203	if (error) {
1204	warn("fib number %d is ignored", fib);
1205	return (error);
1206	}
1207
1208	error = rtmsg(c, *cmd, flags, fib);
1209	return (error);
1210	}
1211
1212	static void
1213	inet_makenetandmask(struct rt_ctx c, u_long net, struct sockaddr_in sin, u_long bits)
1214	{
1215	u_long addr, mask = 0;
1216	char *cp;
1217
1218	c->rtm_addrs \|= RTA_NETMASK;
1219	/*
1220	* XXX: This approach unable to handle 0.0.0.1/32 correctly
1221	* as inet_network() converts 0.0.0.1 and 1 equally.
1222	*/
1223	if (net <= 0xff)
1224	addr = net << IN_CLASSA_NSHIFT;
1225	else if (net <= 0xffff)
1226	addr = net << IN_CLASSB_NSHIFT;
1227	else if (net <= 0xffffff)
1228	addr = net << IN_CLASSC_NSHIFT;
1229	else
1230	addr = net;
1231	/*
1232	* If no /xx was specified we must calculate the
1233	* CIDR address.
1234	*/
1235	if ((bits == 0) && (addr != 0)) {
1236	u_long i, j;
1237	for(i=0,j=0xff; i<4; i++) {
1238	if (addr & j) {
1239	break;
1240	}
1241	j <<= 8;
1242	}
1243	/* i holds the first non zero bit */
1244	bits = 32 - (i*8);
1245	}
1246	if (bits != 0)
1247	mask = 0xffffffff << (32 - bits);
1248
1249	sin->sin_addr.s_addr = htonl(addr);
1250	sin = &c->so_mask.sin;
1251	sin->sin_addr.s_addr = htonl(mask);
1252	sin->sin_len = 0;
1253	sin->sin_family = 0;
1254	cp = (char *)(&sin->sin_addr + 1);
1255	while (--cp == 0 && cp > (char )sin)
1256	;
1257	sin->sin_len = 1 + cp - (char *)sin;
1258	}
1259
1260	#ifdef INET6
1261	/*
1262	* XXX the function may need more improvement...
1263	*/
1264	static int
1265	inet6_makenetandmask(struct rt_ctx c, struct sockaddr_in6 sin6, const char *plen)
1266	{
1267	struct in6_addr in6;
1268
1269	if (plen == NULL) {
1270	if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
1271	sin6->sin6_scope_id == 0) {
1272	plen = "0";
1273	} else if ((sin6->sin6_addr.s6_addr[0] & 0xe0) == 0x20) {
1274	/* aggregatable global unicast - RFC2374 */
1275	memset(&in6, 0, sizeof(in6));
1276	if (!memcmp(&sin6->sin6_addr.s6_addr[8],
1277	&in6.s6_addr[8], 8))
1278	plen = "64";
1279	}
1280	}
1281
1282	if (plen == NULL \|\| strcmp(plen, "128") == 0)
1283	return (1);
1284	c->rtm_addrs \|= RTA_NETMASK;
1285	prefixlen(c, plen);
1286	return (0);
1287	}
1288	#endif
1289
1290	/*
1291	* Interpret an argument as a network address of some kind,
1292	* returning 1 if a host address, 0 if a network address.
1293	*/
1294	static int
1295	getaddr(struct rt_ctx c, int which, char str, struct hostent **hpp, int nrflags)
1296	{
1297	sup su;
1298	struct hostent *hp;
1299	struct netent *np;
1300	u_long val;
1301	char *q;
1302	int afamily; /* local copy of af so we can change it */
1303
1304	if (c->af == 0) {
1305	c->af = AF_INET;
1306	c->aflen = sizeof(struct sockaddr_in);
1307	}
1308	afamily = c->af;
1309	c->rtm_addrs \|= which;
1310	switch (which) {
1311	case RTA_DST:
1312	su = &c->so_dst;
1313	break;
1314	case RTA_GATEWAY:
1315	su = &c->so_gate;
1316	if (nrflags & F_INTERFACE) {
1317	struct ifaddrs ifap, ifa;
1318	struct sockaddr_dl *sdl = NULL;
1319
1320	if (getifaddrs(&ifap))
1321	err(1, "getifaddrs");
1322
1323	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
1324	if (ifa->ifa_addr->sa_family != AF_LINK)
1325	continue;
1326
1327	if (strcmp(str, ifa->ifa_name) != 0)
1328	continue;
1329
1330	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
1331	}
1332	/* If we found it, then use it */
1333	if (sdl != NULL) {
1334	/*
1335	* Copy is safe since we have a
1336	* sockaddr_storage member in sockunion{}.
1337	* Note that we need to copy before calling
1338	* freeifaddrs().
1339	*/
1340	memcpy(&su->sdl, sdl, sdl->sdl_len);
1341	}
1342	freeifaddrs(ifap);
1343	if (sdl != NULL)
1344	return(1);
1345	}
1346	break;
1347	case RTA_NETMASK:
1348	su = &c->so_mask;
1349	break;
1350	case RTA_GENMASK:
1351	su = &c->so_genmask;
1352	break;
1353	case RTA_IFP:
1354	su = &c->so_ifp;
1355	afamily = AF_LINK;
1356	break;
1357	case RTA_IFA:
1358	su = &c->so_ifa;
1359	break;
1360	default:
1361	usage("internal error");
1362	/NOTREACHED/
1363	}
1364	su->sa.sa_len = c->aflen;
1365	su->sa.sa_family = afamily; /* cases that don't want it have left already */
1366	if (strcmp(str, "default") == 0) {
1367	/*
1368	* Default is net 0.0.0.0/0
1369	*/
1370	switch (which) {
1371	case RTA_DST:
1372	c->forcenet++;
1373	#if 0
1374	bzero(su, sizeof(su)); / for readability */
1375	#endif
1376	getaddr(c, RTA_NETMASK, str, 0, nrflags);
1377	break;
1378	#if 0
1379	case RTA_NETMASK:
1380	case RTA_GENMASK:
1381	bzero(su, sizeof(su)); / for readability */
1382	#endif
1383	}
1384	return (0);
1385	}
1386	switch (afamily) {
1387	#ifdef INET6
1388	case AF_INET6:
1389	{
1390	struct addrinfo hints, *res;
1391	int ecode;
1392
1393	q = NULL;
1394	if (which == RTA_DST && (q = strchr(str, '/')) != NULL)
1395	*q = '\0';
1396	memset(&hints, 0, sizeof(hints));
1397	hints.ai_family = afamily; /AF_INET6/
1398	hints.ai_socktype = SOCK_DGRAM; /dummy/
1399	ecode = getaddrinfo(str, NULL, &hints, &res);
1400	if (ecode != 0 \|\| res->ai_family != AF_INET6 \|\|
1401	res->ai_addrlen != sizeof(su->sin6)) {
1402	(void) fprintf(stderr, "%s: %s\n", str,
1403	gai_strerror(ecode));
1404	exit(1);
1405	}
1406	memcpy(&su->sin6, res->ai_addr, sizeof(su->sin6));
1407	#ifdef __KAME__
1408	if ((IN6_IS_ADDR_LINKLOCAL(&su->sin6.sin6_addr) \|\|
1409	IN6_IS_ADDR_MC_LINKLOCAL(&su->sin6.sin6_addr) \|\|
1410	IN6_IS_ADDR_MC_NODELOCAL(&su->sin6.sin6_addr)) &&
1411	su->sin6.sin6_scope_id) {
1412	(u_int16_t )&su->sin6.sin6_addr.s6_addr[2] =
1413	htons(su->sin6.sin6_scope_id);
1414	su->sin6.sin6_scope_id = 0;
1415	}
1416	#endif
1417	freeaddrinfo(res);
1418	if (q != NULL)
1419	*q++ = '/';
1420	if (which == RTA_DST)
1421	return (inet6_makenetandmask(c, &su->sin6, q));
1422	return (0);
1423	}
1424	#endif /* INET6 */
1425
1426	case AF_APPLETALK:
1427	if (!atalk_aton(str, &su->sat.sat_addr))
1428	errx(EX_NOHOST, "bad address: %s", str);
1429	c->rtm_addrs \|= RTA_NETMASK;
1430	return(c->forcehost \|\| su->sat.sat_addr.s_node != 0);
1431
1432	case AF_LINK:
1433	link_addr(str, &su->sdl);
1434	return (1);
1435
1436
1437	case PF_ROUTE:
1438	su->sa.sa_len = sizeof(*su);
1439	sockaddr(str, &su->sa);
1440	return (1);
1441
1442	case AF_INET:
1443	default:
1444	break;
1445	}
1446
1447	if (hpp == NULL)
1448	hpp = &hp;
1449	*hpp = NULL;
1450
1451	q = strchr(str,'/');
1452	if (q != NULL && which == RTA_DST) {
1453	*q = '\0';
1454	if ((val = inet_network(str)) != INADDR_NONE) {
1455	inet_makenetandmask(
1456	c, val, &su->sin, strtoul(q+1, 0, 0));
1457	return (0);
1458	}
1459	*q = '/';
1460	}
1461	if ((which != RTA_DST \|\| c->forcenet == 0) &&
1462	inet_aton(str, &su->sin.sin_addr)) {
1463	val = su->sin.sin_addr.s_addr;
1464	if (which != RTA_DST \|\| c->forcehost \|\|
1465	inet_lnaof(su->sin.sin_addr) != INADDR_ANY)
1466	return (1);
1467	else {
1468	val = ntohl(val);
1469	goto netdone;
1470	}
1471	}
1472	if (which == RTA_DST && c->forcehost == 0 &&
1473	((val = inet_network(str)) != INADDR_NONE \|\|
1474	((np = getnetbyname(str)) != NULL && (val = np->n_net) != 0))) {
1475	netdone:
1476	inet_makenetandmask(c, val, &su->sin, 0);
1477	return (0);
1478	}
1479	hp = gethostbyname(str);
1480	if (hp != NULL) {
1481	*hpp = hp;
1482	su->sin.sin_family = hp->h_addrtype;
1483	memmove((char *)&su->sin.sin_addr, hp->h_addr,
1484	MIN((size_t)hp->h_length, sizeof(su->sin.sin_addr)));
1485	return (1);
1486	}
1487	errx(EX_NOHOST, "bad address: %s", str);
1488	}
1489
1490	static int
1491	prefixlen(struct rt_ctx c, const char str)
1492	{
1493	int len = atoi(str), q, r;
1494	int max;
1495	char *p;
1496
1497	c->rtm_addrs \|= RTA_NETMASK;
1498	switch (c->af) {
1499	#ifdef INET6
1500	case AF_INET6:
1501	max = 128;
1502	p = (char *)&c->so_mask.sin6.sin6_addr;
1503	break;
1504	#endif
1505	case AF_INET:
1506	max = 32;
1507	p = (char *)&c->so_mask.sin.sin_addr;
1508	break;
1509	default:
1510	fprintf(stderr, "prefixlen not supported in this af\n");
1511	exit(1);
1512	}
1513
1514	if (len < 0 \|\| max < len) {
1515	fprintf(stderr, "%s: bad value\n", str);
1516	exit(1);
1517	}
1518
1519	q = len >> 3;
1520	r = len & 7;
1521	c->so_mask.sa.sa_family = c->af;
1522	c->so_mask.sa.sa_len = c->aflen;
1523	memset((void *)p, 0, max / 8);
1524	if (q > 0)
1525	memset((void *)p, 0xff, q);
1526	if (r > 0)
1527	((u_char )p + q) = (0xff00 >> r) & 0xff;
1528	if (len == max)
1529	return (-1);
1530	else
1531	return (len);
1532	}
1533
1534	static void
1535	interfaces(struct rt_ctx *c)
1536	{
1537	size_t needed;
1538	int mib[6];
1539	char buf, lim, *next, count = 0;
1540	struct rt_msghdr *rtm;
1541
1542	retry2:
1543	mib[0] = CTL_NET;
1544	mib[1] = PF_ROUTE;
1545	mib[2] = 0; /* protocol */
1546	mib[3] = 0; /* wildcard address family */
1547	mib[4] = NET_RT_IFLIST;
1548	mib[5] = 0; /* no flags */
1549	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
1550	err(EX_OSERR, "route-sysctl-estimate");
1551	if ((buf = malloc(needed)) == NULL && needed != 0)
1552	errx(EX_OSERR, "malloc failed");
1553	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
1554	if (errno == ENOMEM && count++ < 10) {
1555	warnx("Routing table grew, retrying");
1556	sleep(1);
1557	free(buf);
1558	goto retry2;
1559	}
1560	err(EX_OSERR, "actual retrieval of interface table");
1561	}
1562	lim = buf + needed;
1563	for (next = buf; next < lim; next += rtm->rtm_msglen) {
1564	rtm = (struct rt_msghdr *)next;
1565	print_rtmsg(c, rtm, rtm->rtm_msglen);
1566	}
1567	free(buf);
1568	}
1569
1570	static void
1571	monitor(struct rt_ctx c, int argc, char argv[])
1572	{
1573	int n, fib, error;
1574	char msg[2048], *endptr;
1575
1576	fib = c->defaultfib;
1577	while (argc > 1) {
1578	argc--;
1579	argv++;
1580	if (**argv != '-')
1581	usage(*argv);
1582	switch (keyword(*argv + 1)) {
1583	case K_FIB:
1584	if (!--argc)
1585	usage(*argv);
1586	errno = 0;
1587	fib = strtol(*++argv, &endptr, 0);
1588	if (errno == 0) {
1589	if (*endptr != '\0' \|\|
1590	fib < 0 \|\|
1591	(c->numfibs != -1 && fib > c->numfibs - 1))
1592	errno = EINVAL;
1593	}
1594	if (errno)
1595	errx(EX_USAGE, "invalid fib number: %s", *argv);
1596	break;
1597	default:
1598	usage(*argv);
1599	}
1600	}
1601	error = set_sofib(c, fib);
1602	if (error)
1603	errx(EX_USAGE, "invalid fib number: %d", fib);
1604
1605	c->verbose = 1;
1606	if (c->debugonly) {
1607	interfaces(c);
1608	exit(0);
1609	}
1610	for (;;) {
1611	time_t now;
1612	n = read(c->s, msg, 2048);
1613	now = time(NULL);
1614	(void) printf("\ngot message of size %d on %s", n, ctime(&now));
1615	print_rtmsg(c, (struct rt_msghdr *)msg, n);
1616	}
1617	}
1618
1619	static int
1620	rtmsg(struct rt_ctx *c, int cmd, int flags, int fib)
1621	{
1622	int rlen;
1623	char *cp = c->m_rtmsg.m_space;
1624	int l;
1625
1626	#define NEXTADDR(w, u) \
1627	if (c->rtm_addrs & (w)) {\
1628	l = SA_SIZE(&(u.sa)); memmove(cp, &(u), l); cp += l;\
1629	if (c->verbose) sodump(&(u),#u);\
1630	}
1631
1632	errno = 0;
1633	memset(&c->m_rtmsg, 0, sizeof(c->m_rtmsg));
1634	if (cmd == 'a')
1635	cmd = RTM_ADD;
1636	else if (cmd == 'c')
1637	cmd = RTM_CHANGE;
1638	else if (cmd == 'g' \|\| cmd == 's') {
1639	cmd = RTM_GET;
1640	if (c->so_ifp.sa.sa_family == 0) {
1641	c->so_ifp.sa.sa_family = AF_LINK;
1642	c->so_ifp.sa.sa_len = sizeof(struct sockaddr_dl);
1643	c->rtm_addrs \|= RTA_IFP;
1644	}
1645	} else
1646	cmd = RTM_DELETE;
1647	#define rtm c->m_rtmsg.m_rtm
1648	rtm.rtm_type = cmd;
1649	rtm.rtm_flags = flags;
1650	rtm.rtm_version = RTM_VERSION;
1651	rtm.rtm_seq = ++c->rtm_seq;
1652	rtm.rtm_addrs = c->rtm_addrs;
1653	rtm.rtm_rmx = c->rt_metrics;
1654	rtm.rtm_inits = c->rtm_inits;
1655
1656	if (c->rtm_addrs & RTA_NETMASK)
1657	mask_addr(c);
1658	NEXTADDR(RTA_DST, c->so_dst);
1659	NEXTADDR(RTA_GATEWAY, c->so_gate);
1660	NEXTADDR(RTA_NETMASK, c->so_mask);
1661	NEXTADDR(RTA_GENMASK, c->so_genmask);
1662	NEXTADDR(RTA_IFP, c->so_ifp);
1663	NEXTADDR(RTA_IFA, c->so_ifa);
1664	rtm.rtm_msglen = l = cp - (char *)&c->m_rtmsg;
1665	if (c->verbose)
1666	print_rtmsg(c, &rtm, l);
1667	if (c->debugonly)
1668	return (0);
1669	if ((rlen = write(c->s, (char *)&c->m_rtmsg, l)) < 0) {
1670	if (errno == EPERM)
1671	err(1, "writing to routing socket");
1672	warn("writing to routing socket");
1673	return (-1);
1674	}
1675	if (cmd == RTM_GET) {
1676	do {
1677	l = read(c->s, (char *)&c->m_rtmsg, sizeof(c->m_rtmsg));
1678	} while (l > 0 && (rtm.rtm_seq != c->rtm_seq \|\| rtm.rtm_pid != c->pid));
1679	if (l < 0)
1680	warn("read from routing socket");
1681	else
1682	print_getmsg(c, &rtm, l, fib);
1683	}
1684	#undef rtm
1685	return (0);
1686	}
1687
1688	static void
1689	mask_addr(struct rt_ctx *c)
1690	{
1691	int olen = c->so_mask.sa.sa_len;
1692	char cp1 = olen + (char )&c->so_mask, *cp2;
1693
1694	for (c->so_mask.sa.sa_len = 0; cp1 > (char *)&c->so_mask; )
1695	if (*--cp1 != 0) {
1696	c->so_mask.sa.sa_len = 1 + cp1 - (char *)&c->so_mask;
1697	break;
1698	}
1699	if ((c->rtm_addrs & RTA_DST) == 0)
1700	return;
1701	switch (c->so_dst.sa.sa_family) {
1702	case AF_INET:
1703	#ifdef INET6
1704	case AF_INET6:
1705	#endif
1706	case AF_APPLETALK:
1707	case 0:
1708	return;
1709	}
1710	cp1 = c->so_mask.sa.sa_len + 1 + (char *)&c->so_dst;
1711	cp2 = c->so_dst.sa.sa_len + 1 + (char *)&c->so_dst;
1712	while (cp2 > cp1)
1713	*--cp2 = 0;
1714	cp2 = c->so_mask.sa.sa_len + 1 + (char *)&c->so_mask;
1715	while (cp1 > c->so_dst.sa.sa_data)
1716	--cp1 &= --cp2;
1717	}
1718
1719	static const char *const msgtypes[] = {
1720	"",
1721	"RTM_ADD: Add Route",
1722	"RTM_DELETE: Delete Route",
1723	"RTM_CHANGE: Change Metrics or flags",
1724	"RTM_GET: Report Metrics",
1725	"RTM_LOSING: Kernel Suspects Partitioning",
1726	"RTM_REDIRECT: Told to use different route",
1727	"RTM_MISS: Lookup failed on this address",
1728	"RTM_LOCK: fix specified metrics",
1729	"RTM_OLDADD: caused by SIOCADDRT",
1730	"RTM_OLDDEL: caused by SIOCDELRT",
1731	"RTM_RESOLVE: Route created by cloning",
1732	"RTM_NEWADDR: address being added to iface",
1733	"RTM_DELADDR: address being removed from iface",
1734	"RTM_IFINFO: iface status change",
1735	"RTM_NEWMADDR: new multicast group membership on iface",
1736	"RTM_DELMADDR: multicast group membership removed from iface",
1737	"RTM_IFANNOUNCE: interface arrival/departure",
1738	"RTM_IEEE80211: IEEE 802.11 wireless event",
1739	};
1740
1741	static const char metricnames[] =
1742	"\011weight\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire"
1743	"\1mtu";
1744	static const char routeflags[] =
1745	"\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE"
1746	"\012XRESOLVE\013LLINFO\014STATIC\015BLACKHOLE"
1747	"\017PROTO2\020PROTO1\021PRCLONING\022WASCLONED\023PROTO3"
1748	"\025PINNED\026LOCAL\027BROADCAST\030MULTICAST\035STICKY";
1749	static const char ifnetflags[] =
1750	"\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6b6\7RUNNING\010NOARP"
1751	"\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1"
1752	"\017LINK2\020MULTICAST";
1753	static const char addrnames[] =
1754	"\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD";
1755
1756	static const char errfmt[] =
1757	"\n%s: truncated route message, only %zu bytes left\n";
1758
1759	static void
1760	print_rtmsg(struct rt_ctx c, struct rt_msghdr rtm, size_t msglen)
1761	{
1762	struct if_msghdr *ifm;
1763	struct ifa_msghdr *ifam;
1764	#ifdef RTM_NEWMADDR
1765	struct ifma_msghdr *ifmam;
1766	#endif
1767	struct if_announcemsghdr *ifan;
1768	const char *state;
1769
1770	if (c->verbose == 0)
1771	return;
1772	if (rtm->rtm_version != RTM_VERSION) {
1773	(void) printf("routing message version %d not understood\n",
1774	rtm->rtm_version);
1775	return;
1776	}
1777	if (rtm->rtm_type < sizeof(msgtypes) / sizeof(msgtypes[0]))
1778	(void)printf("%s: ", msgtypes[rtm->rtm_type]);
1779	else
1780	(void)printf("unknown type %d: ", rtm->rtm_type);
1781	(void)printf("len %d, ", rtm->rtm_msglen);
1782
1783	#define REQUIRE(x) do { \
1784	if (msglen < sizeof(x)) \
1785	goto badlen; \
1786	else \
1787	msglen -= sizeof(x); \
1788	} while (0)
1789
1790	switch (rtm->rtm_type) {
1791	case RTM_IFINFO:
1792	REQUIRE(struct if_msghdr);
1793	ifm = (struct if_msghdr *)rtm;
1794	(void) printf("if# %d, ", ifm->ifm_index);
1795	switch (ifm->ifm_data.ifi_link_state) {
1796	case LINK_STATE_DOWN:
1797	state = "down";
1798	break;
1799	case LINK_STATE_UP:
1800	state = "up";
1801	break;
1802	default:
1803	state = "unknown";
1804	break;
1805	}
1806	(void) printf("link: %s, flags:", state);
1807	bprintf(stdout, ifm->ifm_flags, ifnetflags);
1808	pmsg_addrs(c, (char *)(ifm + 1), ifm->ifm_addrs, msglen);
1809	break;
1810	case RTM_NEWADDR:
1811	case RTM_DELADDR:
1812	REQUIRE(struct ifa_msghdr);
1813	ifam = (struct ifa_msghdr *)rtm;
1814	(void) printf("metric %d, flags:", ifam->ifam_metric);
1815	bprintf(stdout, ifam->ifam_flags, routeflags);
1816	pmsg_addrs(c, (char *)(ifam + 1), ifam->ifam_addrs, msglen);
1817	break;
1818	#ifdef RTM_NEWMADDR
1819	case RTM_NEWMADDR:
1820	case RTM_DELMADDR:
1821	REQUIRE(struct ifma_msghdr);
1822	ifmam = (struct ifma_msghdr *)rtm;
1823	pmsg_addrs(c, (char *)(ifmam + 1), ifmam->ifmam_addrs, msglen);
1824	break;
1825	#endif
1826	case RTM_IFANNOUNCE:
1827	REQUIRE(struct if_announcemsghdr);
1828	ifan = (struct if_announcemsghdr *)rtm;
1829	(void) printf("if# %d, what: ", ifan->ifan_index);
1830	switch (ifan->ifan_what) {
1831	case IFAN_ARRIVAL:
1832	printf("arrival");
1833	break;
1834	case IFAN_DEPARTURE:
1835	printf("departure");
1836	break;
1837	default:
1838	printf("#%d", ifan->ifan_what);
1839	break;
1840	}
1841	printf("\n");
1842	fflush(stdout);
1843	break;
1844
1845	default:
1846	(void) printf("pid: %ld, seq %d, errno %d, flags:",
1847	(long)rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno);
1848	bprintf(stdout, rtm->rtm_flags, routeflags);
1849	pmsg_common(c, rtm, msglen);
1850	}
1851
1852	return;
1853
1854	badlen:
1855	(void)printf(errfmt, __func__, msglen);
1856	#undef REQUIRE
1857	}
1858
1859	static void
1860	print_getmsg(struct rt_ctx c, struct rt_msghdr rtm, int msglen, int fib)
1861	{
1862	struct sockaddr dst = NULL, gate = NULL, *mask = NULL;
1863	struct sockaddr_dl *ifp = NULL;
1864	struct sockaddr *sa;
1865	char *cp;
1866	int i;
1867
1868	(void) printf(" route to: %s\n",
1869	routename(c, (struct sockaddr *)&c->so_dst));
1870	if (rtm->rtm_version != RTM_VERSION) {
1871	warnx("routing message version %d not understood",
1872	rtm->rtm_version);
1873	return;
1874	}
1875	if (rtm->rtm_msglen > msglen) {
1876	warnx("message length mismatch, in packet %d, returned %d",
1877	rtm->rtm_msglen, msglen);
1878	}
1879	if (rtm->rtm_errno) {
1880	errno = rtm->rtm_errno;
1881	warn("message indicates error %d", errno);
1882	return;
1883	}
1884	cp = ((char *)(rtm + 1));
1885	if (rtm->rtm_addrs)
1886	for (i = 1; i; i <<= 1)
1887	if (i & rtm->rtm_addrs) {
1888	sa = (struct sockaddr *)cp;
1889	switch (i) {
1890	case RTA_DST:
1891	dst = sa;
1892	break;
1893	case RTA_GATEWAY:
1894	gate = sa;
1895	break;
1896	case RTA_NETMASK:
1897	mask = sa;
1898	break;
1899	case RTA_IFP:
1900	if (sa->sa_family == AF_LINK &&
1901	((struct sockaddr_dl *)sa)->sdl_nlen)
1902	ifp = (struct sockaddr_dl *)sa;
1903	break;
1904	}
1905	cp += SA_SIZE(sa);
1906	}
1907	if (dst && mask)
1908	mask->sa_family = dst->sa_family; /* XXX */
1909	if (dst)
1910	(void)printf("destination: %s\n", routename(c, dst));
1911	if (mask) {
1912	int savenflag = c->nflag;
1913
1914	c->nflag = 1;
1915	(void)printf(" mask: %s\n", routename(c, mask));
1916	c->nflag = savenflag;
1917	}
1918	if (gate && rtm->rtm_flags & RTF_GATEWAY)
1919	(void)printf(" gateway: %s\n", routename(c, gate));
1920	if (fib >= 0)
1921	(void)printf(" fib: %u\n", (unsigned int)fib);
1922	if (ifp)
1923	(void)printf(" interface: %.*s\n",
1924	ifp->sdl_nlen, ifp->sdl_data);
1925	(void)printf(" flags: ");
1926	bprintf(stdout, rtm->rtm_flags, routeflags);
1927
1928	#define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
1929	#define msec(u) (((u) + 500) / 1000) /* usec to msec */
1930
1931	(void) printf("\n%s\n", "\
1932	recvpipe sendpipe ssthresh rtt,msec mtu weight expire");
1933	printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE));
1934	printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE));
1935	printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH));
1936	printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT));
1937	printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU));
1938	printf("%8ld%c ", rtm->rtm_rmx.rmx_weight, lock(WEIGHT));
1939	if (rtm->rtm_rmx.rmx_expire)
1940	rtm->rtm_rmx.rmx_expire -= time(0);
1941	printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE));
1942	#undef lock
1943	#undef msec
1944	#define RTA_IGN (RTA_DST\|RTA_GATEWAY\|RTA_NETMASK\|RTA_IFP\|RTA_IFA\|RTA_BRD)
1945	if (c->verbose)
1946	pmsg_common(c, rtm, msglen);
1947	else if (rtm->rtm_addrs &~ RTA_IGN) {
1948	(void) printf("sockaddrs: ");
1949	bprintf(stdout, rtm->rtm_addrs, addrnames);
1950	putchar('\n');
1951	}
1952	#undef RTA_IGN
1953	}
1954
1955	static void
1956	pmsg_common(struct rt_ctx c, struct rt_msghdr rtm, size_t msglen)
1957	{
1958	(void) printf("\nlocks: ");
1959	bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
1960	(void) printf(" inits: ");
1961	bprintf(stdout, rtm->rtm_inits, metricnames);
1962	if (msglen > sizeof(struct rt_msghdr))
1963	pmsg_addrs(c, ((char *)(rtm + 1)), rtm->rtm_addrs,
1964	msglen - sizeof(struct rt_msghdr));
1965	else
1966	(void) fflush(stdout);
1967	}
1968
1969	static void
1970	pmsg_addrs(struct rt_ctx c, char cp, int addrs, size_t len)
1971	{
1972	struct sockaddr *sa;
1973	int i;
1974
1975	if (addrs == 0) {
1976	(void) putchar('\n');
1977	return;
1978	}
1979	(void) printf("\nsockaddrs: ");
1980	bprintf(stdout, addrs, addrnames);
1981	(void) putchar('\n');
1982	for (i = 1; i != 0; i <<= 1)
1983	if (i & addrs) {
1984	sa = (struct sockaddr *)cp;
1985	if (len == 0 \|\| len < SA_SIZE(sa)) {
1986	(void) printf(errfmt, __func__, len);
1987	break;
1988	}
1989	(void) printf(" %s", routename(c, sa));
1990	len -= SA_SIZE(sa);
1991	cp += SA_SIZE(sa);
1992	}
1993	(void) putchar('\n');
1994	(void) fflush(stdout);
1995	}
1996
1997	static void
1998	bprintf(FILE fp, int b, const char sstr)
1999	{
2000	const u_char str = (const u_char ) sstr;
2001	int i;
2002	int gotsome = 0;
2003
2004	if (b == 0)
2005	return;
2006	while ((i = *str++) != 0) {
2007	if (b & (1 << (i-1))) {
2008	if (gotsome == 0)
2009	i = '<';
2010	else
2011	i = ',';
2012	(void) putc(i, fp);
2013	gotsome = 1;
2014	for (; (i = *str) > 32; str++)
2015	(void) putc(i, fp);
2016	} else
2017	while (*str > 32)
2018	str++;
2019	}
2020	if (gotsome)
2021	(void) putc('>', fp);
2022	}
2023
2024	int
2025	keyword(const char *cp)
2026	{
2027	const struct keytab *kt = keywords;
2028
2029	while (kt->kt_cp != NULL && strcmp(kt->kt_cp, cp) != 0)
2030	kt++;
2031	return (kt->kt_i);
2032	}
2033
2034	static void
2035	sodump(sup su, const char *which)
2036	{
2037	char atalk_buf[20];
2038
2039	switch (su->sa.sa_family) {
2040	case AF_LINK:
2041	(void) printf("%s: link %s; ",
2042	which, link_ntoa(&su->sdl));
2043	break;
2044	case AF_INET:
2045	(void) printf("%s: inet %s; ",
2046	which, inet_ntoa(su->sin.sin_addr));
2047	break;
2048	case AF_APPLETALK:
2049	(void) printf("%s: atalk %s; ",
2050	which, atalk_ntoa(su->sat.sat_addr, atalk_buf));
2051	break;
2052	}
2053	(void) fflush(stdout);
2054	}
2055
2056	/* States*/
2057	#define VIRGIN 0
2058	#define GOTONE 1
2059	#define GOTTWO 2
2060	/* Inputs */
2061	#define DIGIT (4*0)
2062	#define END (4*1)
2063	#define DELIM (4*2)
2064
2065	static void
2066	sockaddr(char addr, struct sockaddr sa)
2067	{
2068	char cp = (char )sa;
2069	int size = sa->sa_len;
2070	char *cplim = cp + size;
2071	int byte = 0, state = VIRGIN, new = 0 /* foil gcc */;
2072
2073	memset(cp, 0, size);
2074	cp++;
2075	do {
2076	if ((addr >= '0') && (addr <= '9')) {
2077	new = *addr - '0';
2078	} else if ((addr >= 'a') && (addr <= 'f')) {
2079	new = *addr - 'a' + 10;
2080	} else if ((addr >= 'A') && (addr <= 'F')) {
2081	new = *addr - 'A' + 10;
2082	} else if (*addr == '\0')
2083	state \|= END;
2084	else
2085	state \|= DELIM;
2086	addr++;
2087	switch (state /* \| INPUT */) {
2088	case GOTTWO \| DIGIT:
2089	cp++ = byte; /FALLTHROUGH*/
2090	case VIRGIN \| DIGIT:
2091	state = GOTONE; byte = new; continue;
2092	case GOTONE \| DIGIT:
2093	state = GOTTWO; byte = new + (byte << 4); continue;
2094	default: /* \| DELIM */
2095	state = VIRGIN; *cp++ = byte; byte = 0; continue;
2096	case GOTONE \| END:
2097	case GOTTWO \| END:
2098	cp++ = byte; / FALLTHROUGH */
2099	case VIRGIN \| END:
2100	break;
2101	}
2102	break;
2103	} while (cp < cplim);
2104	sa->sa_len = cp - (char *)sa;
2105	}
2106
2107	static int
2108	atalk_aton(const char text, struct at_addr addr)
2109	{
2110	u_int net, node;
2111
2112	if (sscanf(text, "%u.%u", &net, &node) != 2
2113	\|\| net > 0xffff \|\| node > 0xff)
2114	return(0);
2115	addr->s_net = htons(net);
2116	addr->s_node = node;
2117	return(1);
2118	}
2119
2120	static char *
2121	atalk_ntoa(struct at_addr at, char buf[20])
2122	{
2123	(void) snprintf(buf, sizeof(buf), "%u.%u", ntohs(at.s_net), at.s_node);
2124	return(buf);
2125	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: rtems-libbsd/freebsd/sbin/route/route.c @ 21abaef

Download in other formats: