networking/libiproute/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 <sys/time.h>
  25 #include <sys/socket.h>
  26 #include <netinet/in.h>
  27 #include <netinet/ip.h>
  28 #include <arpa/inet.h>
  29 #include <linux/in_route.h>
  30
  31 #include "rt_names.h"
  32 #include "utils.h"
  33 #include "ip_common.h"
  34
  35 #include "busybox.h"
  36
  37 #ifndef RTAX_RTTVAR
  38 #define RTAX_RTTVAR RTAX_HOPS
  39 #endif
  40
  41
  42 static struct
  43 {
  44         int tb;
  45         int flushp;
  46         int flushe;
  47         struct rtnl_handle *rth;
  48         int protocol, protocolmask;
  49         int scope, scopemask;
  50         int type, typemask;
  51         int tos, tosmask;
  52         int iif, iifmask;
  53         int oif, oifmask;
  54         int realm, realmmask;
  55         inet_prefix rprefsrc;
  56         inet_prefix rvia;
  57         inet_prefix rdst;
  58         inet_prefix mdst;
  59         inet_prefix rsrc;
  60         inet_prefix msrc;
  61 } filter;
  62
  63 int print_route(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
  64 {
  65         FILE *fp = (FILE*)arg;
  66         struct rtmsg *r = NLMSG_DATA(n);
  67         int len = n->nlmsg_len;
  68         struct rtattr * tb[RTA_MAX+1];
  69         char abuf[256];
  70         int host_len = -1;
  71         SPRINT_BUF(b1);
  72
  73
  74         if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
  75                 fprintf(stderr, "Not a route: %08x %08x %08x\n",
  76                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
  77                 return 0;
  78         }
  79         len -= NLMSG_LENGTH(sizeof(*r));
  80         if (len < 0) {
  81                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
  82                 return -1;
  83         }
  84
  85         if (r->rtm_family == AF_INET6)
  86                 host_len = 128;
  87         else if (r->rtm_family == AF_INET)
  88                 host_len = 32;
  89
  90         if (r->rtm_family == AF_INET6) {
  91                 if (filter.tb) {
  92                         if (filter.tb < 0) {
  93                                 if (!(r->rtm_flags&RTM_F_CLONED))
  94                                         return 0;
  95                         } else {
  96                                 if (r->rtm_flags&RTM_F_CLONED)
  97                                         return 0;
  98                                 if (filter.tb == RT_TABLE_LOCAL) {
  99                                         if (r->rtm_type != RTN_LOCAL)
 100                                                 return 0;
 101                                 } else if (filter.tb == RT_TABLE_MAIN) {
 102                                         if (r->rtm_type == RTN_LOCAL)
 103                                                 return 0;
 104                                 } else {
 105                                         return 0;
 106                                 }
 107                         }
 108                 }
 109         } else {
 110                 if (filter.tb > 0 && filter.tb != r->rtm_table)
 111                         return 0;
 112         }
 113         if (filter.rdst.family &&
 114             (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len))
 115                 return 0;
 116         if (filter.mdst.family &&
 117             (r->rtm_family != filter.mdst.family ||
 118              (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len)))
 119                 return 0;
 120         if (filter.rsrc.family &&
 121             (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len))
 122                 return 0;
 123         if (filter.msrc.family &&
 124             (r->rtm_family != filter.msrc.family ||
 125              (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len)))
 126                 return 0;
 127
 128         memset(tb, 0, sizeof(tb));
 129         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 130
 131         if (n->nlmsg_type == RTM_DELROUTE)
 132                 fprintf(fp, "Deleted ");
 133         if (r->rtm_type != RTN_UNICAST && !filter.type)
 134                 fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
 135
 136         if (tb[RTA_DST]) {
 137                 if (r->rtm_dst_len != host_len) {
 138                         fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family,
 139                                                          RTA_PAYLOAD(tb[RTA_DST]),
 140                                                          RTA_DATA(tb[RTA_DST]),
 141                                                          abuf, sizeof(abuf)),
 142                                 r->rtm_dst_len
 143                                 );
 144                 } else {
 145                         fprintf(fp, "%s ", format_host(r->rtm_family,
 146                                                        RTA_PAYLOAD(tb[RTA_DST]),
 147                                                        RTA_DATA(tb[RTA_DST]),
 148                                                        abuf, sizeof(abuf))
 149                                 );
 150                 }
 151         } else if (r->rtm_dst_len) {
 152                 fprintf(fp, "0/%d ", r->rtm_dst_len);
 153         } else {
 154                 fprintf(fp, "default ");
 155         }
 156         if (tb[RTA_SRC]) {
 157                 if (r->rtm_src_len != host_len) {
 158                         fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family,
 159                                                          RTA_PAYLOAD(tb[RTA_SRC]),
 160                                                          RTA_DATA(tb[RTA_SRC]),
 161                                                          abuf, sizeof(abuf)),
 162                                 r->rtm_src_len
 163                                 );
 164                 } else {
 165                         fprintf(fp, "from %s ", format_host(r->rtm_family,
 166                                                        RTA_PAYLOAD(tb[RTA_SRC]),
 167                                                        RTA_DATA(tb[RTA_SRC]),
 168                                                        abuf, sizeof(abuf))
 169                                 );
 170                 }
 171         } else if (r->rtm_src_len) {
 172                 fprintf(fp, "from 0/%u ", r->rtm_src_len);
 173         }
 174         if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
 175                 fprintf(fp, "via %s ",
 176                         format_host(r->rtm_family,
 177                                     RTA_PAYLOAD(tb[RTA_GATEWAY]),
 178                                     RTA_DATA(tb[RTA_GATEWAY]),
 179                                     abuf, sizeof(abuf)));
 180         }
 181         if (tb[RTA_OIF] && filter.oifmask != -1)
 182                 fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
 183
 184         if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
 185                 /* Do not use format_host(). It is our local addr
 186                    and symbolic name will not be useful.
 187                  */
 188                 fprintf(fp, " src %s ",
 189                         rt_addr_n2a(r->rtm_family,
 190                                     RTA_PAYLOAD(tb[RTA_PREFSRC]),
 191                                     RTA_DATA(tb[RTA_PREFSRC]),
 192                                     abuf, sizeof(abuf)));
 193         }
 194         if (tb[RTA_PRIORITY])
 195                 fprintf(fp, " metric %d ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY]));
 196         if (r->rtm_family == AF_INET6) {
 197                 struct rta_cacheinfo *ci = NULL;
 198                 if (tb[RTA_CACHEINFO])
 199                         ci = RTA_DATA(tb[RTA_CACHEINFO]);
 200                 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
 201                         static int hz;
 202                         if (!hz)
 203                                 hz = get_hz();
 204                         if (r->rtm_flags & RTM_F_CLONED)
 205                                 fprintf(fp, "%s    cache ", _SL_);
 206                         if (ci->rta_expires)
 207                                 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
 208                         if (ci->rta_error != 0)
 209                                 fprintf(fp, " error %d", ci->rta_error);
 210                 } else if (ci) {
 211                         if (ci->rta_error != 0)
 212                                 fprintf(fp, " error %d", ci->rta_error);
 213                 }
 214         }
 215         if (tb[RTA_IIF] && filter.iifmask != -1) {
 216                 fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
 217         }
 218         fprintf(fp, "\n");
 219         fflush(fp);
 220         return 0;
 221 }
 222
 223 int iproute_modify(int cmd, unsigned flags, int argc, char **argv)
 224 {
 225         struct rtnl_handle rth;
 226         struct {
 227                 struct nlmsghdr         n;
 228                 struct rtmsg            r;
 229                 char                    buf[1024];
 230         } req;
 231         char  mxbuf[256];
 232         struct rtattr * mxrta = (void*)mxbuf;
 233         unsigned mxlock = 0;
 234         char  *d = NULL;
 235         int gw_ok = 0;
 236         int dst_ok = 0;
 237         int proto_ok = 0;
 238         int type_ok = 0;
 239
 240         memset(&req, 0, sizeof(req));
 241
 242         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 243         req.n.nlmsg_flags = NLM_F_REQUEST|flags;
 244         req.n.nlmsg_type = cmd;
 245         req.r.rtm_family = preferred_family;
 246         req.r.rtm_table = RT_TABLE_MAIN;
 247         req.r.rtm_scope = RT_SCOPE_NOWHERE;
 248
 249         if (cmd != RTM_DELROUTE) {
 250                 req.r.rtm_protocol = RTPROT_BOOT;
 251                 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 252                 req.r.rtm_type = RTN_UNICAST;
 253         }
 254
 255         mxrta->rta_type = RTA_METRICS;
 256         mxrta->rta_len = RTA_LENGTH(0);
 257
 258         while (argc > 0) {
 259                 if (strcmp(*argv, "src") == 0) {
 260                         inet_prefix addr;
 261                         NEXT_ARG();
 262                         get_addr(&addr, *argv, req.r.rtm_family);
 263                         if (req.r.rtm_family == AF_UNSPEC)
 264                                 req.r.rtm_family = addr.family;
 265                         addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
 266                 } else if (strcmp(*argv, "via") == 0) {
 267                         inet_prefix addr;
 268                         gw_ok = 1;
 269                         NEXT_ARG();
 270                         get_addr(&addr, *argv, req.r.rtm_family);
 271                         if (req.r.rtm_family == AF_UNSPEC)
 272                                 req.r.rtm_family = addr.family;
 273                         addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
 274                 } else if (strcmp(*argv, "mtu") == 0) {
 275                         unsigned mtu;
 276                         NEXT_ARG();
 277                         if (strcmp(*argv, "lock") == 0) {
 278                                 mxlock |= (1<<RTAX_MTU);
 279                                 NEXT_ARG();
 280                         }
 281                         if (get_unsigned(&mtu, *argv, 0))
 282                                 invarg("\"mtu\" value is invalid\n", *argv);
 283                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
 284                 } else if (matches(*argv, "protocol") == 0) {
 285                         int prot;
 286                         NEXT_ARG();
 287                         if (rtnl_rtprot_a2n(&prot, *argv))
 288                                 invarg("\"protocol\" value is invalid\n", *argv);
 289                         req.r.rtm_protocol = prot;
 290                         proto_ok =1;
 291                 } else if (strcmp(*argv, "dev") == 0 ||
 292                            strcmp(*argv, "oif") == 0) {
 293                         NEXT_ARG();
 294                         d = *argv;
 295                 } else {
 296                         int type;
 297                         inet_prefix dst;
 298
 299                         if (strcmp(*argv, "to") == 0) {
 300                                 NEXT_ARG();
 301                         }
 302                         if ((**argv < '0' || **argv > '9') &&
 303                             rtnl_rtntype_a2n(&type, *argv) == 0) {
 304                                 NEXT_ARG();
 305                                 req.r.rtm_type = type;
 306                                 type_ok = 1;
 307                         }
 308
 309                         if (dst_ok)
 310                                 duparg2("to", *argv);
 311                         get_prefix(&dst, *argv, req.r.rtm_family);
 312                         if (req.r.rtm_family == AF_UNSPEC)
 313                                 req.r.rtm_family = dst.family;
 314                         req.r.rtm_dst_len = dst.bitlen;
 315                         dst_ok = 1;
 316                         if (dst.bytelen)
 317                                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 318                 }
 319                 argc--; argv++;
 320         }
 321
 322         if (rtnl_open(&rth, 0) < 0)
 323                 exit(1);
 324
 325         if (d)  {
 326                 int idx;
 327
 328                 ll_init_map(&rth);
 329
 330                 if (d) {
 331                         if ((idx = ll_name_to_index(d)) == 0) {
 332                                 fprintf(stderr, "Cannot find device \"%s\"\n", d);
 333                                 return -1;
 334                         }
 335                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 336                 }
 337         }
 338
 339         if (mxrta->rta_len > RTA_LENGTH(0)) {
 340                 if (mxlock)
 341                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
 342                 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
 343         }
 344
 345         if (req.r.rtm_family == AF_UNSPEC)
 346                 req.r.rtm_family = AF_INET;
 347
 348         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
 349                 exit(2);
 350
 351         return 0;
 352 }
 353
 354 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
 355 {
 356         struct {
 357                 struct nlmsghdr nlh;
 358                 struct rtmsg rtm;
 359         } req;
 360         struct sockaddr_nl nladdr;
 361
 362         memset(&nladdr, 0, sizeof(nladdr));
 363         memset(&req, 0, sizeof(req));
 364         nladdr.nl_family = AF_NETLINK;
 365
 366         req.nlh.nlmsg_len = sizeof(req);
 367         req.nlh.nlmsg_type = RTM_GETROUTE;
 368         req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
 369         req.nlh.nlmsg_pid = 0;
 370         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
 371         req.rtm.rtm_family = family;
 372         req.rtm.rtm_flags |= RTM_F_CLONED;
 373
 374         return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
 375 }
 376
 377 static int iproute_list(int argc, char **argv)
 378 {
 379         int do_ipv6 = preferred_family;
 380         struct rtnl_handle rth;
 381         char *id = NULL;
 382         char *od = NULL;
 383
 384         iproute_reset_filter();
 385         filter.tb = RT_TABLE_MAIN;
 386
 387         while (argc > 0) {
 388                 if (matches(*argv, "protocol") == 0) {
 389                         int prot = 0;
 390                         NEXT_ARG();
 391                         filter.protocolmask = -1;
 392                         if (rtnl_rtprot_a2n(&prot, *argv)) {
 393                                 if (strcmp(*argv, "all") != 0)
 394                                         invarg("invalid \"protocol\"\n", *argv);
 395                                 prot = 0;
 396                                 filter.protocolmask = 0;
 397                         }
 398                         filter.protocol = prot;
 399                 } else if (strcmp(*argv, "dev") == 0 ||
 400                            strcmp(*argv, "oif") == 0) {
 401                         NEXT_ARG();
 402                         od = *argv;
 403                 } else if (strcmp(*argv, "iif") == 0) {
 404                         NEXT_ARG();
 405                         id = *argv;
 406                 } else if (matches(*argv, "from") == 0) {
 407                         NEXT_ARG();
 408                         if (matches(*argv, "root") == 0) {
 409                                 NEXT_ARG();
 410                                 get_prefix(&filter.rsrc, *argv, do_ipv6);
 411                         } else if (matches(*argv, "match") == 0) {
 412                                 NEXT_ARG();
 413                                 get_prefix(&filter.msrc, *argv, do_ipv6);
 414                         } else {
 415                                 if (matches(*argv, "exact") == 0) {
 416                                         NEXT_ARG();
 417                                 }
 418                                 get_prefix(&filter.msrc, *argv, do_ipv6);
 419                                 filter.rsrc = filter.msrc;
 420                         }
 421                 } else {
 422                         if (matches(*argv, "to") == 0) {
 423                                 NEXT_ARG();
 424                         }
 425                         if (matches(*argv, "root") == 0) {
 426                                 NEXT_ARG();
 427                                 get_prefix(&filter.rdst, *argv, do_ipv6);
 428                         } else if (matches(*argv, "match") == 0) {
 429                                 NEXT_ARG();
 430                                 get_prefix(&filter.mdst, *argv, do_ipv6);
 431                         } else {
 432                                 if (matches(*argv, "exact") == 0) {
 433                                         NEXT_ARG();
 434                                 }
 435                                 get_prefix(&filter.mdst, *argv, do_ipv6);
 436                                 filter.rdst = filter.mdst;
 437                         }
 438                 }
 439                 argc--; argv++;
 440         }
 441
 442         if (do_ipv6 == AF_UNSPEC && filter.tb)
 443                 do_ipv6 = AF_INET;
 444
 445         if (rtnl_open(&rth, 0) < 0)
 446                 exit(1);
 447
 448         ll_init_map(&rth);
 449
 450         if (id || od)  {
 451                 int idx;
 452
 453                 if (id) {
 454                         if ((idx = ll_name_to_index(id)) == 0) {
 455                                 fprintf(stderr, "Cannot find device \"%s\"\n", id);
 456                                 return -1;
 457                         }
 458                         filter.iif = idx;
 459                         filter.iifmask = -1;
 460                 }
 461                 if (od) {
 462                         if ((idx = ll_name_to_index(od)) == 0) {
 463                                 fprintf(stderr, "Cannot find device \"%s\"\n", od);
 464                                 return -1;
 465                         }
 466                         filter.oif = idx;
 467                         filter.oifmask = -1;
 468                 }
 469         }
 470
 471         if (filter.tb != -1) {
 472                 if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
 473                         perror("Cannot send dump request");
 474                         exit(1);
 475                 }
 476         } else {
 477                 if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
 478                         perror("Cannot send dump request");
 479                         exit(1);
 480                 }
 481         }
 482
 483         if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
 484                 fprintf(stderr, "Dump terminated\n");
 485                 exit(1);
 486         }
 487
 488         exit(0);
 489 }
 490
 491
 492 int iproute_get(int argc, char **argv)
 493 {
 494         struct rtnl_handle rth;
 495         struct {
 496                 struct nlmsghdr         n;
 497                 struct rtmsg            r;
 498                 char                    buf[1024];
 499         } req;
 500         char  *idev = NULL;
 501         char  *odev = NULL;
 502         int connected = 0;
 503         int from_ok = 0;
 504
 505         memset(&req, 0, sizeof(req));
 506
 507         iproute_reset_filter();
 508
 509         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 510         req.n.nlmsg_flags = NLM_F_REQUEST;
 511         req.n.nlmsg_type = RTM_GETROUTE;
 512         req.r.rtm_family = preferred_family;
 513         req.r.rtm_table = 0;
 514         req.r.rtm_protocol = 0;
 515         req.r.rtm_scope = 0;
 516         req.r.rtm_type = 0;
 517         req.r.rtm_src_len = 0;
 518         req.r.rtm_dst_len = 0;
 519         req.r.rtm_tos = 0;
 520
 521         while (argc > 0) {
 522                 if (matches(*argv, "from") == 0) {
 523                         inet_prefix addr;
 524                         NEXT_ARG();
 525                         from_ok = 1;
 526                         get_prefix(&addr, *argv, req.r.rtm_family);
 527                         if (req.r.rtm_family == AF_UNSPEC)
 528                                 req.r.rtm_family = addr.family;
 529                         if (addr.bytelen)
 530                                 addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
 531                         req.r.rtm_src_len = addr.bitlen;
 532                 } else if (matches(*argv, "iif") == 0) {
 533                         NEXT_ARG();
 534                         idev = *argv;
 535                 } else if (matches(*argv, "oif") == 0 ||
 536                            strcmp(*argv, "dev") == 0) {
 537                         NEXT_ARG();
 538                         odev = *argv;
 539                 } else if (matches(*argv, "notify") == 0) {
 540                         req.r.rtm_flags |= RTM_F_NOTIFY;
 541                 } else if (matches(*argv, "connected") == 0) {
 542                         connected = 1;
 543                 } else {
 544                         inet_prefix addr;
 545                         if (strcmp(*argv, "to") == 0) {
 546                                 NEXT_ARG();
 547                         }
 548                         get_prefix(&addr, *argv, req.r.rtm_family);
 549                         if (req.r.rtm_family == AF_UNSPEC)
 550                                 req.r.rtm_family = addr.family;
 551                         if (addr.bytelen)
 552                                 addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
 553                         req.r.rtm_dst_len = addr.bitlen;
 554                 }
 555                 argc--; argv++;
 556         }
 557
 558         if (req.r.rtm_dst_len == 0) {
 559                 fprintf(stderr, "need at least destination address\n");
 560                 exit(1);
 561         }
 562
 563         if (rtnl_open(&rth, 0) < 0)
 564                 exit(1);
 565
 566         ll_init_map(&rth);
 567
 568         if (idev || odev)  {
 569                 int idx;
 570
 571                 if (idev) {
 572                         if ((idx = ll_name_to_index(idev)) == 0) {
 573                                 fprintf(stderr, "Cannot find device \"%s\"\n", idev);
 574                                 return -1;
 575                         }
 576                         addattr32(&req.n, sizeof(req), RTA_IIF, idx);
 577                 }
 578                 if (odev) {
 579                         if ((idx = ll_name_to_index(odev)) == 0) {
 580                                 fprintf(stderr, "Cannot find device \"%s\"\n", odev);
 581                                 return -1;
 582                         }
 583                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 584                 }
 585         }
 586
 587         if (req.r.rtm_family == AF_UNSPEC)
 588                 req.r.rtm_family = AF_INET;
 589
 590         if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
 591                 exit(2);
 592
 593         if (connected && !from_ok) {
 594                 struct rtmsg *r = NLMSG_DATA(&req.n);
 595                 int len = req.n.nlmsg_len;
 596                 struct rtattr * tb[RTA_MAX+1];
 597
 598                 if (print_route(NULL, &req.n, (void*)stdout) < 0) {
 599                         fprintf(stderr, "An error :-)\n");
 600                         exit(1);
 601                 }
 602
 603                 if (req.n.nlmsg_type != RTM_NEWROUTE) {
 604                         fprintf(stderr, "Not a route?\n");
 605                         return -1;
 606                 }
 607                 len -= NLMSG_LENGTH(sizeof(*r));
 608                 if (len < 0) {
 609                         fprintf(stderr, "Wrong len %d\n", len);
 610                         return -1;
 611                 }
 612
 613                 memset(tb, 0, sizeof(tb));
 614                 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 615
 616                 if (tb[RTA_PREFSRC]) {
 617                         tb[RTA_PREFSRC]->rta_type = RTA_SRC;
 618                         r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
 619                 } else if (!tb[RTA_SRC]) {
 620                         fprintf(stderr, "Failed to connect the route\n");
 621                         return -1;
 622                 }
 623                 if (!odev && tb[RTA_OIF])
 624                         tb[RTA_OIF]->rta_type = 0;
 625                 if (tb[RTA_GATEWAY])
 626                         tb[RTA_GATEWAY]->rta_type = 0;
 627                 if (!idev && tb[RTA_IIF])
 628                         tb[RTA_IIF]->rta_type = 0;
 629                 req.n.nlmsg_flags = NLM_F_REQUEST;
 630                 req.n.nlmsg_type = RTM_GETROUTE;
 631
 632                 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
 633                         exit(2);
 634         }
 635
 636         if (print_route(NULL, &req.n, (void*)stdout) < 0) {
 637                 fprintf(stderr, "An error :-)\n");
 638                 exit(1);
 639         }
 640
 641         exit(0);
 642 }
 643
 644 void iproute_reset_filter()
 645 {
 646         memset(&filter, 0, sizeof(filter));
 647         filter.mdst.bitlen = -1;
 648         filter.msrc.bitlen = -1;
 649 }
 650
 651 int do_iproute(int argc, char **argv)
 652 {
 653         if (argc < 1)
 654                 return iproute_list(0, NULL);
 655
 656         if (matches(*argv, "add") == 0)
 657                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_EXCL,
 658                                       argc-1, argv+1);
 659         if (matches(*argv, "change") == 0 || strcmp(*argv, "chg") == 0)
 660                 return iproute_modify(RTM_NEWROUTE, NLM_F_REPLACE,
 661                                       argc-1, argv+1);
 662         if (matches(*argv, "replace") == 0)
 663                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_REPLACE,
 664                                       argc-1, argv+1);
 665         if (matches(*argv, "prepend") == 0)
 666                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE,
 667                                       argc-1, argv+1);
 668         if (matches(*argv, "append") == 0)
 669                 return iproute_modify(RTM_NEWROUTE, NLM_F_CREATE|NLM_F_APPEND,
 670                                       argc-1, argv+1);
 671         if (matches(*argv, "test") == 0)
 672                 return iproute_modify(RTM_NEWROUTE, NLM_F_EXCL,
 673                                       argc-1, argv+1);
 674         if (matches(*argv, "delete") == 0)
 675                 return iproute_modify(RTM_DELROUTE, 0,
 676                                       argc-1, argv+1);
 677         if (matches(*argv, "list") == 0 || matches(*argv, "show") == 0
 678             || matches(*argv, "lst") == 0)
 679                 return iproute_list(argc-1, argv+1);
 680         if (matches(*argv, "get") == 0)
 681                 return iproute_get(argc-1, argv+1);
 682         fprintf(stderr, "Command \"%s\" is unknown, try \"ip route help\".\n", *argv);
 683         exit(-1);
 684 }
 685