X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=networking%2Flibiproute%2Fiproute.c;h=f8a67d9eedc43f3ede19c506773ce20933b39f61;hb=04f296b28a4927efffced38170d92134982566a6;hp=b622afd47bf8faa480c0b3f2280d9adc27d87cdc;hpb=86f5c9906beac527f3d7966f24811b571a589e08;p=oweals%2Fbusybox.git diff --git a/networking/libiproute/iproute.c b/networking/libiproute/iproute.c index b622afd47..f8a67d9ee 100644 --- a/networking/libiproute/iproute.c +++ b/networking/libiproute/iproute.c @@ -1,94 +1,104 @@ /* vi: set sw=4 ts=4: */ /* - * iproute.c "ip route". - * - * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. - * - * Authors: Alexey Kuznetsov, + * Licensed under GPLv2 or later, see file LICENSE in this source tree. * + * Authors: Alexey Kuznetsov, * * Changes: * - * Rani Assaf 980929: resolve addresses + * Rani Assaf 980929: resolve addresses * Kunihiro Ishiguro 001102: rtnh_ifindex was not initialized */ -#include - -#include -#include -#include -#include - +#include "ip_common.h" /* #include "libbb.h" is inside */ #include "rt_names.h" #include "utils.h" -#include "libbb.h" - #ifndef RTAX_RTTVAR #define RTAX_RTTVAR RTAX_HOPS #endif -static struct -{ +struct filter_t { int tb; - int flushed; + smallint flushed; char *flushb; int flushp; int flushe; struct rtnl_handle *rth; - int protocol, protocolmask; - int scope, scopemask; - int type, typemask; - int tos, tosmask; - int iif, iifmask; - int oif, oifmask; - int realm, realmmask; - inet_prefix rprefsrc; + //int protocol, protocolmask; - write-only fields?! + //int scope, scopemask; - unused + //int type; - read-only + //int typemask; - unused + //int tos, tosmask; - unused + int iif; + int oif; + //int realm, realmmask; - unused + //inet_prefix rprefsrc; - read-only inet_prefix rvia; inet_prefix rdst; inet_prefix mdst; inet_prefix rsrc; inet_prefix msrc; -} filter; +} FIX_ALIASING; +typedef struct filter_t filter_t; + +#define G_filter (*(filter_t*)&bb_common_bufsiz1) static int flush_update(void) { - if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) { - perror("Failed to send flush request\n"); + if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) { + bb_perror_msg("can't send flush request"); return -1; } - filter.flushp = 0; + G_filter.flushp = 0; return 0; } -static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED, - struct nlmsghdr *n, void *arg) +static unsigned get_hz(void) +{ + static unsigned hz_internal; + FILE *fp; + + if (hz_internal) + return hz_internal; + + fp = fopen_for_read("/proc/net/psched"); + if (fp) { + unsigned nom, denom; + + if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2) + if (nom == 1000000) + hz_internal = denom; + fclose(fp); + } + if (!hz_internal) + hz_internal = sysconf(_SC_CLK_TCK); + return hz_internal; +} + +static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM, + struct nlmsghdr *n, void *arg UNUSED_PARAM) { - FILE *fp = (FILE*)arg; struct rtmsg *r = NLMSG_DATA(n); int len = n->nlmsg_len; - struct rtattr * tb[RTA_MAX+1]; + struct rtattr *tb[RTA_MAX+1]; char abuf[256]; inet_prefix dst; inet_prefix src; int host_len = -1; SPRINT_BUF(b1); - if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) { fprintf(stderr, "Not a route: %08x %08x %08x\n", n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags); return 0; } - if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE) + if (G_filter.flushb && n->nlmsg_type != RTM_NEWROUTE) return 0; len -= NLMSG_LENGTH(sizeof(*r)); - if (len < 0) { - bb_error_msg("wrong nlmsg len %d", len); - return -1; - } + if (len < 0) + bb_error_msg_and_die("wrong nlmsg len %d", len); if (r->rtm_family == AF_INET6) host_len = 128; @@ -96,20 +106,20 @@ static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED, host_len = 32; if (r->rtm_family == AF_INET6) { - if (filter.tb) { - if (filter.tb < 0) { - if (!(r->rtm_flags&RTM_F_CLONED)) { + if (G_filter.tb) { + if (G_filter.tb < 0) { + if (!(r->rtm_flags & RTM_F_CLONED)) { return 0; } } else { - if (r->rtm_flags&RTM_F_CLONED) { + if (r->rtm_flags & RTM_F_CLONED) { return 0; } - if (filter.tb == RT_TABLE_LOCAL) { + if (G_filter.tb == RT_TABLE_LOCAL) { if (r->rtm_type != RTN_LOCAL) { return 0; } - } else if (filter.tb == RT_TABLE_MAIN) { + } else if (G_filter.tb == RT_TABLE_MAIN) { if (r->rtm_type == RTN_LOCAL) { return 0; } @@ -119,136 +129,174 @@ static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED, } } } else { - if (filter.tb > 0 && filter.tb != r->rtm_table) { + if (G_filter.tb > 0 && G_filter.tb != r->rtm_table) { return 0; } } - if (filter.rdst.family && - (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len)) { + if (G_filter.rdst.family + && (r->rtm_family != G_filter.rdst.family || G_filter.rdst.bitlen > r->rtm_dst_len) + ) { return 0; } - if (filter.mdst.family && - (r->rtm_family != filter.mdst.family || - (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len))) { + if (G_filter.mdst.family + && (r->rtm_family != G_filter.mdst.family + || (G_filter.mdst.bitlen >= 0 && G_filter.mdst.bitlen < r->rtm_dst_len) + ) + ) { return 0; } - if (filter.rsrc.family && - (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len)) { + if (G_filter.rsrc.family + && (r->rtm_family != G_filter.rsrc.family || G_filter.rsrc.bitlen > r->rtm_src_len) + ) { return 0; } - if (filter.msrc.family && - (r->rtm_family != filter.msrc.family || - (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len))) { + if (G_filter.msrc.family + && (r->rtm_family != G_filter.msrc.family + || (G_filter.msrc.bitlen >= 0 && G_filter.msrc.bitlen < r->rtm_src_len) + ) + ) { return 0; } memset(tb, 0, sizeof(tb)); + memset(&src, 0, sizeof(src)); + memset(&dst, 0, sizeof(dst)); parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len); - if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen)) - return 0; - if (filter.mdst.family && filter.mdst.bitlen >= 0 && - inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len)) - return 0; + if (tb[RTA_SRC]) { + src.bitlen = r->rtm_src_len; + src.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4); + memcpy(src.data, RTA_DATA(tb[RTA_SRC]), src.bytelen); + } + if (tb[RTA_DST]) { + dst.bitlen = r->rtm_dst_len; + dst.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4); + memcpy(dst.data, RTA_DATA(tb[RTA_DST]), dst.bytelen); + } - if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen)) + if (G_filter.rdst.family + && inet_addr_match(&dst, &G_filter.rdst, G_filter.rdst.bitlen) + ) { return 0; - if (filter.msrc.family && filter.msrc.bitlen >= 0 && - inet_addr_match(&src, &filter.msrc, r->rtm_src_len)) + } + if (G_filter.mdst.family + && G_filter.mdst.bitlen >= 0 + && inet_addr_match(&dst, &G_filter.mdst, r->rtm_dst_len) + ) { return 0; - - if (filter.flushb && - r->rtm_family == AF_INET6 && - r->rtm_dst_len == 0 && - r->rtm_type == RTN_UNREACHABLE && - tb[RTA_PRIORITY] && - *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1) + } + if (G_filter.rsrc.family + && inet_addr_match(&src, &G_filter.rsrc, G_filter.rsrc.bitlen) + ) { + return 0; + } + if (G_filter.msrc.family && G_filter.msrc.bitlen >= 0 + && inet_addr_match(&src, &G_filter.msrc, r->rtm_src_len) + ) { return 0; + } + if (G_filter.oif != 0) { + if (!tb[RTA_OIF]) + return 0; + if (G_filter.oif != *(int*)RTA_DATA(tb[RTA_OIF])) + return 0; + } - if (filter.flushb) { + if (G_filter.flushb) { struct nlmsghdr *fn; - if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) { + + /* We are creating route flush commands */ + + if (r->rtm_family == AF_INET6 + && r->rtm_dst_len == 0 + && r->rtm_type == RTN_UNREACHABLE + && tb[RTA_PRIORITY] + && *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1 + ) { + return 0; + } + + if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) { if (flush_update()) - return -1; + bb_error_msg_and_die("flush"); } - fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp)); + fn = (void*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp)); memcpy(fn, n, n->nlmsg_len); fn->nlmsg_type = RTM_DELROUTE; fn->nlmsg_flags = NLM_F_REQUEST; - fn->nlmsg_seq = ++filter.rth->seq; - filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb; - filter.flushed++; + fn->nlmsg_seq = ++G_filter.rth->seq; + G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb; + G_filter.flushed = 1; return 0; } + /* We are printing routes */ + if (n->nlmsg_type == RTM_DELROUTE) { - fprintf(fp, "Deleted "); + printf("Deleted "); } - if (r->rtm_type != RTN_UNICAST && !filter.type) { - fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1))); + if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) { + printf("%s ", rtnl_rtntype_n2a(r->rtm_type, b1)); } if (tb[RTA_DST]) { if (r->rtm_dst_len != host_len) { - fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family, - RTA_PAYLOAD(tb[RTA_DST]), - RTA_DATA(tb[RTA_DST]), - abuf, sizeof(abuf)), - r->rtm_dst_len - ); + printf("%s/%u ", rt_addr_n2a(r->rtm_family, + RTA_DATA(tb[RTA_DST]), + abuf, sizeof(abuf)), + r->rtm_dst_len + ); } else { - fprintf(fp, "%s ", format_host(r->rtm_family, - RTA_PAYLOAD(tb[RTA_DST]), - RTA_DATA(tb[RTA_DST]), - abuf, sizeof(abuf)) - ); + printf("%s ", format_host(r->rtm_family, + RTA_PAYLOAD(tb[RTA_DST]), + RTA_DATA(tb[RTA_DST]), + abuf, sizeof(abuf)) + ); } } else if (r->rtm_dst_len) { - fprintf(fp, "0/%d ", r->rtm_dst_len); + printf("0/%d ", r->rtm_dst_len); } else { - fprintf(fp, "default "); + printf("default "); } if (tb[RTA_SRC]) { if (r->rtm_src_len != host_len) { - fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family, - RTA_PAYLOAD(tb[RTA_SRC]), - RTA_DATA(tb[RTA_SRC]), - abuf, sizeof(abuf)), - r->rtm_src_len - ); + printf("from %s/%u ", rt_addr_n2a(r->rtm_family, + RTA_DATA(tb[RTA_SRC]), + abuf, sizeof(abuf)), + r->rtm_src_len + ); } else { - fprintf(fp, "from %s ", format_host(r->rtm_family, - RTA_PAYLOAD(tb[RTA_SRC]), - RTA_DATA(tb[RTA_SRC]), - abuf, sizeof(abuf)) - ); + printf("from %s ", format_host(r->rtm_family, + RTA_PAYLOAD(tb[RTA_SRC]), + RTA_DATA(tb[RTA_SRC]), + abuf, sizeof(abuf)) + ); } } else if (r->rtm_src_len) { - fprintf(fp, "from 0/%u ", r->rtm_src_len); + printf("from 0/%u ", r->rtm_src_len); } - if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) { - fprintf(fp, "via %s ", - format_host(r->rtm_family, - RTA_PAYLOAD(tb[RTA_GATEWAY]), - RTA_DATA(tb[RTA_GATEWAY]), - abuf, sizeof(abuf))); + if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) { + printf("via %s ", format_host(r->rtm_family, + RTA_PAYLOAD(tb[RTA_GATEWAY]), + RTA_DATA(tb[RTA_GATEWAY]), + abuf, sizeof(abuf))); } - if (tb[RTA_OIF] && filter.oifmask != -1) { - fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF]))); + if (tb[RTA_OIF]) { + printf("dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF]))); } - if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) { + /* Todo: parse & show "proto kernel", "scope link" here */ + + if (tb[RTA_PREFSRC] && /*G_filter.rprefsrc.bitlen - always 0*/ 0 != host_len) { /* Do not use format_host(). It is our local addr and symbolic name will not be useful. */ - fprintf(fp, " src %s ", - rt_addr_n2a(r->rtm_family, - RTA_PAYLOAD(tb[RTA_PREFSRC]), - RTA_DATA(tb[RTA_PREFSRC]), - abuf, sizeof(abuf))); + printf(" src %s ", rt_addr_n2a(r->rtm_family, + RTA_DATA(tb[RTA_PREFSRC]), + abuf, sizeof(abuf))); } if (tb[RTA_PRIORITY]) { - fprintf(fp, " metric %d ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY])); + printf(" metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY])); } if (r->rtm_family == AF_INET6) { struct rta_cacheinfo *ci = NULL; @@ -256,57 +304,73 @@ static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED, ci = RTA_DATA(tb[RTA_CACHEINFO]); } if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) { - static int hz; - if (!hz) { - hz = get_hz(); - } if (r->rtm_flags & RTM_F_CLONED) { - fprintf(fp, "%s cache ", _SL_); + printf("%c cache ", _SL_); } if (ci->rta_expires) { - fprintf(fp, " expires %dsec", ci->rta_expires/hz); + printf(" expires %dsec", ci->rta_expires / get_hz()); } if (ci->rta_error != 0) { - fprintf(fp, " error %d", ci->rta_error); + printf(" error %d", ci->rta_error); } } else if (ci) { if (ci->rta_error != 0) - fprintf(fp, " error %d", ci->rta_error); + printf(" error %d", ci->rta_error); } } - if (tb[RTA_IIF] && filter.iifmask != -1) { - fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF]))); + if (tb[RTA_IIF] && G_filter.iif == 0) { + printf(" iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF]))); } - fprintf(fp, "\n"); - fflush(fp); + bb_putchar('\n'); return 0; } -static int iproute_modify(int cmd, unsigned flags, int argc, char **argv) +/* Return value becomes exitcode. It's okay to not return at all */ +static int iproute_modify(int cmd, unsigned flags, char **argv) { + static const char keywords[] ALIGN1 = + "src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0") + "dev\0""oif\0""to\0""metric\0"; + enum { + ARG_src, + ARG_via, + ARG_mtu, PARM_lock, + ARG_protocol, +IF_FEATURE_IP_RULE(ARG_table,) + ARG_dev, + ARG_oif, + ARG_to, + ARG_metric, + }; + enum { + gw_ok = 1 << 0, + dst_ok = 1 << 1, + proto_ok = 1 << 2, + type_ok = 1 << 3 + }; struct rtnl_handle rth; struct { - struct nlmsghdr n; - struct rtmsg r; - char buf[1024]; + struct nlmsghdr n; + struct rtmsg r; + char buf[1024]; } req; - char mxbuf[256]; + char mxbuf[256]; struct rtattr * mxrta = (void*)mxbuf; unsigned mxlock = 0; - char *d = NULL; - int gw_ok = 0; - int dst_ok = 0; - int proto_ok = 0; - int type_ok = 0; + char *d = NULL; + smalluint ok = 0; + int arg; memset(&req, 0, sizeof(req)); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); - req.n.nlmsg_flags = NLM_F_REQUEST|flags; + req.n.nlmsg_flags = NLM_F_REQUEST | flags; req.n.nlmsg_type = cmd; req.r.rtm_family = preferred_family; - req.r.rtm_table = RT_TABLE_MAIN; - req.r.rtm_scope = RT_SCOPE_NOWHERE; + if (RT_TABLE_MAIN) /* if it is zero, memset already did it */ + req.r.rtm_table = RT_TABLE_MAIN; + if (RT_SCOPE_NOWHERE) + req.r.rtm_scope = RT_SCOPE_NOWHERE; if (cmd != RTM_DELROUTE) { req.r.rtm_protocol = RTPROT_BOOT; @@ -317,61 +381,72 @@ static int iproute_modify(int cmd, unsigned flags, int argc, char **argv) mxrta->rta_type = RTA_METRICS; mxrta->rta_len = RTA_LENGTH(0); - while (argc > 0) { - if (strcmp(*argv, "src") == 0) { + while (*argv) { + arg = index_in_substrings(keywords, *argv); + if (arg == ARG_src) { inet_prefix addr; NEXT_ARG(); get_addr(&addr, *argv, req.r.rtm_family); - if (req.r.rtm_family == AF_UNSPEC) { + if (req.r.rtm_family == AF_UNSPEC) req.r.rtm_family = addr.family; - } addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen); - } else if (strcmp(*argv, "via") == 0) { + } else if (arg == ARG_via) { inet_prefix addr; - gw_ok = 1; + ok |= gw_ok; NEXT_ARG(); get_addr(&addr, *argv, req.r.rtm_family); if (req.r.rtm_family == AF_UNSPEC) { req.r.rtm_family = addr.family; } addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen); - } else if (strcmp(*argv, "mtu") == 0) { + } else if (arg == ARG_mtu) { unsigned mtu; NEXT_ARG(); - if (strcmp(*argv, "lock") == 0) { - mxlock |= (1< '9') && - rtnl_rtntype_a2n(&type, *argv) == 0) { + if ((**argv < '0' || **argv > '9') + && rtnl_rtntype_a2n(&type, *argv) == 0 + ) { NEXT_ARG(); req.r.rtm_type = type; - type_ok = 1; + ok |= type_ok; } - if (dst_ok) { + if (ok & dst_ok) { duparg2("to", *argv); } get_prefix(&dst, *argv, req.r.rtm_family); @@ -379,17 +454,15 @@ static int iproute_modify(int cmd, unsigned flags, int argc, char **argv) req.r.rtm_family = dst.family; } req.r.rtm_dst_len = dst.bitlen; - dst_ok = 1; + ok |= dst_ok; if (dst.bytelen) { addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen); } } - argc--; argv++; + argv++; } - if (rtnl_open(&rth, 0) < 0) { - exit(1); - } + xrtnl_open(&rth); if (d) { int idx; @@ -397,10 +470,7 @@ static int iproute_modify(int cmd, unsigned flags, int argc, char **argv) ll_init_map(&rth); if (d) { - if ((idx = ll_name_to_index(d)) == 0) { - bb_error_msg("Cannot find device \"%s\"", d); - return -1; - } + idx = xll_name_to_index(d); addattr32(&req.n, sizeof(req), RTA_OIF, idx); } } @@ -412,12 +482,28 @@ static int iproute_modify(int cmd, unsigned flags, int argc, char **argv) addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta)); } + if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT) + req.r.rtm_scope = RT_SCOPE_HOST; + else + if (req.r.rtm_type == RTN_BROADCAST + || req.r.rtm_type == RTN_MULTICAST + || req.r.rtm_type == RTN_ANYCAST + ) { + req.r.rtm_scope = RT_SCOPE_LINK; + } + else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) { + if (cmd == RTM_DELROUTE) + req.r.rtm_scope = RT_SCOPE_NOWHERE; + else if (!(ok & gw_ok)) + req.r.rtm_scope = RT_SCOPE_LINK; + } + if (req.r.rtm_family == AF_UNSPEC) { req.r.rtm_family = AF_INET; } if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) { - exit(2); + return 2; } return 0; @@ -436,247 +522,253 @@ static int rtnl_rtcache_request(struct rtnl_handle *rth, int family) nladdr.nl_family = AF_NETLINK; req.nlh.nlmsg_len = sizeof(req); - req.nlh.nlmsg_type = RTM_GETROUTE; - req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST; - req.nlh.nlmsg_pid = 0; + if (RTM_GETROUTE) + req.nlh.nlmsg_type = RTM_GETROUTE; + if (NLM_F_ROOT | NLM_F_REQUEST) + req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST; + /*req.nlh.nlmsg_pid = 0; - memset did it already */ req.nlh.nlmsg_seq = rth->dump = ++rth->seq; req.rtm.rtm_family = family; - req.rtm.rtm_flags |= RTM_F_CLONED; + if (RTM_F_CLONED) + req.rtm.rtm_flags = RTM_F_CLONED; - return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr)); + return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr)); } -static int iproute_flush_cache(void) +static void iproute_flush_cache(void) { -#define ROUTE_FLUSH_PATH "/proc/sys/net/ipv4/route/flush" - - int len; - int flush_fd = open (ROUTE_FLUSH_PATH, O_WRONLY); - char *buffer = "-1"; + static const char fn[] ALIGN1 = "/proc/sys/net/ipv4/route/flush"; + int flush_fd = open_or_warn(fn, O_WRONLY); if (flush_fd < 0) { - fprintf (stderr, "Cannot open \"%s\"\n", ROUTE_FLUSH_PATH); - return -1; + return; } - len = strlen (buffer); - - if ((write (flush_fd, (void *)buffer, len)) < len) { - fprintf (stderr, "Cannot flush routing cache\n"); - return -1; + if (write(flush_fd, "-1", 2) < 2) { + bb_perror_msg("can't flush routing cache"); + return; } close(flush_fd); - return 0; } static void iproute_reset_filter(void) { - memset(&filter, 0, sizeof(filter)); - filter.mdst.bitlen = -1; - filter.msrc.bitlen = -1; + memset(&G_filter, 0, sizeof(G_filter)); + G_filter.mdst.bitlen = -1; + G_filter.msrc.bitlen = -1; } -static int iproute_list_or_flush(int argc, char **argv, int flush) +/* Return value becomes exitcode. It's okay to not return at all */ +static int iproute_list_or_flush(char **argv, int flush) { int do_ipv6 = preferred_family; struct rtnl_handle rth; char *id = NULL; char *od = NULL; + static const char keywords[] ALIGN1 = + /* "ip route list/flush" parameters: */ + "protocol\0" "dev\0" "oif\0" "iif\0" + "via\0" "table\0" "cache\0" + "from\0" "to\0" + /* and possible further keywords */ + "all\0" + "root\0" + "match\0" + "exact\0" + "main\0" + ; + enum { + KW_proto, KW_dev, KW_oif, KW_iif, + KW_via, KW_table, KW_cache, + KW_from, KW_to, + /* */ + KW_all, + KW_root, + KW_match, + KW_exact, + KW_main, + }; + int arg, parm; iproute_reset_filter(); - filter.tb = RT_TABLE_MAIN; + G_filter.tb = RT_TABLE_MAIN; - if (flush && argc <= 0) { - fprintf(stderr, "\"ip route flush\" requires arguments.\n"); - return -1; - } + if (flush && !*argv) + bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\""); - while (argc > 0) { - if (matches(*argv, "protocol") == 0) { - int prot = 0; + while (*argv) { + arg = index_in_substrings(keywords, *argv); + if (arg == KW_proto) { + uint32_t prot = 0; NEXT_ARG(); - filter.protocolmask = -1; + //G_filter.protocolmask = -1; if (rtnl_rtprot_a2n(&prot, *argv)) { - if (strcmp(*argv, "all") != 0) { - invarg("invalid \"protocol\"\n", *argv); - } + if (index_in_strings(keywords, *argv) != KW_all) + invarg(*argv, "protocol"); prot = 0; - filter.protocolmask = 0; + //G_filter.protocolmask = 0; } - filter.protocol = prot; - } else if (strcmp(*argv, "dev") == 0 || - strcmp(*argv, "oif") == 0) { + //G_filter.protocol = prot; + } else if (arg == KW_dev || arg == KW_oif) { NEXT_ARG(); od = *argv; - } else if (strcmp(*argv, "iif") == 0) { + } else if (arg == KW_iif) { NEXT_ARG(); id = *argv; - } else if (matches(*argv, "from") == 0) { + } else if (arg == KW_via) { + NEXT_ARG(); + get_prefix(&G_filter.rvia, *argv, do_ipv6); + } else if (arg == KW_table) { /* table all/cache/main */ + NEXT_ARG(); + parm = index_in_substrings(keywords, *argv); + if (parm == KW_cache) + G_filter.tb = -1; + else if (parm == KW_all) + G_filter.tb = 0; + else if (parm != KW_main) { +#if ENABLE_FEATURE_IP_RULE + uint32_t tid; + if (rtnl_rttable_a2n(&tid, *argv)) + invarg(*argv, "table"); + G_filter.tb = tid; +#else + invarg(*argv, "table"); +#endif + } + } else if (arg == KW_cache) { + /* The command 'ip route flush cache' is used by OpenSWAN. + * Assuming it's a synonym for 'ip route flush table cache' */ + G_filter.tb = -1; + } else if (arg == KW_from) { NEXT_ARG(); - if (matches(*argv, "root") == 0) { + parm = index_in_substrings(keywords, *argv); + if (parm == KW_root) { NEXT_ARG(); - get_prefix(&filter.rsrc, *argv, do_ipv6); - } else if (matches(*argv, "match") == 0) { + get_prefix(&G_filter.rsrc, *argv, do_ipv6); + } else if (parm == KW_match) { NEXT_ARG(); - get_prefix(&filter.msrc, *argv, do_ipv6); + get_prefix(&G_filter.msrc, *argv, do_ipv6); } else { - if (matches(*argv, "exact") == 0) { + if (parm == KW_exact) NEXT_ARG(); - } - get_prefix(&filter.msrc, *argv, do_ipv6); - filter.rsrc = filter.msrc; + get_prefix(&G_filter.msrc, *argv, do_ipv6); + G_filter.rsrc = G_filter.msrc; } - } else { - if (matches(*argv, "to") == 0) { + } else { /* "to" is the default parameter */ + if (arg == KW_to) { NEXT_ARG(); + arg = index_in_substrings(keywords, *argv); } - if (matches(*argv, "root") == 0) { - NEXT_ARG(); - get_prefix(&filter.rdst, *argv, do_ipv6); - } else if (matches(*argv, "match") == 0) { + /* parm = arg; - would be more plausible, but we reuse 'arg' here */ + if (arg == KW_root) { NEXT_ARG(); - get_prefix(&filter.mdst, *argv, do_ipv6); - } else if (matches(*argv, "table") == 0) { + get_prefix(&G_filter.rdst, *argv, do_ipv6); + } else if (arg == KW_match) { NEXT_ARG(); - if (matches(*argv, "cache") == 0) { - filter.tb = -1; - } else if (matches(*argv, "main") != 0) { - invarg("invalid \"table\"", *argv); - } - } else if (matches(*argv, "cache") == 0) { - filter.tb = -1; - } else { - if (matches(*argv, "exact") == 0) { + get_prefix(&G_filter.mdst, *argv, do_ipv6); + } else { /* "to exact" is the default */ + if (arg == KW_exact) NEXT_ARG(); - } - get_prefix(&filter.mdst, *argv, do_ipv6); - filter.rdst = filter.mdst; + get_prefix(&G_filter.mdst, *argv, do_ipv6); + G_filter.rdst = G_filter.mdst; } } - argc--; argv++; + argv++; } - if (do_ipv6 == AF_UNSPEC && filter.tb) { + if (do_ipv6 == AF_UNSPEC && G_filter.tb) { do_ipv6 = AF_INET; } - if (rtnl_open(&rth, 0) < 0) { - exit(1); - } - + xrtnl_open(&rth); ll_init_map(&rth); if (id || od) { int idx; if (id) { - if ((idx = ll_name_to_index(id)) == 0) { - bb_error_msg("Cannot find device \"%s\"", id); - return -1; - } - filter.iif = idx; - filter.iifmask = -1; + idx = xll_name_to_index(id); + G_filter.iif = idx; } if (od) { - if ((idx = ll_name_to_index(od)) == 0) { - bb_error_msg("Cannot find device \"%s\"", od); - } - filter.oif = idx; - filter.oifmask = -1; + idx = xll_name_to_index(od); + G_filter.oif = idx; } } if (flush) { - int _round = 0; char flushb[4096-512]; - if (filter.tb == -1) { + if (G_filter.tb == -1) { /* "flush table cache" */ if (do_ipv6 != AF_INET6) iproute_flush_cache(); if (do_ipv6 == AF_INET) return 0; } - filter.flushb = flushb; - filter.flushp = 0; - filter.flushe = sizeof(flushb); - filter.rth = &rth; + G_filter.flushb = flushb; + G_filter.flushp = 0; + G_filter.flushe = sizeof(flushb); + G_filter.rth = &rth; for (;;) { - if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) { - perror("Cannot send dump request"); - return -1; - } - filter.flushed = 0; - if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) { - bb_error_msg("Flush terminated\n"); - return -1; - } - if (filter.flushed == 0) { - if (_round == 0) { - if (filter.tb != -1 || do_ipv6 == AF_INET6) - fprintf(stderr, "Nothing to flush.\n"); - } - fflush(stdout); + xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE); + G_filter.flushed = 0; + xrtnl_dump_filter(&rth, print_route, NULL); + if (G_filter.flushed == 0) return 0; - } - _round++; - if (flush_update() < 0) - exit(1); - } - } - - if (filter.tb != -1) { - if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) { - bb_perror_msg_and_die("Cannot send dump request"); - } - } else { - if (rtnl_rtcache_request(&rth, do_ipv6) < 0) { - bb_perror_msg_and_die("Cannot send dump request"); + if (flush_update()) + return 1; } } - if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) { - bb_error_msg_and_die("Dump terminated"); + if (G_filter.tb != -1) { + xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE); + } else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) { + bb_perror_msg_and_die("can't send dump request"); } + xrtnl_dump_filter(&rth, print_route, NULL); - exit(0); + return 0; } -static int iproute_get(int argc, char **argv) +/* Return value becomes exitcode. It's okay to not return at all */ +static int iproute_get(char **argv) { struct rtnl_handle rth; struct { - struct nlmsghdr n; - struct rtmsg r; - char buf[1024]; + struct nlmsghdr n; + struct rtmsg r; + char buf[1024]; } req; - char *idev = NULL; - char *odev = NULL; - int connected = 0; - int from_ok = 0; - static const char * const options[] = - { "from", "iif", "oif", "dev", "notify", "connected", "to", 0 }; + char *idev = NULL; + char *odev = NULL; + bool connected = 0; + bool from_ok = 0; + static const char options[] ALIGN1 = + "from\0""iif\0""oif\0""dev\0""notify\0""connected\0""to\0"; memset(&req, 0, sizeof(req)); iproute_reset_filter(); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); - req.n.nlmsg_flags = NLM_F_REQUEST; - req.n.nlmsg_type = RTM_GETROUTE; + if (NLM_F_REQUEST) + req.n.nlmsg_flags = NLM_F_REQUEST; + if (RTM_GETROUTE) + req.n.nlmsg_type = RTM_GETROUTE; req.r.rtm_family = preferred_family; - req.r.rtm_table = 0; - req.r.rtm_protocol = 0; - req.r.rtm_scope = 0; - req.r.rtm_type = 0; - req.r.rtm_src_len = 0; - req.r.rtm_dst_len = 0; - req.r.rtm_tos = 0; - - while (argc > 0) { - switch (compare_string_array(options, *argv)) { + /*req.r.rtm_table = 0; - memset did this already */ + /*req.r.rtm_protocol = 0;*/ + /*req.r.rtm_scope = 0;*/ + /*req.r.rtm_type = 0;*/ + /*req.r.rtm_src_len = 0;*/ + /*req.r.rtm_dst_len = 0;*/ + /*req.r.rtm_tos = 0;*/ + + while (*argv) { + switch (index_in_strings(options, *argv)) { case 0: /* from */ { inet_prefix addr; @@ -721,16 +813,15 @@ static int iproute_get(int argc, char **argv) } req.r.rtm_dst_len = addr.bitlen; } - argc--; argv++; } + argv++; } if (req.r.rtm_dst_len == 0) { bb_error_msg_and_die("need at least destination address"); } - if (rtnl_open(&rth, 0) < 0) - exit(1); + xrtnl_open(&rth); ll_init_map(&rth); @@ -738,17 +829,11 @@ static int iproute_get(int argc, char **argv) int idx; if (idev) { - if ((idx = ll_name_to_index(idev)) == 0) { - bb_error_msg("Cannot find device \"%s\"", idev); - return -1; - } + idx = xll_name_to_index(idev); addattr32(&req.n, sizeof(req), RTA_IIF, idx); } if (odev) { - if ((idx = ll_name_to_index(odev)) == 0) { - bb_error_msg("Cannot find device \"%s\"", odev); - return -1; - } + idx = xll_name_to_index(odev); addattr32(&req.n, sizeof(req), RTA_OIF, idx); } } @@ -758,7 +843,7 @@ static int iproute_get(int argc, char **argv) } if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) { - exit(2); + return 2; } if (connected && !from_ok) { @@ -766,18 +851,14 @@ static int iproute_get(int argc, char **argv) int len = req.n.nlmsg_len; struct rtattr * tb[RTA_MAX+1]; - if (print_route(NULL, &req.n, (void*)stdout) < 0) { - bb_error_msg_and_die("An error :-)"); - } + print_route(NULL, &req.n, NULL); if (req.n.nlmsg_type != RTM_NEWROUTE) { - bb_error_msg("Not a route?"); - return -1; + bb_error_msg_and_die("not a route?"); } len -= NLMSG_LENGTH(sizeof(*r)); if (len < 0) { - bb_error_msg("Wrong len %d", len); - return -1; + bb_error_msg_and_die("wrong len %d", len); } memset(tb, 0, sizeof(tb)); @@ -787,8 +868,7 @@ static int iproute_get(int argc, char **argv) tb[RTA_PREFSRC]->rta_type = RTA_SRC; r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]); } else if (!tb[RTA_SRC]) { - bb_error_msg("Failed to connect the route"); - return -1; + bb_error_msg_and_die("can't connect the route"); } if (!odev && tb[RTA_OIF]) { tb[RTA_OIF]->rta_type = 0; @@ -803,31 +883,33 @@ static int iproute_get(int argc, char **argv) req.n.nlmsg_type = RTM_GETROUTE; if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) { - exit(2); + return 2; } } - - if (print_route(NULL, &req.n, (void*)stdout) < 0) { - bb_error_msg_and_die("An error :-)"); - } - - exit(0); + print_route(NULL, &req.n, NULL); + return 0; } -int do_iproute(int argc, char **argv) +/* Return value becomes exitcode. It's okay to not return at all */ +int FAST_FUNC do_iproute(char **argv) { - static const char * const ip_route_commands[] = - { "add", "append", "change", "chg", "delete", "del", "get", - "list", "show", "prepend", "replace", "test", "flush", 0 }; - int command_num = 7; - unsigned int flags = 0; + static const char ip_route_commands[] ALIGN1 = + /*0-3*/ "add\0""append\0""change\0""chg\0" + /*4-7*/ "delete\0""get\0""list\0""show\0" + /*8..*/ "prepend\0""replace\0""test\0""flush\0"; + int command_num; + unsigned flags = 0; int cmd = RTM_NEWROUTE; - if (*argv) { - command_num = compare_string_array(ip_route_commands, *argv); - } - switch(command_num) { - case 0: /* add*/ + if (!*argv) + return iproute_list_or_flush(argv, 0); + + /* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */ + /* It probably means that it is using "first match" rule */ + command_num = index_in_substrings(ip_route_commands, *argv); + + switch (command_num) { + case 0: /* add */ flags = NLM_F_CREATE|NLM_F_EXCL; break; case 1: /* append */ @@ -838,25 +920,27 @@ int do_iproute(int argc, char **argv) flags = NLM_F_REPLACE; break; case 4: /* delete */ - case 5: /* del */ cmd = RTM_DELROUTE; break; - case 6: /* get */ - return iproute_get(argc-1, argv+1); - case 7: /* list */ - case 8: /* show */ - return iproute_list_or_flush(argc-1, argv+1, 0); - case 9: /* prepend */ + case 5: /* get */ + return iproute_get(argv+1); + case 6: /* list */ + case 7: /* show */ + return iproute_list_or_flush(argv+1, 0); + case 8: /* prepend */ flags = NLM_F_CREATE; - case 10: /* replace */ + break; + case 9: /* replace */ flags = NLM_F_CREATE|NLM_F_REPLACE; - case 11: /* test */ + break; + case 10: /* test */ flags = NLM_F_EXCL; - case 12: /* flush */ - return iproute_list_or_flush(argc-1, argv+1, 1); + break; + case 11: /* flush */ + return iproute_list_or_flush(argv+1, 1); default: - bb_error_msg_and_die("Unknown command %s", *argv); + bb_error_msg_and_die("unknown command %s", *argv); } - return iproute_modify(cmd, flags, argc-1, argv+1); + return iproute_modify(cmd, flags, argv+1); }