1 | /* vi: set sw=4 ts=4: */
|
---|
2 | /* route
|
---|
3 | *
|
---|
4 | * Similar to the standard Unix route, but with only the necessary
|
---|
5 | * parts for AF_INET and AF_INET6
|
---|
6 | *
|
---|
7 | * Bjorn Wesen, Axis Communications AB
|
---|
8 | *
|
---|
9 | * Author of the original route:
|
---|
10 | * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
|
---|
11 | * (derived from FvK's 'route.c 1.70 01/04/94')
|
---|
12 | *
|
---|
13 | * Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
---|
14 | *
|
---|
15 | *
|
---|
16 | * displayroute() code added by Vladimir N. Oleynik <dzo@simtreas.ru>
|
---|
17 | * adjustments by Larry Doolittle <LRDoolittle@lbl.gov>
|
---|
18 | *
|
---|
19 | * IPV6 support added by Bart Visscher <magick@linux-fan.com>
|
---|
20 | */
|
---|
21 |
|
---|
22 | /* 2004/03/09 Manuel Novoa III <mjn3@codepoet.org>
|
---|
23 | *
|
---|
24 | * Rewritten to fix several bugs, add additional error checking, and
|
---|
25 | * remove ridiculous amounts of bloat.
|
---|
26 | */
|
---|
27 |
|
---|
28 | //usage:#define route_trivial_usage
|
---|
29 | //usage: "[{add|del|delete}]"
|
---|
30 | //usage:#define route_full_usage "\n\n"
|
---|
31 | //usage: "Edit kernel routing tables\n"
|
---|
32 | //usage: "\n -n Don't resolve names"
|
---|
33 | //usage: "\n -e Display other/more information"
|
---|
34 | //usage: "\n -A inet" IF_FEATURE_IPV6("{6}") " Select address family"
|
---|
35 |
|
---|
36 | #include <net/route.h>
|
---|
37 | #include <net/if.h>
|
---|
38 |
|
---|
39 | #include "libbb.h"
|
---|
40 | #include "inet_common.h"
|
---|
41 |
|
---|
42 |
|
---|
43 | #ifndef RTF_UP
|
---|
44 | /* Keep this in sync with /usr/src/linux/include/linux/route.h */
|
---|
45 | #define RTF_UP 0x0001 /* route usable */
|
---|
46 | #define RTF_GATEWAY 0x0002 /* destination is a gateway */
|
---|
47 | #define RTF_HOST 0x0004 /* host entry (net otherwise) */
|
---|
48 | #define RTF_REINSTATE 0x0008 /* reinstate route after tmout */
|
---|
49 | #define RTF_DYNAMIC 0x0010 /* created dyn. (by redirect) */
|
---|
50 | #define RTF_MODIFIED 0x0020 /* modified dyn. (by redirect) */
|
---|
51 | #define RTF_MTU 0x0040 /* specific MTU for this route */
|
---|
52 | #ifndef RTF_MSS
|
---|
53 | #define RTF_MSS RTF_MTU /* Compatibility :-( */
|
---|
54 | #endif
|
---|
55 | #define RTF_WINDOW 0x0080 /* per route window clamping */
|
---|
56 | #define RTF_IRTT 0x0100 /* Initial round trip time */
|
---|
57 | #define RTF_REJECT 0x0200 /* Reject route */
|
---|
58 | #endif
|
---|
59 |
|
---|
60 | #if defined(SIOCADDRTOLD) || defined(RTF_IRTT) /* route */
|
---|
61 | #define HAVE_NEW_ADDRT 1
|
---|
62 | #endif
|
---|
63 |
|
---|
64 | #if HAVE_NEW_ADDRT
|
---|
65 | #define mask_in_addr(x) (((struct sockaddr_in *)&((x).rt_genmask))->sin_addr.s_addr)
|
---|
66 | #define full_mask(x) (x)
|
---|
67 | #else
|
---|
68 | #define mask_in_addr(x) ((x).rt_genmask)
|
---|
69 | #define full_mask(x) (((struct sockaddr_in *)&(x))->sin_addr.s_addr)
|
---|
70 | #endif
|
---|
71 |
|
---|
72 | /* The RTACTION entries must agree with tbl_verb[] below! */
|
---|
73 | #define RTACTION_ADD 1
|
---|
74 | #define RTACTION_DEL 2
|
---|
75 |
|
---|
76 | /* For the various tbl_*[] arrays, the 1st byte is the offset to
|
---|
77 | * the next entry and the 2nd byte is return value. */
|
---|
78 |
|
---|
79 | #define NET_FLAG 1
|
---|
80 | #define HOST_FLAG 2
|
---|
81 |
|
---|
82 | /* We remap '-' to '#' to avoid problems with getopt. */
|
---|
83 | static const char tbl_hash_net_host[] ALIGN1 =
|
---|
84 | "\007\001#net\0"
|
---|
85 | /* "\010\002#host\0" */
|
---|
86 | "\007\002#host" /* Since last, we can save a byte. */
|
---|
87 | ;
|
---|
88 |
|
---|
89 | #define KW_TAKES_ARG 020
|
---|
90 | #define KW_SETS_FLAG 040
|
---|
91 |
|
---|
92 | #define KW_IPVx_METRIC 020
|
---|
93 | #define KW_IPVx_NETMASK 021
|
---|
94 | #define KW_IPVx_GATEWAY 022
|
---|
95 | #define KW_IPVx_MSS 023
|
---|
96 | #define KW_IPVx_WINDOW 024
|
---|
97 | #define KW_IPVx_IRTT 025
|
---|
98 | #define KW_IPVx_DEVICE 026
|
---|
99 |
|
---|
100 | #define KW_IPVx_FLAG_ONLY 040
|
---|
101 | #define KW_IPVx_REJECT 040
|
---|
102 | #define KW_IPVx_MOD 041
|
---|
103 | #define KW_IPVx_DYN 042
|
---|
104 | #define KW_IPVx_REINSTATE 043
|
---|
105 |
|
---|
106 | static const char tbl_ipvx[] ALIGN1 =
|
---|
107 | /* 020 is the "takes an arg" bit */
|
---|
108 | #if HAVE_NEW_ADDRT
|
---|
109 | "\011\020metric\0"
|
---|
110 | #endif
|
---|
111 | "\012\021netmask\0"
|
---|
112 | "\005\022gw\0"
|
---|
113 | "\012\022gateway\0"
|
---|
114 | "\006\023mss\0"
|
---|
115 | "\011\024window\0"
|
---|
116 | #ifdef RTF_IRTT
|
---|
117 | "\007\025irtt\0"
|
---|
118 | #endif
|
---|
119 | "\006\026dev\0"
|
---|
120 | "\011\026device\0"
|
---|
121 | /* 040 is the "sets a flag" bit - MUST match flags_ipvx[] values below. */
|
---|
122 | #ifdef RTF_REJECT
|
---|
123 | "\011\040reject\0"
|
---|
124 | #endif
|
---|
125 | "\006\041mod\0"
|
---|
126 | "\006\042dyn\0"
|
---|
127 | /* "\014\043reinstate\0" */
|
---|
128 | "\013\043reinstate" /* Since last, we can save a byte. */
|
---|
129 | ;
|
---|
130 |
|
---|
131 | static const int flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
|
---|
132 | #ifdef RTF_REJECT
|
---|
133 | RTF_REJECT,
|
---|
134 | #endif
|
---|
135 | RTF_MODIFIED,
|
---|
136 | RTF_DYNAMIC,
|
---|
137 | RTF_REINSTATE
|
---|
138 | };
|
---|
139 |
|
---|
140 | static int kw_lookup(const char *kwtbl, char ***pargs)
|
---|
141 | {
|
---|
142 | if (**pargs) {
|
---|
143 | do {
|
---|
144 | if (strcmp(kwtbl+2, **pargs) == 0) { /* Found a match. */
|
---|
145 | *pargs += 1;
|
---|
146 | if (kwtbl[1] & KW_TAKES_ARG) {
|
---|
147 | if (!**pargs) { /* No more args! */
|
---|
148 | bb_show_usage();
|
---|
149 | }
|
---|
150 | *pargs += 1; /* Calling routine will use args[-1]. */
|
---|
151 | }
|
---|
152 | return kwtbl[1];
|
---|
153 | }
|
---|
154 | kwtbl += *kwtbl;
|
---|
155 | } while (*kwtbl);
|
---|
156 | }
|
---|
157 | return 0;
|
---|
158 | }
|
---|
159 |
|
---|
160 | /* Add or delete a route, depending on action. */
|
---|
161 |
|
---|
162 | static NOINLINE void INET_setroute(int action, char **args)
|
---|
163 | {
|
---|
164 | /* char buffer instead of bona-fide struct avoids aliasing warning */
|
---|
165 | char rt_buf[sizeof(struct rtentry)];
|
---|
166 | struct rtentry *const rt = (void *)rt_buf;
|
---|
167 |
|
---|
168 | const char *netmask = NULL;
|
---|
169 | int skfd, isnet, xflag;
|
---|
170 |
|
---|
171 | /* Grab the -net or -host options. Remember they were transformed. */
|
---|
172 | xflag = kw_lookup(tbl_hash_net_host, &args);
|
---|
173 |
|
---|
174 | /* If we did grab -net or -host, make sure we still have an arg left. */
|
---|
175 | if (*args == NULL) {
|
---|
176 | bb_show_usage();
|
---|
177 | }
|
---|
178 |
|
---|
179 | /* Clean out the RTREQ structure. */
|
---|
180 | memset(rt, 0, sizeof(*rt));
|
---|
181 |
|
---|
182 | {
|
---|
183 | const char *target = *args++;
|
---|
184 | char *prefix;
|
---|
185 |
|
---|
186 | /* recognize x.x.x.x/mask format. */
|
---|
187 | prefix = strchr(target, '/');
|
---|
188 | if (prefix) {
|
---|
189 | int prefix_len;
|
---|
190 |
|
---|
191 | prefix_len = xatoul_range(prefix+1, 0, 32);
|
---|
192 | mask_in_addr(*rt) = htonl( ~(0xffffffffUL >> prefix_len));
|
---|
193 | *prefix = '\0';
|
---|
194 | #if HAVE_NEW_ADDRT
|
---|
195 | rt->rt_genmask.sa_family = AF_INET;
|
---|
196 | #endif
|
---|
197 | } else {
|
---|
198 | /* Default netmask. */
|
---|
199 | netmask = "default";
|
---|
200 | }
|
---|
201 | /* Prefer hostname lookup is -host flag (xflag==1) was given. */
|
---|
202 | isnet = INET_resolve(target, (struct sockaddr_in *) &rt->rt_dst,
|
---|
203 | (xflag & HOST_FLAG));
|
---|
204 | if (isnet < 0) {
|
---|
205 | bb_error_msg_and_die("resolving %s", target);
|
---|
206 | }
|
---|
207 | if (prefix) {
|
---|
208 | /* do not destroy prefix for process args */
|
---|
209 | *prefix = '/';
|
---|
210 | }
|
---|
211 | }
|
---|
212 |
|
---|
213 | if (xflag) { /* Reinit isnet if -net or -host was specified. */
|
---|
214 | isnet = (xflag & NET_FLAG);
|
---|
215 | }
|
---|
216 |
|
---|
217 | /* Fill in the other fields. */
|
---|
218 | rt->rt_flags = ((isnet) ? RTF_UP : (RTF_UP | RTF_HOST));
|
---|
219 |
|
---|
220 | while (*args) {
|
---|
221 | int k = kw_lookup(tbl_ipvx, &args);
|
---|
222 | const char *args_m1 = args[-1];
|
---|
223 |
|
---|
224 | if (k & KW_IPVx_FLAG_ONLY) {
|
---|
225 | rt->rt_flags |= flags_ipvx[k & 3];
|
---|
226 | continue;
|
---|
227 | }
|
---|
228 |
|
---|
229 | #if HAVE_NEW_ADDRT
|
---|
230 | if (k == KW_IPVx_METRIC) {
|
---|
231 | rt->rt_metric = xatoul(args_m1) + 1;
|
---|
232 | continue;
|
---|
233 | }
|
---|
234 | #endif
|
---|
235 |
|
---|
236 | if (k == KW_IPVx_NETMASK) {
|
---|
237 | struct sockaddr mask;
|
---|
238 |
|
---|
239 | if (mask_in_addr(*rt)) {
|
---|
240 | bb_show_usage();
|
---|
241 | }
|
---|
242 |
|
---|
243 | netmask = args_m1;
|
---|
244 | isnet = INET_resolve(netmask, (struct sockaddr_in *) &mask, 0);
|
---|
245 | if (isnet < 0) {
|
---|
246 | bb_error_msg_and_die("resolving %s", netmask);
|
---|
247 | }
|
---|
248 | rt->rt_genmask = full_mask(mask);
|
---|
249 | continue;
|
---|
250 | }
|
---|
251 |
|
---|
252 | if (k == KW_IPVx_GATEWAY) {
|
---|
253 | if (rt->rt_flags & RTF_GATEWAY) {
|
---|
254 | bb_show_usage();
|
---|
255 | }
|
---|
256 |
|
---|
257 | isnet = INET_resolve(args_m1,
|
---|
258 | (struct sockaddr_in *) &rt->rt_gateway, 1);
|
---|
259 | rt->rt_flags |= RTF_GATEWAY;
|
---|
260 |
|
---|
261 | if (isnet) {
|
---|
262 | if (isnet < 0) {
|
---|
263 | bb_error_msg_and_die("resolving %s", args_m1);
|
---|
264 | }
|
---|
265 | bb_error_msg_and_die("gateway %s is a NETWORK", args_m1);
|
---|
266 | }
|
---|
267 | continue;
|
---|
268 | }
|
---|
269 |
|
---|
270 | if (k == KW_IPVx_MSS) { /* Check valid MSS bounds. */
|
---|
271 | rt->rt_flags |= RTF_MSS;
|
---|
272 | rt->rt_mss = xatoul_range(args_m1, 64, 32768);
|
---|
273 | continue;
|
---|
274 | }
|
---|
275 |
|
---|
276 | if (k == KW_IPVx_WINDOW) { /* Check valid window bounds. */
|
---|
277 | rt->rt_flags |= RTF_WINDOW;
|
---|
278 | rt->rt_window = xatoul_range(args_m1, 128, INT_MAX);
|
---|
279 | continue;
|
---|
280 | }
|
---|
281 |
|
---|
282 | #ifdef RTF_IRTT
|
---|
283 | if (k == KW_IPVx_IRTT) {
|
---|
284 | rt->rt_flags |= RTF_IRTT;
|
---|
285 | rt->rt_irtt = xatoul(args_m1);
|
---|
286 | rt->rt_irtt *= (sysconf(_SC_CLK_TCK) / 100); /* FIXME */
|
---|
287 | #if 0 /* FIXME: do we need to check anything of this? */
|
---|
288 | if (rt->rt_irtt < 1 || rt->rt_irtt > (120 * HZ)) {
|
---|
289 | bb_error_msg_and_die("bad irtt");
|
---|
290 | }
|
---|
291 | #endif
|
---|
292 | continue;
|
---|
293 | }
|
---|
294 | #endif
|
---|
295 |
|
---|
296 | /* Device is special in that it can be the last arg specified
|
---|
297 | * and doesn't requre the dev/device keyword in that case. */
|
---|
298 | if (!rt->rt_dev && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
|
---|
299 | /* Don't use args_m1 here since args may have changed! */
|
---|
300 | rt->rt_dev = args[-1];
|
---|
301 | continue;
|
---|
302 | }
|
---|
303 |
|
---|
304 | /* Nothing matched. */
|
---|
305 | bb_show_usage();
|
---|
306 | }
|
---|
307 |
|
---|
308 | #ifdef RTF_REJECT
|
---|
309 | if ((rt->rt_flags & RTF_REJECT) && !rt->rt_dev) {
|
---|
310 | rt->rt_dev = (char*)"lo";
|
---|
311 | }
|
---|
312 | #endif
|
---|
313 |
|
---|
314 | /* sanity checks.. */
|
---|
315 | if (mask_in_addr(*rt)) {
|
---|
316 | uint32_t mask = mask_in_addr(*rt);
|
---|
317 |
|
---|
318 | mask = ~ntohl(mask);
|
---|
319 | if ((rt->rt_flags & RTF_HOST) && mask != 0xffffffff) {
|
---|
320 | bb_error_msg_and_die("netmask %.8x and host route conflict",
|
---|
321 | (unsigned int) mask);
|
---|
322 | }
|
---|
323 | if (mask & (mask + 1)) {
|
---|
324 | bb_error_msg_and_die("bogus netmask %s", netmask);
|
---|
325 | }
|
---|
326 | mask = ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr;
|
---|
327 | if (mask & ~(uint32_t)mask_in_addr(*rt)) {
|
---|
328 | bb_error_msg_and_die("netmask and route address conflict");
|
---|
329 | }
|
---|
330 | }
|
---|
331 |
|
---|
332 | /* Fill out netmask if still unset */
|
---|
333 | if ((action == RTACTION_ADD) && (rt->rt_flags & RTF_HOST)) {
|
---|
334 | mask_in_addr(*rt) = 0xffffffff;
|
---|
335 | }
|
---|
336 |
|
---|
337 | /* Create a socket to the INET kernel. */
|
---|
338 | skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
|
---|
339 |
|
---|
340 | if (action == RTACTION_ADD)
|
---|
341 | xioctl(skfd, SIOCADDRT, rt);
|
---|
342 | else
|
---|
343 | xioctl(skfd, SIOCDELRT, rt);
|
---|
344 |
|
---|
345 | if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
|
---|
346 | }
|
---|
347 |
|
---|
348 | #if ENABLE_FEATURE_IPV6
|
---|
349 |
|
---|
350 | static NOINLINE void INET6_setroute(int action, char **args)
|
---|
351 | {
|
---|
352 | struct sockaddr_in6 sa6;
|
---|
353 | struct in6_rtmsg rt;
|
---|
354 | int prefix_len, skfd;
|
---|
355 | const char *devname;
|
---|
356 |
|
---|
357 | /* We know args isn't NULL from the check in route_main. */
|
---|
358 | const char *target = *args++;
|
---|
359 |
|
---|
360 | if (strcmp(target, "default") == 0) {
|
---|
361 | prefix_len = 0;
|
---|
362 | memset(&sa6, 0, sizeof(sa6));
|
---|
363 | } else {
|
---|
364 | char *cp;
|
---|
365 | cp = strchr(target, '/'); /* Yes... const to non is ok. */
|
---|
366 | if (cp) {
|
---|
367 | *cp = '\0';
|
---|
368 | prefix_len = xatoul_range(cp + 1, 0, 128);
|
---|
369 | } else {
|
---|
370 | prefix_len = 128;
|
---|
371 | }
|
---|
372 | if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
|
---|
373 | bb_error_msg_and_die("resolving %s", target);
|
---|
374 | }
|
---|
375 | }
|
---|
376 |
|
---|
377 | /* Clean out the RTREQ structure. */
|
---|
378 | memset(&rt, 0, sizeof(rt));
|
---|
379 |
|
---|
380 | memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
|
---|
381 |
|
---|
382 | /* Fill in the other fields. */
|
---|
383 | rt.rtmsg_dst_len = prefix_len;
|
---|
384 | rt.rtmsg_flags = ((prefix_len == 128) ? (RTF_UP|RTF_HOST) : RTF_UP);
|
---|
385 | rt.rtmsg_metric = 1;
|
---|
386 |
|
---|
387 | devname = NULL;
|
---|
388 |
|
---|
389 | while (*args) {
|
---|
390 | int k = kw_lookup(tbl_ipvx, &args);
|
---|
391 | const char *args_m1 = args[-1];
|
---|
392 |
|
---|
393 | if ((k == KW_IPVx_MOD) || (k == KW_IPVx_DYN)) {
|
---|
394 | rt.rtmsg_flags |= flags_ipvx[k & 3];
|
---|
395 | continue;
|
---|
396 | }
|
---|
397 |
|
---|
398 | if (k == KW_IPVx_METRIC) {
|
---|
399 | rt.rtmsg_metric = xatoul(args_m1);
|
---|
400 | continue;
|
---|
401 | }
|
---|
402 |
|
---|
403 | if (k == KW_IPVx_GATEWAY) {
|
---|
404 | if (rt.rtmsg_flags & RTF_GATEWAY) {
|
---|
405 | bb_show_usage();
|
---|
406 | }
|
---|
407 |
|
---|
408 | if (INET6_resolve(args_m1, (struct sockaddr_in6 *) &sa6) < 0) {
|
---|
409 | bb_error_msg_and_die("resolving %s", args_m1);
|
---|
410 | }
|
---|
411 | memcpy(&rt.rtmsg_gateway, sa6.sin6_addr.s6_addr,
|
---|
412 | sizeof(struct in6_addr));
|
---|
413 | rt.rtmsg_flags |= RTF_GATEWAY;
|
---|
414 | continue;
|
---|
415 | }
|
---|
416 |
|
---|
417 | /* Device is special in that it can be the last arg specified
|
---|
418 | * and doesn't requre the dev/device keyword in that case. */
|
---|
419 | if (!devname && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
|
---|
420 | /* Don't use args_m1 here since args may have changed! */
|
---|
421 | devname = args[-1];
|
---|
422 | continue;
|
---|
423 | }
|
---|
424 |
|
---|
425 | /* Nothing matched. */
|
---|
426 | bb_show_usage();
|
---|
427 | }
|
---|
428 |
|
---|
429 | /* Create a socket to the INET6 kernel. */
|
---|
430 | skfd = xsocket(AF_INET6, SOCK_DGRAM, 0);
|
---|
431 |
|
---|
432 | rt.rtmsg_ifindex = 0;
|
---|
433 |
|
---|
434 | if (devname) {
|
---|
435 | struct ifreq ifr;
|
---|
436 | memset(&ifr, 0, sizeof(ifr));
|
---|
437 | strncpy_IFNAMSIZ(ifr.ifr_name, devname);
|
---|
438 | xioctl(skfd, SIOCGIFINDEX, &ifr);
|
---|
439 | rt.rtmsg_ifindex = ifr.ifr_ifindex;
|
---|
440 | }
|
---|
441 |
|
---|
442 | /* Tell the kernel to accept this route. */
|
---|
443 | if (action == RTACTION_ADD)
|
---|
444 | xioctl(skfd, SIOCADDRT, &rt);
|
---|
445 | else
|
---|
446 | xioctl(skfd, SIOCDELRT, &rt);
|
---|
447 |
|
---|
448 | if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
|
---|
449 | }
|
---|
450 | #endif
|
---|
451 |
|
---|
452 | static const unsigned flagvals[] = { /* Must agree with flagchars[]. */
|
---|
453 | RTF_GATEWAY,
|
---|
454 | RTF_HOST,
|
---|
455 | RTF_REINSTATE,
|
---|
456 | RTF_DYNAMIC,
|
---|
457 | RTF_MODIFIED,
|
---|
458 | #if ENABLE_FEATURE_IPV6
|
---|
459 | RTF_DEFAULT,
|
---|
460 | RTF_ADDRCONF,
|
---|
461 | RTF_CACHE
|
---|
462 | #endif
|
---|
463 | };
|
---|
464 |
|
---|
465 | #define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
|
---|
466 | #define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
|
---|
467 |
|
---|
468 | /* Must agree with flagvals[]. */
|
---|
469 | static const char flagchars[] ALIGN1 =
|
---|
470 | "GHRDM"
|
---|
471 | #if ENABLE_FEATURE_IPV6
|
---|
472 | "DAC"
|
---|
473 | #endif
|
---|
474 | ;
|
---|
475 |
|
---|
476 | static void set_flags(char *flagstr, int flags)
|
---|
477 | {
|
---|
478 | int i;
|
---|
479 |
|
---|
480 | *flagstr++ = 'U';
|
---|
481 |
|
---|
482 | for (i = 0; (*flagstr = flagchars[i]) != 0; i++) {
|
---|
483 | if (flags & flagvals[i]) {
|
---|
484 | ++flagstr;
|
---|
485 | }
|
---|
486 | }
|
---|
487 | }
|
---|
488 |
|
---|
489 | /* also used in netstat */
|
---|
490 | void FAST_FUNC bb_displayroutes(int noresolve, int netstatfmt)
|
---|
491 | {
|
---|
492 | char devname[64], flags[16], *sdest, *sgw;
|
---|
493 | unsigned long d, g, m;
|
---|
494 | int flgs, ref, use, metric, mtu, win, ir;
|
---|
495 | struct sockaddr_in s_addr;
|
---|
496 | struct in_addr mask;
|
---|
497 |
|
---|
498 | FILE *fp = xfopen_for_read("/proc/net/route");
|
---|
499 |
|
---|
500 | printf("Kernel IP routing table\n"
|
---|
501 | "Destination Gateway Genmask Flags %s Iface\n",
|
---|
502 | netstatfmt ? " MSS Window irtt" : "Metric Ref Use");
|
---|
503 |
|
---|
504 | if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
|
---|
505 | goto ERROR; /* Empty or missing line, or read error. */
|
---|
506 | }
|
---|
507 | while (1) {
|
---|
508 | int r;
|
---|
509 | r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
|
---|
510 | devname, &d, &g, &flgs, &ref, &use, &metric, &m,
|
---|
511 | &mtu, &win, &ir);
|
---|
512 | if (r != 11) {
|
---|
513 | if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
|
---|
514 | break;
|
---|
515 | }
|
---|
516 | ERROR:
|
---|
517 | bb_error_msg_and_die("fscanf");
|
---|
518 | }
|
---|
519 |
|
---|
520 | if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
|
---|
521 | continue;
|
---|
522 | }
|
---|
523 |
|
---|
524 | set_flags(flags, (flgs & IPV4_MASK));
|
---|
525 | #ifdef RTF_REJECT
|
---|
526 | if (flgs & RTF_REJECT) {
|
---|
527 | flags[0] = '!';
|
---|
528 | }
|
---|
529 | #endif
|
---|
530 |
|
---|
531 | memset(&s_addr, 0, sizeof(struct sockaddr_in));
|
---|
532 | s_addr.sin_family = AF_INET;
|
---|
533 | s_addr.sin_addr.s_addr = d;
|
---|
534 | sdest = INET_rresolve(&s_addr, (noresolve | 0x8000), m); /* 'default' instead of '*' */
|
---|
535 | s_addr.sin_addr.s_addr = g;
|
---|
536 | sgw = INET_rresolve(&s_addr, (noresolve | 0x4000), m); /* Host instead of net */
|
---|
537 | mask.s_addr = m;
|
---|
538 | /* "%15.15s" truncates hostnames, do we really want that? */
|
---|
539 | printf("%-15.15s %-15.15s %-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
|
---|
540 | free(sdest);
|
---|
541 | free(sgw);
|
---|
542 | if (netstatfmt) {
|
---|
543 | printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
|
---|
544 | } else {
|
---|
545 | printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
|
---|
546 | }
|
---|
547 | }
|
---|
548 | fclose(fp);
|
---|
549 | }
|
---|
550 |
|
---|
551 | #if ENABLE_FEATURE_IPV6
|
---|
552 |
|
---|
553 | static void INET6_displayroutes(void)
|
---|
554 | {
|
---|
555 | char addr6[128], *naddr6;
|
---|
556 | /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
|
---|
557 | * We read the non-delimited strings into the tail of the buffer
|
---|
558 | * using fscanf and then modify the buffer by shifting forward
|
---|
559 | * while inserting ':'s and the nul terminator for the first string.
|
---|
560 | * Hence the strings are at addr6x and addr6x+40. This generates
|
---|
561 | * _much_ less code than the previous (upstream) approach. */
|
---|
562 | char addr6x[80];
|
---|
563 | char iface[16], flags[16];
|
---|
564 | int iflags, metric, refcnt, use, prefix_len, slen;
|
---|
565 | struct sockaddr_in6 snaddr6;
|
---|
566 |
|
---|
567 | FILE *fp = xfopen_for_read("/proc/net/ipv6_route");
|
---|
568 |
|
---|
569 | printf("Kernel IPv6 routing table\n%-44s%-40s"
|
---|
570 | "Flags Metric Ref Use Iface\n",
|
---|
571 | "Destination", "Next Hop");
|
---|
572 |
|
---|
573 | while (1) {
|
---|
574 | int r;
|
---|
575 | r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
|
---|
576 | addr6x+14, &prefix_len, &slen, addr6x+40+7,
|
---|
577 | &metric, &use, &refcnt, &iflags, iface);
|
---|
578 | if (r != 9) {
|
---|
579 | if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
|
---|
580 | break;
|
---|
581 | }
|
---|
582 | ERROR:
|
---|
583 | bb_error_msg_and_die("fscanf");
|
---|
584 | }
|
---|
585 |
|
---|
586 | /* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
|
---|
587 | * For now, always do this to validate the proc route format, even
|
---|
588 | * if the interface is down. */
|
---|
589 | {
|
---|
590 | int i = 0;
|
---|
591 | char *p = addr6x+14;
|
---|
592 |
|
---|
593 | do {
|
---|
594 | if (!*p) {
|
---|
595 | if (i == 40) { /* nul terminator for 1st address? */
|
---|
596 | addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
|
---|
597 | ++p; /* Skip and continue. */
|
---|
598 | continue;
|
---|
599 | }
|
---|
600 | goto ERROR;
|
---|
601 | }
|
---|
602 | addr6x[i++] = *p++;
|
---|
603 | if (!((i+1) % 5)) {
|
---|
604 | addr6x[i++] = ':';
|
---|
605 | }
|
---|
606 | } while (i < 40+28+7);
|
---|
607 | }
|
---|
608 |
|
---|
609 | if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
|
---|
610 | continue;
|
---|
611 | }
|
---|
612 |
|
---|
613 | set_flags(flags, (iflags & IPV6_MASK));
|
---|
614 |
|
---|
615 | r = 0;
|
---|
616 | while (1) {
|
---|
617 | inet_pton(AF_INET6, addr6x + r,
|
---|
618 | (struct sockaddr *) &snaddr6.sin6_addr);
|
---|
619 | snaddr6.sin6_family = AF_INET6;
|
---|
620 | naddr6 = INET6_rresolve((struct sockaddr_in6 *) &snaddr6,
|
---|
621 | 0x0fff /* Apparently, upstream never resolves. */
|
---|
622 | );
|
---|
623 |
|
---|
624 | if (!r) { /* 1st pass */
|
---|
625 | snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
|
---|
626 | r += 40;
|
---|
627 | free(naddr6);
|
---|
628 | } else { /* 2nd pass */
|
---|
629 | /* Print the info. */
|
---|
630 | printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
|
---|
631 | addr6, naddr6, flags, metric, refcnt, use, iface);
|
---|
632 | free(naddr6);
|
---|
633 | break;
|
---|
634 | }
|
---|
635 | }
|
---|
636 | }
|
---|
637 | fclose(fp);
|
---|
638 | }
|
---|
639 |
|
---|
640 | #endif
|
---|
641 |
|
---|
642 | #define ROUTE_OPT_A 0x01
|
---|
643 | #define ROUTE_OPT_n 0x02
|
---|
644 | #define ROUTE_OPT_e 0x04
|
---|
645 | #define ROUTE_OPT_INET6 0x08 /* Not an actual option. See below. */
|
---|
646 |
|
---|
647 | /* 1st byte is offset to next entry offset. 2nd byte is return value. */
|
---|
648 | /* 2nd byte matches RTACTION_* code */
|
---|
649 | static const char tbl_verb[] ALIGN1 =
|
---|
650 | "\006\001add\0"
|
---|
651 | "\006\002del\0"
|
---|
652 | /* "\011\002delete\0" */
|
---|
653 | "\010\002delete" /* Since it's last, we can save a byte. */
|
---|
654 | ;
|
---|
655 |
|
---|
656 | int route_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
657 | int route_main(int argc UNUSED_PARAM, char **argv)
|
---|
658 | {
|
---|
659 | unsigned opt;
|
---|
660 | int what;
|
---|
661 | char *family;
|
---|
662 | char **p;
|
---|
663 |
|
---|
664 | /* First, remap '-net' and '-host' to avoid getopt problems. */
|
---|
665 | p = argv;
|
---|
666 | while (*++p) {
|
---|
667 | if (strcmp(*p, "-net") == 0 || strcmp(*p, "-host") == 0) {
|
---|
668 | p[0][0] = '#';
|
---|
669 | }
|
---|
670 | }
|
---|
671 |
|
---|
672 | opt = getopt32(argv, "A:ne", &family);
|
---|
673 |
|
---|
674 | if ((opt & ROUTE_OPT_A) && strcmp(family, "inet") != 0) {
|
---|
675 | #if ENABLE_FEATURE_IPV6
|
---|
676 | if (strcmp(family, "inet6") == 0) {
|
---|
677 | opt |= ROUTE_OPT_INET6; /* Set flag for ipv6. */
|
---|
678 | } else
|
---|
679 | #endif
|
---|
680 | bb_show_usage();
|
---|
681 | }
|
---|
682 |
|
---|
683 | argv += optind;
|
---|
684 |
|
---|
685 | /* No more args means display the routing table. */
|
---|
686 | if (!*argv) {
|
---|
687 | int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
|
---|
688 | #if ENABLE_FEATURE_IPV6
|
---|
689 | if (opt & ROUTE_OPT_INET6)
|
---|
690 | INET6_displayroutes();
|
---|
691 | else
|
---|
692 | #endif
|
---|
693 | bb_displayroutes(noresolve, opt & ROUTE_OPT_e);
|
---|
694 |
|
---|
695 | fflush_stdout_and_exit(EXIT_SUCCESS);
|
---|
696 | }
|
---|
697 |
|
---|
698 | /* Check verb. At the moment, must be add, del, or delete. */
|
---|
699 | what = kw_lookup(tbl_verb, &argv);
|
---|
700 | if (!what || !*argv) { /* Unknown verb or no more args. */
|
---|
701 | bb_show_usage();
|
---|
702 | }
|
---|
703 |
|
---|
704 | #if ENABLE_FEATURE_IPV6
|
---|
705 | if (opt & ROUTE_OPT_INET6)
|
---|
706 | INET6_setroute(what, argv);
|
---|
707 | else
|
---|
708 | #endif
|
---|
709 | INET_setroute(what, argv);
|
---|
710 |
|
---|
711 | return EXIT_SUCCESS;
|
---|
712 | }
|
---|