1 /* vi: set sw=4 ts=4: */
3 * iproute.c "ip route".
5 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
7 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
12 * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
13 * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
16 #include "ip_common.h" /* #include "libbb.h" is inside */
21 #define RTAX_RTTVAR RTAX_HOPS
25 typedef struct filter_t {
31 struct rtnl_handle *rth;
32 int protocol, protocolmask;
47 #define filter (*(filter_t*)&bb_common_bufsiz1)
49 static int flush_update(void)
51 if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
52 bb_perror_msg("failed to send flush request");
59 static unsigned get_hz(void)
61 static unsigned hz_internal;
67 fp = fopen("/proc/net/psched", "r");
71 if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
77 hz_internal = sysconf(_SC_CLK_TCK);
81 static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED,
82 struct nlmsghdr *n, void *arg)
84 FILE *fp = (FILE*)arg;
85 struct rtmsg *r = NLMSG_DATA(n);
86 int len = n->nlmsg_len;
87 struct rtattr * tb[RTA_MAX+1];
95 if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
96 fprintf(stderr, "Not a route: %08x %08x %08x\n",
97 n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
100 if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
102 len -= NLMSG_LENGTH(sizeof(*r));
104 bb_error_msg_and_die("wrong nlmsg len %d", len);
106 if (r->rtm_family == AF_INET6)
108 else if (r->rtm_family == AF_INET)
111 if (r->rtm_family == AF_INET6) {
114 if (!(r->rtm_flags&RTM_F_CLONED)) {
118 if (r->rtm_flags&RTM_F_CLONED) {
121 if (filter.tb == RT_TABLE_LOCAL) {
122 if (r->rtm_type != RTN_LOCAL) {
125 } else if (filter.tb == RT_TABLE_MAIN) {
126 if (r->rtm_type == RTN_LOCAL) {
135 if (filter.tb > 0 && filter.tb != r->rtm_table) {
139 if (filter.rdst.family &&
140 (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len)) {
143 if (filter.mdst.family &&
144 (r->rtm_family != filter.mdst.family ||
145 (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len))) {
148 if (filter.rsrc.family &&
149 (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len)) {
152 if (filter.msrc.family &&
153 (r->rtm_family != filter.msrc.family ||
154 (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len))) {
158 memset(tb, 0, sizeof(tb));
159 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
161 if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))
163 if (filter.mdst.family && filter.mdst.bitlen >= 0 &&
164 inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
167 if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))
169 if (filter.msrc.family && filter.msrc.bitlen >= 0 &&
170 inet_addr_match(&src, &filter.msrc, r->rtm_src_len))
174 r->rtm_family == AF_INET6 &&
175 r->rtm_dst_len == 0 &&
176 r->rtm_type == RTN_UNREACHABLE &&
178 *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1)
183 if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
185 bb_error_msg_and_die("flush");
187 fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
188 memcpy(fn, n, n->nlmsg_len);
189 fn->nlmsg_type = RTM_DELROUTE;
190 fn->nlmsg_flags = NLM_F_REQUEST;
191 fn->nlmsg_seq = ++filter.rth->seq;
192 filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
197 if (n->nlmsg_type == RTM_DELROUTE) {
198 fprintf(fp, "Deleted ");
200 if (r->rtm_type != RTN_UNICAST && !filter.type) {
201 fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
205 if (r->rtm_dst_len != host_len) {
206 fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family,
207 RTA_PAYLOAD(tb[RTA_DST]),
208 RTA_DATA(tb[RTA_DST]),
213 fprintf(fp, "%s ", format_host(r->rtm_family,
214 RTA_PAYLOAD(tb[RTA_DST]),
215 RTA_DATA(tb[RTA_DST]),
219 } else if (r->rtm_dst_len) {
220 fprintf(fp, "0/%d ", r->rtm_dst_len);
222 fprintf(fp, "default ");
225 if (r->rtm_src_len != host_len) {
226 fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family,
227 RTA_PAYLOAD(tb[RTA_SRC]),
228 RTA_DATA(tb[RTA_SRC]),
233 fprintf(fp, "from %s ", format_host(r->rtm_family,
234 RTA_PAYLOAD(tb[RTA_SRC]),
235 RTA_DATA(tb[RTA_SRC]),
239 } else if (r->rtm_src_len) {
240 fprintf(fp, "from 0/%u ", r->rtm_src_len);
242 if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
243 fprintf(fp, "via %s ",
244 format_host(r->rtm_family,
245 RTA_PAYLOAD(tb[RTA_GATEWAY]),
246 RTA_DATA(tb[RTA_GATEWAY]),
247 abuf, sizeof(abuf)));
249 if (tb[RTA_OIF] && filter.oifmask != -1) {
250 fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
253 if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
254 /* Do not use format_host(). It is our local addr
255 and symbolic name will not be useful.
257 fprintf(fp, " src %s ",
258 rt_addr_n2a(r->rtm_family,
259 RTA_PAYLOAD(tb[RTA_PREFSRC]),
260 RTA_DATA(tb[RTA_PREFSRC]),
261 abuf, sizeof(abuf)));
263 if (tb[RTA_PRIORITY]) {
264 fprintf(fp, " metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
266 if (r->rtm_family == AF_INET6) {
267 struct rta_cacheinfo *ci = NULL;
268 if (tb[RTA_CACHEINFO]) {
269 ci = RTA_DATA(tb[RTA_CACHEINFO]);
271 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
272 if (r->rtm_flags & RTM_F_CLONED) {
273 fprintf(fp, "%c cache ", _SL_);
275 if (ci->rta_expires) {
276 fprintf(fp, " expires %dsec", ci->rta_expires / get_hz());
278 if (ci->rta_error != 0) {
279 fprintf(fp, " error %d", ci->rta_error);
282 if (ci->rta_error != 0)
283 fprintf(fp, " error %d", ci->rta_error);
286 if (tb[RTA_IIF] && filter.iifmask != -1) {
287 fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
294 /* Return value becomes exitcode. It's okay to not return at all */
295 static int iproute_modify(int cmd, unsigned flags, int argc, char **argv)
297 struct rtnl_handle rth;
304 struct rtattr * mxrta = (void*)mxbuf;
307 enum { gw_ok = 1<<0, dst_ok = 1<<1, proto_ok = 1<<2, type_ok = 1<<3};
309 static const char * const keywords[] = {
310 "src", "via", "mtu", "lock", "protocol", USE_FEATURE_IP_RULE("table",)
311 "dev", "oif", "to", NULL
318 USE_FEATURE_IP_RULE(ARG_table,)
325 memset(&req, 0, sizeof(req));
327 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
328 req.n.nlmsg_flags = NLM_F_REQUEST|flags;
329 req.n.nlmsg_type = cmd;
330 req.r.rtm_family = preferred_family;
331 req.r.rtm_table = RT_TABLE_MAIN;
332 req.r.rtm_scope = RT_SCOPE_NOWHERE;
334 if (cmd != RTM_DELROUTE) {
335 req.r.rtm_protocol = RTPROT_BOOT;
336 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
337 req.r.rtm_type = RTN_UNICAST;
340 mxrta->rta_type = RTA_METRICS;
341 mxrta->rta_len = RTA_LENGTH(0);
344 arg = index_in_substr_array(keywords, *argv);
345 if (arg == ARG_src) {
348 get_addr(&addr, *argv, req.r.rtm_family);
349 if (req.r.rtm_family == AF_UNSPEC)
350 req.r.rtm_family = addr.family;
351 addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
352 } else if (arg == ARG_via) {
356 get_addr(&addr, *argv, req.r.rtm_family);
357 if (req.r.rtm_family == AF_UNSPEC) {
358 req.r.rtm_family = addr.family;
360 addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
361 } else if (arg == ARG_mtu) {
364 if (index_in_str_array(keywords, *argv) == PARM_lock) {
365 mxlock |= (1<<RTAX_MTU);
368 if (get_unsigned(&mtu, *argv, 0))
369 invarg(*argv, "mtu");
370 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
371 } else if (arg == ARG_protocol) {
374 if (rtnl_rtprot_a2n(&prot, *argv))
375 invarg(*argv, "protocol");
376 req.r.rtm_protocol = prot;
378 #if ENABLE_FEATURE_IP_RULE
379 } else if (arg == ARG_table) {
382 if (rtnl_rttable_a2n(&tid, *argv))
383 invarg(*argv, "table");
384 req.r.rtm_table = tid;
386 } else if (arg == ARG_dev || arg == ARG_oif) {
396 if ((**argv < '0' || **argv > '9')
397 && rtnl_rtntype_a2n(&type, *argv) == 0) {
399 req.r.rtm_type = type;
404 duparg2("to", *argv);
406 get_prefix(&dst, *argv, req.r.rtm_family);
407 if (req.r.rtm_family == AF_UNSPEC) {
408 req.r.rtm_family = dst.family;
410 req.r.rtm_dst_len = dst.bitlen;
413 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
427 idx = xll_name_to_index(d);
428 addattr32(&req.n, sizeof(req), RTA_OIF, idx);
432 if (mxrta->rta_len > RTA_LENGTH(0)) {
434 rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
436 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
439 if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
440 req.r.rtm_scope = RT_SCOPE_HOST;
441 else if (req.r.rtm_type == RTN_BROADCAST ||
442 req.r.rtm_type == RTN_MULTICAST ||
443 req.r.rtm_type == RTN_ANYCAST)
444 req.r.rtm_scope = RT_SCOPE_LINK;
445 else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
446 if (cmd == RTM_DELROUTE)
447 req.r.rtm_scope = RT_SCOPE_NOWHERE;
448 else if (!(ok & gw_ok))
449 req.r.rtm_scope = RT_SCOPE_LINK;
452 if (req.r.rtm_family == AF_UNSPEC) {
453 req.r.rtm_family = AF_INET;
456 if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
463 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
469 struct sockaddr_nl nladdr;
471 memset(&nladdr, 0, sizeof(nladdr));
472 memset(&req, 0, sizeof(req));
473 nladdr.nl_family = AF_NETLINK;
475 req.nlh.nlmsg_len = sizeof(req);
476 req.nlh.nlmsg_type = RTM_GETROUTE;
477 req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
478 req.nlh.nlmsg_pid = 0;
479 req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
480 req.rtm.rtm_family = family;
481 req.rtm.rtm_flags |= RTM_F_CLONED;
483 return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr));
486 static void iproute_flush_cache(void)
488 static const char fn[] = "/proc/sys/net/ipv4/route/flush";
489 int flush_fd = open_or_warn(fn, O_WRONLY);
495 if (write(flush_fd, "-1", 2) < 2) {
496 bb_perror_msg("cannot flush routing cache");
502 static void iproute_reset_filter(void)
504 memset(&filter, 0, sizeof(filter));
505 filter.mdst.bitlen = -1;
506 filter.msrc.bitlen = -1;
509 /* Return value becomes exitcode. It's okay to not return at all */
510 static int iproute_list_or_flush(int argc, char **argv, int flush)
512 int do_ipv6 = preferred_family;
513 struct rtnl_handle rth;
516 static const char * const keywords[] = {
517 "protocol", "all", "dev", "oif", "iif", "via", "table", "cache",/*all,*/
518 "from", "root", "match", "exact", "to", /*root,match,exact*/ NULL
526 ARG_table, PARM_cache, /*PARM_all,*/
527 ARG_from, PARM_root, PARM_match, PARM_exact,
528 ARG_to /*PARM_root, PARM_match, PARM_exact*/
531 iproute_reset_filter();
532 filter.tb = RT_TABLE_MAIN;
534 if (flush && argc <= 0)
535 bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
538 arg = index_in_substr_array(keywords, *argv);
539 if (arg == ARG_proto) {
542 filter.protocolmask = -1;
543 if (rtnl_rtprot_a2n(&prot, *argv)) {
544 if (index_in_str_array(keywords, *argv) != PARM_all)
545 invarg(*argv, "protocol");
547 filter.protocolmask = 0;
549 filter.protocol = prot;
550 } else if (arg == ARG_dev || arg == ARG_oif) {
553 } else if (arg == ARG_iif) {
556 } else if (arg == ARG_via) {
558 get_prefix(&filter.rvia, *argv, do_ipv6);
559 } else if (arg == ARG_table) {
561 parm = index_in_substr_array(keywords, *argv);
562 if (parm == PARM_cache)
564 else if (parm == PARM_all)
567 invarg(*argv, "table");
568 } else if (arg == ARG_from) {
570 parm = index_in_substr_array(keywords, *argv);
571 if (parm == PARM_root) {
573 get_prefix(&filter.rsrc, *argv, do_ipv6);
574 } else if (parm == PARM_match) {
576 get_prefix(&filter.msrc, *argv, do_ipv6);
578 if (parm == PARM_exact)
580 get_prefix(&filter.msrc, *argv, do_ipv6);
581 filter.rsrc = filter.msrc;
584 /* parm = arg; // would be more plausible, we reuse arg here */
587 arg = index_in_substr_array(keywords, *argv);
589 if (arg == PARM_root) {
591 get_prefix(&filter.rdst, *argv, do_ipv6);
592 } else if (arg == PARM_match) {
594 get_prefix(&filter.mdst, *argv, do_ipv6);
596 if (arg == PARM_exact)
598 get_prefix(&filter.mdst, *argv, do_ipv6);
599 filter.rdst = filter.mdst;
606 if (do_ipv6 == AF_UNSPEC && filter.tb) {
618 idx = xll_name_to_index(id);
623 idx = xll_name_to_index(od);
630 char flushb[4096-512];
632 if (filter.tb == -1) {
633 if (do_ipv6 != AF_INET6)
634 iproute_flush_cache();
635 if (do_ipv6 == AF_INET)
639 filter.flushb = flushb;
641 filter.flushe = sizeof(flushb);
645 xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
647 xrtnl_dump_filter(&rth, print_route, stdout);
648 if (filter.flushed == 0) {
656 if (filter.tb != -1) {
657 xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
659 if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
660 bb_perror_msg_and_die("cannot send dump request");
663 xrtnl_dump_filter(&rth, print_route, stdout);
669 /* Return value becomes exitcode. It's okay to not return at all */
670 static int iproute_get(int argc, char **argv)
672 struct rtnl_handle rth;
682 static const char * const options[] =
683 { "from", "iif", "oif", "dev", "notify", "connected", "to", 0 };
685 memset(&req, 0, sizeof(req));
687 iproute_reset_filter();
689 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
690 req.n.nlmsg_flags = NLM_F_REQUEST;
691 req.n.nlmsg_type = RTM_GETROUTE;
692 req.r.rtm_family = preferred_family;
694 req.r.rtm_protocol = 0;
697 req.r.rtm_src_len = 0;
698 req.r.rtm_dst_len = 0;
702 switch (index_in_str_array(options, *argv)) {
708 get_prefix(&addr, *argv, req.r.rtm_family);
709 if (req.r.rtm_family == AF_UNSPEC) {
710 req.r.rtm_family = addr.family;
713 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
715 req.r.rtm_src_len = addr.bitlen;
728 req.r.rtm_flags |= RTM_F_NOTIFY;
730 case 5: /* connected */
738 get_prefix(&addr, *argv, req.r.rtm_family);
739 if (req.r.rtm_family == AF_UNSPEC) {
740 req.r.rtm_family = addr.family;
743 addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
745 req.r.rtm_dst_len = addr.bitlen;
751 if (req.r.rtm_dst_len == 0) {
752 bb_error_msg_and_die("need at least destination address");
763 idx = xll_name_to_index(idev);
764 addattr32(&req.n, sizeof(req), RTA_IIF, idx);
767 idx = xll_name_to_index(odev);
768 addattr32(&req.n, sizeof(req), RTA_OIF, idx);
772 if (req.r.rtm_family == AF_UNSPEC) {
773 req.r.rtm_family = AF_INET;
776 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
780 if (connected && !from_ok) {
781 struct rtmsg *r = NLMSG_DATA(&req.n);
782 int len = req.n.nlmsg_len;
783 struct rtattr * tb[RTA_MAX+1];
785 print_route(NULL, &req.n, (void*)stdout);
787 if (req.n.nlmsg_type != RTM_NEWROUTE) {
788 bb_error_msg_and_die("not a route?");
790 len -= NLMSG_LENGTH(sizeof(*r));
792 bb_error_msg_and_die("wrong len %d", len);
795 memset(tb, 0, sizeof(tb));
796 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
798 if (tb[RTA_PREFSRC]) {
799 tb[RTA_PREFSRC]->rta_type = RTA_SRC;
800 r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
801 } else if (!tb[RTA_SRC]) {
802 bb_error_msg_and_die("failed to connect the route");
804 if (!odev && tb[RTA_OIF]) {
805 tb[RTA_OIF]->rta_type = 0;
807 if (tb[RTA_GATEWAY]) {
808 tb[RTA_GATEWAY]->rta_type = 0;
810 if (!idev && tb[RTA_IIF]) {
811 tb[RTA_IIF]->rta_type = 0;
813 req.n.nlmsg_flags = NLM_F_REQUEST;
814 req.n.nlmsg_type = RTM_GETROUTE;
816 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
820 print_route(NULL, &req.n, (void*)stdout);
824 /* Return value becomes exitcode. It's okay to not return at all */
825 int do_iproute(int argc, char **argv)
827 static const char * const ip_route_commands[] = {
828 /*0-3*/ "add", "append", "change", "chg",
829 /*4-7*/ "delete", "get", "list", "show",
830 /*8..*/ "prepend", "replace", "test", "flush", 0
833 unsigned int flags = 0;
834 int cmd = RTM_NEWROUTE;
836 /* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
837 /* It probably means that it is using "first match" rule */
839 command_num = index_in_substr_array(ip_route_commands, *argv);
841 switch (command_num) {
843 flags = NLM_F_CREATE|NLM_F_EXCL;
846 flags = NLM_F_CREATE|NLM_F_APPEND;
850 flags = NLM_F_REPLACE;
856 return iproute_get(argc-1, argv+1);
859 return iproute_list_or_flush(argc-1, argv+1, 0);
860 case 8: /* prepend */
861 flags = NLM_F_CREATE;
862 case 9: /* replace */
863 flags = NLM_F_CREATE|NLM_F_REPLACE;
867 return iproute_list_or_flush(argc-1, argv+1, 1);
869 bb_error_msg_and_die("unknown command %s", *argv);
872 return iproute_modify(cmd, flags, argc-1, argv+1);