networking/libiproute/iproute.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   4  *
   5  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   6  *
   7  * Changes:
   8  *
   9  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  10  * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
  11  */
  12
  13 #include "ip_common.h"  /* #include "libbb.h" is inside */
  14 #include "common_bufsiz.h"
  15 #include "rt_names.h"
  16 #include "utils.h"
  17
  18 #ifndef RTAX_RTTVAR
  19 #define RTAX_RTTVAR RTAX_HOPS
  20 #endif
  21
  22
  23 struct filter_t {
  24         int tb;
  25         smallint flushed;
  26         char *flushb;
  27         int flushp;
  28         int flushe;
  29         struct rtnl_handle *rth;
  30         //int protocol, protocolmask; - write-only fields?!
  31         //int scope, scopemask; - unused
  32         //int type; - read-only
  33         //int typemask; - unused
  34         //int tos, tosmask; - unused
  35         int iif;
  36         int oif;
  37         //int realm, realmmask; - unused
  38         //inet_prefix rprefsrc; - read-only
  39         inet_prefix rvia;
  40         inet_prefix rdst;
  41         inet_prefix mdst;
  42         inet_prefix rsrc;
  43         inet_prefix msrc;
  44 } FIX_ALIASING;
  45 typedef struct filter_t filter_t;
  46
  47 #define G_filter (*(filter_t*)bb_common_bufsiz1)
  48 #define INIT_G() do { setup_common_bufsiz(); } while (0)
  49
  50 static int flush_update(void)
  51 {
  52         if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
  53                 bb_perror_msg("can't send flush request");
  54                 return -1;
  55         }
  56         G_filter.flushp = 0;
  57         return 0;
  58 }
  59
  60 static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
  61                 struct nlmsghdr *n, void *arg UNUSED_PARAM)
  62 {
  63         struct rtmsg *r = NLMSG_DATA(n);
  64         int len = n->nlmsg_len;
  65         struct rtattr *tb[RTA_MAX+1];
  66         inet_prefix dst;
  67         inet_prefix src;
  68         int host_len = -1;
  69
  70         if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
  71                 fprintf(stderr, "Not a route: %08x %08x %08x\n",
  72                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
  73                 return 0;
  74         }
  75         if (G_filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
  76                 return 0;
  77         len -= NLMSG_LENGTH(sizeof(*r));
  78         if (len < 0)
  79                 bb_error_msg_and_die("wrong nlmsg len %d", len);
  80
  81         if (r->rtm_family == AF_INET6)
  82                 host_len = 128;
  83         else if (r->rtm_family == AF_INET)
  84                 host_len = 32;
  85
  86         if (r->rtm_family == AF_INET6) {
  87                 if (G_filter.tb) {
  88                         if (G_filter.tb < 0) {
  89                                 if (!(r->rtm_flags & RTM_F_CLONED)) {
  90                                         return 0;
  91                                 }
  92                         } else {
  93                                 if (r->rtm_flags & RTM_F_CLONED) {
  94                                         return 0;
  95                                 }
  96                                 if (G_filter.tb == RT_TABLE_LOCAL) {
  97                                         if (r->rtm_type != RTN_LOCAL) {
  98                                                 return 0;
  99                                         }
 100                                 } else if (G_filter.tb == RT_TABLE_MAIN) {
 101                                         if (r->rtm_type == RTN_LOCAL) {
 102                                                 return 0;
 103                                         }
 104                                 } else {
 105                                         return 0;
 106                                 }
 107                         }
 108                 }
 109         } else {
 110                 if (G_filter.tb > 0 && G_filter.tb != r->rtm_table) {
 111                         return 0;
 112                 }
 113         }
 114         if (G_filter.rdst.family
 115          && (r->rtm_family != G_filter.rdst.family || G_filter.rdst.bitlen > r->rtm_dst_len)
 116         ) {
 117                 return 0;
 118         }
 119         if (G_filter.mdst.family
 120          && (r->rtm_family != G_filter.mdst.family
 121             || (G_filter.mdst.bitlen >= 0 && G_filter.mdst.bitlen < r->rtm_dst_len)
 122             )
 123         ) {
 124                 return 0;
 125         }
 126         if (G_filter.rsrc.family
 127          && (r->rtm_family != G_filter.rsrc.family || G_filter.rsrc.bitlen > r->rtm_src_len)
 128         ) {
 129                 return 0;
 130         }
 131         if (G_filter.msrc.family
 132          && (r->rtm_family != G_filter.msrc.family
 133             || (G_filter.msrc.bitlen >= 0 && G_filter.msrc.bitlen < r->rtm_src_len)
 134             )
 135         ) {
 136                 return 0;
 137         }
 138
 139         memset(tb, 0, sizeof(tb));
 140         memset(&src, 0, sizeof(src));
 141         memset(&dst, 0, sizeof(dst));
 142         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 143
 144         if (tb[RTA_SRC]) {
 145                 src.bitlen = r->rtm_src_len;
 146                 src.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
 147                 memcpy(src.data, RTA_DATA(tb[RTA_SRC]), src.bytelen);
 148         }
 149         if (tb[RTA_DST]) {
 150                 dst.bitlen = r->rtm_dst_len;
 151                 dst.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
 152                 memcpy(dst.data, RTA_DATA(tb[RTA_DST]), dst.bytelen);
 153         }
 154
 155         if (G_filter.rdst.family
 156          && inet_addr_match(&dst, &G_filter.rdst, G_filter.rdst.bitlen)
 157         ) {
 158                 return 0;
 159         }
 160         if (G_filter.mdst.family
 161          && G_filter.mdst.bitlen >= 0
 162          && inet_addr_match(&dst, &G_filter.mdst, r->rtm_dst_len)
 163         ) {
 164                 return 0;
 165         }
 166         if (G_filter.rsrc.family
 167          && inet_addr_match(&src, &G_filter.rsrc, G_filter.rsrc.bitlen)
 168         ) {
 169                 return 0;
 170         }
 171         if (G_filter.msrc.family && G_filter.msrc.bitlen >= 0
 172          && inet_addr_match(&src, &G_filter.msrc, r->rtm_src_len)
 173         ) {
 174                 return 0;
 175         }
 176         if (G_filter.oif != 0) {
 177                 if (!tb[RTA_OIF])
 178                         return 0;
 179                 if (G_filter.oif != *(int*)RTA_DATA(tb[RTA_OIF]))
 180                         return 0;
 181         }
 182
 183         if (G_filter.flushb) {
 184                 struct nlmsghdr *fn;
 185
 186                 /* We are creating route flush commands */
 187
 188                 if (r->rtm_family == AF_INET6
 189                  && r->rtm_dst_len == 0
 190                  && r->rtm_type == RTN_UNREACHABLE
 191                  && tb[RTA_PRIORITY]
 192                  && *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1
 193                 ) {
 194                         return 0;
 195                 }
 196
 197                 if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
 198                         if (flush_update())
 199                                 xfunc_die();
 200                 }
 201                 fn = (void*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
 202                 memcpy(fn, n, n->nlmsg_len);
 203                 fn->nlmsg_type = RTM_DELROUTE;
 204                 fn->nlmsg_flags = NLM_F_REQUEST;
 205                 fn->nlmsg_seq = ++G_filter.rth->seq;
 206                 G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
 207                 G_filter.flushed = 1;
 208                 return 0;
 209         }
 210
 211         /* We are printing routes */
 212
 213         if (n->nlmsg_type == RTM_DELROUTE) {
 214                 printf("Deleted ");
 215         }
 216         if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) {
 217                 printf("%s ", rtnl_rtntype_n2a(r->rtm_type));
 218         }
 219
 220         if (tb[RTA_DST]) {
 221                 if (r->rtm_dst_len != host_len) {
 222                         printf("%s/%u ",
 223                                 rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_DST])),
 224                                 r->rtm_dst_len
 225                         );
 226                 } else {
 227                         printf("%s ", format_host(r->rtm_family,
 228                                                 RTA_PAYLOAD(tb[RTA_DST]),
 229                                                 RTA_DATA(tb[RTA_DST]))
 230                         );
 231                 }
 232         } else if (r->rtm_dst_len) {
 233                 printf("0/%d ", r->rtm_dst_len);
 234         } else {
 235                 printf("default ");
 236         }
 237         if (tb[RTA_SRC]) {
 238                 if (r->rtm_src_len != host_len) {
 239                         printf("from %s/%u ",
 240                                 rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_SRC])),
 241                                 r->rtm_src_len
 242                         );
 243                 } else {
 244                         printf("from %s ", format_host(r->rtm_family,
 245                                                 RTA_PAYLOAD(tb[RTA_SRC]),
 246                                                 RTA_DATA(tb[RTA_SRC]))
 247                         );
 248                 }
 249         } else if (r->rtm_src_len) {
 250                 printf("from 0/%u ", r->rtm_src_len);
 251         }
 252         if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) {
 253                 printf("via %s ", format_host(r->rtm_family,
 254                                         RTA_PAYLOAD(tb[RTA_GATEWAY]),
 255                                         RTA_DATA(tb[RTA_GATEWAY]))
 256                 );
 257         }
 258         if (tb[RTA_OIF]) {
 259                 printf("dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
 260         }
 261
 262         /* Todo: parse & show "proto kernel", "scope link" here */
 263
 264         if (tb[RTA_PREFSRC] && /*G_filter.rprefsrc.bitlen - always 0*/ 0 != host_len) {
 265                 /* Do not use format_host(). It is our local addr
 266                    and symbolic name will not be useful.
 267                  */
 268                 printf(" src %s ", rt_addr_n2a(r->rtm_family,
 269                                         RTA_DATA(tb[RTA_PREFSRC])));
 270         }
 271         if (tb[RTA_PRIORITY]) {
 272                 printf(" metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
 273         }
 274         if (r->rtm_flags & RTNH_F_DEAD) {
 275                 printf("dead ");
 276         }
 277         if (r->rtm_flags & RTNH_F_ONLINK) {
 278                 printf("onlink ");
 279         }
 280         if (r->rtm_flags & RTNH_F_PERVASIVE) {
 281                 printf("pervasive ");
 282         }
 283         if (r->rtm_flags & RTM_F_NOTIFY) {
 284                 printf("notify ");
 285         }
 286
 287         if (r->rtm_family == AF_INET6) {
 288                 struct rta_cacheinfo *ci = NULL;
 289                 if (tb[RTA_CACHEINFO]) {
 290                         ci = RTA_DATA(tb[RTA_CACHEINFO]);
 291                 }
 292                 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
 293                         if (r->rtm_flags & RTM_F_CLONED) {
 294                                 printf("%c    cache ", _SL_);
 295                         }
 296                         if (ci->rta_expires) {
 297                                 printf(" expires %dsec", ci->rta_expires / get_hz());
 298                         }
 299                         if (ci->rta_error != 0) {
 300                                 printf(" error %d", ci->rta_error);
 301                         }
 302                 } else if (ci) {
 303                         if (ci->rta_error != 0)
 304                                 printf(" error %d", ci->rta_error);
 305                 }
 306         }
 307         if (tb[RTA_IIF] && G_filter.iif == 0) {
 308                 printf(" iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
 309         }
 310         bb_putchar('\n');
 311         return 0;
 312 }
 313
 314 /* Return value becomes exitcode. It's okay to not return at all */
 315 static int iproute_modify(int cmd, unsigned flags, char **argv)
 316 {
 317         static const char keywords[] ALIGN1 =
 318                 "src\0""via\0""mtu\0""lock\0""scope\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
 319                 "dev\0""oif\0""to\0""metric\0""onlink\0";
 320         enum {
 321                 ARG_src,
 322                 ARG_via,
 323                 ARG_mtu, PARM_lock,
 324                 ARG_scope,
 325                 ARG_protocol,
 326 IF_FEATURE_IP_RULE(ARG_table,)
 327                 ARG_dev,
 328                 ARG_oif,
 329                 ARG_to,
 330                 ARG_metric,
 331                 ARG_onlink,
 332         };
 333         enum {
 334                 gw_ok = 1 << 0,
 335                 dst_ok = 1 << 1,
 336                 proto_ok = 1 << 2,
 337                 type_ok = 1 << 3
 338         };
 339         struct rtnl_handle rth;
 340         struct {
 341                 struct nlmsghdr n;
 342                 struct rtmsg    r;
 343                 char            buf[1024];
 344         } req;
 345         char mxbuf[256];
 346         struct rtattr * mxrta = (void*)mxbuf;
 347         unsigned mxlock = 0;
 348         char *d = NULL;
 349         smalluint ok = 0;
 350         smalluint scope_ok = 0;
 351         int arg;
 352
 353         memset(&req, 0, sizeof(req));
 354
 355         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 356         req.n.nlmsg_flags = NLM_F_REQUEST | flags;
 357         req.n.nlmsg_type = cmd;
 358         req.r.rtm_family = preferred_family;
 359         if (RT_TABLE_MAIN != 0) /* if it is zero, memset already did it */
 360                 req.r.rtm_table = RT_TABLE_MAIN;
 361         if (RT_SCOPE_NOWHERE != 0)
 362                 req.r.rtm_scope = RT_SCOPE_NOWHERE;
 363
 364         if (cmd != RTM_DELROUTE) {
 365                 if (RTPROT_BOOT != 0)
 366                         req.r.rtm_protocol = RTPROT_BOOT;
 367                 if (RT_SCOPE_UNIVERSE != 0)
 368                         req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 369                 if (RTN_UNICAST != 0)
 370                         req.r.rtm_type = RTN_UNICAST;
 371         }
 372
 373         mxrta->rta_type = RTA_METRICS;
 374         mxrta->rta_len = RTA_LENGTH(0);
 375
 376         while (*argv) {
 377                 arg = index_in_substrings(keywords, *argv);
 378                 if (arg == ARG_src) {
 379                         inet_prefix addr;
 380                         NEXT_ARG();
 381                         get_addr(&addr, *argv, req.r.rtm_family);
 382                         if (req.r.rtm_family == AF_UNSPEC)
 383                                 req.r.rtm_family = addr.family;
 384                         addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
 385                 } else if (arg == ARG_via) {
 386                         inet_prefix addr;
 387                         ok |= gw_ok;
 388                         NEXT_ARG();
 389                         get_addr(&addr, *argv, req.r.rtm_family);
 390                         if (req.r.rtm_family == AF_UNSPEC) {
 391                                 req.r.rtm_family = addr.family;
 392                         }
 393                         addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
 394                 } else if (arg == ARG_mtu) {
 395                         unsigned mtu;
 396                         NEXT_ARG();
 397                         if (index_in_strings(keywords, *argv) == PARM_lock) {
 398                                 mxlock |= (1 << RTAX_MTU);
 399                                 NEXT_ARG();
 400                         }
 401                         mtu = get_unsigned(*argv, "mtu");
 402                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
 403                 } else if (arg == ARG_scope) {
 404                         uint32_t scope;
 405                         NEXT_ARG();
 406                         if (rtnl_rtscope_a2n(&scope, *argv))
 407                                 invarg_1_to_2(*argv, "scope");
 408                         req.r.rtm_scope = scope;
 409                         scope_ok = 1;
 410                 } else if (arg == ARG_protocol) {
 411                         uint32_t prot;
 412                         NEXT_ARG();
 413                         if (rtnl_rtprot_a2n(&prot, *argv))
 414                                 invarg_1_to_2(*argv, "protocol");
 415                         req.r.rtm_protocol = prot;
 416                         ok |= proto_ok;
 417 #if ENABLE_FEATURE_IP_RULE
 418                 } else if (arg == ARG_table) {
 419                         uint32_t tid;
 420                         NEXT_ARG();
 421                         if (rtnl_rttable_a2n(&tid, *argv))
 422                                 invarg_1_to_2(*argv, "table");
 423                         req.r.rtm_table = tid;
 424 #endif
 425                 } else if (arg == ARG_dev || arg == ARG_oif) {
 426                         NEXT_ARG();
 427                         d = *argv;
 428                 } else if (arg == ARG_metric) {
 429                         uint32_t metric;
 430                         NEXT_ARG();
 431                         metric = get_u32(*argv, "metric");
 432                         addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
 433                 } else if (arg == ARG_onlink) {
 434                         req.r.rtm_flags |= RTNH_F_ONLINK;
 435                 } else {
 436                         int type;
 437                         inet_prefix dst;
 438
 439                         if (arg == ARG_to) {
 440                                 NEXT_ARG();
 441                         }
 442                         if ((**argv < '0' || **argv > '9')
 443                          && rtnl_rtntype_a2n(&type, *argv) == 0
 444                         ) {
 445                                 NEXT_ARG();
 446                                 req.r.rtm_type = type;
 447                                 ok |= type_ok;
 448                         }
 449
 450                         if (ok & dst_ok) {
 451                                 duparg2("to", *argv);
 452                         }
 453                         get_prefix(&dst, *argv, req.r.rtm_family);
 454                         if (req.r.rtm_family == AF_UNSPEC) {
 455                                 req.r.rtm_family = dst.family;
 456                         }
 457                         req.r.rtm_dst_len = dst.bitlen;
 458                         ok |= dst_ok;
 459                         if (dst.bytelen) {
 460                                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 461                         }
 462                 }
 463                 argv++;
 464         }
 465
 466         xrtnl_open(&rth);
 467
 468         if (d)  {
 469                 int idx;
 470
 471                 ll_init_map(&rth);
 472
 473                 if (d) {
 474                         idx = xll_name_to_index(d);
 475                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 476                 }
 477         }
 478
 479         if (mxrta->rta_len > RTA_LENGTH(0)) {
 480                 if (mxlock) {
 481                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
 482                 }
 483                 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
 484         }
 485
 486         if (!scope_ok) {
 487                 if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
 488                         req.r.rtm_scope = RT_SCOPE_HOST;
 489                 else
 490                 if (req.r.rtm_type == RTN_BROADCAST
 491                  || req.r.rtm_type == RTN_MULTICAST
 492                  || req.r.rtm_type == RTN_ANYCAST
 493                 ) {
 494                         req.r.rtm_scope = RT_SCOPE_LINK;
 495                 }
 496                 else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
 497                         if (cmd == RTM_DELROUTE)
 498                                 req.r.rtm_scope = RT_SCOPE_NOWHERE;
 499                         else if (!(ok & gw_ok))
 500                                 req.r.rtm_scope = RT_SCOPE_LINK;
 501                 }
 502         }
 503
 504         if (req.r.rtm_family == AF_UNSPEC) {
 505                 req.r.rtm_family = AF_INET;
 506         }
 507
 508         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
 509                 return 2;
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
 516 {
 517         struct {
 518                 struct nlmsghdr nlh;
 519                 struct rtmsg rtm;
 520         } req;
 521         struct sockaddr_nl nladdr;
 522
 523         memset(&nladdr, 0, sizeof(nladdr));
 524         memset(&req, 0, sizeof(req));
 525         nladdr.nl_family = AF_NETLINK;
 526
 527         req.nlh.nlmsg_len = sizeof(req);
 528         if (RTM_GETROUTE)
 529                 req.nlh.nlmsg_type = RTM_GETROUTE;
 530         if (NLM_F_ROOT | NLM_F_REQUEST)
 531                 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST;
 532         /*req.nlh.nlmsg_pid = 0; - memset did it already */
 533         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
 534         req.rtm.rtm_family = family;
 535         if (RTM_F_CLONED)
 536                 req.rtm.rtm_flags = RTM_F_CLONED;
 537
 538         return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr));
 539 }
 540
 541 static void iproute_flush_cache(void)
 542 {
 543         static const char fn[] ALIGN1 = "/proc/sys/net/ipv4/route/flush";
 544         int flush_fd = open_or_warn(fn, O_WRONLY);
 545
 546         if (flush_fd < 0) {
 547                 return;
 548         }
 549
 550         if (write(flush_fd, "-1", 2) < 2) {
 551                 bb_perror_msg("can't flush routing cache");
 552                 return;
 553         }
 554         close(flush_fd);
 555 }
 556
 557 static void iproute_reset_filter(void)
 558 {
 559         memset(&G_filter, 0, sizeof(G_filter));
 560         G_filter.mdst.bitlen = -1;
 561         G_filter.msrc.bitlen = -1;
 562 }
 563
 564 /* Return value becomes exitcode. It's okay to not return at all */
 565 static int iproute_list_or_flush(char **argv, int flush)
 566 {
 567         int do_ipv6 = preferred_family;
 568         struct rtnl_handle rth;
 569         char *id = NULL;
 570         char *od = NULL;
 571         static const char keywords[] ALIGN1 =
 572                 /* "ip route list/flush" parameters: */
 573                 "protocol\0" "dev\0"   "oif\0"   "iif\0"
 574                 "via\0"      "table\0" "cache\0"
 575                 "from\0"     "to\0"
 576                 /* and possible further keywords */
 577                 "all\0"
 578                 "root\0"
 579                 "match\0"
 580                 "exact\0"
 581                 "main\0"
 582                 ;
 583         enum {
 584                 KW_proto, KW_dev,   KW_oif,  KW_iif,
 585                 KW_via,   KW_table, KW_cache,
 586                 KW_from,  KW_to,
 587                 /* */
 588                 KW_all,
 589                 KW_root,
 590                 KW_match,
 591                 KW_exact,
 592                 KW_main,
 593         };
 594         int arg, parm;
 595
 596         iproute_reset_filter();
 597         G_filter.tb = RT_TABLE_MAIN;
 598
 599         if (flush && !*argv)
 600                 bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
 601
 602         while (*argv) {
 603                 arg = index_in_substrings(keywords, *argv);
 604                 if (arg == KW_proto) {
 605                         uint32_t prot = 0;
 606                         NEXT_ARG();
 607                         //G_filter.protocolmask = -1;
 608                         if (rtnl_rtprot_a2n(&prot, *argv)) {
 609                                 if (index_in_strings(keywords, *argv) != KW_all)
 610                                         invarg_1_to_2(*argv, "protocol");
 611                                 prot = 0;
 612                                 //G_filter.protocolmask = 0;
 613                         }
 614                         //G_filter.protocol = prot;
 615                 } else if (arg == KW_dev || arg == KW_oif) {
 616                         NEXT_ARG();
 617                         od = *argv;
 618                 } else if (arg == KW_iif) {
 619                         NEXT_ARG();
 620                         id = *argv;
 621                 } else if (arg == KW_via) {
 622                         NEXT_ARG();
 623                         get_prefix(&G_filter.rvia, *argv, do_ipv6);
 624                 } else if (arg == KW_table) { /* table all/cache/main */
 625                         NEXT_ARG();
 626                         parm = index_in_substrings(keywords, *argv);
 627                         if (parm == KW_cache)
 628                                 G_filter.tb = -1;
 629                         else if (parm == KW_all)
 630                                 G_filter.tb = 0;
 631                         else if (parm != KW_main) {
 632 #if ENABLE_FEATURE_IP_RULE
 633                                 uint32_t tid;
 634                                 if (rtnl_rttable_a2n(&tid, *argv))
 635                                         invarg_1_to_2(*argv, "table");
 636                                 G_filter.tb = tid;
 637 #else
 638                                 invarg_1_to_2(*argv, "table");
 639 #endif
 640                         }
 641                 } else if (arg == KW_cache) {
 642                         /* The command 'ip route flush cache' is used by OpenSWAN.
 643                          * Assuming it's a synonym for 'ip route flush table cache' */
 644                         G_filter.tb = -1;
 645                 } else if (arg == KW_from) {
 646                         NEXT_ARG();
 647                         parm = index_in_substrings(keywords, *argv);
 648                         if (parm == KW_root) {
 649                                 NEXT_ARG();
 650                                 get_prefix(&G_filter.rsrc, *argv, do_ipv6);
 651                         } else if (parm == KW_match) {
 652                                 NEXT_ARG();
 653                                 get_prefix(&G_filter.msrc, *argv, do_ipv6);
 654                         } else {
 655                                 if (parm == KW_exact)
 656                                         NEXT_ARG();
 657                                 get_prefix(&G_filter.msrc, *argv, do_ipv6);
 658                                 G_filter.rsrc = G_filter.msrc;
 659                         }
 660                 } else { /* "to" is the default parameter */
 661                         if (arg == KW_to) {
 662                                 NEXT_ARG();
 663                                 arg = index_in_substrings(keywords, *argv);
 664                         }
 665                         /* parm = arg; - would be more plausible, but we reuse 'arg' here */
 666                         if (arg == KW_root) {
 667                                 NEXT_ARG();
 668                                 get_prefix(&G_filter.rdst, *argv, do_ipv6);
 669                         } else if (arg == KW_match) {
 670                                 NEXT_ARG();
 671                                 get_prefix(&G_filter.mdst, *argv, do_ipv6);
 672                         } else { /* "to exact" is the default */
 673                                 if (arg == KW_exact)
 674                                         NEXT_ARG();
 675                                 get_prefix(&G_filter.mdst, *argv, do_ipv6);
 676                                 G_filter.rdst = G_filter.mdst;
 677                         }
 678                 }
 679                 argv++;
 680         }
 681
 682         if (do_ipv6 == AF_UNSPEC && G_filter.tb) {
 683                 do_ipv6 = AF_INET;
 684         }
 685
 686         xrtnl_open(&rth);
 687         ll_init_map(&rth);
 688
 689         if (id || od)  {
 690                 int idx;
 691
 692                 if (id) {
 693                         idx = xll_name_to_index(id);
 694                         G_filter.iif = idx;
 695                 }
 696                 if (od) {
 697                         idx = xll_name_to_index(od);
 698                         G_filter.oif = idx;
 699                 }
 700         }
 701
 702         if (flush) {
 703                 char flushb[4096-512];
 704
 705                 if (G_filter.tb == -1) { /* "flush table cache" */
 706                         if (do_ipv6 != AF_INET6)
 707                                 iproute_flush_cache();
 708                         if (do_ipv6 == AF_INET)
 709                                 return 0;
 710                 }
 711
 712                 G_filter.flushb = flushb;
 713                 G_filter.flushp = 0;
 714                 G_filter.flushe = sizeof(flushb);
 715                 G_filter.rth = &rth;
 716
 717                 for (;;) {
 718                         xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
 719                         G_filter.flushed = 0;
 720                         xrtnl_dump_filter(&rth, print_route, NULL);
 721                         if (G_filter.flushed == 0)
 722                                 return 0;
 723                         if (flush_update())
 724                                 return 1;
 725                 }
 726         }
 727
 728         if (G_filter.tb != -1) {
 729                 xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
 730         } else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
 731                 bb_perror_msg_and_die("can't send dump request");
 732         }
 733         xrtnl_dump_filter(&rth, print_route, NULL);
 734
 735         return 0;
 736 }
 737
 738
 739 /* Return value becomes exitcode. It's okay to not return at all */
 740 static int iproute_get(char **argv)
 741 {
 742         struct rtnl_handle rth;
 743         struct {
 744                 struct nlmsghdr n;
 745                 struct rtmsg    r;
 746                 char            buf[1024];
 747         } req;
 748         char *idev = NULL;
 749         char *odev = NULL;
 750         bool connected = 0;
 751         bool from_ok = 0;
 752         static const char options[] ALIGN1 =
 753                 "from\0""iif\0""oif\0""dev\0""notify\0""connected\0""to\0";
 754
 755         memset(&req, 0, sizeof(req));
 756
 757         iproute_reset_filter();
 758
 759         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 760         if (NLM_F_REQUEST)
 761                 req.n.nlmsg_flags = NLM_F_REQUEST;
 762         if (RTM_GETROUTE)
 763                 req.n.nlmsg_type = RTM_GETROUTE;
 764         req.r.rtm_family = preferred_family;
 765         /*req.r.rtm_table = 0; - memset did this already */
 766         /*req.r.rtm_protocol = 0;*/
 767         /*req.r.rtm_scope = 0;*/
 768         /*req.r.rtm_type = 0;*/
 769         /*req.r.rtm_src_len = 0;*/
 770         /*req.r.rtm_dst_len = 0;*/
 771         /*req.r.rtm_tos = 0;*/
 772
 773         while (*argv) {
 774                 switch (index_in_strings(options, *argv)) {
 775                         case 0: /* from */
 776                         {
 777                                 inet_prefix addr;
 778                                 NEXT_ARG();
 779                                 from_ok = 1;
 780                                 get_prefix(&addr, *argv, req.r.rtm_family);
 781                                 if (req.r.rtm_family == AF_UNSPEC) {
 782                                         req.r.rtm_family = addr.family;
 783                                 }
 784                                 if (addr.bytelen) {
 785                                         addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
 786                                 }
 787                                 req.r.rtm_src_len = addr.bitlen;
 788                                 break;
 789                         }
 790                         case 1: /* iif */
 791                                 NEXT_ARG();
 792                                 idev = *argv;
 793                                 break;
 794                         case 2: /* oif */
 795                         case 3: /* dev */
 796                                 NEXT_ARG();
 797                                 odev = *argv;
 798                                 break;
 799                         case 4: /* notify */
 800                                 req.r.rtm_flags |= RTM_F_NOTIFY;
 801                                 break;
 802                         case 5: /* connected */
 803                                 connected = 1;
 804                                 break;
 805                         case 6: /* to */
 806                                 NEXT_ARG();
 807                         default:
 808                         {
 809                                 inet_prefix addr;
 810                                 get_prefix(&addr, *argv, req.r.rtm_family);
 811                                 if (req.r.rtm_family == AF_UNSPEC) {
 812                                         req.r.rtm_family = addr.family;
 813                                 }
 814                                 if (addr.bytelen) {
 815                                         addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
 816                                 }
 817                                 req.r.rtm_dst_len = addr.bitlen;
 818                         }
 819                 }
 820                 argv++;
 821         }
 822
 823         if (req.r.rtm_dst_len == 0) {
 824                 bb_error_msg_and_die("need at least destination address");
 825         }
 826
 827         xrtnl_open(&rth);
 828
 829         ll_init_map(&rth);
 830
 831         if (idev || odev)  {
 832                 int idx;
 833
 834                 if (idev) {
 835                         idx = xll_name_to_index(idev);
 836                         addattr32(&req.n, sizeof(req), RTA_IIF, idx);
 837                 }
 838                 if (odev) {
 839                         idx = xll_name_to_index(odev);
 840                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 841                 }
 842         }
 843
 844         if (req.r.rtm_family == AF_UNSPEC) {
 845                 req.r.rtm_family = AF_INET;
 846         }
 847
 848         if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
 849                 return 2;
 850         }
 851
 852         if (connected && !from_ok) {
 853                 struct rtmsg *r = NLMSG_DATA(&req.n);
 854                 int len = req.n.nlmsg_len;
 855                 struct rtattr * tb[RTA_MAX+1];
 856
 857                 print_route(NULL, &req.n, NULL);
 858
 859                 if (req.n.nlmsg_type != RTM_NEWROUTE) {
 860                         bb_error_msg_and_die("not a route?");
 861                 }
 862                 len -= NLMSG_LENGTH(sizeof(*r));
 863                 if (len < 0) {
 864                         bb_error_msg_and_die("wrong len %d", len);
 865                 }
 866
 867                 memset(tb, 0, sizeof(tb));
 868                 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 869
 870                 if (tb[RTA_PREFSRC]) {
 871                         tb[RTA_PREFSRC]->rta_type = RTA_SRC;
 872                         r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
 873                 } else if (!tb[RTA_SRC]) {
 874                         bb_error_msg_and_die("can't connect the route");
 875                 }
 876                 if (!odev && tb[RTA_OIF]) {
 877                         tb[RTA_OIF]->rta_type = 0;
 878                 }
 879                 if (tb[RTA_GATEWAY]) {
 880                         tb[RTA_GATEWAY]->rta_type = 0;
 881                 }
 882                 if (!idev && tb[RTA_IIF]) {
 883                         tb[RTA_IIF]->rta_type = 0;
 884                 }
 885                 req.n.nlmsg_flags = NLM_F_REQUEST;
 886                 req.n.nlmsg_type = RTM_GETROUTE;
 887
 888                 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
 889                         return 2;
 890                 }
 891         }
 892         print_route(NULL, &req.n, NULL);
 893         return 0;
 894 }
 895
 896 /* Return value becomes exitcode. It's okay to not return at all */
 897 int FAST_FUNC do_iproute(char **argv)
 898 {
 899         static const char ip_route_commands[] ALIGN1 =
 900         /*0-3*/ "add\0""append\0""change\0""chg\0"
 901         /*4-7*/ "delete\0""get\0""list\0""show\0"
 902         /*8..*/ "prepend\0""replace\0""test\0""flush\0";
 903         int command_num;
 904         unsigned flags = 0;
 905         int cmd = RTM_NEWROUTE;
 906
 907         INIT_G();
 908
 909         if (!*argv)
 910                 return iproute_list_or_flush(argv, 0);
 911
 912         /* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
 913         /* It probably means that it is using "first match" rule */
 914         command_num = index_in_substrings(ip_route_commands, *argv);
 915
 916         switch (command_num) {
 917                 case 0: /* add */
 918                         flags = NLM_F_CREATE|NLM_F_EXCL;
 919                         break;
 920                 case 1: /* append */
 921                         flags = NLM_F_CREATE|NLM_F_APPEND;
 922                         break;
 923                 case 2: /* change */
 924                 case 3: /* chg */
 925                         flags = NLM_F_REPLACE;
 926                         break;
 927                 case 4: /* delete */
 928                         cmd = RTM_DELROUTE;
 929                         break;
 930                 case 5: /* get */
 931                         return iproute_get(argv+1);
 932                 case 6: /* list */
 933                 case 7: /* show */
 934                         return iproute_list_or_flush(argv+1, 0);
 935                 case 8: /* prepend */
 936                         flags = NLM_F_CREATE;
 937                         break;
 938                 case 9: /* replace */
 939                         flags = NLM_F_CREATE|NLM_F_REPLACE;
 940                         break;
 941                 case 10: /* test */
 942                         flags = NLM_F_EXCL;
 943                         break;
 944                 case 11: /* flush */
 945                         return iproute_list_or_flush(argv+1, 1);
 946                 default:
 947                         invarg_1_to_2(*argv, applet_name);
 948         }
 949
 950         return iproute_modify(cmd, flags, argv+1);
 951 }