Commit | Line | Data |
---|---|---|
5ff67f98 | 1 | /* |
048d388c | 2 | * |
1a010d0f KB |
3 | * Copyright (c) 1983, 1989, 1991, 1993 |
4 | * The Regents of the University of California. All rights reserved. | |
fca7493d | 5 | * |
70ab3c27 | 6 | * %sccs.include.redist.c% |
5ff67f98 DF |
7 | */ |
8 | ||
9 | #ifndef lint | |
1a010d0f KB |
10 | static char copyright[] = |
11 | "@(#) Copyright (c) 1983, 1989, 1991, 1993\n\ | |
12 | The Regents of the University of California. All rights reserved.\n"; | |
fca7493d | 13 | #endif /* not lint */ |
5ff67f98 | 14 | |
4bec325f | 15 | #ifndef lint |
1a010d0f | 16 | static char sccsid[] = "@(#)route.c 8.1 (Berkeley) %G%"; |
fca7493d | 17 | #endif /* not lint */ |
4bec325f | 18 | |
a2280e64 | 19 | #include <sys/param.h> |
79394449 | 20 | #include <sys/file.h> |
4bec325f BJ |
21 | #include <sys/socket.h> |
22 | #include <sys/ioctl.h> | |
63c817da | 23 | #include <sys/mbuf.h> |
555ca562 | 24 | #include <sys/sysctl.h> |
94a2d2a7 | 25 | |
fcf43e01 | 26 | #include <net/if.h> |
4bec325f | 27 | #include <net/route.h> |
31bd2db6 | 28 | #include <net/if_dl.h> |
94a2d2a7 | 29 | #include <netinet/in.h> |
eac76d14 | 30 | #include <netns/ns.h> |
7d5f817b | 31 | #include <netiso/iso.h> |
79394449 | 32 | #include <netccitt/x25.h> |
789bb287 | 33 | #include <arpa/inet.h> |
5c7868a2 | 34 | #include <netdb.h> |
789bb287 | 35 | |
4bec325f | 36 | #include <errno.h> |
789bb287 | 37 | #include <unistd.h> |
9494af5d | 38 | #include <stdio.h> |
789bb287 | 39 | #include <ctype.h> |
9494af5d CT |
40 | #include <stdlib.h> |
41 | #include <string.h> | |
505837c5 | 42 | #include <paths.h> |
4bec325f | 43 | |
31bd2db6 KS |
44 | struct keytab { |
45 | char *kt_cp; | |
46 | int kt_i; | |
47 | } keywords[] = { | |
48 | #include "keywords.h" | |
6a01ae04 | 49 | {0, 0} |
31bd2db6 KS |
50 | }; |
51 | ||
57cacc90 | 52 | struct ortentry route; |
31bd2db6 | 53 | union sockunion { |
7d5f817b KS |
54 | struct sockaddr sa; |
55 | struct sockaddr_in sin; | |
56 | struct sockaddr_ns sns; | |
57 | struct sockaddr_iso siso; | |
31bd2db6 | 58 | struct sockaddr_dl sdl; |
79394449 | 59 | struct sockaddr_x25 sx25; |
789bb287 MK |
60 | } so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp; |
61 | ||
31bd2db6 | 62 | typedef union sockunion *sup; |
c64fbe35 | 63 | int pid, rtm_addrs, uid; |
4bec325f | 64 | int s; |
d19a4594 | 65 | int forcehost, forcenet, doflush, nflag, af, qflag, tflag, keyword(); |
eb03b231 | 66 | int iflag, verbose, aflen = sizeof (struct sockaddr_in); |
7cd60aa5 | 67 | int locking, lockrest, debugonly; |
7cd60aa5 | 68 | struct rt_metrics rt_metrics; |
7d8dd943 | 69 | u_long rtm_inits; |
379dcc38 | 70 | struct in_addr inet_makeaddr(); |
9494af5d | 71 | char *routename(), *netname(); |
fcf43e01 KS |
72 | void flushroutes(), newroute(), monitor(), sockaddr(), sodump(), bprintf(); |
73 | void print_getmsg(), print_rtmsg(), pmsg_common(), pmsg_addrs(); | |
c70cd151 | 74 | int getaddr(), rtmsg(), x25_makemask(); |
9494af5d | 75 | extern char *inet_ntoa(), *iso_ntoa(), *link_ntoa(); |
4bec325f | 76 | |
9494af5d | 77 | void |
31bd2db6 | 78 | usage(cp) |
9494af5d CT |
79 | char *cp; |
80 | { | |
9494af5d | 81 | if (cp) |
e6a1ded8 KB |
82 | (void) fprintf(stderr, "route: botched keyword: %s\n", cp); |
83 | (void) fprintf(stderr, | |
d19a4594 | 84 | "usage: route [ -nqv ] cmd [[ -<qualifers> ] args ]\n"); |
9494af5d CT |
85 | exit(1); |
86 | /* NOTREACHED */ | |
87 | } | |
88 | ||
89 | void | |
90 | quit(s) | |
91 | char *s; | |
31bd2db6 | 92 | { |
9494af5d | 93 | int sverrno = errno; |
31bd2db6 | 94 | |
9494af5d CT |
95 | (void) fprintf(stderr, "route: "); |
96 | if (s) | |
97 | (void) fprintf(stderr, "%s: ", s); | |
98 | (void) fprintf(stderr, "%s\n", strerror(sverrno)); | |
31bd2db6 | 99 | exit(1); |
9494af5d | 100 | /* NOTREACHED */ |
31bd2db6 | 101 | } |
7d8dd943 | 102 | |
c64fbe35 KS |
103 | #define ROUNDUP(a) \ |
104 | ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) | |
105 | #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) | |
106 | ||
4bec325f BJ |
107 | main(argc, argv) |
108 | int argc; | |
e6a1ded8 | 109 | char **argv; |
4bec325f | 110 | { |
e6a1ded8 KB |
111 | extern int optind; |
112 | int ch; | |
b268b889 | 113 | char *argvp; |
9494af5d | 114 | |
4bec325f | 115 | if (argc < 2) |
9494af5d | 116 | usage((char *)NULL); |
e6a1ded8 | 117 | |
fcf43e01 | 118 | while ((ch = getopt(argc, argv, "nqdtv")) != EOF) |
e6a1ded8 | 119 | switch(ch) { |
e6a1ded8 KB |
120 | case 'n': |
121 | nflag = 1; | |
122 | break; | |
123 | case 'q': | |
124 | qflag = 1; | |
125 | break; | |
126 | case 'v': | |
127 | verbose = 1; | |
128 | break; | |
79394449 KS |
129 | case 't': |
130 | tflag = 1; | |
131 | break; | |
fcf43e01 KS |
132 | case 'd': |
133 | debugonly = 1; | |
134 | break; | |
e6a1ded8 KB |
135 | case '?': |
136 | default: | |
8d480bfd | 137 | usage((char *)NULL); |
e6a1ded8 KB |
138 | } |
139 | argc -= optind; | |
140 | argv += optind; | |
141 | ||
5c7868a2 | 142 | pid = getpid(); |
c64fbe35 | 143 | uid = getuid(); |
79394449 KS |
144 | if (tflag) |
145 | s = open("/dev/null", O_WRONLY, 0); | |
5c7868a2 KS |
146 | else |
147 | s = socket(PF_ROUTE, SOCK_RAW, 0); | |
9494af5d CT |
148 | if (s < 0) |
149 | quit("socket"); | |
e6a1ded8 | 150 | if (*argv) |
789bb287 | 151 | switch (keyword(*argv)) { |
ac62fbdc | 152 | case K_GET: |
c64fbe35 KS |
153 | uid = 0; |
154 | /* FALLTHROUGH */ | |
789bb287 | 155 | |
31bd2db6 | 156 | case K_CHANGE: |
c64fbe35 | 157 | case K_ADD: |
31bd2db6 | 158 | case K_DELETE: |
63c817da | 159 | newroute(argc, argv); |
789bb287 MK |
160 | exit(0); |
161 | /* NOTREACHED */ | |
162 | ||
31bd2db6 | 163 | case K_MONITOR: |
5c7868a2 | 164 | monitor(); |
789bb287 MK |
165 | /* NOTREACHED */ |
166 | ||
31bd2db6 KS |
167 | case K_FLUSH: |
168 | flushroutes(argc, argv); | |
789bb287 MK |
169 | exit(0); |
170 | /* NOTREACHED */ | |
e6a1ded8 | 171 | } |
31bd2db6 | 172 | usage(*argv); |
9494af5d | 173 | /* NOTREACHED */ |
63c817da SL |
174 | } |
175 | ||
176 | /* | |
177 | * Purge all entries in the routing tables not | |
178 | * associated with network interfaces. | |
179 | */ | |
9494af5d | 180 | void |
31bd2db6 | 181 | flushroutes(argc, argv) |
9494af5d CT |
182 | int argc; |
183 | char *argv[]; | |
b268b889 | 184 | { |
555ca562 KM |
185 | size_t needed; |
186 | int mib[6], rlen, seqno; | |
9eb5d442 KS |
187 | char *buf, *next, *lim; |
188 | register struct rt_msghdr *rtm; | |
9eb5d442 | 189 | |
c64fbe35 | 190 | if (uid) |
789bb287 | 191 | quit("must be root to alter routing table"); |
104e26d6 | 192 | shutdown(s, 0); /* Don't want to read back our messages */ |
31bd2db6 KS |
193 | if (argc > 1) { |
194 | argv++; | |
789bb287 MK |
195 | if (argc == 2 && **argv == '-') |
196 | switch (keyword(*argv + 1)) { | |
197 | case K_INET: | |
198 | af = AF_INET; | |
199 | break; | |
200 | case K_XNS: | |
201 | af = AF_NS; | |
202 | break; | |
203 | case K_LINK: | |
204 | af = AF_LINK; | |
205 | break; | |
206 | case K_ISO: | |
207 | case K_OSI: | |
208 | af = AF_ISO; | |
209 | break; | |
79394449 KS |
210 | case K_X25: |
211 | af = AF_CCITT; | |
789bb287 MK |
212 | default: |
213 | goto bad; | |
31bd2db6 | 214 | } else |
789bb287 | 215 | bad: usage(*argv); |
31bd2db6 | 216 | } |
555ca562 KM |
217 | mib[0] = CTL_NET; |
218 | mib[1] = PF_ROUTE; | |
219 | mib[2] = 0; /* protocol */ | |
220 | mib[3] = 0; /* wildcard address family */ | |
221 | mib[4] = NET_RT_DUMP; | |
222 | mib[5] = 0; /* no flags */ | |
223 | if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) | |
224 | quit("route-sysctl-estimate"); | |
9494af5d CT |
225 | if ((buf = malloc(needed)) == NULL) |
226 | quit("malloc"); | |
555ca562 | 227 | if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) |
9494af5d | 228 | quit("actual retrieval of routing table"); |
555ca562 | 229 | lim = buf + needed; |
fcf43e01 | 230 | if (verbose) |
555ca562 | 231 | (void) printf("Examining routing table from sysctl\n"); |
9494af5d | 232 | seqno = 0; /* ??? */ |
9eb5d442 KS |
233 | for (next = buf; next < lim; next += rtm->rtm_msglen) { |
234 | rtm = (struct rt_msghdr *)next; | |
fcf43e01 KS |
235 | if (verbose) |
236 | print_rtmsg(rtm, rtm->rtm_msglen); | |
eb03b231 | 237 | if ((rtm->rtm_flags & RTF_GATEWAY) == 0) |
9eb5d442 | 238 | continue; |
31bd2db6 KS |
239 | if (af) { |
240 | struct sockaddr *sa = (struct sockaddr *)(rtm + 1); | |
789bb287 | 241 | |
31bd2db6 KS |
242 | if (sa->sa_family != af) |
243 | continue; | |
244 | } | |
fcf43e01 KS |
245 | if (debugonly) |
246 | continue; | |
9eb5d442 KS |
247 | rtm->rtm_type = RTM_DELETE; |
248 | rtm->rtm_seq = seqno; | |
ac62fbdc KS |
249 | rlen = write(s, next, rtm->rtm_msglen); |
250 | if (rlen < (int)rtm->rtm_msglen) { | |
9494af5d CT |
251 | (void) fprintf(stderr, |
252 | "route: write to routing socket: %s\n", | |
253 | strerror(errno)); | |
254 | (void) printf("got only %d for rlen\n", rlen); | |
31bd2db6 | 255 | break; |
b268b889 | 256 | } |
9eb5d442 KS |
257 | seqno++; |
258 | if (qflag) | |
259 | continue; | |
9494af5d | 260 | if (verbose) |
31bd2db6 | 261 | print_rtmsg(rtm, rlen); |
9494af5d | 262 | else { |
039256d2 | 263 | struct sockaddr *sa = (struct sockaddr *)(rtm + 1); |
9494af5d | 264 | (void) printf("%-20.20s ", rtm->rtm_flags & RTF_HOST ? |
9eb5d442 KS |
265 | routename(sa) : netname(sa)); |
266 | sa = (struct sockaddr *)(sa->sa_len + (char *)sa); | |
9494af5d CT |
267 | (void) printf("%-20.20s ", routename(sa)); |
268 | (void) printf("done\n"); | |
57cacc90 KS |
269 | } |
270 | } | |
57cacc90 | 271 | } |
9eb5d442 | 272 | |
63c817da | 273 | char * |
eac76d14 MK |
274 | routename(sa) |
275 | struct sockaddr *sa; | |
63c817da | 276 | { |
a2280e64 | 277 | register char *cp; |
63c817da | 278 | static char line[50]; |
6edb1941 | 279 | struct hostent *hp; |
a2280e64 MK |
280 | static char domain[MAXHOSTNAMELEN + 1]; |
281 | static int first = 1; | |
eac76d14 | 282 | char *ns_print(); |
63c817da | 283 | |
a2280e64 MK |
284 | if (first) { |
285 | first = 0; | |
286 | if (gethostname(domain, MAXHOSTNAMELEN) == 0 && | |
287 | (cp = index(domain, '.'))) | |
288 | (void) strcpy(domain, cp + 1); | |
289 | else | |
290 | domain[0] = 0; | |
291 | } | |
b762b60d KS |
292 | |
293 | if (sa->sa_len == 0) | |
294 | strcpy(line, "default"); | |
295 | else switch (sa->sa_family) { | |
eac76d14 MK |
296 | |
297 | case AF_INET: | |
298 | { struct in_addr in; | |
299 | in = ((struct sockaddr_in *)sa)->sin_addr; | |
300 | ||
301 | cp = 0; | |
b762b60d | 302 | if (in.s_addr == INADDR_ANY || sa->sa_len < 4) |
eac76d14 MK |
303 | cp = "default"; |
304 | if (cp == 0 && !nflag) { | |
789bb287 | 305 | hp = gethostbyaddr((char *)&in, sizeof (struct in_addr), |
eac76d14 MK |
306 | AF_INET); |
307 | if (hp) { | |
308 | if ((cp = index(hp->h_name, '.')) && | |
309 | !strcmp(cp + 1, domain)) | |
310 | *cp = 0; | |
311 | cp = hp->h_name; | |
312 | } | |
a2280e64 | 313 | } |
eac76d14 MK |
314 | if (cp) |
315 | strcpy(line, cp); | |
316 | else { | |
a2280e64 | 317 | #define C(x) ((x) & 0xff) |
eac76d14 | 318 | in.s_addr = ntohl(in.s_addr); |
9494af5d | 319 | (void) sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), |
eac76d14 MK |
320 | C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr)); |
321 | } | |
322 | break; | |
323 | } | |
324 | ||
325 | case AF_NS: | |
326 | return (ns_print((struct sockaddr_ns *)sa)); | |
327 | ||
31bd2db6 KS |
328 | case AF_LINK: |
329 | return (link_ntoa((struct sockaddr_dl *)sa)); | |
330 | ||
331 | case AF_ISO: | |
332 | (void) sprintf(line, "iso %s", | |
333 | iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); | |
334 | break; | |
335 | ||
eac76d14 | 336 | default: |
048d388c | 337 | { u_short *s = (u_short *)sa; |
9494af5d | 338 | u_short *slim = s + ((sa->sa_len + 1) >> 1); |
31bd2db6 | 339 | char *cp = line + sprintf(line, "(%d)", sa->sa_family); |
eac76d14 | 340 | |
048d388c KS |
341 | while (++s < slim) /* start with sa->sa_data */ |
342 | cp += sprintf(cp, " %x", *s); | |
eac76d14 MK |
343 | break; |
344 | } | |
a2280e64 MK |
345 | } |
346 | return (line); | |
347 | } | |
348 | ||
349 | /* | |
350 | * Return the name of the network whose address is given. | |
351 | * The address is assumed to be that of a net or subnet, not a host. | |
352 | */ | |
353 | char * | |
eac76d14 MK |
354 | netname(sa) |
355 | struct sockaddr *sa; | |
a2280e64 MK |
356 | { |
357 | char *cp = 0; | |
358 | static char line[50]; | |
359 | struct netent *np = 0; | |
360 | u_long net, mask; | |
e2fe1192 | 361 | register u_long i; |
a2280e64 | 362 | int subnetshift; |
a48a48cc | 363 | char *ns_print(); |
a2280e64 | 364 | |
eac76d14 MK |
365 | switch (sa->sa_family) { |
366 | ||
367 | case AF_INET: | |
368 | { struct in_addr in; | |
369 | in = ((struct sockaddr_in *)sa)->sin_addr; | |
370 | ||
e2fe1192 | 371 | i = in.s_addr = ntohl(in.s_addr); |
eac76d14 MK |
372 | if (in.s_addr == 0) |
373 | cp = "default"; | |
374 | else if (!nflag) { | |
375 | if (IN_CLASSA(i)) { | |
376 | mask = IN_CLASSA_NET; | |
377 | subnetshift = 8; | |
378 | } else if (IN_CLASSB(i)) { | |
379 | mask = IN_CLASSB_NET; | |
380 | subnetshift = 8; | |
381 | } else { | |
382 | mask = IN_CLASSC_NET; | |
383 | subnetshift = 4; | |
384 | } | |
385 | /* | |
386 | * If there are more bits than the standard mask | |
387 | * would suggest, subnets must be in use. | |
388 | * Guess at the subnet mask, assuming reasonable | |
389 | * width subnet fields. | |
390 | */ | |
391 | while (in.s_addr &~ mask) | |
392 | mask = (long)mask >> subnetshift; | |
393 | net = in.s_addr & mask; | |
394 | while ((mask & 1) == 0) | |
395 | mask >>= 1, net >>= 1; | |
396 | np = getnetbyaddr(net, AF_INET); | |
397 | if (np) | |
398 | cp = np->n_name; | |
a2280e64 | 399 | } |
eac76d14 MK |
400 | if (cp) |
401 | strcpy(line, cp); | |
402 | else if ((in.s_addr & 0xffffff) == 0) | |
9494af5d | 403 | (void) sprintf(line, "%u", C(in.s_addr >> 24)); |
eac76d14 | 404 | else if ((in.s_addr & 0xffff) == 0) |
9494af5d | 405 | (void) sprintf(line, "%u.%u", C(in.s_addr >> 24), |
eac76d14 MK |
406 | C(in.s_addr >> 16)); |
407 | else if ((in.s_addr & 0xff) == 0) | |
9494af5d | 408 | (void) sprintf(line, "%u.%u.%u", C(in.s_addr >> 24), |
eac76d14 MK |
409 | C(in.s_addr >> 16), C(in.s_addr >> 8)); |
410 | else | |
9494af5d | 411 | (void) sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24), |
eac76d14 MK |
412 | C(in.s_addr >> 16), C(in.s_addr >> 8), |
413 | C(in.s_addr)); | |
414 | break; | |
415 | } | |
416 | ||
417 | case AF_NS: | |
418 | return (ns_print((struct sockaddr_ns *)sa)); | |
419 | break; | |
420 | ||
31bd2db6 KS |
421 | case AF_LINK: |
422 | return (link_ntoa((struct sockaddr_dl *)sa)); | |
423 | ||
424 | case AF_ISO: | |
425 | (void) sprintf(line, "iso %s", | |
426 | iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); | |
427 | break; | |
428 | ||
eac76d14 MK |
429 | default: |
430 | { u_short *s = (u_short *)sa->sa_data; | |
31bd2db6 KS |
431 | u_short *slim = s + ((sa->sa_len + 1)>>1); |
432 | char *cp = line + sprintf(line, "af %d:", sa->sa_family); | |
eac76d14 | 433 | |
9494af5d CT |
434 | while (s < slim) |
435 | cp += sprintf(cp, " %x", *s++); | |
eac76d14 MK |
436 | break; |
437 | } | |
63c817da SL |
438 | } |
439 | return (line); | |
4bec325f BJ |
440 | } |
441 | ||
9494af5d | 442 | void |
7cd60aa5 | 443 | set_metric(value, key) |
9494af5d CT |
444 | char *value; |
445 | int key; | |
7cd60aa5 KS |
446 | { |
447 | int flag = 0; | |
448 | u_long noval, *valp = &noval; | |
449 | ||
450 | switch (key) { | |
451 | #define caseof(x, y, z) case x: valp = &rt_metrics.z; flag = y; break | |
452 | caseof(K_MTU, RTV_MTU, rmx_mtu); | |
453 | caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount); | |
454 | caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire); | |
455 | caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe); | |
456 | caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe); | |
457 | caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh); | |
458 | caseof(K_RTT, RTV_RTT, rmx_rtt); | |
459 | caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar); | |
460 | } | |
7d8dd943 | 461 | rtm_inits |= flag; |
7cd60aa5 KS |
462 | if (lockrest || locking) |
463 | rt_metrics.rmx_locks |= flag; | |
464 | if (locking) | |
465 | locking = 0; | |
466 | *valp = atoi(value); | |
467 | } | |
468 | ||
9494af5d | 469 | void |
4bec325f BJ |
470 | newroute(argc, argv) |
471 | int argc; | |
31bd2db6 | 472 | register char **argv; |
4bec325f | 473 | { |
9494af5d | 474 | char *cmd, *dest = "", *gateway = "", *err; |
b762b60d | 475 | int ishost = 0, ret, attempts, oerrno, flags = RTF_STATIC; |
7cd60aa5 | 476 | int key; |
31bd2db6 | 477 | struct hostent *hp = 0; |
4bec325f | 478 | |
c64fbe35 | 479 | if (uid) |
789bb287 | 480 | quit("must be root to alter routing table"); |
183ef13b | 481 | cmd = argv[0]; |
ac62fbdc KS |
482 | if (*cmd != 'g') |
483 | shutdown(s, 0); /* Don't want to read back our messages */ | |
31bd2db6 KS |
484 | while (--argc > 0) { |
485 | if (**(++argv)== '-') { | |
9494af5d | 486 | switch (key = keyword(1 + *argv)) { |
31bd2db6 KS |
487 | case K_LINK: |
488 | af = AF_LINK; | |
eb03b231 | 489 | aflen = sizeof(struct sockaddr_dl); |
31bd2db6 KS |
490 | break; |
491 | case K_OSI: | |
eb03b231 | 492 | case K_ISO: |
31bd2db6 | 493 | af = AF_ISO; |
eb03b231 | 494 | aflen = sizeof(struct sockaddr_iso); |
31bd2db6 KS |
495 | break; |
496 | case K_INET: | |
497 | af = AF_INET; | |
eb03b231 | 498 | aflen = sizeof(struct sockaddr_in); |
31bd2db6 | 499 | break; |
79394449 KS |
500 | case K_X25: |
501 | af = AF_CCITT; | |
502 | aflen = sizeof(struct sockaddr_x25); | |
503 | break; | |
504 | case K_SA: | |
83929a15 | 505 | af = PF_ROUTE; |
79394449 KS |
506 | aflen = sizeof(union sockunion); |
507 | break; | |
31bd2db6 KS |
508 | case K_XNS: |
509 | af = AF_NS; | |
eb03b231 | 510 | aflen = sizeof(struct sockaddr_ns); |
31bd2db6 KS |
511 | break; |
512 | case K_IFACE: | |
7cd60aa5 | 513 | case K_INTERFACE: |
31bd2db6 | 514 | iflag++; |
b762b60d KS |
515 | case K_NOSTATIC: |
516 | flags &= ~RTF_STATIC; | |
31bd2db6 | 517 | break; |
7cd60aa5 KS |
518 | case K_LOCK: |
519 | locking = 1; | |
520 | break; | |
521 | case K_LOCKREST: | |
522 | lockrest = 1; | |
523 | break; | |
31bd2db6 KS |
524 | case K_HOST: |
525 | forcehost++; | |
526 | break; | |
039256d2 KS |
527 | case K_REJECT: |
528 | flags |= RTF_REJECT; | |
529 | break; | |
67506849 KS |
530 | case K_PROTO1: |
531 | flags |= RTF_PROTO1; | |
532 | break; | |
533 | case K_PROTO2: | |
534 | flags |= RTF_PROTO2; | |
535 | break; | |
7cd60aa5 KS |
536 | case K_CLONING: |
537 | flags |= RTF_CLONING; | |
538 | break; | |
539 | case K_XRESOLVE: | |
540 | flags |= RTF_XRESOLVE; | |
541 | break; | |
b762b60d KS |
542 | case K_STATIC: |
543 | flags |= RTF_STATIC; | |
544 | break; | |
ac62fbdc KS |
545 | case K_IFA: |
546 | argc--; | |
547 | (void) getaddr(RTA_IFA, *++argv, 0); | |
548 | break; | |
549 | case K_IFP: | |
550 | argc--; | |
551 | (void) getaddr(RTA_IFP, *++argv, 0); | |
552 | break; | |
31bd2db6 KS |
553 | case K_GENMASK: |
554 | argc--; | |
555 | (void) getaddr(RTA_GENMASK, *++argv, 0); | |
556 | break; | |
ac62fbdc KS |
557 | case K_GATEWAY: |
558 | argc--; | |
559 | (void) getaddr(RTA_GATEWAY, *++argv, 0); | |
560 | break; | |
561 | case K_DST: | |
562 | argc--; | |
563 | ishost = getaddr(RTA_DST, *++argv, &hp); | |
564 | dest = *argv; | |
565 | break; | |
566 | case K_NETMASK: | |
567 | argc--; | |
568 | (void) getaddr(RTA_NETMASK, *++argv, 0); | |
569 | /* FALLTHROUGH */ | |
570 | case K_NET: | |
571 | forcenet++; | |
572 | break; | |
7cd60aa5 KS |
573 | case K_MTU: |
574 | case K_HOPCOUNT: | |
575 | case K_EXPIRE: | |
576 | case K_RECVPIPE: | |
577 | case K_SENDPIPE: | |
578 | case K_SSTHRESH: | |
579 | case K_RTT: | |
580 | case K_RTTVAR: | |
581 | argc--; | |
582 | set_metric(*++argv, key); | |
583 | break; | |
31bd2db6 KS |
584 | default: |
585 | usage(1+*argv); | |
586 | } | |
587 | } else { | |
588 | if ((rtm_addrs & RTA_DST) == 0) { | |
589 | dest = *argv; | |
590 | ishost = getaddr(RTA_DST, *argv, &hp); | |
591 | } else if ((rtm_addrs & RTA_GATEWAY) == 0) { | |
592 | gateway = *argv; | |
593 | (void) getaddr(RTA_GATEWAY, *argv, &hp); | |
594 | } else { | |
595 | int ret = atoi(*argv); | |
d19a4594 | 596 | |
31bd2db6 | 597 | if (ret == 0) { |
d19a4594 MK |
598 | if (strcmp(*argv, "0") == 0) |
599 | printf("%s,%s", | |
600 | "old usage of trailing 0", | |
601 | "assuming route to if\n"); | |
602 | else | |
8d480bfd | 603 | usage((char *)NULL); |
31bd2db6 KS |
604 | iflag = 1; |
605 | continue; | |
606 | } else if (ret > 0 && ret < 10) { | |
607 | printf("old usage of trailing digit, "); | |
608 | printf("assuming route via gateway\n"); | |
609 | iflag = 0; | |
610 | continue; | |
611 | } | |
612 | (void) getaddr(RTA_NETMASK, *argv, 0); | |
613 | } | |
614 | } | |
615 | } | |
b3933da8 MK |
616 | if (forcehost) |
617 | ishost = 1; | |
618 | if (forcenet) | |
619 | ishost = 0; | |
7cd60aa5 | 620 | flags |= RTF_UP; |
6edb1941 | 621 | if (ishost) |
7d5f817b | 622 | flags |= RTF_HOST; |
57cacc90 | 623 | if (iflag == 0) |
7d5f817b | 624 | flags |= RTF_GATEWAY; |
792b0612 MK |
625 | for (attempts = 1; ; attempts++) { |
626 | errno = 0; | |
d19a4594 MK |
627 | if ((ret = rtmsg(*cmd, flags)) == 0) |
628 | break; | |
792b0612 MK |
629 | if (errno != ENETUNREACH && errno != ESRCH) |
630 | break; | |
d19a4594 | 631 | if (af == AF_INET && *gateway && hp && hp->h_addr_list[1]) { |
792b0612 | 632 | hp->h_addr_list++; |
d19a4594 | 633 | bcopy(hp->h_addr_list[0], &so_gate.sin.sin_addr, |
792b0612 MK |
634 | hp->h_length); |
635 | } else | |
636 | break; | |
637 | } | |
ac62fbdc KS |
638 | if (*cmd == 'g') |
639 | exit(0); | |
792b0612 | 640 | oerrno = errno; |
d19a4594 MK |
641 | (void) printf("%s %s %s", cmd, ishost? "host" : "net", dest); |
642 | if (*gateway) { | |
643 | (void) printf(": gateway %s", gateway); | |
644 | if (attempts > 1 && ret == 0 && af == AF_INET) | |
645 | (void) printf(" (%s)", | |
646 | inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr)); | |
647 | } | |
792b0612 | 648 | if (ret == 0) |
9494af5d | 649 | (void) printf("\n"); |
792b0612 | 650 | else { |
9494af5d CT |
651 | switch (oerrno) { |
652 | case ESRCH: | |
653 | err = "not in table"; | |
654 | break; | |
655 | case EBUSY: | |
656 | err = "entry in use"; | |
657 | break; | |
658 | case ENOBUFS: | |
659 | err = "routing table overflow"; | |
660 | break; | |
661 | default: | |
662 | err = strerror(oerrno); | |
663 | break; | |
664 | } | |
665 | (void) printf(": %s\n", err); | |
792b0612 | 666 | } |
4bec325f BJ |
667 | } |
668 | ||
9494af5d | 669 | void |
31bd2db6 | 670 | inet_makenetandmask(net, sin) |
9494af5d CT |
671 | u_long net; |
672 | register struct sockaddr_in *sin; | |
57cacc90 | 673 | { |
9494af5d | 674 | u_long addr, mask = 0; |
31bd2db6 | 675 | register char *cp; |
57cacc90 | 676 | |
31bd2db6 | 677 | rtm_addrs |= RTA_NETMASK; |
57cacc90 | 678 | if (net == 0) |
5c7868a2 | 679 | mask = addr = 0; |
57cacc90 KS |
680 | else if (net < 128) { |
681 | addr = net << IN_CLASSA_NSHIFT; | |
5c7868a2 | 682 | mask = IN_CLASSA_NET; |
57cacc90 KS |
683 | } else if (net < 65536) { |
684 | addr = net << IN_CLASSB_NSHIFT; | |
5c7868a2 | 685 | mask = IN_CLASSB_NET; |
57cacc90 KS |
686 | } else if (net < 16777216L) { |
687 | addr = net << IN_CLASSC_NSHIFT; | |
5c7868a2 | 688 | mask = IN_CLASSC_NET; |
57cacc90 KS |
689 | } else { |
690 | addr = net; | |
691 | if ((addr & IN_CLASSA_HOST) == 0) | |
5c7868a2 | 692 | mask = IN_CLASSA_NET; |
57cacc90 | 693 | else if ((addr & IN_CLASSB_HOST) == 0) |
5c7868a2 | 694 | mask = IN_CLASSB_NET; |
57cacc90 | 695 | else if ((addr & IN_CLASSC_HOST) == 0) |
5c7868a2 | 696 | mask = IN_CLASSC_NET; |
57cacc90 | 697 | else |
5c7868a2 KS |
698 | mask = -1; |
699 | } | |
31bd2db6 KS |
700 | sin->sin_addr.s_addr = htonl(addr); |
701 | sin = &so_mask.sin; | |
702 | sin->sin_addr.s_addr = htonl(mask); | |
703 | sin->sin_len = 0; | |
704 | sin->sin_family = 0; | |
9494af5d | 705 | cp = (char *)(&sin->sin_addr + 1); |
31bd2db6 KS |
706 | while (*--cp == 0 && cp > (char *)sin) |
707 | ; | |
708 | sin->sin_len = 1 + cp - (char *)sin; | |
57cacc90 KS |
709 | } |
710 | ||
6edb1941 MK |
711 | /* |
712 | * Interpret an argument as a network address of some kind, | |
713 | * returning 1 if a host address, 0 if a network address. | |
714 | */ | |
9494af5d | 715 | int |
31bd2db6 | 716 | getaddr(which, s, hpp) |
9494af5d | 717 | int which; |
4bec325f | 718 | char *s; |
792b0612 | 719 | struct hostent **hpp; |
4bec325f | 720 | { |
ac62fbdc | 721 | register sup su; |
9494af5d | 722 | struct ns_addr ns_addr(); |
eb03b231 | 723 | struct iso_addr *iso_addr(); |
accbc2e3 | 724 | struct hostent *hp; |
379dcc38 | 725 | struct netent *np; |
31bd2db6 | 726 | u_long val; |
accbc2e3 | 727 | |
eb03b231 | 728 | if (af == 0) { |
31bd2db6 | 729 | af = AF_INET; |
eb03b231 KS |
730 | aflen = sizeof(struct sockaddr_in); |
731 | } | |
732 | rtm_addrs |= which; | |
31bd2db6 | 733 | switch (which) { |
6a01ae04 MK |
734 | case RTA_DST: |
735 | su = &so_dst; | |
736 | su->sa.sa_family = af; | |
737 | break; | |
738 | case RTA_GATEWAY: | |
739 | su = &so_gate; | |
740 | su->sa.sa_family = af; | |
741 | break; | |
742 | case RTA_NETMASK: | |
743 | su = &so_mask; | |
744 | break; | |
745 | case RTA_GENMASK: | |
746 | su = &so_genmask; | |
747 | break; | |
748 | case RTA_IFP: | |
749 | su = &so_ifp; | |
750 | su->sa.sa_family = af; | |
751 | break; | |
752 | case RTA_IFA: | |
753 | su = &so_ifa; | |
754 | su->sa.sa_family = af; | |
755 | break; | |
756 | default: | |
757 | usage("Internal Error"); | |
758 | /*NOTREACHED*/ | |
31bd2db6 | 759 | } |
eb03b231 | 760 | su->sa.sa_len = aflen; |
7d5f817b | 761 | if (strcmp(s, "default") == 0) { |
eb03b231 KS |
762 | switch (which) { |
763 | case RTA_DST: | |
764 | forcenet++; | |
9494af5d | 765 | (void) getaddr(RTA_NETMASK, s, 0); |
eb03b231 KS |
766 | break; |
767 | case RTA_NETMASK: | |
768 | case RTA_GENMASK: | |
769 | su->sa.sa_len = 0; | |
770 | } | |
6a01ae04 MK |
771 | return (0); |
772 | } | |
773 | switch (af) { | |
774 | case AF_NS: | |
775 | if (which == RTA_DST) { | |
776 | extern short ns_bh[3]; | |
777 | struct sockaddr_ns *sms = &(so_mask.sns); | |
778 | bzero((char *)sms, sizeof(*sms)); | |
779 | sms->sns_family = 0; | |
780 | sms->sns_len = 6; | |
781 | sms->sns_addr.x_net = *(union ns_net *)ns_bh; | |
782 | rtm_addrs |= RTA_NETMASK; | |
783 | } | |
784 | su->sns.sns_addr = ns_addr(s); | |
785 | return (!ns_nullhost(su->sns.sns_addr)); | |
786 | ||
787 | case AF_OSI: | |
788 | su->siso.siso_addr = *iso_addr(s); | |
789 | if (which == RTA_NETMASK || which == RTA_GENMASK) { | |
790 | register char *cp = (char *)TSEL(&su->siso); | |
791 | su->siso.siso_nlen = 0; | |
792 | do {--cp ;} while ((cp > (char *)su) && (*cp == 0)); | |
793 | su->siso.siso_len = 1 + cp - (char *)su; | |
794 | } | |
795 | return (1); | |
796 | ||
797 | case AF_LINK: | |
798 | link_addr(s, &su->sdl); | |
799 | return (1); | |
800 | ||
801 | case AF_CCITT: | |
802 | ccitt_addr(s, &su->sx25); | |
c70cd151 | 803 | return (which == RTA_DST ? x25_makemask() : 1); |
6a01ae04 MK |
804 | |
805 | case PF_ROUTE: | |
806 | su->sa.sa_len = sizeof(*su); | |
807 | sockaddr(s, &su->sa); | |
808 | return (1); | |
809 | ||
810 | case AF_INET: | |
811 | default: | |
812 | break; | |
7d5f817b | 813 | } |
6a01ae04 | 814 | |
9494af5d CT |
815 | if (hpp == NULL) |
816 | hpp = &hp; | |
817 | *hpp = NULL; | |
85e467b1 KS |
818 | if (((val = inet_addr(s)) != -1) && |
819 | (which != RTA_DST || forcenet == 0)) { | |
31bd2db6 KS |
820 | su->sin.sin_addr.s_addr = val; |
821 | if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY) | |
822 | return (1); | |
823 | else { | |
824 | val = ntohl(val); | |
6a01ae04 | 825 | goto netdone; |
a2280e64 | 826 | } |
792b0612 | 827 | } |
c70cd151 KS |
828 | if ((val = inet_network(s)) != -1 || |
829 | ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0)) { | |
6a01ae04 MK |
830 | netdone: |
831 | if (which == RTA_DST) | |
832 | inet_makenetandmask(val, &su->sin); | |
833 | return (0); | |
379dcc38 | 834 | } |
78160c55 MK |
835 | hp = gethostbyname(s); |
836 | if (hp) { | |
792b0612 | 837 | *hpp = hp; |
31bd2db6 | 838 | su->sin.sin_family = hp->h_addrtype; |
9494af5d | 839 | bcopy(hp->h_addr, (char *)&su->sin.sin_addr, hp->h_length); |
57cacc90 | 840 | return (1); |
78160c55 | 841 | } |
9494af5d | 842 | (void) fprintf(stderr, "%s: bad value\n", s); |
379dcc38 | 843 | exit(1); |
183ef13b | 844 | } |
eac76d14 | 845 | |
c70cd151 KS |
846 | x25_makemask() |
847 | { | |
848 | register char *cp; | |
849 | ||
850 | if ((rtm_addrs & RTA_NETMASK) == 0) { | |
851 | rtm_addrs |= RTA_NETMASK; | |
852 | for (cp = (char *)&so_mask.sx25.x25_net; | |
853 | cp < &so_mask.sx25.x25_opts.op_flags; cp++) | |
854 | *cp = -1; | |
855 | so_mask.sx25.x25_len = (u_char)&(((sup)0)->sx25.x25_opts); | |
856 | } | |
857 | return 0; | |
858 | } | |
859 | ||
eac76d14 MK |
860 | short ns_nullh[] = {0,0,0}; |
861 | short ns_bh[] = {-1,-1,-1}; | |
862 | ||
863 | char * | |
864 | ns_print(sns) | |
9494af5d | 865 | struct sockaddr_ns *sns; |
eac76d14 MK |
866 | { |
867 | struct ns_addr work; | |
868 | union { union ns_net net_e; u_long long_e; } net; | |
869 | u_short port; | |
870 | static char mybuf[50], cport[10], chost[25]; | |
871 | char *host = ""; | |
9494af5d CT |
872 | register char *p; |
873 | register u_char *q; | |
eac76d14 MK |
874 | |
875 | work = sns->sns_addr; | |
876 | port = ntohs(work.x_port); | |
877 | work.x_port = 0; | |
878 | net.net_e = work.x_net; | |
879 | if (ns_nullhost(work) && net.long_e == 0) { | |
9494af5d CT |
880 | if (!port) |
881 | return ("*.*"); | |
882 | (void) sprintf(mybuf, "*.%XH", port); | |
eac76d14 MK |
883 | return (mybuf); |
884 | } | |
885 | ||
9494af5d | 886 | if (bcmp((char *)ns_bh, (char *)work.x_host.c_host, 6) == 0) |
eac76d14 | 887 | host = "any"; |
9494af5d | 888 | else if (bcmp((char *)ns_nullh, (char *)work.x_host.c_host, 6) == 0) |
eac76d14 | 889 | host = "*"; |
9494af5d | 890 | else { |
eac76d14 | 891 | q = work.x_host.c_host; |
9494af5d | 892 | (void) sprintf(chost, "%02X%02X%02X%02X%02X%02XH", |
eac76d14 | 893 | q[0], q[1], q[2], q[3], q[4], q[5]); |
9494af5d CT |
894 | for (p = chost; *p == '0' && p < chost + 12; p++) |
895 | /* void */; | |
eac76d14 MK |
896 | host = p; |
897 | } | |
898 | if (port) | |
9494af5d | 899 | (void) sprintf(cport, ".%XH", htons(port)); |
eac76d14 MK |
900 | else |
901 | *cport = 0; | |
902 | ||
9494af5d CT |
903 | (void) sprintf(mybuf,"%XH.%s%s", ntohl(net.long_e), host, cport); |
904 | return (mybuf); | |
eac76d14 | 905 | } |
57cacc90 | 906 | |
048d388c KS |
907 | void |
908 | interfaces() | |
909 | { | |
555ca562 KM |
910 | size_t needed; |
911 | int mib[6], af; | |
048d388c KS |
912 | char *buf, *lim, *next; |
913 | register struct rt_msghdr *rtm; | |
914 | ||
555ca562 KM |
915 | mib[0] = CTL_NET; |
916 | mib[1] = PF_ROUTE; | |
917 | mib[2] = 0; /* protocol */ | |
918 | mib[3] = 0; /* wildcard address family */ | |
919 | mib[4] = NET_RT_IFLIST; | |
920 | mib[5] = 0; /* no flags */ | |
921 | if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) | |
922 | quit("route-sysctl-estimate"); | |
048d388c KS |
923 | if ((buf = malloc(needed)) == NULL) |
924 | quit("malloc"); | |
555ca562 | 925 | if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) |
048d388c | 926 | quit("actual retrieval of interface table"); |
555ca562 | 927 | lim = buf + needed; |
048d388c KS |
928 | for (next = buf; next < lim; next += rtm->rtm_msglen) { |
929 | rtm = (struct rt_msghdr *)next; | |
930 | print_rtmsg(rtm, rtm->rtm_msglen); | |
931 | } | |
932 | } | |
933 | ||
9494af5d | 934 | void |
57cacc90 KS |
935 | monitor() |
936 | { | |
937 | int n; | |
938 | char msg[2048]; | |
9494af5d | 939 | |
9eb5d442 | 940 | verbose = 1; |
048d388c KS |
941 | if (debugonly) { |
942 | interfaces(); | |
943 | exit(0); | |
944 | } | |
57cacc90 KS |
945 | for(;;) { |
946 | n = read(s, msg, 2048); | |
9494af5d | 947 | (void) printf("got message of size %d\n", n); |
fcf43e01 | 948 | print_rtmsg((struct rt_msghdr *)msg, n); |
57cacc90 KS |
949 | } |
950 | } | |
951 | ||
952 | struct { | |
953 | struct rt_msghdr m_rtm; | |
9494af5d | 954 | char m_space[512]; |
57cacc90 KS |
955 | } m_rtmsg; |
956 | ||
9494af5d | 957 | int |
31bd2db6 | 958 | rtmsg(cmd, flags) |
9494af5d | 959 | int cmd, flags; |
57cacc90 KS |
960 | { |
961 | static int seq; | |
85e467b1 | 962 | int rlen; |
31bd2db6 KS |
963 | register char *cp = m_rtmsg.m_space; |
964 | register int l; | |
57cacc90 | 965 | |
c64fbe35 KS |
966 | #define NEXTADDR(w, u) \ |
967 | if (rtm_addrs & (w)) {\ | |
968 | l = ROUNDUP(u.sa.sa_len); bcopy((char *)&(u), cp, l); cp += l;\ | |
969 | if (verbose) sodump(&(u),"u");\ | |
970 | } | |
ac62fbdc | 971 | |
57cacc90 KS |
972 | errno = 0; |
973 | bzero((char *)&m_rtmsg, sizeof(m_rtmsg)); | |
974 | if (cmd == 'a') | |
975 | cmd = RTM_ADD; | |
976 | else if (cmd == 'c') | |
977 | cmd = RTM_CHANGE; | |
6a01ae04 | 978 | else if (cmd == 'g') { |
ac62fbdc | 979 | cmd = RTM_GET; |
6a01ae04 MK |
980 | if (so_ifp.sa.sa_family == 0) { |
981 | so_ifp.sa.sa_family == AF_LINK; | |
982 | so_ifp.sa.sa_len == sizeof(struct sockaddr_dl); | |
983 | rtm_addrs |= RTA_IFP; | |
984 | } | |
985 | } else | |
57cacc90 | 986 | cmd = RTM_DELETE; |
ac62fbdc KS |
987 | #define rtm m_rtmsg.m_rtm |
988 | rtm.rtm_type = cmd; | |
989 | rtm.rtm_flags = flags; | |
990 | rtm.rtm_version = RTM_VERSION; | |
991 | rtm.rtm_seq = ++seq; | |
992 | rtm.rtm_addrs = rtm_addrs; | |
993 | rtm.rtm_rmx = rt_metrics; | |
994 | rtm.rtm_inits = rtm_inits; | |
31bd2db6 | 995 | |
79394449 KS |
996 | if (rtm_addrs & RTA_NETMASK) |
997 | mask_addr(); | |
31bd2db6 KS |
998 | NEXTADDR(RTA_DST, so_dst); |
999 | NEXTADDR(RTA_GATEWAY, so_gate); | |
1000 | NEXTADDR(RTA_NETMASK, so_mask); | |
1001 | NEXTADDR(RTA_GENMASK, so_genmask); | |
ac62fbdc KS |
1002 | NEXTADDR(RTA_IFP, so_ifp); |
1003 | NEXTADDR(RTA_IFA, so_ifa); | |
1004 | rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; | |
31bd2db6 | 1005 | if (verbose) |
ac62fbdc | 1006 | print_rtmsg(&rtm, l); |
7cd60aa5 | 1007 | if (debugonly) |
d19a4594 | 1008 | return (0); |
85e467b1 | 1009 | if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) { |
57cacc90 | 1010 | perror("writing to routing socket"); |
7d5f817b | 1011 | return (-1); |
57cacc90 | 1012 | } |
ac62fbdc KS |
1013 | if (cmd == RTM_GET) { |
1014 | do { | |
1015 | l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg)); | |
1016 | } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid)); | |
1017 | if (l < 0) | |
9494af5d CT |
1018 | (void) fprintf(stderr, |
1019 | "route: read from routing socket: %s\n", | |
1020 | strerror(errno)); | |
ac62fbdc KS |
1021 | else |
1022 | print_getmsg(&rtm, l); | |
1023 | } | |
1024 | #undef rtm | |
57cacc90 KS |
1025 | return (0); |
1026 | } | |
1027 | ||
d19a4594 MK |
1028 | mask_addr() |
1029 | { | |
b762b60d KS |
1030 | int olen = so_mask.sa.sa_len; |
1031 | register char *cp1 = olen + (char *)&so_mask, *cp2; | |
79394449 | 1032 | |
b762b60d KS |
1033 | for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; ) |
1034 | if (*--cp1 != 0) { | |
1035 | so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask; | |
1036 | break; | |
1037 | } | |
79394449 KS |
1038 | if ((rtm_addrs & RTA_DST) == 0) |
1039 | return; | |
d19a4594 MK |
1040 | switch (so_dst.sa.sa_family) { |
1041 | case AF_NS: | |
1042 | case AF_INET: | |
b762b60d | 1043 | case AF_CCITT: |
d19a4594 | 1044 | case 0: |
79394449 KS |
1045 | return; |
1046 | case AF_ISO: | |
58c92547 KS |
1047 | olen = MIN(so_dst.siso.siso_nlen, |
1048 | MAX(so_mask.sa.sa_len - 6, 0)); | |
d19a4594 | 1049 | break; |
79394449 KS |
1050 | } |
1051 | cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst; | |
1052 | cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst; | |
1053 | while (cp2 > cp1) | |
1054 | *--cp2 = 0; | |
1055 | cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask; | |
1056 | while (cp1 > so_dst.sa.sa_data) | |
1057 | *--cp1 &= *--cp2; | |
d19a4594 | 1058 | switch (so_dst.sa.sa_family) { |
79394449 KS |
1059 | case AF_ISO: |
1060 | so_dst.siso.siso_nlen = olen; | |
d19a4594 | 1061 | break; |
79394449 KS |
1062 | } |
1063 | } | |
1064 | ||
57cacc90 | 1065 | char *msgtypes[] = { |
9494af5d CT |
1066 | "", |
1067 | "RTM_ADD: Add Route", | |
1068 | "RTM_DELETE: Delete Route", | |
1069 | "RTM_CHANGE: Change Metrics or flags", | |
1070 | "RTM_GET: Report Metrics", | |
1071 | "RTM_LOSING: Kernel Suspects Partitioning", | |
1072 | "RTM_REDIRECT: Told to use different route", | |
1073 | "RTM_MISS: Lookup failed on this address", | |
1074 | "RTM_LOCK: fix specified metrics", | |
1075 | "RTM_OLDADD: caused by SIOCADDRT", | |
1076 | "RTM_OLDDEL: caused by SIOCDELRT", | |
fcf43e01 KS |
1077 | "RTM_RESOLVE: Route created by cloning", |
1078 | "RTM_NEWADDR: address being added to iface", | |
1079 | "RTM_DELADDR: address being removed from iface", | |
1080 | "RTM_IFINFO: iface status change", | |
9494af5d CT |
1081 | 0, |
1082 | }; | |
57cacc90 KS |
1083 | |
1084 | char metricnames[] = | |
fcf43e01 | 1085 | "\011pksent\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu"; |
7cd60aa5 | 1086 | char routeflags[] = |
b762b60d | 1087 | "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\014STATIC\017PROTO2\020PROTO1"; |
fcf43e01 | 1088 | char ifnetflags[] = |
58c92547 | 1089 | "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6NOTRAILERS\7RUNNING\010NOARP\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST"; |
fcf43e01 KS |
1090 | char addrnames[] = |
1091 | "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD"; | |
57cacc90 | 1092 | |
9494af5d | 1093 | void |
ac62fbdc | 1094 | print_rtmsg(rtm, msglen) |
9494af5d CT |
1095 | register struct rt_msghdr *rtm; |
1096 | int msglen; | |
57cacc90 | 1097 | { |
fcf43e01 KS |
1098 | struct if_msghdr *ifm; |
1099 | struct ifa_msghdr *ifam; | |
1100 | ||
7d5f817b KS |
1101 | if (verbose == 0) |
1102 | return; | |
a387100b | 1103 | if (rtm->rtm_version != RTM_VERSION) { |
9494af5d CT |
1104 | (void) printf("routing message version %d not understood\n", |
1105 | rtm->rtm_version); | |
1106 | return; | |
57cacc90 | 1107 | } |
fcf43e01 KS |
1108 | (void)printf("%s: len %d, ", msgtypes[rtm->rtm_type], rtm->rtm_msglen); |
1109 | switch (rtm->rtm_type) { | |
1110 | case RTM_IFINFO: | |
1111 | ifm = (struct if_msghdr *)rtm; | |
1112 | (void) printf("if# %d, flags:", ifm->ifm_index); | |
1113 | bprintf(stdout, ifm->ifm_flags, ifnetflags); | |
1114 | pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs); | |
1115 | break; | |
1116 | case RTM_NEWADDR: | |
1117 | case RTM_DELADDR: | |
fcf43e01 | 1118 | ifam = (struct ifa_msghdr *)rtm; |
046022a0 | 1119 | (void) printf("metric %d, flags:", ifam->ifam_metric); |
fcf43e01 KS |
1120 | bprintf(stdout, ifam->ifam_flags, routeflags); |
1121 | pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs); | |
1122 | break; | |
1123 | default: | |
1124 | (void) printf("pid: %d, seq %d, errno %d, flags:", | |
1125 | rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno); | |
1126 | bprintf(stdout, rtm->rtm_flags, routeflags); | |
1127 | pmsg_common(rtm); | |
1128 | } | |
ac62fbdc KS |
1129 | } |
1130 | ||
9494af5d | 1131 | void |
ac62fbdc | 1132 | print_getmsg(rtm, msglen) |
9494af5d CT |
1133 | register struct rt_msghdr *rtm; |
1134 | int msglen; | |
ac62fbdc | 1135 | { |
d19a4594 | 1136 | struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL; |
6a01ae04 | 1137 | struct sockaddr_dl *ifp = NULL; |
d19a4594 MK |
1138 | register struct sockaddr *sa; |
1139 | register char *cp; | |
1140 | register int i; | |
1141 | ||
7f0cc49c | 1142 | (void) printf(" route to: %s\n", routename(&so_dst)); |
ac62fbdc | 1143 | if (rtm->rtm_version != RTM_VERSION) { |
d19a4594 MK |
1144 | (void)fprintf(stderr, |
1145 | "routing message version %d not understood\n", | |
9494af5d | 1146 | rtm->rtm_version); |
ac62fbdc KS |
1147 | return; |
1148 | } | |
c64fbe35 | 1149 | if (rtm->rtm_msglen > msglen) { |
d19a4594 MK |
1150 | (void)fprintf(stderr, |
1151 | "message length mismatch, in packet %d, returned %d\n", | |
9494af5d | 1152 | rtm->rtm_msglen, msglen); |
ac62fbdc | 1153 | } |
d19a4594 MK |
1154 | if (rtm->rtm_errno) { |
1155 | (void) fprintf(stderr, "RTM_GET: %s (errno %d)\n", | |
1156 | strerror(rtm->rtm_errno), rtm->rtm_errno); | |
1157 | return; | |
1158 | } | |
1159 | cp = ((char *)(rtm + 1)); | |
1160 | if (rtm->rtm_addrs) | |
1161 | for (i = 1; i; i <<= 1) | |
1162 | if (i & rtm->rtm_addrs) { | |
1163 | sa = (struct sockaddr *)cp; | |
1164 | switch (i) { | |
1165 | case RTA_DST: | |
1166 | dst = sa; | |
1167 | break; | |
1168 | case RTA_GATEWAY: | |
1169 | gate = sa; | |
1170 | break; | |
1171 | case RTA_NETMASK: | |
1172 | mask = sa; | |
1173 | break; | |
6a01ae04 MK |
1174 | case RTA_IFP: |
1175 | if (sa->sa_family == AF_LINK && | |
1176 | ((struct sockaddr_dl *)sa)->sdl_nlen) | |
1177 | ifp = (struct sockaddr_dl *)sa; | |
1178 | break; | |
d19a4594 MK |
1179 | } |
1180 | ADVANCE(cp, sa); | |
1181 | } | |
1182 | if (dst && mask) | |
1183 | mask->sa_family = dst->sa_family; /* XXX */ | |
1184 | if (dst) | |
1185 | (void)printf("destination: %s\n", routename(dst)); | |
1186 | if (mask) { | |
1187 | int savenflag = nflag; | |
1188 | ||
1189 | nflag = 1; | |
1190 | (void)printf(" mask: %s\n", routename(mask)); | |
1191 | nflag = savenflag; | |
1192 | } | |
1193 | if (gate && rtm->rtm_flags & RTF_GATEWAY) | |
1194 | (void)printf(" gateway: %s\n", routename(gate)); | |
6a01ae04 MK |
1195 | if (ifp) |
1196 | (void)printf(" interface: %.*s\n", | |
1197 | ifp->sdl_nlen, ifp->sdl_data); | |
d19a4594 | 1198 | (void)printf(" flags: "); |
ac62fbdc | 1199 | bprintf(stdout, rtm->rtm_flags, routeflags); |
d19a4594 MK |
1200 | |
1201 | #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ') | |
1202 | #define msec(u) (((u) + 500) / 1000) /* usec to msec */ | |
1203 | ||
1204 | (void) printf("\n%s\n", "\ | |
1205 | recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire"); | |
1206 | printf("%8d%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE)); | |
1207 | printf("%8d%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE)); | |
1208 | printf("%8d%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH)); | |
1209 | printf("%8d%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT)); | |
1210 | printf("%8d%c ", msec(rtm->rtm_rmx.rmx_rttvar), lock(RTTVAR)); | |
1211 | printf("%8d%c ", rtm->rtm_rmx.rmx_hopcount, lock(HOPCOUNT)); | |
1212 | printf("%8d%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU)); | |
1213 | if (rtm->rtm_rmx.rmx_expire) | |
1214 | rtm->rtm_rmx.rmx_expire -= time(0); | |
1215 | printf("%8d%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE)); | |
1216 | #undef lock | |
1217 | #undef msec | |
fcf43e01 | 1218 | #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD) |
d19a4594 MK |
1219 | if (verbose) |
1220 | pmsg_common(rtm); | |
6a01ae04 | 1221 | else if (rtm->rtm_addrs &~ RTA_IGN) { |
d19a4594 | 1222 | (void) printf("sockaddrs: "); |
fcf43e01 | 1223 | bprintf(stdout, rtm->rtm_addrs, addrnames); |
6a01ae04 | 1224 | putchar('\n'); |
d19a4594 | 1225 | } |
6a01ae04 | 1226 | #undef RTA_IGN |
ac62fbdc KS |
1227 | } |
1228 | ||
9494af5d | 1229 | void |
ac62fbdc | 1230 | pmsg_common(rtm) |
9494af5d | 1231 | register struct rt_msghdr *rtm; |
ac62fbdc | 1232 | { |
9494af5d CT |
1233 | (void) printf("\nlocks: "); |
1234 | bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames); | |
1235 | (void) printf(" inits: "); | |
1236 | bprintf(stdout, rtm->rtm_inits, metricnames); | |
fcf43e01 KS |
1237 | pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs); |
1238 | } | |
1239 | ||
1240 | void | |
1241 | pmsg_addrs(cp, addrs) | |
1242 | char *cp; | |
1243 | int addrs; | |
1244 | { | |
1245 | register struct sockaddr *sa; | |
1246 | int i; | |
1247 | ||
1248 | if (addrs == 0) | |
1249 | return; | |
9494af5d | 1250 | (void) printf("\nsockaddrs: "); |
fcf43e01 | 1251 | bprintf(stdout, addrs, addrnames); |
9494af5d | 1252 | (void) putchar('\n'); |
fcf43e01 KS |
1253 | for (i = 1; i; i <<= 1) |
1254 | if (i & addrs) { | |
1255 | sa = (struct sockaddr *)cp; | |
1256 | (void) printf(" %s", routename(sa)); | |
1257 | ADVANCE(cp, sa); | |
1258 | } | |
9494af5d CT |
1259 | (void) putchar('\n'); |
1260 | (void) fflush(stdout); | |
57cacc90 KS |
1261 | } |
1262 | ||
9494af5d | 1263 | void |
57cacc90 | 1264 | bprintf(fp, b, s) |
9494af5d CT |
1265 | register FILE *fp; |
1266 | register int b; | |
1267 | register u_char *s; | |
57cacc90 KS |
1268 | { |
1269 | register int i; | |
1270 | int gotsome = 0; | |
1271 | ||
1272 | if (b == 0) | |
1273 | return; | |
1274 | while (i = *s++) { | |
1275 | if (b & (1 << (i-1))) { | |
9494af5d CT |
1276 | if (gotsome == 0) |
1277 | i = '<'; | |
1278 | else | |
1279 | i = ','; | |
1280 | (void) putc(i, fp); | |
57cacc90 KS |
1281 | gotsome = 1; |
1282 | for (; (i = *s) > 32; s++) | |
9494af5d | 1283 | (void) putc(i, fp); |
57cacc90 KS |
1284 | } else |
1285 | while (*s > 32) | |
1286 | s++; | |
1287 | } | |
1288 | if (gotsome) | |
9494af5d | 1289 | (void) putc('>', fp); |
57cacc90 | 1290 | } |
9494af5d | 1291 | |
31bd2db6 KS |
1292 | int |
1293 | keyword(cp) | |
9494af5d | 1294 | char *cp; |
31bd2db6 KS |
1295 | { |
1296 | register struct keytab *kt = keywords; | |
9494af5d | 1297 | |
31bd2db6 KS |
1298 | while (kt->kt_cp && strcmp(kt->kt_cp, cp)) |
1299 | kt++; | |
1300 | return kt->kt_i; | |
1301 | } | |
1302 | ||
9494af5d | 1303 | void |
31bd2db6 | 1304 | sodump(su, which) |
9494af5d CT |
1305 | register sup su; |
1306 | char *which; | |
31bd2db6 KS |
1307 | { |
1308 | switch (su->sa.sa_family) { | |
1309 | case AF_LINK: | |
9494af5d CT |
1310 | (void) printf("%s: link %s; ", |
1311 | which, link_ntoa(&su->sdl)); | |
31bd2db6 KS |
1312 | break; |
1313 | case AF_ISO: | |
9494af5d CT |
1314 | (void) printf("%s: iso %s; ", |
1315 | which, iso_ntoa(&su->siso.siso_addr)); | |
31bd2db6 KS |
1316 | break; |
1317 | case AF_INET: | |
9494af5d CT |
1318 | (void) printf("%s: inet %s; ", |
1319 | which, inet_ntoa(su->sin.sin_addr)); | |
31bd2db6 KS |
1320 | break; |
1321 | case AF_NS: | |
9494af5d CT |
1322 | (void) printf("%s: xns %s; ", |
1323 | which, ns_ntoa(su->sns.sns_addr)); | |
31bd2db6 KS |
1324 | break; |
1325 | } | |
9494af5d | 1326 | (void) fflush(stdout); |
31bd2db6 | 1327 | } |
d19a4594 | 1328 | |
79394449 KS |
1329 | /* States*/ |
1330 | #define VIRGIN 0 | |
1331 | #define GOTONE 1 | |
1332 | #define GOTTWO 2 | |
1333 | /* Inputs */ | |
1334 | #define DIGIT (4*0) | |
1335 | #define END (4*1) | |
1336 | #define DELIM (4*2) | |
1337 | ||
1338 | void | |
1339 | sockaddr(addr, sa) | |
d19a4594 MK |
1340 | register char *addr; |
1341 | register struct sockaddr *sa; | |
79394449 KS |
1342 | { |
1343 | register char *cp = (char *)sa; | |
1344 | int size = sa->sa_len; | |
1345 | char *cplim = cp + size; | |
1346 | register int byte = 0, state = VIRGIN, new; | |
1347 | ||
1348 | bzero(cp, size); | |
83929a15 | 1349 | cp++; |
79394449 KS |
1350 | do { |
1351 | if ((*addr >= '0') && (*addr <= '9')) { | |
1352 | new = *addr - '0'; | |
1353 | } else if ((*addr >= 'a') && (*addr <= 'f')) { | |
1354 | new = *addr - 'a' + 10; | |
1355 | } else if ((*addr >= 'A') && (*addr <= 'F')) { | |
1356 | new = *addr - 'A' + 10; | |
1357 | } else if (*addr == 0) | |
1358 | state |= END; | |
1359 | else | |
1360 | state |= DELIM; | |
1361 | addr++; | |
1362 | switch (state /* | INPUT */) { | |
1363 | case GOTTWO | DIGIT: | |
1364 | *cp++ = byte; /*FALLTHROUGH*/ | |
1365 | case VIRGIN | DIGIT: | |
1366 | state = GOTONE; byte = new; continue; | |
1367 | case GOTONE | DIGIT: | |
1368 | state = GOTTWO; byte = new + (byte << 4); continue; | |
1369 | default: /* | DELIM */ | |
1370 | state = VIRGIN; *cp++ = byte; byte = 0; continue; | |
1371 | case GOTONE | END: | |
1372 | case GOTTWO | END: | |
1373 | *cp++ = byte; /* FALLTHROUGH */ | |
1374 | case VIRGIN | END: | |
1375 | break; | |
1376 | } | |
1377 | break; | |
1378 | } while (cp < cplim); | |
1379 | sa->sa_len = cp - (char *)sa; | |
1380 | } |