ip/iproute.c

   1 /*
   2  * iproute.c            "ip route".
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  *
  11  *
  12  * Changes:
  13  *
  14  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  15  * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <syslog.h>
  22 #include <fcntl.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <sys/time.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <netinet/ip.h>
  29 #include <arpa/inet.h>
  30 #include <linux/in_route.h>
  31 #include <linux/ip_mp_alg.h>
  32
  33 #include "rt_names.h"
  34 #include "utils.h"
  35 #include "ip_common.h"
  36
  37 #ifndef RTAX_RTTVAR
  38 #define RTAX_RTTVAR RTAX_HOPS
  39 #endif
  40
  41
  42 static void usage(void) __attribute__((noreturn));
  43
  44 static void usage(void)
  45 {
  46         fprintf(stderr, "Usage: ip route { list | flush } SELECTOR\n");
  47         fprintf(stderr, "       ip route get ADDRESS [ from ADDRESS iif STRING ]\n");
  48         fprintf(stderr, "                            [ oif STRING ]  [ tos TOS ]\n");
  49         fprintf(stderr, "       ip route { add | del | change | append | replace | monitor } ROUTE\n");
  50         fprintf(stderr, "SELECTOR := [ root PREFIX ] [ match PREFIX ] [ exact PREFIX ]\n");
  51         fprintf(stderr, "            [ table TABLE_ID ] [ proto RTPROTO ]\n");
  52         fprintf(stderr, "            [ type TYPE ] [ scope SCOPE ]\n");
  53         fprintf(stderr, "ROUTE := NODE_SPEC [ INFO_SPEC ]\n");
  54         fprintf(stderr, "NODE_SPEC := [ TYPE ] PREFIX [ tos TOS ]\n");
  55         fprintf(stderr, "             [ table TABLE_ID ] [ proto RTPROTO ]\n");
  56         fprintf(stderr, "             [ scope SCOPE ] [ metric METRIC ]\n");
  57         fprintf(stderr, "             [ mpath MP_ALGO ]\n");
  58         fprintf(stderr, "INFO_SPEC := NH OPTIONS FLAGS [ nexthop NH ]...\n");
  59         fprintf(stderr, "NH := [ via ADDRESS ] [ dev STRING ] [ weight NUMBER ] NHFLAGS\n");
  60         fprintf(stderr, "OPTIONS := FLAGS [ mtu NUMBER ] [ advmss NUMBER ]\n");
  61         fprintf(stderr, "           [ rtt NUMBER ] [ rttvar NUMBER ]\n");
  62         fprintf(stderr, "           [ window NUMBER] [ cwnd NUMBER ] [ ssthresh NUMBER ]\n");
  63         fprintf(stderr, "           [ realms REALM ]\n");
  64         fprintf(stderr, "TYPE := [ unicast | local | broadcast | multicast | throw |\n");
  65         fprintf(stderr, "          unreachable | prohibit | blackhole | nat ]\n");
  66         fprintf(stderr, "TABLE_ID := [ local | main | default | all | NUMBER ]\n");
  67         fprintf(stderr, "SCOPE := [ host | link | global | NUMBER ]\n");
  68         fprintf(stderr, "FLAGS := [ equalize ]\n");
  69         fprintf(stderr, "MP_ALGO := { rr | drr | random | wrandom }\n");
  70         fprintf(stderr, "NHFLAGS := [ onlink | pervasive ]\n");
  71         fprintf(stderr, "RTPROTO := [ kernel | boot | static | NUMBER ]\n");
  72         exit(-1);
  73 }
  74
  75
  76 static struct
  77 {
  78         int tb;
  79         int flushed;
  80         char *flushb;
  81         int flushp;
  82         int flushe;
  83         int protocol, protocolmask;
  84         int scope, scopemask;
  85         int type, typemask;
  86         int tos, tosmask;
  87         int iif, iifmask;
  88         int oif, oifmask;
  89         int realm, realmmask;
  90         inet_prefix rprefsrc;
  91         inet_prefix rvia;
  92         inet_prefix rdst;
  93         inet_prefix mdst;
  94         inet_prefix rsrc;
  95         inet_prefix msrc;
  96 } filter;
  97
  98 static char *mp_alg_names[IP_MP_ALG_MAX+1] = {
  99         [IP_MP_ALG_NONE] = "none",
 100         [IP_MP_ALG_RR] = "rr",
 101         [IP_MP_ALG_DRR] = "drr",
 102         [IP_MP_ALG_RANDOM] = "random",
 103         [IP_MP_ALG_WRANDOM] = "wrandom"
 104 };
 105
 106 static int flush_update(void)
 107 {
 108         if (rtnl_send(&rth, filter.flushb, filter.flushp) < 0) {
 109                 perror("Failed to send flush request\n");
 110                 return -1;
 111         }
 112         filter.flushp = 0;
 113         return 0;
 114 }
 115
 116 int print_route(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
 117 {
 118         FILE *fp = (FILE*)arg;
 119         struct rtmsg *r = NLMSG_DATA(n);
 120         int len = n->nlmsg_len;
 121         struct rtattr * tb[RTA_MAX+1];
 122         char abuf[256];
 123         inet_prefix dst;
 124         inet_prefix src;
 125         inet_prefix prefsrc;
 126         inet_prefix via;
 127         int host_len = -1;
 128         SPRINT_BUF(b1);
 129
 130
 131         if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
 132                 fprintf(stderr, "Not a route: %08x %08x %08x\n",
 133                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
 134                 return 0;
 135         }
 136         if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
 137                 return 0;
 138         len -= NLMSG_LENGTH(sizeof(*r));
 139         if (len < 0) {
 140                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
 141                 return -1;
 142         }
 143
 144         if (r->rtm_family == AF_INET6)
 145                 host_len = 128;
 146         else if (r->rtm_family == AF_INET)
 147                 host_len = 32;
 148         else if (r->rtm_family == AF_DECnet)
 149                 host_len = 16;
 150         else if (r->rtm_family == AF_IPX)
 151                 host_len = 80;
 152
 153         if (r->rtm_family == AF_INET6) {
 154                 if (filter.tb) {
 155                         if (filter.tb < 0) {
 156                                 if (!(r->rtm_flags&RTM_F_CLONED))
 157                                         return 0;
 158                         } else {
 159                                 if (r->rtm_flags&RTM_F_CLONED)
 160                                         return 0;
 161                                 if (filter.tb == RT_TABLE_LOCAL) {
 162                                         if (r->rtm_type != RTN_LOCAL)
 163                                                 return 0;
 164                                 } else if (filter.tb == RT_TABLE_MAIN) {
 165                                         if (r->rtm_type == RTN_LOCAL)
 166                                                 return 0;
 167                                 } else {
 168                                         return 0;
 169                                 }
 170                         }
 171                 }
 172         } else {
 173                 if (filter.tb > 0 && filter.tb != r->rtm_table)
 174                         return 0;
 175         }
 176         if ((filter.protocol^r->rtm_protocol)&filter.protocolmask)
 177                 return 0;
 178         if ((filter.scope^r->rtm_scope)&filter.scopemask)
 179                 return 0;
 180         if ((filter.type^r->rtm_type)&filter.typemask)
 181                 return 0;
 182         if ((filter.tos^r->rtm_tos)&filter.tosmask)
 183                 return 0;
 184         if (filter.rdst.family &&
 185             (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len))
 186                 return 0;
 187         if (filter.mdst.family &&
 188             (r->rtm_family != filter.mdst.family ||
 189              (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len)))
 190                 return 0;
 191         if (filter.rsrc.family &&
 192             (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len))
 193                 return 0;
 194         if (filter.msrc.family &&
 195             (r->rtm_family != filter.msrc.family ||
 196              (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len)))
 197                 return 0;
 198         if (filter.rvia.family && r->rtm_family != filter.rvia.family)
 199                 return 0;
 200         if (filter.rprefsrc.family && r->rtm_family != filter.rprefsrc.family)
 201                 return 0;
 202
 203         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 204
 205         memset(&dst, 0, sizeof(dst));
 206         dst.family = r->rtm_family;
 207         if (tb[RTA_DST])
 208                 memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), (r->rtm_dst_len+7)/8);
 209         if (filter.rsrc.family || filter.msrc.family) {
 210                 memset(&src, 0, sizeof(src));
 211                 src.family = r->rtm_family;
 212                 if (tb[RTA_SRC])
 213                         memcpy(&src.data, RTA_DATA(tb[RTA_SRC]), (r->rtm_src_len+7)/8);
 214         }
 215         if (filter.rvia.bitlen>0) {
 216                 memset(&via, 0, sizeof(via));
 217                 via.family = r->rtm_family;
 218                 if (tb[RTA_GATEWAY])
 219                         memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]), host_len/8);
 220         }
 221         if (filter.rprefsrc.bitlen>0) {
 222                 memset(&prefsrc, 0, sizeof(prefsrc));
 223                 prefsrc.family = r->rtm_family;
 224                 if (tb[RTA_PREFSRC])
 225                         memcpy(&prefsrc.data, RTA_DATA(tb[RTA_PREFSRC]), host_len/8);
 226         }
 227
 228         if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))
 229                 return 0;
 230         if (filter.mdst.family && filter.mdst.bitlen >= 0 &&
 231             inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
 232                 return 0;
 233
 234         if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))
 235                 return 0;
 236         if (filter.msrc.family && filter.msrc.bitlen >= 0 &&
 237             inet_addr_match(&src, &filter.msrc, r->rtm_src_len))
 238                 return 0;
 239
 240         if (filter.rvia.family && inet_addr_match(&via, &filter.rvia, filter.rvia.bitlen))
 241                 return 0;
 242         if (filter.rprefsrc.family && inet_addr_match(&prefsrc, &filter.rprefsrc, filter.rprefsrc.bitlen))
 243                 return 0;
 244         if (filter.realmmask) {
 245                 __u32 realms = 0;
 246                 if (tb[RTA_FLOW])
 247                         realms = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
 248                 if ((realms^filter.realm)&filter.realmmask)
 249                         return 0;
 250         }
 251         if (filter.iifmask) {
 252                 int iif = 0;
 253                 if (tb[RTA_IIF])
 254                         iif = *(int*)RTA_DATA(tb[RTA_IIF]);
 255                 if ((iif^filter.iif)&filter.iifmask)
 256                         return 0;
 257         }
 258         if (filter.oifmask) {
 259                 int oif = 0;
 260                 if (tb[RTA_OIF])
 261                         oif = *(int*)RTA_DATA(tb[RTA_OIF]);
 262                 if ((oif^filter.oif)&filter.oifmask)
 263                         return 0;
 264         }
 265         if (filter.flushb &&
 266             r->rtm_family == AF_INET6 &&
 267             r->rtm_dst_len == 0 &&
 268             r->rtm_type == RTN_UNREACHABLE &&
 269             tb[RTA_PRIORITY] &&
 270             *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1)
 271                 return 0;
 272
 273         if (filter.flushb) {
 274                 struct nlmsghdr *fn;
 275                 if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
 276                         if (flush_update())
 277                                 return -1;
 278                 }
 279                 fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
 280                 memcpy(fn, n, n->nlmsg_len);
 281                 fn->nlmsg_type = RTM_DELROUTE;
 282                 fn->nlmsg_flags = NLM_F_REQUEST;
 283                 fn->nlmsg_seq = ++rth.seq;
 284                 filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
 285                 filter.flushed++;
 286                 if (show_stats < 2)
 287                         return 0;
 288         }
 289
 290         if (n->nlmsg_type == RTM_DELROUTE)
 291                 fprintf(fp, "Deleted ");
 292         if (r->rtm_type != RTN_UNICAST && !filter.type)
 293                 fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
 294
 295         if (tb[RTA_DST]) {
 296                 if (r->rtm_dst_len != host_len) {
 297                         fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family,
 298                                                          RTA_PAYLOAD(tb[RTA_DST]),
 299                                                          RTA_DATA(tb[RTA_DST]),
 300                                                          abuf, sizeof(abuf)),
 301                                 r->rtm_dst_len
 302                                 );
 303                 } else {
 304                         fprintf(fp, "%s ", format_host(r->rtm_family,
 305                                                        RTA_PAYLOAD(tb[RTA_DST]),
 306                                                        RTA_DATA(tb[RTA_DST]),
 307                                                        abuf, sizeof(abuf))
 308                                 );
 309                 }
 310         } else if (r->rtm_dst_len) {
 311                 fprintf(fp, "0/%d ", r->rtm_dst_len);
 312         } else {
 313                 fprintf(fp, "default ");
 314         }
 315         if (tb[RTA_SRC]) {
 316                 if (r->rtm_src_len != host_len) {
 317                         fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family,
 318                                                          RTA_PAYLOAD(tb[RTA_SRC]),
 319                                                          RTA_DATA(tb[RTA_SRC]),
 320                                                          abuf, sizeof(abuf)),
 321                                 r->rtm_src_len
 322                                 );
 323                 } else {
 324                         fprintf(fp, "from %s ", format_host(r->rtm_family,
 325                                                        RTA_PAYLOAD(tb[RTA_SRC]),
 326                                                        RTA_DATA(tb[RTA_SRC]),
 327                                                        abuf, sizeof(abuf))
 328                                 );
 329                 }
 330         } else if (r->rtm_src_len) {
 331                 fprintf(fp, "from 0/%u ", r->rtm_src_len);
 332         }
 333         if (r->rtm_tos && filter.tosmask != -1) {
 334                 SPRINT_BUF(b1);
 335                 fprintf(fp, "tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1)));
 336         }
 337
 338         if (tb[RTA_MP_ALGO]) {
 339                 __u32 mp_alg = *(__u32*) RTA_DATA(tb[RTA_MP_ALGO]);
 340                 if (mp_alg > IP_MP_ALG_NONE) {
 341                         fprintf(fp, "mpath %s ",
 342                             mp_alg < IP_MP_ALG_MAX ? mp_alg_names[mp_alg] : "unknown");
 343                 }
 344         }
 345
 346         if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
 347                 fprintf(fp, "via %s ",
 348                         format_host(r->rtm_family,
 349                                     RTA_PAYLOAD(tb[RTA_GATEWAY]),
 350                                     RTA_DATA(tb[RTA_GATEWAY]),
 351                                     abuf, sizeof(abuf)));
 352         }
 353         if (tb[RTA_OIF] && filter.oifmask != -1)
 354                 fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
 355
 356         if (!(r->rtm_flags&RTM_F_CLONED)) {
 357                 if (r->rtm_table != RT_TABLE_MAIN && !filter.tb)
 358                         fprintf(fp, " table %s ", rtnl_rttable_n2a(r->rtm_table, b1, sizeof(b1)));
 359                 if (r->rtm_protocol != RTPROT_BOOT && filter.protocolmask != -1)
 360                         fprintf(fp, " proto %s ", rtnl_rtprot_n2a(r->rtm_protocol, b1, sizeof(b1)));
 361                 if (r->rtm_scope != RT_SCOPE_UNIVERSE && filter.scopemask != -1)
 362                         fprintf(fp, " scope %s ", rtnl_rtscope_n2a(r->rtm_scope, b1, sizeof(b1)));
 363         }
 364         if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
 365                 /* Do not use format_host(). It is our local addr
 366                    and symbolic name will not be useful.
 367                  */
 368                 fprintf(fp, " src %s ",
 369                         rt_addr_n2a(r->rtm_family,
 370                                     RTA_PAYLOAD(tb[RTA_PREFSRC]),
 371                                     RTA_DATA(tb[RTA_PREFSRC]),
 372                                     abuf, sizeof(abuf)));
 373         }
 374         if (tb[RTA_PRIORITY])
 375                 fprintf(fp, " metric %d ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY]));
 376         if (r->rtm_flags & RTNH_F_DEAD)
 377                 fprintf(fp, "dead ");
 378         if (r->rtm_flags & RTNH_F_ONLINK)
 379                 fprintf(fp, "onlink ");
 380         if (r->rtm_flags & RTNH_F_PERVASIVE)
 381                 fprintf(fp, "pervasive ");
 382         if (r->rtm_flags & RTM_F_EQUALIZE)
 383                 fprintf(fp, "equalize ");
 384         if (r->rtm_flags & RTM_F_NOTIFY)
 385                 fprintf(fp, "notify ");
 386
 387         if (tb[RTA_FLOW] && filter.realmmask != ~0U) {
 388                 __u32 to = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
 389                 __u32 from = to>>16;
 390                 to &= 0xFFFF;
 391                 fprintf(fp, "realm%s ", from ? "s" : "");
 392                 if (from) {
 393                         fprintf(fp, "%s/",
 394                                 rtnl_rtrealm_n2a(from, b1, sizeof(b1)));
 395                 }
 396                 fprintf(fp, "%s ",
 397                         rtnl_rtrealm_n2a(to, b1, sizeof(b1)));
 398         }
 399         if ((r->rtm_flags&RTM_F_CLONED) && r->rtm_family == AF_INET) {
 400                 __u32 flags = r->rtm_flags&~0xFFFF;
 401                 int first = 1;
 402
 403                 fprintf(fp, "%s    cache ", _SL_);
 404
 405 #define PRTFL(fl,flname) if (flags&RTCF_##fl) { \
 406   flags &= ~RTCF_##fl; \
 407   fprintf(fp, "%s" flname "%s", first ? "<" : "", flags ? "," : "> "); \
 408   first = 0; }
 409                 PRTFL(LOCAL, "local");
 410                 PRTFL(REJECT, "reject");
 411                 PRTFL(MULTICAST, "mc");
 412                 PRTFL(BROADCAST, "brd");
 413                 PRTFL(DNAT, "dst-nat");
 414                 PRTFL(SNAT, "src-nat");
 415                 PRTFL(MASQ, "masq");
 416                 PRTFL(DIRECTDST, "dst-direct");
 417                 PRTFL(DIRECTSRC, "src-direct");
 418                 PRTFL(REDIRECTED, "redirected");
 419                 PRTFL(DOREDIRECT, "redirect");
 420                 PRTFL(FAST, "fastroute");
 421                 PRTFL(NOTIFY, "notify");
 422                 PRTFL(TPROXY, "proxy");
 423 #ifdef RTCF_EQUALIZE
 424                 PRTFL(EQUALIZE, "equalize");
 425 #endif
 426                 if (flags)
 427                         fprintf(fp, "%s%x> ", first ? "<" : "", flags);
 428                 if (tb[RTA_CACHEINFO]) {
 429                         struct rta_cacheinfo *ci = RTA_DATA(tb[RTA_CACHEINFO]);
 430                         static int hz;
 431                         if (!hz)
 432                                 hz = get_user_hz();
 433                         if (ci->rta_expires != 0)
 434                                 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
 435                         if (ci->rta_error != 0)
 436                                 fprintf(fp, " error %d", ci->rta_error);
 437                         if (show_stats) {
 438                                 if (ci->rta_clntref)
 439                                         fprintf(fp, " users %d", ci->rta_clntref);
 440                                 if (ci->rta_used != 0)
 441                                         fprintf(fp, " used %d", ci->rta_used);
 442                                 if (ci->rta_lastuse != 0)
 443                                         fprintf(fp, " age %dsec", ci->rta_lastuse/hz);
 444                         }
 445 #ifdef RTNETLINK_HAVE_PEERINFO
 446                         if (ci->rta_id)
 447                                 fprintf(fp, " ipid 0x%04x", ci->rta_id);
 448                         if (ci->rta_ts || ci->rta_tsage)
 449                                 fprintf(fp, " ts 0x%x tsage %dsec", ci->rta_ts, ci->rta_tsage);
 450 #endif
 451                 }
 452         } else if (r->rtm_family == AF_INET6) {
 453                 struct rta_cacheinfo *ci = NULL;
 454                 if (tb[RTA_CACHEINFO])
 455                         ci = RTA_DATA(tb[RTA_CACHEINFO]);
 456                 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
 457                         static int hz;
 458                         if (!hz)
 459                                 hz = get_user_hz();
 460                         if (r->rtm_flags & RTM_F_CLONED)
 461                                 fprintf(fp, "%s    cache ", _SL_);
 462                         if (ci->rta_expires)
 463                                 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
 464                         if (ci->rta_error != 0)
 465                                 fprintf(fp, " error %d", ci->rta_error);
 466                         if (show_stats) {
 467                                 if (ci->rta_clntref)
 468                                         fprintf(fp, " users %d", ci->rta_clntref);
 469                                 if (ci->rta_used != 0)
 470                                         fprintf(fp, " used %d", ci->rta_used);
 471                                 if (ci->rta_lastuse != 0)
 472                                         fprintf(fp, " age %dsec", ci->rta_lastuse/hz);
 473                         }
 474                 } else if (ci) {
 475                         if (ci->rta_error != 0)
 476                                 fprintf(fp, " error %d", ci->rta_error);
 477                 }
 478         }
 479         if (tb[RTA_METRICS]) {
 480                 int i;
 481                 unsigned mxlock = 0;
 482                 struct rtattr *mxrta[RTAX_MAX+1];
 483
 484                 parse_rtattr(mxrta, RTAX_MAX, RTA_DATA(tb[RTA_METRICS]),
 485                             RTA_PAYLOAD(tb[RTA_METRICS]));
 486                 if (mxrta[RTAX_LOCK])
 487                         mxlock = *(unsigned*)RTA_DATA(mxrta[RTAX_LOCK]);
 488
 489                 for (i=2; i<=RTAX_MAX; i++) {
 490                         static char *mx_names[] =
 491                         {
 492                                 "mtu",
 493                                 "window",
 494                                 "rtt",
 495                                 "rttvar",
 496                                 "ssthresh",
 497                                 "cwnd",
 498                                 "advmss",
 499                                 "reordering",
 500                         };
 501                         static int hz;
 502                         if (mxrta[i] == NULL)
 503                                 continue;
 504                         if (!hz)
 505                                 hz = get_hz();
 506                         if (i-2 < sizeof(mx_names)/sizeof(char*))
 507                                 fprintf(fp, " %s", mx_names[i-2]);
 508                         else
 509                                 fprintf(fp, " metric %d", i);
 510                         if (mxlock & (1<<i))
 511                                 fprintf(fp, " lock");
 512
 513                         if (i != RTAX_RTT && i != RTAX_RTTVAR)
 514                                 fprintf(fp, " %u", *(unsigned*)RTA_DATA(mxrta[i]));
 515                         else {
 516                                 unsigned val = *(unsigned*)RTA_DATA(mxrta[i]);
 517
 518                                 val *= 1000;
 519                                 if (i == RTAX_RTT)
 520                                         val /= 8;
 521                                 else
 522                                         val /= 4;
 523                                 if (val >= hz)
 524                                         fprintf(fp, " %ums", val/hz);
 525                                 else
 526                                         fprintf(fp, " %.2fms", (float)val/hz);
 527                         }
 528                 }
 529         }
 530         if (tb[RTA_IIF] && filter.iifmask != -1) {
 531                 fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
 532         }
 533         if (tb[RTA_MULTIPATH]) {
 534                 struct rtnexthop *nh = RTA_DATA(tb[RTA_MULTIPATH]);
 535                 int first = 0;
 536
 537                 len = RTA_PAYLOAD(tb[RTA_MULTIPATH]);
 538
 539                 for (;;) {
 540                         if (len < sizeof(*nh))
 541                                 break;
 542                         if (nh->rtnh_len > len)
 543                                 break;
 544                         if (r->rtm_flags&RTM_F_CLONED && r->rtm_type == RTN_MULTICAST) {
 545                                 if (first)
 546                                         fprintf(fp, " Oifs:");
 547                                 else
 548                                         fprintf(fp, " ");
 549                         } else
 550                                 fprintf(fp, "%s\tnexthop", _SL_);
 551                         if (nh->rtnh_len > sizeof(*nh)) {
 552                                 parse_rtattr(tb, RTA_MAX, RTNH_DATA(nh), nh->rtnh_len - sizeof(*nh));
 553                                 if (tb[RTA_GATEWAY]) {
 554                                         fprintf(fp, " via %s ",
 555                                                 format_host(r->rtm_family,
 556                                                             RTA_PAYLOAD(tb[RTA_GATEWAY]),
 557                                                             RTA_DATA(tb[RTA_GATEWAY]),
 558                                                             abuf, sizeof(abuf)));
 559                                 }
 560                         }
 561                         if (r->rtm_flags&RTM_F_CLONED && r->rtm_type == RTN_MULTICAST) {
 562                                 fprintf(fp, " %s", ll_index_to_name(nh->rtnh_ifindex));
 563                                 if (nh->rtnh_hops != 1)
 564                                         fprintf(fp, "(ttl>%d)", nh->rtnh_hops);
 565                         } else {
 566                                 fprintf(fp, " dev %s", ll_index_to_name(nh->rtnh_ifindex));
 567                                 fprintf(fp, " weight %d", nh->rtnh_hops+1);
 568                         }
 569                         if (nh->rtnh_flags & RTNH_F_DEAD)
 570                                 fprintf(fp, " dead");
 571                         if (nh->rtnh_flags & RTNH_F_ONLINK)
 572                                 fprintf(fp, " onlink");
 573                         if (nh->rtnh_flags & RTNH_F_PERVASIVE)
 574                                 fprintf(fp, " pervasive");
 575                         len -= NLMSG_ALIGN(nh->rtnh_len);
 576                         nh = RTNH_NEXT(nh);
 577                 }
 578         }
 579         fprintf(fp, "\n");
 580         fflush(fp);
 581         return 0;
 582 }
 583
 584
 585 int parse_one_nh(struct rtattr *rta, struct rtnexthop *rtnh, int *argcp, char ***argvp)
 586 {
 587         int argc = *argcp;
 588         char **argv = *argvp;
 589
 590         while (++argv, --argc > 0) {
 591                 if (strcmp(*argv, "via") == 0) {
 592                         NEXT_ARG();
 593                         rta_addattr32(rta, 4096, RTA_GATEWAY, get_addr32(*argv));
 594                         rtnh->rtnh_len += sizeof(struct rtattr) + 4;
 595                 } else if (strcmp(*argv, "dev") == 0) {
 596                         NEXT_ARG();
 597                         if ((rtnh->rtnh_ifindex = ll_name_to_index(*argv)) == 0) {
 598                                 fprintf(stderr, "Cannot find device \"%s\"\n", *argv);
 599                                 exit(1);
 600                         }
 601                 } else if (strcmp(*argv, "weight") == 0) {
 602                         unsigned w;
 603                         NEXT_ARG();
 604                         if (get_unsigned(&w, *argv, 0) || w == 0 || w > 256)
 605                                 invarg("\"weight\" is invalid\n", *argv);
 606                         rtnh->rtnh_hops = w - 1;
 607                 } else if (strcmp(*argv, "onlink") == 0) {
 608                         rtnh->rtnh_flags |= RTNH_F_ONLINK;
 609                 } else
 610                         break;
 611         }
 612         *argcp = argc;
 613         *argvp = argv;
 614         return 0;
 615 }
 616
 617 int parse_nexthops(struct nlmsghdr *n, struct rtmsg *r, int argc, char **argv)
 618 {
 619         char buf[1024];
 620         struct rtattr *rta = (void*)buf;
 621         struct rtnexthop *rtnh;
 622
 623         rta->rta_type = RTA_MULTIPATH;
 624         rta->rta_len = RTA_LENGTH(0);
 625         rtnh = RTA_DATA(rta);
 626
 627         while (argc > 0) {
 628                 if (strcmp(*argv, "nexthop") != 0) {
 629                         fprintf(stderr, "Error: \"nexthop\" or end of line is expected instead of \"%s\"\n", *argv);
 630                         exit(-1);
 631                 }
 632                 if (argc <= 1) {
 633                         fprintf(stderr, "Error: unexpected end of line after \"nexthop\"\n");
 634                         exit(-1);
 635                 }
 636                 memset(rtnh, 0, sizeof(*rtnh));
 637                 rtnh->rtnh_len = sizeof(*rtnh);
 638                 rta->rta_len += rtnh->rtnh_len;
 639                 parse_one_nh(rta, rtnh, &argc, &argv);
 640                 rtnh = RTNH_NEXT(rtnh);
 641         }
 642
 643         if (rta->rta_len > RTA_LENGTH(0))
 644                 addattr_l(n, 1024, RTA_MULTIPATH, RTA_DATA(rta), RTA_PAYLOAD(rta));
 645         return 0;
 646 }
 647
 648
 649 int iproute_modify(int cmd, unsigned flags, int argc, char **argv)
 650 {
 651         struct {
 652                 struct nlmsghdr         n;
 653                 struct rtmsg            r;
 654                 char                    buf[1024];
 655         } req;
 656         char  mxbuf[256];
 657         struct rtattr * mxrta = (void*)mxbuf;
 658         unsigned mxlock = 0;
 659         char  *d = NULL;
 660         int gw_ok = 0;
 661         int dst_ok = 0;
 662         int nhs_ok = 0;
 663         int scope_ok = 0;
 664         int table_ok = 0;
 665         int proto_ok = 0;
 666         int type_ok = 0;
 667
 668         memset(&req, 0, sizeof(req));
 669
 670         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 671         req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 672         req.n.nlmsg_type = cmd;
 673         req.r.rtm_family = preferred_family;
 674         req.r.rtm_table = RT_TABLE_MAIN;
 675         req.r.rtm_scope = RT_SCOPE_NOWHERE;
 676
 677         if (cmd != RTM_DELROUTE) {
 678                 req.r.rtm_protocol = RTPROT_BOOT;
 679                 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 680                 req.r.rtm_type = RTN_UNICAST;
 681         }
 682
 683         mxrta->rta_type = RTA_METRICS;
 684         mxrta->rta_len = RTA_LENGTH(0);
 685
 686         while (argc > 0) {
 687                 if (strcmp(*argv, "src") == 0) {
 688                         inet_prefix addr;
 689                         NEXT_ARG();
 690                         get_addr(&addr, *argv, req.r.rtm_family);
 691                         if (req.r.rtm_family == AF_UNSPEC)
 692                                 req.r.rtm_family = addr.family;
 693                         addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
 694                 } else if (strcmp(*argv, "via") == 0) {
 695                         inet_prefix addr;
 696                         gw_ok = 1;
 697                         NEXT_ARG();
 698                         get_addr(&addr, *argv, req.r.rtm_family);
 699                         if (req.r.rtm_family == AF_UNSPEC)
 700                                 req.r.rtm_family = addr.family;
 701                         addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
 702                 } else if (strcmp(*argv, "from") == 0) {
 703                         inet_prefix addr;
 704                         NEXT_ARG();
 705                         get_prefix(&addr, *argv, req.r.rtm_family);
 706                         if (req.r.rtm_family == AF_UNSPEC)
 707                                 req.r.rtm_family = addr.family;
 708                         if (addr.bytelen)
 709                                 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
 710                         req.r.rtm_src_len = addr.bitlen;
 711                 } else if (strcmp(*argv, "tos") == 0 ||
 712                            matches(*argv, "dsfield") == 0) {
 713                         __u32 tos;
 714                         NEXT_ARG();
 715                         if (rtnl_dsfield_a2n(&tos, *argv))
 716                                 invarg("\"tos\" value is invalid\n", *argv);
 717                         req.r.rtm_tos = tos;
 718                 } else if (matches(*argv, "metric") == 0 ||
 719                            matches(*argv, "priority") == 0 ||
 720                            matches(*argv, "preference") == 0) {
 721                         __u32 metric;
 722                         NEXT_ARG();
 723                         if (get_u32(&metric, *argv, 0))
 724                                 invarg("\"metric\" value is invalid\n", *argv);
 725                         addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
 726                 } else if (strcmp(*argv, "scope") == 0) {
 727                         __u32 scope = 0;
 728                         NEXT_ARG();
 729                         if (rtnl_rtscope_a2n(&scope, *argv))
 730                                 invarg("invalid \"scope\" value\n", *argv);
 731                         req.r.rtm_scope = scope;
 732                         scope_ok = 1;
 733                 } else if (strcmp(*argv, "mtu") == 0) {
 734                         unsigned mtu;
 735                         NEXT_ARG();
 736                         if (strcmp(*argv, "lock") == 0) {
 737                                 mxlock |= (1<<RTAX_MTU);
 738                                 NEXT_ARG();
 739                         }
 740                         if (get_unsigned(&mtu, *argv, 0))
 741                                 invarg("\"mtu\" value is invalid\n", *argv);
 742                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
 743 #ifdef RTAX_ADVMSS
 744                 } else if (strcmp(*argv, "advmss") == 0) {
 745                         unsigned mss;
 746                         NEXT_ARG();
 747                         if (strcmp(*argv, "lock") == 0) {
 748                                 mxlock |= (1<<RTAX_ADVMSS);
 749                                 NEXT_ARG();
 750                         }
 751                         if (get_unsigned(&mss, *argv, 0))
 752                                 invarg("\"mss\" value is invalid\n", *argv);
 753                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_ADVMSS, mss);
 754 #endif
 755 #ifdef RTAX_REORDERING
 756                 } else if (matches(*argv, "reordering") == 0) {
 757                         unsigned reord;
 758                         NEXT_ARG();
 759                         if (strcmp(*argv, "lock") == 0) {
 760                                 mxlock |= (1<<RTAX_REORDERING);
 761                                 NEXT_ARG();
 762                         }
 763                         if (get_unsigned(&reord, *argv, 0))
 764                                 invarg("\"reordering\" value is invalid\n", *argv);
 765                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_REORDERING, reord);
 766 #endif
 767                 } else if (strcmp(*argv, "rtt") == 0) {
 768                         unsigned rtt;
 769                         NEXT_ARG();
 770                         if (strcmp(*argv, "lock") == 0) {
 771                                 mxlock |= (1<<RTAX_RTT);
 772                                 NEXT_ARG();
 773                         }
 774                         if (get_unsigned(&rtt, *argv, 0))
 775                                 invarg("\"rtt\" value is invalid\n", *argv);
 776                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTT, rtt);
 777                 } else if (matches(*argv, "window") == 0) {
 778                         unsigned win;
 779                         NEXT_ARG();
 780                         if (strcmp(*argv, "lock") == 0) {
 781                                 mxlock |= (1<<RTAX_WINDOW);
 782                                 NEXT_ARG();
 783                         }
 784                         if (get_unsigned(&win, *argv, 0))
 785                                 invarg("\"window\" value is invalid\n", *argv);
 786                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_WINDOW, win);
 787                 } else if (matches(*argv, "cwnd") == 0) {
 788                         unsigned win;
 789                         NEXT_ARG();
 790                         if (strcmp(*argv, "lock") == 0) {
 791                                 mxlock |= (1<<RTAX_CWND);
 792                                 NEXT_ARG();
 793                         }
 794                         if (get_unsigned(&win, *argv, 0))
 795                                 invarg("\"cwnd\" value is invalid\n", *argv);
 796                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_CWND, win);
 797                 } else if (matches(*argv, "rttvar") == 0) {
 798                         unsigned win;
 799                         NEXT_ARG();
 800                         if (strcmp(*argv, "lock") == 0) {
 801                                 mxlock |= (1<<RTAX_RTTVAR);
 802                                 NEXT_ARG();
 803                         }
 804                         if (get_unsigned(&win, *argv, 0))
 805                                 invarg("\"rttvar\" value is invalid\n", *argv);
 806                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTTVAR, win);
 807                 } else if (matches(*argv, "ssthresh") == 0) {
 808                         unsigned win;
 809                         NEXT_ARG();
 810                         if (strcmp(*argv, "lock") == 0) {
 811                                 mxlock |= (1<<RTAX_SSTHRESH);
 812                                 NEXT_ARG();
 813                         }
 814                         if (get_unsigned(&win, *argv, 0))
 815                                 invarg("\"ssthresh\" value is invalid\n", *argv);
 816                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_SSTHRESH, win);
 817                 } else if (matches(*argv, "realms") == 0) {
 818                         __u32 realm;
 819                         NEXT_ARG();
 820                         if (get_rt_realms(&realm, *argv))
 821                                 invarg("\"realm\" value is invalid\n", *argv);
 822                         addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
 823                 } else if (strcmp(*argv, "onlink") == 0) {
 824                         req.r.rtm_flags |= RTNH_F_ONLINK;
 825                 } else if (matches(*argv, "equalize") == 0 ||
 826                            strcmp(*argv, "eql") == 0) {
 827                         req.r.rtm_flags |= RTM_F_EQUALIZE;
 828                 } else if (strcmp(*argv, "nexthop") == 0) {
 829                         nhs_ok = 1;
 830                         break;
 831                 } else if (matches(*argv, "protocol") == 0) {
 832                         __u32 prot;
 833                         NEXT_ARG();
 834                         if (rtnl_rtprot_a2n(&prot, *argv))
 835                                 invarg("\"protocol\" value is invalid\n", *argv);
 836                         req.r.rtm_protocol = prot;
 837                         proto_ok =1;
 838                 } else if (matches(*argv, "table") == 0) {
 839                         __u32 tid;
 840                         NEXT_ARG();
 841                         if (rtnl_rttable_a2n(&tid, *argv))
 842                                 invarg("\"table\" value is invalid\n", *argv);
 843                         req.r.rtm_table = tid;
 844                         table_ok = 1;
 845                 } else if (strcmp(*argv, "dev") == 0 ||
 846                            strcmp(*argv, "oif") == 0) {
 847                         NEXT_ARG();
 848                         d = *argv;
 849                 } else if (strcmp(*argv, "mpath") == 0 ||
 850                            strcmp(*argv, "mp") == 0) {
 851                         int i;
 852                         __u32 mp_alg = IP_MP_ALG_NONE;
 853
 854                         NEXT_ARG();
 855                         for (i = 1; i < ARRAY_SIZE(mp_alg_names); i++)
 856                                 if (strcmp(*argv, mp_alg_names[i]) == 0)
 857                                         mp_alg = i;
 858                         if (mp_alg == IP_MP_ALG_NONE)
 859                                 invarg("\"mpath\" value is invalid\n", *argv);
 860                         addattr_l(&req.n, sizeof(req), RTA_MP_ALGO, &mp_alg, sizeof(mp_alg));
 861                 } else {
 862                         int type;
 863                         inet_prefix dst;
 864
 865                         if (strcmp(*argv, "to") == 0) {
 866                                 NEXT_ARG();
 867                         }
 868                         if ((**argv < '0' || **argv > '9') &&
 869                             rtnl_rtntype_a2n(&type, *argv) == 0) {
 870                                 NEXT_ARG();
 871                                 req.r.rtm_type = type;
 872                                 type_ok = 1;
 873                         }
 874
 875                         if (matches(*argv, "help") == 0)
 876                                 usage();
 877                         if (dst_ok)
 878                                 duparg2("to", *argv);
 879                         get_prefix(&dst, *argv, req.r.rtm_family);
 880                         if (req.r.rtm_family == AF_UNSPEC)
 881                                 req.r.rtm_family = dst.family;
 882                         req.r.rtm_dst_len = dst.bitlen;
 883                         dst_ok = 1;
 884                         if (dst.bytelen)
 885                                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 886                 }
 887                 argc--; argv++;
 888         }
 889
 890         if (d || nhs_ok)  {
 891                 int idx;
 892
 893                 ll_init_map(&rth);
 894
 895                 if (d) {
 896                         if ((idx = ll_name_to_index(d)) == 0) {
 897                                 fprintf(stderr, "Cannot find device \"%s\"\n", d);
 898                                 return -1;
 899                         }
 900                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 901                 }
 902         }
 903
 904         if (mxrta->rta_len > RTA_LENGTH(0)) {
 905                 if (mxlock)
 906                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
 907                 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
 908         }
 909
 910         if (nhs_ok)
 911                 parse_nexthops(&req.n, &req.r, argc, argv);
 912
 913         if (!table_ok) {
 914                 if (req.r.rtm_type == RTN_LOCAL ||
 915                     req.r.rtm_type == RTN_BROADCAST ||
 916                     req.r.rtm_type == RTN_NAT ||
 917                     req.r.rtm_type == RTN_ANYCAST)
 918                         req.r.rtm_table = RT_TABLE_LOCAL;
 919         }
 920         if (!scope_ok) {
 921                 if (req.r.rtm_type == RTN_LOCAL ||
 922                     req.r.rtm_type == RTN_NAT)
 923                         req.r.rtm_scope = RT_SCOPE_HOST;
 924                 else if (req.r.rtm_type == RTN_BROADCAST ||
 925                          req.r.rtm_type == RTN_MULTICAST ||
 926                          req.r.rtm_type == RTN_ANYCAST)
 927                         req.r.rtm_scope = RT_SCOPE_LINK;
 928                 else if (req.r.rtm_type == RTN_UNICAST ||
 929                          req.r.rtm_type == RTN_UNSPEC) {
 930                         if (cmd == RTM_DELROUTE)
 931                                 req.r.rtm_scope = RT_SCOPE_NOWHERE;
 932                         else if (!gw_ok && !nhs_ok)
 933                                 req.r.rtm_scope = RT_SCOPE_LINK;
 934                 }
 935         }
 936
 937         if (req.r.rtm_family == AF_UNSPEC)
 938                 req.r.rtm_family = AF_INET;
 939
 940         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
 941                 exit(2);
 942
 943         return 0;
 944 }
 945
 946 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
 947 {
 948         struct {
 949                 struct nlmsghdr nlh;
 950                 struct rtmsg rtm;
 951         } req;
 952         struct sockaddr_nl nladdr;
 953
 954         memset(&nladdr, 0, sizeof(nladdr));
 955         memset(&req, 0, sizeof(req));
 956         nladdr.nl_family = AF_NETLINK;
 957
 958         req.nlh.nlmsg_len = sizeof(req);
 959         req.nlh.nlmsg_type = RTM_GETROUTE;
 960         req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
 961         req.nlh.nlmsg_pid = 0;
 962         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
 963         req.rtm.rtm_family = family;
 964         req.rtm.rtm_flags |= RTM_F_CLONED;
 965
 966         return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
 967 }
 968
 969 static int iproute_flush_cache(void)
 970 {
 971 #define ROUTE_FLUSH_PATH "/proc/sys/net/ipv4/route/flush"
 972
 973         int len;
 974         int flush_fd = open (ROUTE_FLUSH_PATH, O_WRONLY);
 975         char *buffer = "-1";
 976
 977         if (flush_fd < 0) {
 978                 fprintf (stderr, "Cannot open \"%s\"\n", ROUTE_FLUSH_PATH);
 979                 return -1;
 980         }
 981
 982         len = strlen (buffer);
 983
 984         if ((write (flush_fd, (void *)buffer, len)) < len) {
 985                 fprintf (stderr, "Cannot flush routing cache\n");
 986                 return -1;
 987         }
 988         close(flush_fd);
 989         return 0;
 990 }
 991
 992
 993 static int iproute_list_or_flush(int argc, char **argv, int flush)
 994 {
 995         int do_ipv6 = preferred_family;
 996         char *id = NULL;
 997         char *od = NULL;
 998
 999         iproute_reset_filter();
1000         filter.tb = RT_TABLE_MAIN;
1001
1002         if (flush && argc <= 0) {
1003                 fprintf(stderr, "\"ip route flush\" requires arguments.\n");
1004                 return -1;
1005         }
1006
1007         while (argc > 0) {
1008                 if (matches(*argv, "table") == 0) {
1009                         __u32 tid;
1010                         NEXT_ARG();
1011                         if (rtnl_rttable_a2n(&tid, *argv)) {
1012                                 if (strcmp(*argv, "all") == 0) {
1013                                         tid = 0;
1014                                 } else if (strcmp(*argv, "cache") == 0) {
1015                                         tid = -1;
1016                                 } else if (strcmp(*argv, "help") == 0) {
1017                                         usage();
1018                                 } else {
1019                                         invarg("table id value is invalid\n", *argv);
1020                                 }
1021                         }
1022                         filter.tb = tid;
1023                 } else if (matches(*argv, "cached") == 0 ||
1024                            matches(*argv, "cloned") == 0) {
1025                         filter.tb = -1;
1026                 } else if (strcmp(*argv, "tos") == 0 ||
1027                            matches(*argv, "dsfield") == 0) {
1028                         __u32 tos;
1029                         NEXT_ARG();
1030                         if (rtnl_dsfield_a2n(&tos, *argv))
1031                                 invarg("TOS value is invalid\n", *argv);
1032                         filter.tos = tos;
1033                         filter.tosmask = -1;
1034                 } else if (matches(*argv, "protocol") == 0) {
1035                         __u32 prot = 0;
1036                         NEXT_ARG();
1037                         filter.protocolmask = -1;
1038                         if (rtnl_rtprot_a2n(&prot, *argv)) {
1039                                 if (strcmp(*argv, "all") != 0)
1040                                         invarg("invalid \"protocol\"\n", *argv);
1041                                 prot = 0;
1042                                 filter.protocolmask = 0;
1043                         }
1044                         filter.protocol = prot;
1045                 } else if (matches(*argv, "scope") == 0) {
1046                         __u32 scope = 0;
1047                         NEXT_ARG();
1048                         filter.scopemask = -1;
1049                         if (rtnl_rtscope_a2n(&scope, *argv)) {
1050                                 if (strcmp(*argv, "all") != 0)
1051                                         invarg("invalid \"scope\"\n", *argv);
1052                                 scope = RT_SCOPE_NOWHERE;
1053                                 filter.scopemask = 0;
1054                         }
1055                         filter.scope = scope;
1056                 } else if (matches(*argv, "type") == 0) {
1057                         int type;
1058                         NEXT_ARG();
1059                         filter.typemask = -1;
1060                         if (rtnl_rtntype_a2n(&type, *argv))
1061                                 invarg("node type value is invalid\n", *argv);
1062                         filter.type = type;
1063                 } else if (strcmp(*argv, "dev") == 0 ||
1064                            strcmp(*argv, "oif") == 0) {
1065                         NEXT_ARG();
1066                         od = *argv;
1067                 } else if (strcmp(*argv, "iif") == 0) {
1068                         NEXT_ARG();
1069                         id = *argv;
1070                 } else if (strcmp(*argv, "via") == 0) {
1071                         NEXT_ARG();
1072                         get_prefix(&filter.rvia, *argv, do_ipv6);
1073                 } else if (strcmp(*argv, "src") == 0) {
1074                         NEXT_ARG();
1075                         get_prefix(&filter.rprefsrc, *argv, do_ipv6);
1076                 } else if (matches(*argv, "realms") == 0) {
1077                         __u32 realm;
1078                         NEXT_ARG();
1079                         if (get_rt_realms(&realm, *argv))
1080                                 invarg("invalid realms\n", *argv);
1081                         filter.realm = realm;
1082                         filter.realmmask = ~0U;
1083                         if ((filter.realm&0xFFFF) == 0 &&
1084                             (*argv)[strlen(*argv) - 1] == '/')
1085                                 filter.realmmask &= ~0xFFFF;
1086                         if ((filter.realm&0xFFFF0000U) == 0 &&
1087                             (strchr(*argv, '/') == NULL ||
1088                              (*argv)[0] == '/'))
1089                                 filter.realmmask &= ~0xFFFF0000U;
1090                 } else if (matches(*argv, "from") == 0) {
1091                         NEXT_ARG();
1092                         if (matches(*argv, "root") == 0) {
1093                                 NEXT_ARG();
1094                                 get_prefix(&filter.rsrc, *argv, do_ipv6);
1095                         } else if (matches(*argv, "match") == 0) {
1096                                 NEXT_ARG();
1097                                 get_prefix(&filter.msrc, *argv, do_ipv6);
1098                         } else {
1099                                 if (matches(*argv, "exact") == 0) {
1100                                         NEXT_ARG();
1101                                 }
1102                                 get_prefix(&filter.msrc, *argv, do_ipv6);
1103                                 filter.rsrc = filter.msrc;
1104                         }
1105                 } else {
1106                         if (matches(*argv, "to") == 0) {
1107                                 NEXT_ARG();
1108                         }
1109                         if (matches(*argv, "root") == 0) {
1110                                 NEXT_ARG();
1111                                 get_prefix(&filter.rdst, *argv, do_ipv6);
1112                         } else if (matches(*argv, "match") == 0) {
1113                                 NEXT_ARG();
1114                                 get_prefix(&filter.mdst, *argv, do_ipv6);
1115                         } else {
1116                                 if (matches(*argv, "exact") == 0) {
1117                                         NEXT_ARG();
1118                                 }
1119                                 get_prefix(&filter.mdst, *argv, do_ipv6);
1120                                 filter.rdst = filter.mdst;
1121                         }
1122                 }
1123                 argc--; argv++;
1124         }
1125
1126         if (do_ipv6 == AF_UNSPEC && filter.tb)
1127                 do_ipv6 = AF_INET;
1128
1129         ll_init_map(&rth);
1130
1131         if (id || od)  {
1132                 int idx;
1133
1134                 if (id) {
1135                         if ((idx = ll_name_to_index(id)) == 0) {
1136                                 fprintf(stderr, "Cannot find device \"%s\"\n", id);
1137                                 return -1;
1138                         }
1139                         filter.iif = idx;
1140                         filter.iifmask = -1;
1141                 }
1142                 if (od) {
1143                         if ((idx = ll_name_to_index(od)) == 0) {
1144                                 fprintf(stderr, "Cannot find device \"%s\"\n", od);
1145                                 return -1;
1146                         }
1147                         filter.oif = idx;
1148                         filter.oifmask = -1;
1149                 }
1150         }
1151
1152         if (flush) {
1153                 int round = 0;
1154                 char flushb[4096-512];
1155                 time_t start = time(0);
1156
1157                 if (filter.tb == -1) {
1158                         if (do_ipv6 != AF_INET6) {
1159                                 iproute_flush_cache();
1160                                 if (show_stats)
1161                                         printf("*** IPv4 routing cache is flushed.\n");
1162                         }
1163                         if (do_ipv6 == AF_INET)
1164                                 return 0;
1165                 }
1166
1167                 filter.flushb = flushb;
1168                 filter.flushp = 0;
1169                 filter.flushe = sizeof(flushb);
1170
1171                 for (;;) {
1172                         if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
1173                                 perror("Cannot send dump request");
1174                                 exit(1);
1175                         }
1176                         filter.flushed = 0;
1177                         if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
1178                                 fprintf(stderr, "Flush terminated\n");
1179                                 exit(1);
1180                         }
1181                         if (filter.flushed == 0) {
1182                                 if (round == 0) {
1183                                         if (filter.tb != -1 || do_ipv6 == AF_INET6)
1184                                                 fprintf(stderr, "Nothing to flush.\n");
1185                                 } else if (show_stats)
1186                                         printf("*** Flush is complete after %d round%s ***\n", round, round>1?"s":"");
1187                                 fflush(stdout);
1188                                 return 0;
1189                         }
1190                         round++;
1191                         if (flush_update() < 0)
1192                                 exit(1);
1193
1194                         if (time(0) - start > 30) {
1195                                 printf("\n*** Flush not completed after %ld seconds, %d entries remain ***\n",
1196                                        time(0) - start, filter.flushed);
1197                                 exit(1);
1198                         }
1199
1200                         if (show_stats) {
1201                                 printf("\n*** Round %d, deleting %d entries ***\n", round, filter.flushed);
1202                                 fflush(stdout);
1203                         }
1204                 }
1205         }
1206
1207         if (filter.tb != -1) {
1208                 if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
1209                         perror("Cannot send dump request");
1210                         exit(1);
1211                 }
1212         } else {
1213                 if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
1214                         perror("Cannot send dump request");
1215                         exit(1);
1216                 }
1217         }
1218
1219         if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
1220                 fprintf(stderr, "Dump terminated\n");
1221                 exit(1);
1222         }
1223
1224         exit(0);
1225 }
1226
1227
1228 int iproute_get(int argc, char **argv)
1229 {
1230         struct {
1231                 struct nlmsghdr         n;
1232                 struct rtmsg            r;
1233                 char                    buf[1024];
1234         } req;
1235         char  *idev = NULL;
1236         char  *odev = NULL;
1237         int connected = 0;
1238         int from_ok = 0;
1239
1240         memset(&req, 0, sizeof(req));
1241
1242         iproute_reset_filter();
1243
1244         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
1245         req.n.nlmsg_flags = NLM_F_REQUEST;
1246         req.n.nlmsg_type = RTM_GETROUTE;
1247         req.r.rtm_family = preferred_family;
1248         req.r.rtm_table = 0;
1249         req.r.rtm_protocol = 0;
1250         req.r.rtm_scope = 0;
1251         req.r.rtm_type = 0;
1252         req.r.rtm_src_len = 0;
1253         req.r.rtm_dst_len = 0;
1254         req.r.rtm_tos = 0;
1255
1256         while (argc > 0) {
1257                 if (strcmp(*argv, "tos") == 0 ||
1258                     matches(*argv, "dsfield") == 0) {
1259                         __u32 tos;
1260                         NEXT_ARG();
1261                         if (rtnl_dsfield_a2n(&tos, *argv))
1262                                 invarg("TOS value is invalid\n", *argv);
1263                         req.r.rtm_tos = tos;
1264                 } else if (matches(*argv, "from") == 0) {
1265                         inet_prefix addr;
1266                         NEXT_ARG();
1267                         if (matches(*argv, "help") == 0)
1268                                 usage();
1269                         from_ok = 1;
1270                         get_prefix(&addr, *argv, req.r.rtm_family);
1271                         if (req.r.rtm_family == AF_UNSPEC)
1272                                 req.r.rtm_family = addr.family;
1273                         if (addr.bytelen)
1274                                 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
1275                         req.r.rtm_src_len = addr.bitlen;
1276                 } else if (matches(*argv, "iif") == 0) {
1277                         NEXT_ARG();
1278                         idev = *argv;
1279                 } else if (matches(*argv, "oif") == 0 ||
1280                            strcmp(*argv, "dev") == 0) {
1281                         NEXT_ARG();
1282                         odev = *argv;
1283                 } else if (matches(*argv, "notify") == 0) {
1284                         req.r.rtm_flags |= RTM_F_NOTIFY;
1285                 } else if (matches(*argv, "connected") == 0) {
1286                         connected = 1;
1287                 } else {
1288                         inet_prefix addr;
1289                         if (strcmp(*argv, "to") == 0) {
1290                                 NEXT_ARG();
1291                         }
1292                         if (matches(*argv, "help") == 0)
1293                                 usage();
1294                         get_prefix(&addr, *argv, req.r.rtm_family);
1295                         if (req.r.rtm_family == AF_UNSPEC)
1296                                 req.r.rtm_family = addr.family;
1297                         if (addr.bytelen)
1298                                 addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
1299                         req.r.rtm_dst_len = addr.bitlen;
1300                 }
1301                 argc--; argv++;
1302         }
1303
1304         if (req.r.rtm_dst_len == 0) {
1305                 fprintf(stderr, "need at least destination address\n");
1306                 exit(1);
1307         }
1308
1309         ll_init_map(&rth);
1310
1311         if (idev || odev)  {
1312                 int idx;
1313
1314                 if (idev) {
1315                         if ((idx = ll_name_to_index(idev)) == 0) {
1316                                 fprintf(stderr, "Cannot find device \"%s\"\n", idev);
1317                                 return -1;
1318                         }
1319                         addattr32(&req.n, sizeof(req), RTA_IIF, idx);
1320                 }
1321                 if (odev) {
1322                         if ((idx = ll_name_to_index(odev)) == 0) {
1323                                 fprintf(stderr, "Cannot find device \"%s\"\n", odev);
1324                                 return -1;
1325                         }
1326                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
1327                 }
1328         }
1329
1330         if (req.r.rtm_family == AF_UNSPEC)
1331                 req.r.rtm_family = AF_INET;
1332
1333         if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
1334                 exit(2);
1335
1336         if (connected && !from_ok) {
1337                 struct rtmsg *r = NLMSG_DATA(&req.n);
1338                 int len = req.n.nlmsg_len;
1339                 struct rtattr * tb[RTA_MAX+1];
1340
1341                 if (print_route(NULL, &req.n, (void*)stdout) < 0) {
1342                         fprintf(stderr, "An error :-)\n");
1343                         exit(1);
1344                 }
1345
1346                 if (req.n.nlmsg_type != RTM_NEWROUTE) {
1347                         fprintf(stderr, "Not a route?\n");
1348                         return -1;
1349                 }
1350                 len -= NLMSG_LENGTH(sizeof(*r));
1351                 if (len < 0) {
1352                         fprintf(stderr, "Wrong len %d\n", len);
1353                         return -1;
1354                 }
1355
1356                 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
1357
1358                 if (tb[RTA_PREFSRC]) {
1359                         tb[RTA_PREFSRC]->rta_type = RTA_SRC;
1360                         r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
1361                 } else if (!tb[RTA_SRC]) {
1362                         fprintf(stderr, "Failed to connect the route\n");
1363                         return -1;
1364                 }
1365                 if (!odev && tb[RTA_OIF])
1366                         tb[RTA_OIF]->rta_type = 0;
1367                 if (tb[RTA_GATEWAY])
1368                         tb[RTA_GATEWAY]->rta_type = 0;
1369                 if (!idev && tb[RTA_IIF])
1370                         tb[RTA_IIF]->rta_type = 0;
1371                 req.n.nlmsg_flags = NLM_F_REQUEST;
1372                 req.n.nlmsg_type = RTM_GETROUTE;
1373
1374                 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
1375                         exit(2);
1376         }
1377
1378         if (print_route(NULL, &req.n, (void*)stdout) < 0) {
1379                 fprintf(stderr, "An error :-)\n");
1380                 exit(1);
1381         }
1382
1383         exit(0);
1384 }
1385
1386 void iproute_reset_filter()
1387 {
1388         memset(&filter, 0, sizeof(filter));
1389         filter.mdst.bitlen = -1;
1390         filter.msrc.bitlen = -1;
1391 }
1392
1393 int do_iproute(int argc, char **argv)
1394 {
1395         if (argc < 1)
1396                 return iproute_list_or_flush(0, NULL, 0);
1397
1398         if (matches(*argv, "add") == 0)
1399                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_EXCL,
1400                                       argc-1, argv+1);
1401         if (matches(*argv, "change") == 0 || strcmp(*argv, "chg") == 0)
1402                 return iproute_modify(RTM_NEWROUTE, NLM_F_REPLACE,
1403                                       argc-1, argv+1);
1404         if (matches(*argv, "replace") == 0)
1405                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_REPLACE,
1406                                       argc-1, argv+1);
1407         if (matches(*argv, "prepend") == 0)
1408                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE,
1409                                       argc-1, argv+1);
1410         if (matches(*argv, "append") == 0)
1411                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_APPEND,
1412                                       argc-1, argv+1);
1413         if (matches(*argv, "test") == 0)
1414                 return iproute_modify(RTM_NEWROUTE, NLM_F_EXCL,
1415                                       argc-1, argv+1);
1416         if (matches(*argv, "delete") == 0)
1417                 return iproute_modify(RTM_DELROUTE, 0,
1418                                       argc-1, argv+1);
1419         if (matches(*argv, "list") == 0 || matches(*argv, "show") == 0
1420             || matches(*argv, "lst") == 0)
1421                 return iproute_list_or_flush(argc-1, argv+1, 0);
1422         if (matches(*argv, "get") == 0)
1423                 return iproute_get(argc-1, argv+1);
1424         if (matches(*argv, "flush") == 0)
1425                 return iproute_list_or_flush(argc-1, argv+1, 1);
1426         if (matches(*argv, "help") == 0)
1427                 usage();
1428         fprintf(stderr, "Command \"%s\" is unknown, try \"ip route help\".\n", *argv);
1429         exit(-1);
1430 }
1431