Home | History | Annotate | Download | only in pending
      1 /* ip.c - Show / manipulate routing, devices, policy routing and tunnels.
      2  *
      3  * Copyright 2014 Sameer Prakash Pradhan <sameer.p.pradhan (at) gmail.com>
      4  * Copyright 2014 Ranjan Kumar <ranjankumar.bth (at) gmail.com>
      5  * Copyright 2014 Rajni Kant <rajnikant12345 (at) gmail.com>
      6  * Copyright 2014 Bilal Qureshi <bilal.jmi (at) gmail.com>
      7  *
      8  * No Standard.
      9  *
     10 USE_IP(NEWTOY(ip, NULL, TOYFLAG_SBIN))
     11 USE_IP(OLDTOY(ipaddr, ip, TOYFLAG_SBIN))
     12 USE_IP(OLDTOY(iplink, ip, TOYFLAG_SBIN))
     13 USE_IP(OLDTOY(iproute, ip, TOYFLAG_SBIN))
     14 USE_IP(OLDTOY(iprule, ip, TOYFLAG_SBIN))
     15 USE_IP(OLDTOY(iptunnel, ip, TOYFLAG_SBIN))
     16 
     17 config IP
     18   bool "ip"
     19   default n
     20   help
     21     usage: ip [ OPTIONS ] OBJECT { COMMAND }
     22 
     23     Show / manipulate routing, devices, policy routing and tunnels.
     24 
     25     where OBJECT := {address | link | route | rule | tunnel}
     26     OPTIONS := { -f[amily] { inet | inet6 | link } | -o[neline] }
     27 */
     28 #define FOR_ip
     29 #include "toys.h"
     30 #include <linux/netlink.h>
     31 #include <linux/rtnetlink.h>
     32 #include <linux/if_ether.h>
     33 #include <linux/if_addr.h>
     34 #include <net/if_arp.h>
     35 #include <ifaddrs.h>
     36 #include <fnmatch.h>
     37 #include <netinet/ip.h>
     38 #include <linux/if_tunnel.h>
     39 
     40 GLOBALS(
     41   char stats, singleline, flush, *filter_dev, gbuf[8192];
     42   int sockfd, connected, from_ok, route_cmd;
     43   int8_t addressfamily, is_addr;
     44 )
     45 
     46 struct arglist {
     47   char *name;
     48   int idx;
     49 };
     50 
     51 static struct
     52 {
     53   int ifindex, scope, scopemask, up, to;
     54   char *label, *addr;
     55 } addrinfo;
     56 
     57 struct linkdata  {
     58   struct linkdata *next, *prev;
     59   int flags, iface_idx, mtu, txqueuelen, parent,iface_type;
     60   char qdiscpline[IFNAMSIZ+1], state[IFNAMSIZ+1], type[IFNAMSIZ+1],
     61        iface[IFNAMSIZ+1], laddr[64], bcast[64];
     62   struct  rtnl_link_stats rt_stat;
     63 }*linfo;
     64 
     65 typedef int (*cmdobj)(char **argv);
     66 
     67 #define MESG_LEN 8192
     68 
     69 // For "/etc/iproute2/RPDB_tables"
     70 enum {
     71   RPDB_rtdsfield = 1,
     72   RPDB_rtprotos = 2,
     73   RPDB_rtrealms = 3,
     74   RPDB_rtscopes = 4,
     75   RPDB_rttables = 5
     76 };
     77 
     78 #define RPDB_ENTRIES 256
     79 static int8_t rttable_init;
     80 static int8_t rtprotos_init;
     81 static int8_t rtdsfield_init;
     82 static int8_t rtscope_init;
     83 static int8_t rtrealms_init;
     84 
     85 static struct arglist *rt_dsfield[RPDB_ENTRIES];
     86 static struct arglist *rt_protos[RPDB_ENTRIES];
     87 static struct arglist *rt_tables[RPDB_ENTRIES];
     88 static struct arglist *rt_realms[RPDB_ENTRIES];
     89 static struct arglist *rt_scope[RPDB_ENTRIES];
     90 
     91 static struct arglist rtmtypes[] = { {"none", RTN_UNSPEC},
     92   {"unicast", RTN_UNICAST}, {"local", RTN_LOCAL},
     93   {"broadcast", RTN_BROADCAST}, {"anycast", RTN_ANYCAST},
     94   {"multicast", RTN_MULTICAST}, {"blackhole", RTN_BLACKHOLE},
     95   {"unreachable", RTN_UNREACHABLE}, {"prohibit", RTN_PROHIBIT},
     96   {"throw", RTN_THROW}, {"nat", RTN_NAT},
     97   {"xresolve", RTN_XRESOLVE}, {NULL, -1}
     98 };
     99 
    100 static int filter_nlmesg(int (*fun)(struct nlmsghdr *mhdr, char **), char **);
    101 static int  ipaddr_print(struct linkdata *, int flg);
    102 
    103 
    104 // ===========================================================================
    105 // Common Code for IP Options (like: addr, link, route etc.)
    106 // ===========================================================================
    107 static int substring_to_idx(char *str, struct arglist *list)
    108 {
    109   struct arglist *alist;
    110   int len;
    111 
    112   if (!str) return -1;
    113   len = strlen(str);
    114 
    115   for (alist = list; alist->name; alist++)
    116     if (!memcmp(str, alist->name, len)) return alist->idx;
    117   return -1;
    118 }
    119 
    120 static int string_to_idx(char *str, struct arglist *list)
    121 {
    122   struct arglist *alist;
    123 
    124   if (!str) return -1;
    125   for (alist = list; alist->name; alist++)
    126     if (!strcmp(str, alist->name)) return alist->idx;
    127   return -1;
    128 }
    129 
    130 static char *idx_to_string(int idx, struct arglist *list)
    131 {
    132   struct arglist *alist;
    133 
    134   if (idx < 0) return NULL;
    135   for (alist = list; alist->name; alist++)
    136     if (idx == alist->idx) return alist->name;
    137   return NULL;
    138 }
    139 
    140 static void send_nlmesg(int type, int flags, int family,
    141     void *buf, int blen)
    142 {
    143   struct {
    144     struct nlmsghdr nlh;
    145     struct rtgenmsg g;
    146   } req;
    147 
    148   if (!buf) {
    149     memset(&req, 0, sizeof(req));
    150     req.nlh.nlmsg_len = sizeof(req);
    151     req.nlh.nlmsg_type = type;
    152     req.nlh.nlmsg_flags = flags;
    153     req.g.rtgen_family = family;
    154     buf = &req;
    155     blen = sizeof(req);
    156   }
    157   if (send(TT.sockfd , (void*)buf, blen, 0) < 0)
    158     perror_exit("Unable to send data on socket.");
    159 }
    160 
    161 // Parse /etc/iproute2/RPDB_tables and prepare list.
    162 static void parseRPDB(char *fname, struct arglist **list, int32_t size)
    163 {
    164   char *line;
    165   int fd = open(fname, O_RDONLY);
    166 
    167   if (fd < 0) return;
    168   for (; (line = get_line(fd)); free(line)) {
    169     char *ptr = line;
    170     int32_t idx;
    171 
    172     while (*ptr == ' ' || *ptr == '\t') ptr++;
    173     if (*ptr == 0 || *ptr == '#' || *ptr == '\n') continue;
    174     if ((sscanf(ptr, "0x%x %s\n", &idx, toybuf) != 2) &&
    175         (sscanf(ptr, "0x%x %s #", &idx, toybuf) != 2) &&
    176         (sscanf(ptr, "%d %s\n", &idx, toybuf) != 2) &&
    177         (sscanf(ptr, "%d %s #", &idx, toybuf) != 2)) {
    178       error_msg("Corrupted '%s' file", fname);
    179       xclose(fd);
    180       free(line);
    181       return;
    182     }
    183     if (idx >= 0 && idx < size) {
    184       int index = idx & (size-1);
    185       if (list[index]) free(list[index]->name);
    186       else list[index] = xzalloc(sizeof(struct arglist));
    187       list[index]->idx = idx;
    188       list[index]->name = xstrdup(toybuf);
    189     }
    190   }
    191   xclose(fd);
    192 }
    193 
    194 static void free_alist(struct arglist **list)
    195 {
    196   int i;
    197   for (i = 0;i<RPDB_ENTRIES;i++) {
    198     if (list[i]) {
    199       free(list[i]->name);
    200       free(list[i]);
    201     }
    202   }
    203 }
    204 
    205 static void init_arglist(struct arglist **list,int value, char* name)
    206 {
    207   if (!list[value]) list[value] =  xzalloc(sizeof(struct arglist));
    208   list[value]->idx = value;
    209   list[value]->name = xstrdup(name);
    210 }
    211 
    212 static struct arglist **getlist(u_int8_t whichDB)
    213 {
    214   struct arglist **alist;
    215 
    216   switch (whichDB) {
    217     case RPDB_rtdsfield:
    218       alist = rt_dsfield;
    219       if (!rtdsfield_init) {
    220         rtdsfield_init = 1;
    221         parseRPDB("/etc/iproute2/rt_dsfield", alist, ARRAY_LEN(rt_dsfield));
    222       }
    223       break;
    224     case RPDB_rtprotos:
    225       alist = rt_protos;
    226       if (!rttable_init) {
    227         rtprotos_init = 1;
    228         init_arglist(rt_protos,0,"none");
    229         init_arglist(rt_protos,1,"redirect");
    230         init_arglist(rt_protos,2,"kernel");
    231         init_arglist(rt_protos,3,"boot");
    232         init_arglist(rt_protos,4,"static");
    233         init_arglist(rt_protos,8,"gated");
    234         init_arglist(rt_protos,9,"ra");
    235         init_arglist(rt_protos,10,"mrt");
    236         init_arglist(rt_protos,11,"zebra");
    237         init_arglist(rt_protos,12,"bird");
    238         parseRPDB("/etc/iproute2/rt_protos", alist, ARRAY_LEN(rt_protos));
    239       }
    240       break;
    241     case RPDB_rtrealms:
    242       alist = rt_realms;
    243       if (!rtrealms_init) {
    244         rtrealms_init = 1;
    245         init_arglist(rt_realms,0,"unspec");
    246         parseRPDB("/etc/iproute2/rt_realms", alist, ARRAY_LEN(rt_realms));
    247       }
    248       break;
    249     case RPDB_rtscopes:
    250       alist = rt_scope;
    251       if (!rtscope_init) {
    252         rtscope_init = 1;
    253         init_arglist(rt_scope,0,"global");
    254         init_arglist(rt_scope,200,"site");
    255         init_arglist(rt_scope,253,"link");
    256         init_arglist(rt_scope,254,"host");
    257         init_arglist(rt_scope,255,"nowhere");
    258         parseRPDB("/etc/iproute2/rt_scopes", alist, ARRAY_LEN(rt_scope));
    259       }
    260       break;
    261     case RPDB_rttables:
    262       alist = rt_tables;
    263       if (!rttable_init) {
    264         rttable_init = 1;
    265         init_arglist(rt_tables,RT_TABLE_DEFAULT,"default");
    266         init_arglist(rt_tables,RT_TABLE_MAIN,"main");
    267         init_arglist(rt_tables,RT_TABLE_LOCAL,"local");
    268         parseRPDB("/etc/iproute2/rt_tables", alist, ARRAY_LEN(rt_tables));
    269       }
    270       break;
    271     default:
    272       error_exit("wrong database");
    273       break; // Unreachable code.
    274   }
    275   return alist;
    276 }
    277 
    278 /*
    279  * Parse RPBD tables (if not parsed already).
    280  * return RPDB table name as per idx.
    281  */
    282 static char *namefromRPDB(int idx, u_int8_t whichDB)
    283 {
    284   struct arglist **alist;
    285 
    286   if (idx < 0 || idx >= RPDB_ENTRIES) {
    287     snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
    288     return toybuf;
    289   }
    290 
    291   alist = getlist(whichDB);
    292 
    293   if (alist[idx] && alist[idx]->name) return alist[idx]->name;
    294 
    295   if (whichDB == RPDB_rtdsfield) snprintf(toybuf, RPDB_ENTRIES, "0x%02x", idx);
    296   else snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
    297 
    298   return toybuf;
    299 }
    300 
    301 static int idxfromRPDB(char *name, u_int8_t whichDB)
    302 {
    303   struct arglist **alist;
    304   long i = 0;
    305   char *ptr = NULL;
    306 
    307   for (alist = getlist(whichDB); i < RPDB_ENTRIES; i++) {
    308     if (!alist[i] || !alist[i]->name) continue;
    309     if (!strcmp(alist[i]->name, name)) return i;
    310   }
    311   i = strtol(name, &ptr, 0);
    312   if (errno || (ptr && *ptr) || i < 0 || i > 255)
    313     return -1;
    314   return i;
    315 }
    316 
    317 static char *rtmtype_idx2str(u_int8_t idx)
    318 {
    319   char *name = idx_to_string(idx, rtmtypes);
    320 
    321   if (!name) snprintf(toybuf, RPDB_ENTRIES, "%u", idx);
    322   else snprintf(toybuf, sizeof(toybuf), "%s", name);
    323   return toybuf;
    324 }
    325 
    326 static int rtmtype_str2idx(char *name)
    327 {
    328   int idx = string_to_idx(name, rtmtypes);
    329 
    330   if (idx < 0) return atolx_range(name, 0, 255);
    331   return idx;
    332 }
    333 
    334 /*
    335  * Used to get the prefix value in binary form.
    336  * For IPv4: non-standard parsing used; as 10.10 will be treated as 10.10.0.0
    337  * unlike inet_aton which is 10.0.0.10
    338  */
    339 static int get_prefix(uint32_t *addr, uint8_t *af, char *name, int family)
    340 {
    341   if (family == AF_PACKET) error_exit("'%s' may be inet prefix", name);
    342   if (!memcmp(name, "default", strlen(name))
    343       || !memcmp(name, "all", strlen(name))
    344       || !memcmp(name, "any", strlen(name))) {
    345     *af = family;
    346     return 0;
    347   }
    348   if (strchr(name, ':')) {
    349     *af = AF_INET6;
    350     if (family != AF_UNSPEC && family != AF_INET6) return 1;
    351     if (inet_pton(AF_INET6, name, (void *)addr) != 1)
    352       return 1;
    353   } else { // for IPv4.
    354     char *ptr = name;
    355     uint8_t count = 0;
    356 
    357     *af = AF_INET;
    358     if (family != AF_UNSPEC && family != AF_INET) return 1;
    359     while (*ptr) {
    360       int val, len = 0;
    361 
    362       if (*ptr == '.') ptr++;
    363       sscanf(ptr, "%d%n", &val, &len);
    364       if (!len || len > 3 || val < 0 || val > 255 || count > 3) return 1;
    365       ptr += len;
    366       ((uint8_t*)addr)[count++] = val;
    367     }
    368   }
    369   return 0;
    370 }
    371 
    372 /*
    373  * Used to calculate netmask, which can be in the form of
    374  * either 255.255.255.0 or 24 or default or any or all strings.
    375  */
    376 static int get_nmask_prefix(uint32_t *netmask, uint8_t af,
    377     char *name, uint8_t family)
    378 {
    379   char *ptr;
    380   uint32_t naddr[4] = {0,};
    381   uint64_t plen;
    382   uint8_t naf = AF_UNSPEC;
    383 
    384   *netmask = (af == AF_INET6) ? 128 : 32; // set default netmask
    385   plen = strtoul(name, &ptr, 0);
    386 
    387   if (!ptr || ptr == name || *ptr || !plen || plen > *netmask) {
    388     if (get_prefix(naddr, &naf, name, family)) return -1;
    389     if (naf == AF_INET) {
    390       uint32_t mask = htonl(*naddr), host = ~mask;
    391       if (host & (host + 1)) return -1;
    392       for (plen = 0; mask; mask <<= 1) ++plen;
    393       if (plen > 32) return -1;
    394     }
    395   }
    396   *netmask = plen;
    397   return 0;
    398 }
    399 
    400 /*
    401  * Parse prefix, which will be in form of
    402  * either default or default/default or default/24 or default/255.255.255.0
    403  * or 10.20.30.40 or 10.20.30.40/default or 10.20.30.40/24
    404  * or 10.20.30.40/255.255.255.0
    405  */
    406 static void parse_prefix(uint32_t *addr, uint32_t *netmask, uint8_t *len,
    407     char *name, int family)
    408 {
    409   uint8_t af = AF_UNSPEC;
    410   char *slash = strchr(name, '/');
    411 
    412   if (slash) *slash = 0;
    413   if (get_prefix(addr, &af, name, family)) error_exit("Invalid prefix");
    414 
    415   if (slash) { // grab netmask.
    416     if (get_nmask_prefix(netmask, af, slash+1, family))
    417       error_exit("Invalid prefix");
    418     *slash ='/';
    419   }
    420   else if (af == AF_INET && *addr) *netmask = 32;
    421   else if (af == AF_INET6 && (*addr || *(addr+3))) *netmask = 128;
    422 
    423   if (!*addr && !slash && !af) *len = 0;
    424   else *len = (af == AF_INET6) ? 16 : 4;
    425 }
    426 
    427 static void add_string_to_rtattr(struct nlmsghdr *n, int maxlen,
    428     int type, void *data, int alen)
    429 {
    430   int len = RTA_LENGTH(alen);
    431   struct rtattr *rta;
    432 
    433   if ((int)(NLMSG_ALIGN(n->nlmsg_len) + len) > maxlen) return;
    434   rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
    435   rta->rta_type = type;
    436   rta->rta_len = len;
    437   memcpy(RTA_DATA(rta), data, alen);
    438   n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
    439 }
    440 
    441 
    442 
    443 // ===========================================================================
    444 // Code for ip link.
    445 // ===========================================================================
    446 #ifndef NLMSG_TAIL
    447 #define NLMSG_TAIL(nmsg) \
    448   ((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
    449 #endif
    450 
    451 static uint32_t get_ifaceindex(char *name, int ext)
    452 {
    453   struct if_nameindex *if_ni, *i;
    454   int index = -1;
    455 
    456   if_ni = if_nameindex();
    457   if (!if_ni) perror_exit("if_nameindex");
    458 
    459   for (i = if_ni; i->if_index && i->if_name; i++)
    460     if (!strcmp(name, i->if_name)) {
    461       index = i->if_index;
    462       break;
    463     }
    464   if_freenameindex(if_ni);
    465   if (index == -1 && ext) perror_exit("can't find device '%s'", name);
    466   return index;
    467 }
    468 
    469 static void fill_hwaddr(char *arg, int len, unsigned char *address)
    470 {
    471   int count = 0, val, length;
    472 
    473   while (count < len) {
    474     val = length = 0;
    475     if (!arg) error_exit("bad hw-addr '%s'", "");
    476     if (*arg == ':') arg++, count++;
    477     sscanf(arg, "%2x%n", &val, &length);
    478     if (!length || length > 2)
    479       error_exit("bad hw-addr '%s'", arg);
    480     arg += length;
    481     count += length;
    482     *address++ = val;
    483   }
    484 }
    485 
    486 // Multimach = 1, single match = 0
    487 static char *get_flag_string(struct arglist *aflags, int flags, int ismulti)
    488 {
    489   struct arglist *p = aflags;
    490   char *out = NULL, *tmp = NULL;
    491 
    492   for (; p->name; p++) {
    493     int test = (ismulti ? p->idx & flags : 0) || p->idx == flags;
    494     if (test) { // flags can be zero
    495       tmp = out ? xmprintf("%s,%s", out, p->name) : xmprintf("%s", p->name);
    496       if (out) free(out);
    497       out = tmp;
    498     }
    499   }
    500   return out;
    501 }
    502 
    503 static void vlan_parse_opt(char **argv, struct nlmsghdr *n, unsigned int size)
    504 {
    505   struct arglist vlan_optlist[] = {{"id", 0}, {"protocol", 1},
    506     {"reorder_hdr", 2}, {"gvrp", 3}, {NULL,-1}};
    507   struct arglist vlan_protolist[] = {{"802.1q", 0}, {"802.1ad", 1}, {NULL,-1}};
    508   struct arglist on_off[] = { {"on", 0}, {"off", 1}, {NULL,-1}};
    509   int idx;
    510   struct ifla_vlan_flags flags;
    511 
    512   memset(&flags, 0, sizeof(flags));
    513   for (; *argv; argv++) {
    514     int param, proto;
    515 
    516     if ((idx = substring_to_idx(*argv++, vlan_optlist)) == -1) help_exit(0);
    517     switch (idx) {
    518       case 0: // ARG_id
    519         if (!*argv) help_exit(0);
    520         param = atolx(*argv);
    521         add_string_to_rtattr(n, size, IFLA_VLAN_ID, &param, sizeof(param));
    522         break;
    523       case 1: // ARG_protocol
    524         if (!*argv) error_exit("Invalid vlan id.");
    525         if ((idx = substring_to_idx(*argv, vlan_protolist)) == -1) help_exit(0);
    526         if (!idx) proto = ETH_P_8021Q; // PROTO_8021Q - 0
    527         else if (idx == 1) proto = 0x88A8; // ETH Protocol - 8021AD
    528         // IFLA VLAN PROTOCOL - 5
    529         add_string_to_rtattr(n, size, 5, &proto, sizeof(proto));
    530         break;
    531       case 2: // ARG_reorder_hdr
    532       case 3: // ARG_gvrp
    533         if ((param = substring_to_idx(*argv, on_off)) == -1) help_exit(0);
    534 
    535         flags.mask |= (idx -1); // VLAN FLAG REORDER Header
    536         flags.flags &= ~(idx -1); // VLAN FLAG REORDER Header
    537         if (!param) flags.flags |= (idx -1); // VLAN FLAG REORDER Header
    538         break;
    539     }
    540   }
    541   if (flags.mask)
    542     add_string_to_rtattr(n, size, IFLA_VLAN_FLAGS, &flags, sizeof(flags));
    543 }
    544 
    545 static int linkupdate(char **argv)
    546 {
    547   struct {
    548     struct nlmsghdr mhdr;
    549     struct ifinfomsg info;
    550     char buf[1024];
    551   } request;
    552   char *name, *dev, *type, *link, *addr;
    553   struct rtattr *attr = NULL;
    554   int len = 0, add = (*argv[-1] == 'a') ? 1 : 0;
    555 
    556   name = dev = type = link = addr = NULL;
    557   for (; *argv; argv++) {
    558     struct arglist objectlist[] = { {"type", 0}, {"name", 1}, {"link", 2},
    559       {"address", 3}, {NULL,-1}};
    560     uint8_t idx = substring_to_idx(*argv, objectlist);
    561 
    562     if (!idx) {
    563       type = *++argv;
    564       break;
    565     }
    566     else if (idx == 1) dev = name = *++argv;
    567     else if (idx == 2) link = *++argv;
    568     else if (idx == 3) addr = *++argv;
    569     else if (!dev) name = dev = *argv;
    570   }
    571 
    572   if (!name && !add)
    573     error_exit("Not enough information: \"dev\" argument is required.\n");
    574   else if (!type  && add)
    575     error_exit("Not enough information: \"type\" argument is required.\n");
    576 
    577   memset(&request, 0, sizeof(request));
    578   request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
    579   request.mhdr.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
    580   if (add) {
    581     request.mhdr.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
    582     request.mhdr.nlmsg_type = RTM_NEWLINK;
    583   } else {
    584     request.mhdr.nlmsg_type = RTM_DELLINK;
    585     request.info.ifi_index = get_ifaceindex(name, 1);
    586   }
    587   request.info.ifi_family = AF_UNSPEC;
    588   attr = NLMSG_TAIL(&request.mhdr);
    589   if (type) {
    590     add_string_to_rtattr(&request.mhdr, sizeof(request),
    591         IFLA_LINKINFO, NULL, 0);
    592     add_string_to_rtattr(&request.mhdr, sizeof(request),
    593         IFLA_INFO_KIND, type, strlen(type));
    594     if (!strcmp(type, "vlan")) {
    595       struct rtattr *data = NLMSG_TAIL(&request.mhdr);
    596       add_string_to_rtattr(&request.mhdr, sizeof(request),
    597           IFLA_INFO_DATA, NULL, 0);
    598       vlan_parse_opt(++argv, &request.mhdr, sizeof(request));
    599       data->rta_len = (void *)NLMSG_TAIL(&request.mhdr) - (void *)data;
    600     }
    601     attr->rta_len = (void *)NLMSG_TAIL(&request.mhdr) - (void *)attr;
    602   }
    603 
    604   if (link) {
    605     uint32_t idx = get_ifaceindex(link, 1);
    606     add_string_to_rtattr(&request.mhdr, sizeof(request),
    607         IFLA_LINK, &idx, sizeof(uint32_t));
    608   }
    609   if (addr) {
    610     char abuf[IF_NAMESIZE] = {0,};
    611 
    612     fill_hwaddr(addr, IF_NAMESIZE, (unsigned char *)abuf);
    613     add_string_to_rtattr(&request.mhdr, sizeof(request),
    614         IFLA_ADDRESS, abuf, strlen(abuf));
    615   }
    616   if (!name) {
    617     snprintf(toybuf, IFNAMSIZ, "%s%d", type, 0);
    618     for (len = 1; ; len++) {
    619       if (!get_ifaceindex(toybuf, 0)) break;
    620       snprintf(toybuf, IFNAMSIZ, "%s%d", type, len);
    621     }
    622     name = toybuf;
    623   }
    624   len = strlen(name) + 1;
    625   if (len < 2 || len > IFNAMSIZ) error_exit("Invalid device name.");
    626   add_string_to_rtattr(&request.mhdr, sizeof(request), IFLA_IFNAME, name, len);
    627 
    628   send_nlmesg(0, 0, 0, (void *)&request, request.mhdr.nlmsg_len);
    629   return (filter_nlmesg(NULL,NULL));
    630 }
    631 
    632 static int link_set(char **argv)
    633 {
    634   struct arglist cmd_objectlist[] = {{"up", 0}, {"down", 1}, {"arp", 2},
    635     {"multicast", 3}, {"dynamic", 4}, {"name", 5}, {"txqueuelen", 6},
    636     {"mtu", 7},{"address", 8}, {"broadcast", 9}, {NULL,-1}};
    637   int case_flags[] = {IFF_NOARP,IFF_MULTICAST,IFF_DYNAMIC};
    638   struct ifreq req;
    639   int idx, flags = 0, masks = 0xffff, fd;
    640 
    641   memset(&req, 0, sizeof(req));
    642   if (!*argv) error_exit("\"dev\" missing");
    643   xstrncpy(req.ifr_name, *argv, IF_NAMESIZE);
    644   fd = xsocket(AF_INET, SOCK_DGRAM, 0);
    645   xioctl(fd, SIOCGIFINDEX, &req);
    646   for (++argv; *argv;) {
    647     if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1) help_exit(0);
    648     switch(idx) {
    649       case 0:
    650         flags |= IFF_UP; break;
    651       case 1:
    652         masks &= ~IFF_UP; break;
    653       case 2:
    654       case 3:
    655       case 4:
    656         if (!*argv) help_exit(0);
    657         else if (!strcmp(*argv, "on")) {
    658           if (idx == 2) {
    659             masks &= ~case_flags[idx-2];
    660             flags &= ~case_flags[idx-2];
    661           } else flags |= case_flags[idx-2];
    662         } else if (!strcmp(*argv,"off")) {
    663           if (idx == 2) {
    664             masks |= case_flags[idx-2];
    665             flags |= case_flags[idx-2];
    666           } else masks &= ~case_flags[idx-2];
    667         } else help_exit(0);
    668         ++argv;
    669         break;
    670       case 5:
    671         xstrncpy(req.ifr_ifru.ifru_newname, *argv, IF_NAMESIZE);
    672         xioctl(fd, SIOCSIFNAME, &req);
    673         xstrncpy(req.ifr_name, *argv++, IF_NAMESIZE);
    674         xioctl(fd, SIOCGIFINDEX, &req);
    675         break;
    676       case 6:
    677         req.ifr_ifru.ifru_ivalue = atolx(*argv++);
    678         xioctl(fd, SIOCSIFTXQLEN, &req);
    679         break;
    680       case 7:
    681         req.ifr_ifru.ifru_mtu = atolx(*argv++);
    682         xioctl(fd, SIOCSIFMTU, &req);
    683         break;
    684       case 8:
    685         xioctl(fd, SIOCGIFHWADDR, &req);
    686         fill_hwaddr(*argv++, IF_NAMESIZE,
    687             (unsigned char *)(req.ifr_hwaddr.sa_data));
    688         xioctl(fd, SIOCSIFHWADDR, &req);
    689         break;
    690       case 9:
    691         xioctl(fd, SIOCGIFHWADDR, &req);
    692         fill_hwaddr(*argv++, IF_NAMESIZE,
    693             (unsigned char *)(req.ifr_hwaddr.sa_data));
    694         xioctl(fd, SIOCSIFHWBROADCAST, &req);
    695         break;
    696     }
    697   }
    698   xioctl(fd, SIOCGIFFLAGS, &req);
    699   req.ifr_ifru.ifru_flags |= flags;
    700   req.ifr_ifru.ifru_flags &= masks;
    701   xioctl(fd, SIOCSIFFLAGS, &req);
    702   xclose(fd);
    703   return 0;
    704 }
    705 
    706 static void print_stats(struct  rtnl_link_stats *rtstat)
    707 {
    708   char *line_feed = (!TT.singleline ? "\n    " : " ");
    709 
    710   if (TT.stats > 0) {
    711     xprintf("    RX: bytes  packets  errors  "
    712         "dropped  overrun  mcast%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
    713         line_feed, rtstat->rx_bytes, rtstat->rx_packets, rtstat->rx_errors,
    714         rtstat->rx_dropped, rtstat->rx_over_errors, rtstat->multicast);
    715     if (TT.stats > 1) {
    716       xprintf("    RX: errors  length  crc  "
    717           "frame  fifo  missed%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
    718           line_feed, rtstat->rx_errors, rtstat->rx_length_errors,
    719           rtstat->rx_crc_errors, rtstat->rx_frame_errors,
    720           rtstat->rx_fifo_errors, rtstat->rx_missed_errors);
    721     }
    722     xprintf("    TX: bytes  packets  errors  "
    723         "dropped  carrier  collsns%s%-10u %-8u %-7u %-8u %-8u %-8u\n",
    724         line_feed, rtstat->tx_bytes, rtstat->tx_packets, rtstat->tx_errors,
    725         rtstat->tx_dropped, rtstat->tx_carrier_errors, rtstat->collisions);
    726     if (TT.stats > 1) {
    727       xprintf("    TX: errors  aborted  fifo  window  "
    728           "heartbeat%s%-10u %-8u %-7u %-8u %-8u\n",
    729           line_feed, rtstat->tx_errors, rtstat->tx_aborted_errors,
    730           rtstat->tx_fifo_errors, rtstat->tx_window_errors,
    731           rtstat->tx_heartbeat_errors);
    732     }
    733   }
    734 }
    735 
    736 static int print_link_output(struct linkdata *link)
    737 {
    738   char *line_feed = " ", *flags,*peer = "brd";
    739   struct arglist iface_flags[] = {{"",0},{"UP", IFF_UP},
    740     {"BROADCAST", IFF_BROADCAST}, {"DEBUG", IFF_DEBUG},
    741     {"LOOPBACK", IFF_LOOPBACK}, {"POINTOPOINT", IFF_POINTOPOINT},
    742     {"NOTRAILERS", IFF_NOTRAILERS}, {"RUNNING", IFF_RUNNING},
    743     {"NOARP", IFF_NOARP}, {"PROMISC",IFF_PROMISC},
    744     {"ALLMULTI", IFF_ALLMULTI}, {"MASTER", IFF_MASTER}, {"SLAVE", IFF_SLAVE},
    745     {"MULTICAST", IFF_MULTICAST}, {"PORTSEL", IFF_PORTSEL},
    746     {"AUTOMEDIA", IFF_AUTOMEDIA}, {"DYNAMIC", IFF_DYNAMIC}, {NULL,-1}};
    747 
    748   if (link->parent != -1) {
    749     int fd = 0;
    750     struct ifreq req;
    751 
    752     memset(&req, 0, sizeof(req));
    753     if_indextoname( link->parent,req.ifr_ifrn.ifrn_name);
    754     fd = xsocket(AF_INET, SOCK_DGRAM, 0);
    755     if (ioctl(fd, SIOCGIFTXQLEN, &req)) perror("");
    756     else link->txqueuelen = req.ifr_ifru.ifru_ivalue;
    757     xclose(fd);
    758   }
    759 
    760   if (TT.is_addr && addrinfo.label && fnmatch(addrinfo.label, link->iface, 0))
    761     return 0;
    762 
    763 
    764   if (!(flags = get_flag_string(iface_flags, link->flags, 1)))
    765     error_exit("Invalid data.");
    766   if (!TT.singleline) line_feed="\n    ";
    767   if (link->parent != -1) {
    768     char iface[IF_NAMESIZE];
    769 
    770     if (!if_indextoname(link->parent, iface)) perror_exit(NULL);
    771     sprintf(toybuf,"%s@%s", link->iface, iface);
    772   }
    773   if (link->flags & IFF_POINTOPOINT) peer = "peer";
    774   if (TT.is_addr && TT.singleline && TT.addressfamily)
    775     xprintf("%d: %s", link->iface_idx,
    776         ((link->parent == -1) ? link->iface : toybuf));
    777   else xprintf("%d: %s: <%s> mtu %d qdisc %s state %s qlen %d",
    778       link->iface_idx, ((link->parent == -1) ? link->iface : toybuf), flags,
    779       link->mtu, link->qdiscpline, link->state, link->txqueuelen);
    780 
    781   if (!TT.addressfamily || TT.addressfamily == AF_PACKET)
    782     xprintf("%slink/%s %s %s %s",
    783         line_feed, link->type, link->laddr, peer ,link->bcast);
    784 
    785   xputc('\n');
    786 
    787   //user can specify stats flag two times
    788   //one for stats and other for erros e.g. -s and -s -s
    789   print_stats(&link->rt_stat);
    790   free(flags);
    791 
    792   return 0;
    793 }
    794 
    795 static void fill_address(void *p, char *ip)
    796 {
    797   unsigned char *ptr = (unsigned char*)p;
    798   snprintf(ip, 64, " %02x:%02x:%02x:%02x:%02x:%02x",
    799       ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
    800 }
    801 
    802 static int get_link_info(struct nlmsghdr* h,struct linkdata* link,char **argv)
    803 {
    804   struct ifinfomsg *iface = NLMSG_DATA(h);
    805   struct rtattr *attr = IFLA_RTA(iface);
    806   int len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*iface));
    807   struct arglist hwtypes[]={{"generic",0},{"ether",ARPHRD_ETHER},
    808     {"loopback", ARPHRD_LOOPBACK},{"sit",ARPHRD_SIT},
    809 #ifdef ARPHRD_INFINIBAND
    810     {"infiniband",ARPHRD_INFINIBAND},
    811 #endif
    812 #ifdef ARPHRD_IEEE802_TR
    813     {"ieee802",ARPHRD_IEEE802}, {"tr",ARPHRD_IEEE802_TR},
    814 #else
    815     {"tr",ARPHRD_IEEE802},
    816 #endif
    817 #ifdef ARPHRD_IEEE80211
    818     {"ieee802.11",ARPHRD_IEEE80211},
    819 #endif
    820 #ifdef ARPHRD_IEEE1394
    821     {"ieee1394",ARPHRD_IEEE1394},
    822 #endif
    823     {"irda",ARPHRD_IRDA},{"slip",ARPHRD_SLIP},{"cslip",ARPHRD_CSLIP},
    824     {"slip6",ARPHRD_SLIP6}, {"cslip6",ARPHRD_CSLIP6}, {"ppp",ARPHRD_PPP},
    825     {"ipip",ARPHRD_TUNNEL}, {"tunnel6",ARPHRD_TUNNEL6},
    826     {"gre",ARPHRD_IPGRE},
    827 #ifdef ARPHRD_VOID
    828     {"void",ARPHRD_VOID},
    829 #endif
    830     {NULL,-1}};
    831   char *lname = get_flag_string(hwtypes, iface->ifi_type, 0);
    832 
    833   link->next = link->prev = 0;
    834   link->iface_type = iface->ifi_type;
    835   if (!lname) error_exit("Invalid link.");
    836   xstrncpy(link->type, lname, IFNAMSIZ);
    837   free(lname);
    838   link->iface_idx = iface->ifi_index;
    839   link->flags = iface->ifi_flags;
    840   if (*argv && !strcasecmp("up",*argv) && !(link->flags & IFF_UP)) return 1;
    841   link->parent =  -1;
    842   for (; RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) {
    843     switch(attr->rta_type) {
    844       case IFLA_IFNAME:
    845         snprintf(link->iface, IFNAMSIZ, "%s",(char *) RTA_DATA(attr));
    846         break;
    847       case IFLA_ADDRESS:
    848         if ( iface->ifi_type== ARPHRD_TUNNEL ||
    849             iface->ifi_type == ARPHRD_SIT ||
    850             iface->ifi_type == ARPHRD_IPGRE)
    851           inet_ntop(AF_INET, RTA_DATA(attr), link->laddr, 64);
    852         else fill_address(RTA_DATA(attr), link->laddr);
    853         break;
    854       case IFLA_BROADCAST:
    855         if (iface->ifi_type== ARPHRD_TUNNEL ||
    856             iface->ifi_type == ARPHRD_SIT ||
    857             iface->ifi_type == ARPHRD_IPGRE)
    858           inet_ntop(AF_INET, RTA_DATA(attr), link->bcast, 64);
    859         else  fill_address(RTA_DATA(attr), link->bcast);
    860         break;
    861       case IFLA_MTU:
    862         link->mtu = *((int*)(RTA_DATA(attr)));
    863         break;
    864       case IFLA_QDISC:
    865         snprintf(link->qdiscpline, IFNAMSIZ, "%s", (char *) RTA_DATA(attr));
    866         break;
    867       case IFLA_STATS  :
    868         link->rt_stat = *((struct rtnl_link_stats*) RTA_DATA(attr));
    869         break;
    870       case IFLA_LINK:
    871         link->parent = *((int*)(RTA_DATA(attr)));
    872         break;
    873       case IFLA_TXQLEN:
    874         link->txqueuelen = *((int*)(RTA_DATA(attr)));
    875         break;
    876       case IFLA_OPERSTATE:
    877         {
    878           struct arglist flags[]={{"UNKNOWN", 0}, {"NOTPRESENT", 1},
    879             {"DOWN", 2}, {"LOWERLAYERDOWN", 3}, {"TESTING", 4},
    880             {"DORMANT", 5}, {"UP", 6}, {NULL, -1}};
    881           if (!(lname = get_flag_string(flags, *((int*)(RTA_DATA(attr))), 0)))
    882             error_exit("Invalid state.");
    883           xstrncpy(link->state, lname,IFNAMSIZ);
    884           free(lname);
    885         }
    886         break;
    887       default: break;
    888     }
    889   }
    890   return 0;
    891 }
    892 
    893 static int display_link_info(struct nlmsghdr *mhdr, char **argv)
    894 {
    895   struct linkdata link;
    896 
    897   if (!get_link_info(mhdr, &link, argv)) {
    898     if (TT.is_addr) {
    899       struct linkdata *lnk = xzalloc(sizeof(struct linkdata));
    900       memcpy(lnk, &link, sizeof(struct linkdata));
    901       dlist_add_nomalloc((struct double_list **)&linfo,
    902           (struct double_list *)lnk);
    903     }
    904     else print_link_output(&link);
    905   }
    906   return 0;
    907 }
    908 
    909 static int link_show(char **argv)
    910 {
    911   struct {
    912     struct nlmsghdr mhdr;
    913     struct ifinfomsg info;
    914   } request;
    915   uint32_t index = 0;
    916 
    917   if (*argv && strcasecmp("up",*argv)) index = get_ifaceindex(*argv, 1);
    918   memset(&request, 0, sizeof(request));
    919   request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
    920   request.mhdr.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
    921   if (!index) request.mhdr.nlmsg_flags |= NLM_F_ROOT|NLM_F_MATCH;
    922   else request.info.ifi_change =  0xffffffff; // used in single operation
    923   request.mhdr.nlmsg_type = RTM_GETLINK;
    924   request.info.ifi_index = index;
    925   request.info.ifi_family = AF_UNSPEC;
    926   send_nlmesg(0, 0, 0, (void*)&request, sizeof(request));
    927   return (filter_nlmesg(display_link_info, argv));
    928 }
    929 
    930 static int iplink(char **argv)
    931 {
    932   int idx;
    933   cmdobj ipcmd, cmdobjlist[] = {linkupdate, link_set, link_show};
    934   struct arglist cmd_objectlist[] = {{"add", 0}, {"delete", 0},
    935     {"set", 1}, {"show", 2}, {"list", 2}, {"lst", 2}, {NULL,-1}};
    936 
    937   if (!*argv) idx = 2;
    938   else if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1)
    939     help_exit(0);
    940   ipcmd = cmdobjlist[idx];
    941   return ipcmd(argv);
    942 }
    943 
    944 // ===========================================================================
    945 // Code for ip addr.
    946 // ===========================================================================
    947 
    948 static int print_addrinfo(struct nlmsghdr *h, int flag_l)
    949 {
    950   struct rtattr *rta, *rta_tb[IFA_MAX+1] = {0,};
    951   char *family = toybuf, *scope = toybuf+256, *label = toybuf+512,
    952        *brd = toybuf+768, *peer = toybuf+1024, *any = toybuf+1280,
    953        lbuf[INET6_ADDRSTRLEN] = {0,}, lbuf_ifa[INET6_ADDRSTRLEN] = {0,};
    954   struct ifaddrmsg *ifa = NLMSG_DATA(h);
    955   int len;
    956 
    957   if ((len = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa))) < 0) {
    958     error_msg("wrong nlmsg len %d", len);
    959     return 0;
    960   }
    961 
    962   for (rta = IFA_RTA(ifa); RTA_OK(rta, len); rta=RTA_NEXT(rta, len))
    963     if (rta->rta_type <= IFA_MAX) rta_tb[rta->rta_type] = rta;
    964 
    965   if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
    966   if (!rta_tb[IFA_ADDRESS]) rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
    967   if ((addrinfo.scope ^ ifa->ifa_scope)&addrinfo.scopemask) return 0;
    968   if (addrinfo.ifindex && addrinfo.ifindex != ifa->ifa_index) return 0;
    969 
    970   if (flag_l && addrinfo.label && ifa->ifa_family == AF_INET6) return 0;
    971   if ((rta_tb[IFA_LABEL])) {
    972     xstrncpy(label, RTA_DATA(rta_tb[IFA_LABEL]), 256);
    973     label[255] = '\0';
    974     if (addrinfo.label && fnmatch(addrinfo.label, label, 0))
    975       return 0;
    976   }
    977 
    978   if (TT.flush) {
    979     if (ifa->ifa_index == addrinfo.ifindex) {
    980       h->nlmsg_type = RTM_DELADDR;
    981       h->nlmsg_flags = NLM_F_REQUEST;
    982       send_nlmesg(RTM_DELADDR, 0, 0, h, h->nlmsg_len);
    983       return 0;
    984     }
    985   }
    986 
    987   if (h->nlmsg_type == RTM_DELADDR) printf("Deleted ");
    988 
    989   if (TT.singleline) {
    990     if (!if_indextoname(ifa->ifa_index, lbuf)) perror_exit(NULL);
    991     printf("%u: %s",ifa->ifa_index, lbuf);
    992   }
    993 
    994   sprintf(scope, " scope %s ", namefromRPDB(ifa->ifa_scope, RPDB_rtscopes));
    995 
    996   if (ifa->ifa_family == AF_INET) strcpy(family, "    inet ");
    997   else if (ifa->ifa_family == AF_INET6) strcpy(family, "    inet6 ");
    998   else sprintf(family, "    family %d", ifa->ifa_family);
    999 
   1000   if (rta_tb[IFA_LOCAL]) {
   1001     if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_LOCAL]),
   1002           lbuf, sizeof(lbuf))) perror_exit("inet");
   1003 
   1004     sprintf(family+strlen(family), lbuf, strlen(lbuf));
   1005     if (!rta_tb[IFA_ADDRESS] || !memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]),
   1006           RTA_DATA(rta_tb[IFA_LOCAL]), 4))
   1007       sprintf(family+strlen(family), "/%d ", ifa->ifa_prefixlen);
   1008     else {
   1009       if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_ADDRESS]),
   1010             lbuf_ifa, sizeof(lbuf_ifa))) perror_exit("inet");
   1011       sprintf(peer, " peer %s/%d ", lbuf_ifa, ifa->ifa_prefixlen);
   1012     }
   1013   }
   1014 
   1015   if (addrinfo.to && strcmp(addrinfo.addr, lbuf))
   1016     return 0;
   1017 
   1018   if (rta_tb[IFA_BROADCAST]) {
   1019     if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_BROADCAST]),
   1020           lbuf, sizeof(lbuf))) perror_exit("inet");
   1021     sprintf(brd, " brd %s", lbuf);
   1022   }else brd = "";
   1023 
   1024   if (rta_tb[IFA_ANYCAST]) {
   1025     if (!inet_ntop(ifa->ifa_family, RTA_DATA(rta_tb[IFA_ANYCAST]),
   1026           lbuf, sizeof(lbuf))) perror_exit("inet");
   1027     sprintf(any, " any %s", lbuf);
   1028   }
   1029 
   1030   if (ifa->ifa_family == AF_INET)
   1031     printf("%s%s%s%s%s %c", family, brd, peer, scope, label,
   1032         (TT.singleline? '\0' : '\n'));
   1033   else printf("%s%s %c", family, scope, (TT.singleline? '\0' : '\n'));
   1034   if (TT.singleline && (ifa->ifa_family == AF_INET)) xputc('\n');
   1035 
   1036   if (rta_tb[IFA_CACHEINFO]) {
   1037     struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
   1038 
   1039     printf("%c      valid_lft ", (TT.singleline? '\\' : '\0'));
   1040     if (ci->ifa_valid ==  0xFFFFFFFFU) printf("forever");
   1041     else printf("%usec", ci->ifa_valid);
   1042     printf(" preferred_lft ");
   1043     if (ci->ifa_prefered ==  0xFFFFFFFFU) printf("forever");
   1044     else printf("%dsec", ci->ifa_prefered);
   1045     xputc('\n');
   1046   }
   1047   return 0;
   1048 }
   1049 
   1050 static int ipaddrupdate(char **argv)
   1051 {
   1052   int length, cmd = !memcmp("add", argv[-1], strlen(argv[-1]))
   1053     ? RTM_NEWADDR: RTM_DELADDR;
   1054   int idx = 0,length_brd = 0, length_peer = 0,length_any = 0,length_local = 0,
   1055       scoped = 0;
   1056   char *dev = NULL,*label = NULL, reply[8192];
   1057 
   1058   struct nlmsghdr *addr_ptr = NULL;
   1059   struct nlmsgerr *err = NULL;
   1060   struct arglist cmd_objectlist[] = {{"dev",0}, {"peer", 1},
   1061     {"remote", 2}, {"broadcast", 3}, {"brd", 4}, {"label", 5},
   1062     {"anycast", 6},{"scope", 7}, {"local", 8}, {NULL, -1}};
   1063   struct {
   1064     struct nlmsghdr nlm;
   1065     struct ifaddrmsg ifadd;
   1066     char buf[256];
   1067   } req;
   1068   typedef struct {
   1069     int family, bytelen, bitlen;
   1070     __u32  data[8];
   1071   } option_data;
   1072   option_data local;
   1073 
   1074   memset(&req, 0, sizeof(req));
   1075   req.nlm.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
   1076   req.nlm.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
   1077   req.nlm.nlmsg_type = cmd;
   1078   req.ifadd.ifa_family = TT.addressfamily;
   1079 
   1080   while (*argv) {
   1081     idx = substring_to_idx(*argv, cmd_objectlist);
   1082     if (idx >= 0)
   1083       if (!*++argv)
   1084         error_exit("Incomplete Command line");
   1085     switch(idx) {
   1086       case 0:
   1087         dev = *argv;
   1088         break;
   1089       case 1:
   1090       case 2:
   1091         {
   1092           uint32_t addr[4] = {0,}, netmask = 0;
   1093           uint8_t len = 0;
   1094           parse_prefix(addr, &netmask, &len, *argv,
   1095               req.ifadd.ifa_family);
   1096           if (len)
   1097             req.ifadd.ifa_family = ((len == 4) ? AF_INET : AF_INET6);
   1098           length_peer = len;
   1099           add_string_to_rtattr(&req.nlm, sizeof(req),
   1100               IFA_ADDRESS, addr, len);
   1101           req.ifadd.ifa_prefixlen = netmask;
   1102         }
   1103         break;
   1104       case 3:
   1105       case 4:
   1106         if (*argv[0] == '+') {
   1107           length_brd = -1;
   1108         } else if (*argv[0] == '-') {
   1109           length_brd = -2;
   1110         } else {
   1111           uint32_t addr[4] = {0,};
   1112           uint8_t af = AF_UNSPEC;
   1113 
   1114           if (get_prefix(addr, &af, *argv, req.ifadd.ifa_family))
   1115             error_exit("Invalid prefix");
   1116 
   1117           length_brd = ((af == AF_INET6) ? 16 : 4);
   1118           if (req.ifadd.ifa_family == AF_UNSPEC)
   1119             req.ifadd.ifa_family = af;
   1120           add_string_to_rtattr(&req.nlm, sizeof(req),
   1121               IFA_BROADCAST, &addr, length_brd);
   1122         }
   1123         break;
   1124       case 5:
   1125         label = *argv;
   1126         add_string_to_rtattr(&req.nlm, sizeof(req),
   1127             IFA_LABEL, label, strlen(label) + 1);
   1128         break;
   1129       case 6:
   1130         {
   1131           uint32_t addr[4] = {0,};
   1132           uint8_t af = AF_UNSPEC;
   1133 
   1134           if (get_prefix(addr, &af, *argv, req.ifadd.ifa_family))
   1135             error_exit("Invalid prefix");
   1136           length_any = ((af == AF_INET6) ? 16 : 4);
   1137           if (req.ifadd.ifa_family == AF_UNSPEC)
   1138             req.ifadd.ifa_family = af;
   1139           add_string_to_rtattr(&req.nlm, sizeof(req),
   1140               IFA_ANYCAST, &addr, length_any);
   1141         }
   1142         break;
   1143       case 7:
   1144         {
   1145           int scope = idxfromRPDB(*argv, RPDB_rtscopes);
   1146           if (scope < 0) error_exit("wrong scope '%s'", *argv);
   1147           req.ifadd.ifa_scope = scope;
   1148           scoped = 1;
   1149         }
   1150         break;
   1151       default:
   1152         {
   1153           //local is by default
   1154           uint32_t addr[8] = {0,}, netmask = 0;
   1155           uint8_t len = 0;
   1156 
   1157           parse_prefix(addr, &netmask, &len, *argv,
   1158               req.ifadd.ifa_family);
   1159           if (len)
   1160             req.ifadd.ifa_family = ((len == 4) ? AF_INET : AF_INET6);
   1161           length_local = len;
   1162           local.bitlen = netmask;
   1163           local.bytelen = len;
   1164           memcpy(local.data, addr, sizeof(local.data));
   1165           local.family = req.ifadd.ifa_family;
   1166           add_string_to_rtattr(&req.nlm, sizeof(req),
   1167               IFA_LOCAL, &local.data, local.bytelen);
   1168         }
   1169         break;
   1170     }
   1171     argv++;
   1172   }
   1173   if (!dev) error_exit("need \"dev \" argument");
   1174   if (label && strncmp(dev, label, strlen(dev)) != 0)
   1175     error_exit("\"dev\" (%s) must match \"label\" (%s)", dev, label);
   1176 
   1177   if (length_peer == 0 && length_local && cmd != RTM_DELADDR){
   1178     add_string_to_rtattr(&req.nlm, sizeof(req),
   1179         IFA_ADDRESS, &local.data, local.bytelen);
   1180   }
   1181 
   1182   if (length_brd < 0 && cmd != RTM_DELADDR){
   1183     int i;
   1184 
   1185     if (req.ifadd.ifa_family != AF_INET)
   1186       error_exit("broadcast can be set only for IPv4 addresses");
   1187 
   1188     if (local.bitlen <= 30) {
   1189       for (i = 31; i >= local.bitlen; i--) {
   1190         if (length_brd == -1)
   1191           local.data[0] |= htonl(1<<(31-i));
   1192         else
   1193           local.data[0] &= ~htonl(1<<(31-i));
   1194       }
   1195       add_string_to_rtattr(&req.nlm, sizeof(req),
   1196           IFA_BROADCAST, &local.data, local.bytelen);
   1197       length_brd = local.bytelen;
   1198     }
   1199   }
   1200   if (req.ifadd.ifa_prefixlen == 0)
   1201     req.ifadd.ifa_prefixlen = local.bitlen;
   1202   if (!scoped && (cmd != RTM_DELADDR) && (local.family == AF_INET)
   1203       && (local.bytelen >= 1 && *(uint8_t*)&local.data == 127))
   1204     req.ifadd.ifa_scope = RT_SCOPE_HOST;
   1205   req.ifadd.ifa_index = get_ifaceindex(dev, 1);
   1206 
   1207   send_nlmesg(RTM_NEWADDR, 0, AF_UNSPEC, (void *)&req, req.nlm.nlmsg_len);
   1208   length = recv(TT.sockfd, reply, sizeof(reply), 0);
   1209   addr_ptr = (struct nlmsghdr *) reply;
   1210   for (; NLMSG_OK(addr_ptr, length); addr_ptr = NLMSG_NEXT(addr_ptr, length)) {
   1211     if (addr_ptr->nlmsg_type == NLMSG_DONE)
   1212       return 1;
   1213     if (addr_ptr->nlmsg_type == NLMSG_ERROR)
   1214       err = (struct nlmsgerr*) NLMSG_DATA(addr_ptr);
   1215     if (err && err->error) {
   1216       errno = -err->error;
   1217       perror_exit("RTNETLINK answers:");
   1218     }
   1219   }
   1220   return 0;
   1221 }
   1222 
   1223 static int ipaddr_listflush(char **argv)
   1224 {
   1225   int idx; uint32_t netmask = 0, found = 0;
   1226   char *tmp = NULL, *name = NULL;
   1227   struct double_list *dlist;
   1228   struct arglist cmd_objectlist[] = {{"to", 0}, {"scope", 1}, {"up", 2},
   1229     {"label", 3}, {"dev", 4}, {NULL, -1}};
   1230 
   1231   TT.flush = *argv[-1] == 'f' ? 1 : 0;
   1232   memset(&addrinfo, 0, sizeof(addrinfo));
   1233 
   1234   if (TT.flush) {
   1235     if (!*argv)
   1236       error_exit("Incomplete command for \"flush\"");
   1237     if (TT.addressfamily == AF_PACKET)
   1238       error_exit("Can't flush link Addressess");
   1239   }
   1240   addrinfo.scope = -1;
   1241   while (*argv) {
   1242     switch (idx = substring_to_idx(*argv, cmd_objectlist)) {
   1243       case 0:
   1244         {// ADDR_TO
   1245           if (!*++argv) error_exit("Incomplete Command line");
   1246           else if (!strcmp(*argv, "0")) return 0;
   1247           uint32_t addr[4] = {0,};
   1248           uint8_t len = 0;
   1249 
   1250           addrinfo.to = 1;
   1251           parse_prefix(addr, &netmask, &len, *argv, TT.addressfamily);
   1252           if (len)
   1253             TT.addressfamily = ((len == 4) ? AF_INET : AF_INET6);
   1254           addrinfo.addr  = strtok(*argv, "/");
   1255         }
   1256         break;
   1257       case 1: // ADDR_SCOPE
   1258         {
   1259           int scope = 0;
   1260           if (!*++argv) error_exit("Incomplete Command line");
   1261           name = *argv;
   1262 
   1263           addrinfo.scopemask = -1;
   1264           if (isdigit(**argv)) {
   1265             int idx = atolx(*argv);
   1266 
   1267             name = xstrdup(namefromRPDB(idx, RPDB_rtscopes));
   1268           }
   1269           if ((scope = idxfromRPDB(name, RPDB_rtscopes)) < 0) {
   1270             if (strcmp(name, "all"))
   1271               error_exit("wrong scope '%s'", name);
   1272             scope = RT_SCOPE_NOWHERE;
   1273             addrinfo.scopemask = 0;
   1274           }
   1275 
   1276           if (isdigit(**argv))
   1277             free(name);
   1278           addrinfo.scope = scope;
   1279         }
   1280         break;
   1281       case 2: // ADDR_UP
   1282         addrinfo.up = 1;
   1283         break;
   1284       case 3: // ADDR_LABEL
   1285         if (!*++argv) error_exit("Incomplete Command line");
   1286         addrinfo.label = *argv;
   1287         break;
   1288       case 4: // ADDR_DEV
   1289         if (!*++argv) error_exit("Incomplete Command line");
   1290 
   1291       default:
   1292         if (TT.filter_dev)
   1293           error_exit("Either \"dev\" is duplicate or %s is garbage",
   1294               *argv);
   1295         TT.filter_dev = *argv;
   1296         break;
   1297     }
   1298     argv++;
   1299   }
   1300 
   1301   link_show(&tmp);
   1302   while ( linfo && (dlist = dlist_pop(&linfo))){
   1303     struct linkdata *tmp  = (struct linkdata*) dlist;
   1304     char *temp = &tmp->iface[0];
   1305 
   1306     if (TT.filter_dev && strcmp(TT.filter_dev, temp))
   1307       continue;
   1308     found = 1;
   1309     if (TT.flush && addrinfo.label) ipaddr_print( tmp, 0);
   1310     if (addrinfo.up && !(tmp->flags & IFF_UP)){
   1311       ipaddr_print(tmp, 0);
   1312       continue;
   1313     }
   1314     if (addrinfo.label){
   1315       if ( fnmatch(addrinfo.label, temp, 0)) {
   1316         ipaddr_print(tmp, 1);
   1317         continue;
   1318       }
   1319     }
   1320     if (!TT.addressfamily && ! TT.flush ) print_link_output(tmp);
   1321 
   1322     ipaddr_print(tmp, 0);
   1323     free(tmp);
   1324   }
   1325   if (TT.filter_dev && !found)
   1326     error_exit("Device \"%s\" doesn't exist. \n", TT.filter_dev);
   1327   return 0;
   1328 }
   1329 
   1330 static int ipaddr_print( struct linkdata *link, int flag_l)
   1331 {
   1332   struct nlmsghdr *addr_ptr;
   1333   int ip_match = 0;
   1334 
   1335   addrinfo.ifindex = link->iface_idx;
   1336   send_nlmesg(RTM_GETADDR, NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,
   1337       AF_UNSPEC, NULL, 0);
   1338   if (TT.addressfamily == AF_PACKET) print_link_output(link);
   1339 
   1340   if (addrinfo.label){
   1341     char *col = strchr(addrinfo.label, ':');
   1342     if (!col && (fnmatch(addrinfo.label, &link->iface[0], 0)))
   1343       return 0;
   1344   }
   1345 
   1346   while (1){
   1347     int len = recv(TT.sockfd, TT.gbuf, sizeof(TT.gbuf), 0);
   1348     addr_ptr = (struct nlmsghdr *)TT.gbuf;
   1349     struct ifaddrmsg *addressInfo = NLMSG_DATA(addr_ptr);
   1350     char lbuf[INET6_ADDRSTRLEN];
   1351     struct rtattr *rta, *rta_tb[IFA_MAX+1] = {0,};
   1352 
   1353     int len1 = addr_ptr->nlmsg_len - NLMSG_LENGTH(sizeof(*addressInfo));
   1354     if (len1 > 0) {
   1355       for (; NLMSG_OK(addr_ptr, len); addr_ptr = NLMSG_NEXT(addr_ptr, len)) {
   1356         addressInfo = NLMSG_DATA(addr_ptr);
   1357         if (TT.addressfamily && TT.addressfamily != addressInfo->ifa_family)
   1358           continue;
   1359         if (addrinfo.ifindex && addrinfo.ifindex != addressInfo->ifa_index)
   1360           continue;
   1361 
   1362         if (addrinfo.to) {
   1363           memset(rta_tb, 0, sizeof(rta_tb));
   1364           int rt_len = IFA_PAYLOAD(addr_ptr);
   1365           for (rta = IFA_RTA(addressInfo); RTA_OK(rta, rt_len); rta=RTA_NEXT(rta, rt_len)) {
   1366             if (rta->rta_type <= IFA_MAX) rta_tb[rta->rta_type] = rta;
   1367           }
   1368           if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
   1369           if (rta_tb[IFA_LOCAL]) {
   1370             if (!inet_ntop(TT.addressfamily, RTA_DATA(rta_tb[IFA_LOCAL]),
   1371                   lbuf, sizeof(lbuf))) perror_exit("inet");
   1372             if (strcmp(addrinfo.addr, lbuf))
   1373               continue;
   1374             ip_match=1;
   1375           }
   1376           if (!ip_match)
   1377             continue;
   1378         }
   1379 
   1380         if (!TT.flush){
   1381           if (addrinfo.scope != -1 && TT.addressfamily && TT.addressfamily ==
   1382               addressInfo->ifa_family &&
   1383               (addrinfo.ifindex == addressInfo->ifa_index)) {
   1384             if ((addrinfo.scope ^ addressInfo->ifa_scope) & addrinfo.scopemask)
   1385               continue;
   1386             else if (addrinfo.up && (link->flags & IFF_UP))
   1387               print_link_output(link);
   1388             else if (!addrinfo.up) print_link_output(link);
   1389           }
   1390           if (TT.addressfamily &&
   1391               (addrinfo.ifindex == addressInfo->ifa_index) &&
   1392               (addrinfo.scope == -1)){
   1393             if (addrinfo.up && (link->flags & IFF_UP))
   1394               print_link_output(link);
   1395             else if (!addrinfo.up) print_link_output(link);
   1396           }
   1397         }
   1398 
   1399         for (; NLMSG_OK(addr_ptr, len); addr_ptr = NLMSG_NEXT(addr_ptr, len)) {
   1400           if ((addr_ptr->nlmsg_type == RTM_NEWADDR))
   1401             print_addrinfo(addr_ptr, flag_l);
   1402           if ((addr_ptr->nlmsg_type == NLMSG_DONE) ||
   1403               (addr_ptr->nlmsg_type == NLMSG_ERROR) ||
   1404               (TT.flush && addrinfo.to))
   1405             goto ret_stop;
   1406         }
   1407         if ((addr_ptr->nlmsg_type == NLMSG_DONE) ||
   1408             (addr_ptr->nlmsg_type == NLMSG_ERROR))
   1409           break;
   1410       }
   1411     }
   1412     else
   1413       return 0;
   1414   }
   1415 
   1416 ret_stop:
   1417   return 0;
   1418 }
   1419 
   1420 static int ipaddr(char **argv)
   1421 {
   1422   int    idx;
   1423   cmdobj ipcmd, cmdobjlist[] = {ipaddrupdate, ipaddr_listflush};
   1424   struct arglist cmd_objectlist[] = { {"add", 0}, {"delete", 0},
   1425     {"list", 1},{"show", 1},{"lst", 1}, {"flush", 1}, {NULL,-1}};
   1426 
   1427   TT.is_addr++;
   1428   if (!*argv) idx = 1;
   1429   else if ((idx = substring_to_idx(*argv++, cmd_objectlist)) == -1)
   1430     help_exit(0);
   1431 
   1432   ipcmd = cmdobjlist[idx];
   1433   return ipcmd(argv);
   1434 }
   1435 
   1436 // ===========================================================================
   1437 // code for ip route
   1438 // ===========================================================================
   1439 struct I_data {
   1440   unsigned char family;
   1441   uint32_t addr[8] , netmask ;
   1442   uint8_t len ;
   1443 };
   1444 
   1445 struct {
   1446   int tb,idev,odev,proto;
   1447   struct I_data rvia, rdst, mdst, rsrc, msrc;
   1448 } gfilter;
   1449 
   1450 static void show_iproute_help(void)
   1451 {
   1452   char *errmsg = "\n\n" \
   1453        "iproute { list | flush } SELECTOR\n" \
   1454        "iproute get ADDRESS [from ADDRESS iif STRING]\n" \
   1455        "	[oif STRING]\n" \
   1456        "iproute { add | del | change | append | replace | test } ROUTE\n" \
   1457        "	SELECTOR := [root PREFIX] [match PREFIX] [proto RTPROTO]\n" \
   1458        "	ROUTE := [TYPE] PREFIX [proto RTPROTO] [metric METRIC]";
   1459 
   1460   error_exit(errmsg);
   1461 }
   1462 
   1463 static int display_route_info(struct nlmsghdr *mhdr, char **argv)
   1464 {
   1465   char *inetval = NULL, out[1024] = {0};
   1466   struct rtmsg *msg = NLMSG_DATA(mhdr);
   1467   struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
   1468   int32_t tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
   1469   int hlen = ((msg->rtm_family == AF_INET) ? 32
   1470       : ((msg->rtm_family == AF_INET6) ? 128 : -1));
   1471 
   1472   if (mhdr->nlmsg_type != RTM_NEWROUTE) return 0;
   1473   if (msglen < 0) return 1;
   1474 
   1475   if (msg->rtm_family == AF_INET6) {
   1476     if (gfilter.tb) {
   1477       if (gfilter.tb < 0) {
   1478         if (!(msg->rtm_flags & RTM_F_CLONED)) return 0;
   1479       } else {
   1480         if (msg->rtm_flags & RTM_F_CLONED) return 0;
   1481         if (gfilter.tb == RT_TABLE_LOCAL && msg->rtm_type != RTN_LOCAL)
   1482           return 0;
   1483         else if (gfilter.tb == RT_TABLE_MAIN && msg->rtm_type == RTN_LOCAL)
   1484           return 0;
   1485       }
   1486     }
   1487   }
   1488   else if (gfilter.tb > 0 && gfilter.tb != msg->rtm_table) return 0;
   1489 
   1490   if (gfilter.proto && (msg->rtm_protocol != gfilter.proto)) return 0;
   1491 
   1492 
   1493   if (gfilter.rdst.family && (msg->rtm_family != gfilter.rdst.family ||
   1494         gfilter.rdst.netmask > msg->rtm_dst_len)) return 0;
   1495   if (gfilter.mdst.family && (msg->rtm_family != gfilter.mdst.family
   1496         || (gfilter.mdst.netmask < msg->rtm_dst_len))) return 0;
   1497   if (gfilter.rsrc.family && (msg->rtm_family != gfilter.rsrc.family
   1498         || gfilter.rsrc.netmask > msg->rtm_src_len)) return 0;
   1499   if (gfilter.msrc.family && (msg->rtm_family != gfilter.msrc.family
   1500         || (gfilter.msrc.netmask < msg->rtm_src_len))) return 0;
   1501   tvar = msglen;
   1502 
   1503   for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
   1504     if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
   1505 
   1506   if (msg->rtm_type != RTN_UNICAST)
   1507     sprintf(out,"%s%s ", out,rtmtype_idx2str(msg->rtm_type));
   1508   if (attr[RTA_DST]) {
   1509     inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_DST]),
   1510         toybuf, sizeof(toybuf));
   1511     if (gfilter.rdst.family &&
   1512         memcmp(RTA_DATA(attr[RTA_DST]), &gfilter.rdst.addr, gfilter.rdst.len))
   1513       return 0;
   1514     if (gfilter.mdst.family &&
   1515         memcmp(RTA_DATA(attr[RTA_DST]), &gfilter.mdst.addr, gfilter.mdst.len))
   1516       return 0;
   1517     sprintf(out,"%s%s",out,inetval);
   1518   }
   1519   if (msg->rtm_dst_len) sprintf(out,"%s/%d ", out,msg->rtm_dst_len);
   1520   else sprintf(out,"%s%s",out,"default ");
   1521 
   1522   if (attr[RTA_SRC]) {
   1523     inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_SRC]),
   1524         toybuf, sizeof(toybuf));
   1525     if (gfilter.rsrc.family &&
   1526         memcmp(RTA_DATA(attr[RTA_SRC]), &gfilter.rsrc.addr, gfilter.rsrc.len))
   1527       return 0;
   1528     if (gfilter.msrc.family &&
   1529         memcmp(RTA_DATA(attr[RTA_SRC]), &gfilter.msrc.addr, gfilter.msrc.len))
   1530       return 0;
   1531     sprintf(out, "%s from %s", out, inetval);
   1532   }
   1533   if (msg->rtm_src_len) sprintf(out, "%s/%d ", out, msg->rtm_src_len);
   1534 
   1535   if (attr[RTA_GATEWAY]) {
   1536     inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_GATEWAY]),
   1537         toybuf, sizeof(toybuf));
   1538     sprintf(out, "%s via %s ", out, inetval);
   1539   }
   1540   if (gfilter.rvia.family) {
   1541     char tmp[256];
   1542 
   1543     if (!attr[RTA_GATEWAY]) return 0;
   1544     if (strcmp((char *)inet_ntop(msg->rtm_family, gfilter.rvia.addr,
   1545             tmp, sizeof(tmp)), inetval)) return 0;
   1546   }
   1547 
   1548   if (gfilter.odev != 0) if (!attr[RTA_OIF]) return 0;
   1549   if (attr[RTA_OIF]) {
   1550     if (gfilter.odev !=0 && gfilter.odev != *(int*)RTA_DATA(attr[RTA_OIF]))
   1551       return 0;
   1552     sprintf(out, "%s dev %s ", out,
   1553         if_indextoname(*(int*)RTA_DATA(attr[RTA_OIF]), toybuf));
   1554   }
   1555 
   1556   if (attr[RTA_PREFSRC] && hlen) {
   1557     inetval = (char *)inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_PREFSRC]),
   1558         toybuf, sizeof(toybuf));
   1559     sprintf(out, "%s src %s ", out, inetval);
   1560   }
   1561   if (attr[RTA_PRIORITY])
   1562     sprintf(out, "%s metric %d ", out, *(uint32_t*)RTA_DATA(attr[RTA_PRIORITY]));
   1563   if (msg->rtm_family == AF_INET6) {
   1564     struct rta_cacheinfo *ci = NULL;
   1565     if (attr[RTA_CACHEINFO]) ci = RTA_DATA(attr[RTA_CACHEINFO]);
   1566     if ((msg->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
   1567       if (msg->rtm_flags & RTM_F_CLONED) sprintf(out, "%s%s    cache ",
   1568           out, (!TT.singleline ? "\n" : " "));
   1569       if (ci && ci->rta_expires) {
   1570         int hz = 0;
   1571         FILE *fp = xfopen("/proc/net/psched","r");
   1572 
   1573         if (fp) {
   1574           unsigned int nom, denom;
   1575 
   1576           if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
   1577             if (nom == 1000000)
   1578               hz = denom;
   1579           fclose(fp);
   1580         }
   1581         if (!hz) hz = sysconf(_SC_CLK_TCK);
   1582         sprintf(out, "%s expires %dsec", out, ci->rta_expires /hz);
   1583       }
   1584       if (ci && ci->rta_error) sprintf(out, "%s error %d", out, ci->rta_error);
   1585     }
   1586     else if (ci && ci->rta_error)
   1587       sprintf(out, "%s error %d", out, ci->rta_error);
   1588   }
   1589   if (attr[RTA_IIF] && !gfilter.idev)
   1590     sprintf(out, "%s iif %s", out,
   1591         if_indextoname(*(int*)RTA_DATA(attr[RTA_IIF]), toybuf));
   1592   if (TT.flush || (TT.connected && !TT.from_ok))
   1593     memcpy(toybuf, (void*)mhdr,mhdr->nlmsg_len);
   1594 
   1595   if (TT.flush) {
   1596     int sockfd = 0;
   1597     struct nlmsghdr* mhdr = (struct nlmsghdr*)toybuf;
   1598     struct rtmsg *msg = NLMSG_DATA(mhdr);
   1599     int tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
   1600     struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
   1601 
   1602     tvar = msglen;
   1603     for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
   1604       if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
   1605 
   1606     if (msg->rtm_family == AF_INET6
   1607         && !msg->rtm_dst_len
   1608         && msg->rtm_type == RTN_UNREACHABLE
   1609         && attr[RTA_PRIORITY]
   1610         && *(int*)RTA_DATA(attr[RTA_PRIORITY]) == -1)
   1611       return 0;
   1612 
   1613     mhdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
   1614     mhdr->nlmsg_type  = RTM_DELROUTE;
   1615     mhdr->nlmsg_pid = 0;
   1616     sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
   1617     if (send(sockfd , (void*)mhdr, mhdr->nlmsg_len, 0) < 0)
   1618       perror_exit("Unable to send data on socket.");
   1619 
   1620     while (1) {
   1621       struct nlmsghdr *mhdr;
   1622       int msglen = recv(sockfd, toybuf, sizeof(toybuf), 0);
   1623 
   1624       if ((msglen < 0) && (errno == EINTR || errno == EAGAIN)) continue;
   1625       else if (msglen < 0) {
   1626         error_msg("netlink receive error %s", strerror(errno));
   1627         xclose(sockfd);
   1628         return 1;
   1629       } else if (!msglen) {
   1630         error_msg("EOF on netlink");
   1631         xclose(sockfd);
   1632         return 1;
   1633       }
   1634 
   1635       for (mhdr = (struct nlmsghdr*)toybuf; NLMSG_OK(mhdr, msglen);
   1636           mhdr = NLMSG_NEXT(mhdr, msglen)) {
   1637         switch (mhdr->nlmsg_type) {
   1638           case NLMSG_DONE:
   1639             xclose(sockfd);
   1640             return 0;
   1641           case NLMSG_ERROR:
   1642             {
   1643               struct nlmsgerr *merr = (struct nlmsgerr*)NLMSG_DATA(mhdr);
   1644 
   1645               if (merr->error == 0)  { xclose(sockfd); return 0; }
   1646               if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
   1647                 error_msg("ERROR truncated");
   1648               else {
   1649                 errno = -merr->error;
   1650                 perror_msg("RTNETLINK answers");
   1651               }
   1652               xclose(sockfd);
   1653               return 1;
   1654             }
   1655           default:
   1656             break;
   1657         }
   1658       } // End of for loop.
   1659     } // End of while loop.
   1660 
   1661     xclose(sockfd);
   1662   } else printf("%s\n",out);
   1663   return 0;
   1664 }
   1665 
   1666 static int route_get(char **argv)
   1667 {
   1668   int idx, flag;
   1669   struct arglist cmd_objectlist[] = {{"from", 0}, {"iif", 1}, {"oif", 2},
   1670     {"dev", 3}, {"notify", 4}, {"connected", 5}, {"to", 6}, {NULL, -1}};
   1671   char *idev = NULL, *odev = NULL;
   1672   struct {
   1673     struct nlmsghdr mhdr;
   1674     struct rtmsg msg;
   1675     char buf[1024];
   1676   } request;
   1677 
   1678   memset(&request, 0, sizeof(request));
   1679   request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
   1680   request.mhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
   1681   request.mhdr.nlmsg_type = RTM_GETROUTE;
   1682   request.msg.rtm_family = AF_UNSPEC;
   1683 
   1684   for (; *argv; argv++) {
   1685     switch(idx = substring_to_idx(*argv, cmd_objectlist)) {
   1686       case 0: TT.from_ok = 1; // dst address
   1687       case 6: argv++; //fallthrough
   1688       default:
   1689               {
   1690                 uint32_t addr[8] = {0,}, netmask = 0;
   1691                 uint8_t len = 0;
   1692 
   1693                 if (!*argv) error_exit("'%s': Missing Prefix", argv[-1]);
   1694                 parse_prefix(addr, &netmask, &len, *argv, request.msg.rtm_family);
   1695                 if (len) request.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
   1696                 netmask = (request.msg.rtm_family == AF_INET6) ? 128 : 32;
   1697                 if (!idx) request.msg.rtm_src_len = netmask;
   1698                 else request.msg.rtm_dst_len = netmask;
   1699                 add_string_to_rtattr(&request.mhdr, sizeof(request),
   1700                     (!idx ? RTA_SRC : RTA_DST), addr, len);
   1701                 break;
   1702               }
   1703       case 1:
   1704       case 2:
   1705       case 3:
   1706               if (!*++argv) show_iproute_help();
   1707               if (idx == 1) idev = *argv, flag = RTA_IIF;
   1708               else odev = *argv, flag = RTA_OIF;
   1709               idx = get_ifaceindex(*argv, 1);
   1710               add_string_to_rtattr(&request.mhdr, sizeof(request),
   1711                   flag, (char*)&idx, sizeof(idx));
   1712               break;
   1713       case 4:
   1714               request.msg.rtm_flags |= RTM_F_NOTIFY;
   1715               break;
   1716       case 5:
   1717               TT.connected = 1;
   1718               break;
   1719     }
   1720   }
   1721   if (!request.msg.rtm_dst_len)
   1722     error_exit("need at least destination address");
   1723 
   1724   send_nlmesg(0, 0, 0, &request, sizeof(request));
   1725   filter_nlmesg(display_route_info, NULL);
   1726 
   1727   if (TT.connected && !TT.from_ok) {
   1728     struct nlmsghdr *mhdr = (struct nlmsghdr*)toybuf;
   1729     struct rtmsg *msg = NLMSG_DATA(mhdr);
   1730     int tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
   1731     struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
   1732 
   1733     if (mhdr->nlmsg_type != RTM_NEWROUTE) error_exit("not a route?");
   1734     if (msglen < 0) error_exit("wrong len %d", msglen);
   1735 
   1736     tvar = msglen;
   1737     for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
   1738       if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
   1739 
   1740     if (attr[RTA_PREFSRC]) {
   1741       attr[RTA_PREFSRC]->rta_type = RTA_SRC;
   1742       msg->rtm_src_len = 8*RTA_PAYLOAD(attr[RTA_PREFSRC]);
   1743     } else if (!attr[RTA_SRC]) error_exit("can't connect the route");
   1744 
   1745     if (!odev && attr[RTA_OIF]) attr[RTA_OIF]->rta_type = 0;
   1746     if (attr[RTA_GATEWAY]) attr[RTA_GATEWAY]->rta_type = 0;
   1747     if (!idev && attr[RTA_IIF]) attr[RTA_IIF]->rta_type = 0;
   1748     mhdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
   1749     mhdr->nlmsg_type  = RTM_GETROUTE;
   1750     mhdr->nlmsg_pid = 0;
   1751     xclose(TT.sockfd);
   1752     TT.sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
   1753     send_nlmesg(0, 0, 0, mhdr, mhdr->nlmsg_len);
   1754     filter_nlmesg(display_route_info, NULL);
   1755   }
   1756   return 0;
   1757 }
   1758 
   1759 static int route_show_flush(char **argv)
   1760 {
   1761   struct arglist cmd_objectlist[] = {{"protocol", 0}, {"dev", 1}, {"oif", 2},
   1762     {"iif", 3}, {"via", 4}, {"table", 5}, {"cache", 6}, {"from", 7},
   1763     {"to", 8}, {"all", 9}, {"root", 10}, {"match", 11}, {"exact", 12},
   1764     {"main", 13}, {NULL,-1}};
   1765   int family = TT.addressfamily, idx;
   1766   struct {
   1767     struct nlmsghdr mhdr;
   1768     struct rtmsg msg;
   1769   } request;
   1770 
   1771   if (*argv[-1] == 'f') TT.flush = 1;
   1772   if (TT.flush && !*argv) show_iproute_help();
   1773 
   1774   gfilter.tb = RT_TABLE_MAIN;
   1775   for (; *argv; argv++) {
   1776     switch (idx = substring_to_idx(*argv, cmd_objectlist)) {
   1777       case 0:
   1778         if (!*++argv) show_iproute_help();
   1779         if ((idx = idxfromRPDB(*argv,RPDB_rtprotos)) < 0)
   1780           error_exit("Invalid argument protocol.");
   1781         gfilter.proto = idx;
   1782         break;
   1783       case 1:
   1784       case 2:
   1785       case 3:
   1786         {
   1787           if (!*++argv) show_iproute_help();
   1788           int dev = get_ifaceindex(*argv, 1);
   1789 
   1790           if (idx == 3) gfilter.idev = dev;
   1791           else gfilter.odev = dev;
   1792         }
   1793         break;
   1794       case 4:
   1795         if (!*++argv) show_iproute_help();
   1796         parse_prefix(gfilter.rvia.addr, &gfilter.rvia.netmask,
   1797             &gfilter.rvia.len, *argv, gfilter.rvia.family);
   1798         if (gfilter.rvia.len)
   1799           gfilter.rvia.family = ((gfilter.rvia.len == 4) ?
   1800               AF_INET : AF_INET6);
   1801         break;
   1802       case 5:
   1803         if (!*++argv) show_iproute_help();
   1804         idx = substring_to_idx(*argv, cmd_objectlist);
   1805         if (idx == 6) gfilter.tb = -1;
   1806         else if (idx == 9) gfilter.tb = 0;
   1807         else if (idx != 13) {
   1808           if ((gfilter.tb = idxfromRPDB(*argv, RPDB_rttables)) < 0)
   1809             error_exit("table %s is invalid.", *argv);
   1810         }
   1811         break;
   1812       case 6:
   1813         gfilter.tb = -1;
   1814         break;
   1815       case 7:
   1816         if (!*++argv) show_iproute_help();
   1817         idx = substring_to_idx(*argv, cmd_objectlist);
   1818         if (idx < 0)  if (!*++argv) show_iproute_help();
   1819         if (idx == 10)
   1820            if (!*++argv) show_iproute_help();
   1821           parse_prefix(gfilter.rsrc.addr, &gfilter.rsrc.netmask,
   1822               &gfilter.rsrc.len, *argv, gfilter.rsrc.family);
   1823         if (gfilter.rsrc.len)
   1824           gfilter.rsrc.family = ((gfilter.rsrc.len == 4) ?
   1825               AF_INET : AF_INET6);
   1826         else {
   1827           if ((idx == 12 ||idx == 11) && !*++argv) show_iproute_help();
   1828           parse_prefix(gfilter.msrc.addr, &gfilter.msrc.netmask,
   1829               &gfilter.msrc.len, *argv, gfilter.msrc.family);
   1830           if (gfilter.msrc.len)
   1831             gfilter.msrc.family = ((gfilter.msrc.len == 4) ?
   1832                 AF_INET : AF_INET6);
   1833           if (idx != 11) gfilter.rsrc = gfilter.msrc;
   1834         }
   1835         break;
   1836       case 8:
   1837         idx = substring_to_idx(*argv, cmd_objectlist);
   1838         if (idx != -1 && !*++argv) show_iproute_help();
   1839       default: // fallthrough
   1840         if (idx == 10) {
   1841           if (!*++argv) show_iproute_help();
   1842           parse_prefix(gfilter.rdst.addr, &gfilter.rdst.netmask,
   1843               &gfilter.rdst.len, *argv, gfilter.rdst.family);
   1844         if (gfilter.rdst.len)
   1845           gfilter.rdst.family = ((gfilter.rdst.len == 4) ?
   1846               AF_INET : AF_INET6);
   1847         }
   1848         else {
   1849           if ((idx == 12 ||idx == 11) && !*++argv) show_iproute_help();
   1850           parse_prefix(gfilter.mdst.addr, &gfilter.mdst.netmask,
   1851               &gfilter.mdst.len, *argv, gfilter.mdst.family);
   1852           if (gfilter.mdst.len)
   1853             gfilter.mdst.family = ((gfilter.mdst.len == 4) ?
   1854                 AF_INET : AF_INET6);
   1855           if (idx != 11) gfilter.rdst = gfilter.mdst;
   1856         }
   1857         break;
   1858     }
   1859   }
   1860   if (family == AF_UNSPEC && gfilter.tb) family = AF_INET;
   1861 
   1862   if (TT.flush) {
   1863     if (gfilter.tb < 0) { // flush table cache
   1864       if (family != AF_INET6) {
   1865         FILE *fp = xfopen("/proc/sys/net/ipv4/route/flush", "w");
   1866 
   1867         if (fwrite("-1",1,2,fp) < 2) error_exit("can't flush routing cache");
   1868         fclose(fp);
   1869       }
   1870       if (family == AF_INET) return 0;
   1871     }
   1872   }
   1873 
   1874   memset(&request, 0, sizeof (request));
   1875   request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof (struct rtmsg));
   1876   request.mhdr.nlmsg_flags = NLM_F_REQUEST;
   1877   request.mhdr.nlmsg_flags |= NLM_F_ROOT | NLM_F_MATCH;
   1878   request.mhdr.nlmsg_type = RTM_GETROUTE;
   1879   request.msg.rtm_family = family;
   1880   if (gfilter.tb < 0) request.msg.rtm_flags = RTM_F_CLONED;
   1881   send_nlmesg(0, 0, 0, (void*)&request, sizeof (request));
   1882   return (filter_nlmesg(display_route_info, NULL));
   1883 }
   1884 
   1885 static int route_update(char **argv, unsigned int route_flags)
   1886 {
   1887   char mxbuf[256], *d = NULL;
   1888   struct rtattr *mxrta = (void*)mxbuf;
   1889   unsigned mxlock = 0, ok = 0;
   1890   int idx;
   1891   uint32_t addr[8] = {0,}, netmask = 0;
   1892   uint8_t len = 0;
   1893 
   1894   struct arglist cmd_objectlist[] = {{"src", 0}, {"via", 1}, {"mtu", 2},
   1895     {"lock", 3}, {"protocol", 4}, {"table", 5}, {"dev", 6}, {"oif", 7},
   1896     {"to", 8}, {"metric", 9}, {NULL,-1}
   1897   };
   1898   enum {
   1899     gtwy_ok = 1,
   1900     dst_ok = 2,
   1901     proto_ok = 4,
   1902     type_ok = 8
   1903   };
   1904   struct {
   1905     struct nlmsghdr hdr;
   1906     struct rtmsg msg;
   1907     char buf[1024];
   1908   } req;
   1909 
   1910   memset(&req, 0, sizeof(req));
   1911   req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
   1912   req.hdr.nlmsg_flags = NLM_F_ACK| NLM_F_REQUEST | route_flags;
   1913   req.hdr.nlmsg_type = TT.route_cmd;
   1914   req.msg.rtm_family = AF_UNSPEC;
   1915   req.msg.rtm_table = RT_TABLE_MAIN;
   1916   req.msg.rtm_scope = RT_SCOPE_NOWHERE;
   1917 
   1918   if (TT.route_cmd != RTM_DELROUTE) {
   1919     req.msg.rtm_protocol = RTPROT_BOOT;
   1920     req.msg.rtm_scope = RT_SCOPE_UNIVERSE;
   1921     req.msg.rtm_type = RTN_UNICAST;
   1922   }
   1923 
   1924   mxrta->rta_type = RTA_METRICS;
   1925   mxrta->rta_len = RTA_LENGTH(0);
   1926 
   1927   for (; *argv; argv++) {
   1928     idx = substring_to_idx(*argv, cmd_objectlist);
   1929     if (!idx) {
   1930       if (!*++argv) show_iproute_help();
   1931       parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
   1932       if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
   1933       add_string_to_rtattr(&req.hdr, sizeof(req), RTA_PREFSRC, addr, len);
   1934     } else if (idx == 1) {
   1935       ok |= gtwy_ok;
   1936       if (!*++argv) show_iproute_help();
   1937       parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
   1938       if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
   1939       add_string_to_rtattr(&req.hdr, sizeof(req),RTA_GATEWAY, addr, len);
   1940     } else if (idx == 2) {
   1941       if (!*++argv) show_iproute_help();
   1942       if (substring_to_idx(*argv, cmd_objectlist ) == 3) {
   1943         mxlock |= (1 << RTAX_MTU);
   1944         if (!*++argv) show_iproute_help();
   1945       }
   1946       idx = atolx(*argv);
   1947       add_string_to_rtattr(&req.hdr, sizeof(req),
   1948           RTAX_MTU, (char*)&idx, sizeof(idx));
   1949     } else if (idx == 4) {
   1950       if (!*++argv) show_iproute_help();
   1951       if ((idx = idxfromRPDB(*argv,RPDB_rtprotos)) < 0)
   1952       error_exit("Invalid argument protocol %s.",*argv);
   1953       req.msg.rtm_protocol = idx;
   1954       ok |= proto_ok;
   1955     } else if (idx == 5) {
   1956       if (!*++argv) show_iproute_help();
   1957       req.msg.rtm_table = idxfromRPDB(*argv, RPDB_rttables);
   1958     } else if (idx == 6 || idx == 7) {
   1959       if (!*++argv) show_iproute_help();
   1960       d = *argv;
   1961     } else if (idx == 9) {
   1962       unsigned long metric;
   1963       unsigned int res;
   1964       char* ptr;
   1965       if (!*++argv) show_iproute_help();
   1966       metric = strtoul(*argv, &ptr, 0);
   1967       if (!(!*ptr && metric <= 0xFFFFFFFFUL))
   1968         error_exit("Invalid argument metric %s.",*argv);
   1969       else
   1970         res = metric;
   1971       add_string_to_rtattr(&req.hdr, sizeof(req),
   1972           RTA_PRIORITY, (char*)&res, sizeof(res));
   1973     } else {
   1974       if (idx == 8)
   1975         if (!*++argv) show_iproute_help();
   1976       idx = substring_to_idx(*argv,rtmtypes);
   1977       if (idx != -1) {
   1978         if (!*++argv) show_iproute_help();
   1979         req.msg.rtm_type = idx;
   1980         ok |= type_ok;
   1981       }
   1982       if (ok & dst_ok) error_exit("Duplicate argument 'to'");
   1983       parse_prefix(addr, &netmask, &len, *argv, req.msg.rtm_family);
   1984       if (len) req.msg.rtm_family = ((len == 4) ? AF_INET : AF_INET6);
   1985       req.msg.rtm_dst_len = netmask;
   1986       ok |= dst_ok;
   1987       if (len) add_string_to_rtattr(&req.hdr, sizeof(req),RTA_DST, addr, len);
   1988     }
   1989   }
   1990 
   1991   if (d) {
   1992     idx = get_ifaceindex(d,1);
   1993     add_string_to_rtattr(&req.hdr, sizeof(req),
   1994         RTA_OIF, (char*)&idx, sizeof(idx));
   1995   }
   1996   if (mxrta->rta_len > RTA_LENGTH(0)) {
   1997     if (mxlock)
   1998       add_string_to_rtattr(&req.hdr, sizeof(req),
   1999           RTAX_LOCK, (char*)&mxlock, sizeof(mxlock));
   2000     add_string_to_rtattr(&req.hdr, sizeof(req),
   2001         RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
   2002   }
   2003 
   2004   if (req.msg.rtm_type == RTN_LOCAL || req.msg.rtm_type == RTN_NAT)
   2005     req.msg.rtm_scope = RT_SCOPE_HOST;
   2006   else if (req.msg.rtm_type == RTN_BROADCAST||req.msg.rtm_type == RTN_MULTICAST
   2007       || req.msg.rtm_type == RTN_ANYCAST)
   2008     req.msg.rtm_scope = RT_SCOPE_LINK;
   2009   else if (req.msg.rtm_type == RTN_UNICAST || req.msg.rtm_type == RTN_UNSPEC) {
   2010     if (TT.route_cmd == RTM_DELROUTE)
   2011       req.msg.rtm_scope = RT_SCOPE_NOWHERE;
   2012     else if (!(ok & gtwy_ok))
   2013       req.msg.rtm_scope = RT_SCOPE_LINK;
   2014   }
   2015   if (req.msg.rtm_family == AF_UNSPEC) req.msg.rtm_family = AF_INET;
   2016   send_nlmesg(0, 0, 0, &req, sizeof(req));
   2017   filter_nlmesg(NULL, NULL);
   2018   return 0;
   2019 }
   2020 
   2021 static int iproute(char **argv)
   2022 {
   2023   int idx = 1;
   2024   struct arglist cmd_objectlist1[] = {{"add", 0}, {"append", 1},{"change", 2},
   2025     {"chg", 3},{"delete",4}, {"get", 5}, {"list", 6}, {"show", 7},
   2026     {"prepend", 8},{"replace", 9},{"test", 10}, {"flush", 11},{NULL,-1}};
   2027 
   2028   TT.route_cmd = RTM_NEWROUTE;
   2029   switch (idx = substring_to_idx(*argv , cmd_objectlist1)) {
   2030     case 0: // add
   2031       return route_update(++argv , NLM_F_CREATE|NLM_F_EXCL);
   2032     case 1: // append
   2033       return route_update(++argv , NLM_F_CREATE|NLM_F_APPEND);
   2034     case 2: // change
   2035     case 3: // chg
   2036       return route_update(++argv , NLM_F_REPLACE);
   2037     case 4: // delete
   2038       TT.route_cmd = RTM_DELROUTE;
   2039       return route_update(++argv , RTM_DELROUTE);
   2040     case 5:
   2041       return route_get(++argv);
   2042     case 6:
   2043     case 7:
   2044       return route_show_flush(++argv);
   2045     case 8: // prepend
   2046       return route_update(++argv , NLM_F_CREATE);
   2047     case 9: // replace
   2048       return route_update(++argv ,  NLM_F_CREATE|NLM_F_REPLACE);
   2049     case 10: // test
   2050       return route_update(++argv , NLM_F_EXCL);
   2051     case 11: // flush
   2052       return route_show_flush(++argv);
   2053     default:
   2054       if (!*argv) return route_show_flush(argv);
   2055       else show_iproute_help();
   2056   }
   2057   return 0; // non reachable code.
   2058 }
   2059 
   2060 
   2061 // ===========================================================================
   2062 // code for ip rule.
   2063 // ===========================================================================
   2064 static void show_iprule_help(void)
   2065 {
   2066   char *errmsg = "usage: ip rule [ list | add | del ] SELECTOR ACTION\n"
   2067     "SELECTOR := [ from PREFIX ] [ to PREFIX ] [pref NUMBER] [ tos TOS ]\n"
   2068     "            [ fwmark FWMARK] [ dev/iif STRING ] [type TYPE]\n"
   2069     "ACTION := [ table TABLE_ID ] [ realms [SRCREALM/]DSTREALM ]";
   2070 
   2071   error_exit(errmsg);
   2072 }
   2073 
   2074 static int ruleupdate(char **argv)
   2075 {
   2076   int8_t idx, tflag = 0, opt = (*argv[-1] == 'a') ? RTM_NEWRULE : RTM_DELRULE;
   2077   struct arglist options[] = {{"from", 0}, {"to", 1}, {"preference", 2},
   2078     {"order", 2}, {"priority", 2}, {"tos", 3}, {"dsfield", 3}, {"fwmark", 4},
   2079     {"realms", 5}, {"table", 6}, {"lookup", 6}, {"dev", 7}, {"iif", 7},
   2080     {"nat", 8}, {"map-to", 8}, {"type", 9}, {"help", 10}, {NULL, -1}};
   2081   struct {
   2082     struct nlmsghdr mhdr;
   2083     struct rtmsg    msg;
   2084     char buf[1024];
   2085   } request;
   2086 
   2087   memset(&request, 0, sizeof(request));
   2088   request.mhdr.nlmsg_type = opt;
   2089   request.mhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
   2090   request.mhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK |
   2091     ((opt == RTM_DELRULE) ? 0 : NLM_F_CREATE | NLM_F_EXCL);
   2092   request.msg.rtm_family = TT.addressfamily;
   2093   request.msg.rtm_protocol = RTPROT_BOOT;
   2094   request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
   2095   request.msg.rtm_table = 0;
   2096   request.msg.rtm_type = ((opt == RTM_DELRULE) ? RTN_UNSPEC : RTN_UNICAST);
   2097 
   2098   for (; *argv; argv++) {
   2099     switch ((idx = substring_to_idx(*argv, options))) {
   2100       case 0:
   2101       case 1:
   2102         { // e.g. from IP/Netmask and to IP/Netmask.
   2103           uint32_t addr[4] = {0,}, netmask = 0;
   2104           uint8_t len = 0, *tmp;
   2105 
   2106           if (!*++argv) error_exit("'%s': Missing Prefix", argv[-1]);
   2107           parse_prefix(addr, &netmask, &len, *argv, request.msg.rtm_family);
   2108 
   2109           tmp = idx ? &request.msg.rtm_dst_len : &request.msg.rtm_src_len;
   2110           if (!netmask) *tmp = 0;
   2111           else *tmp = netmask;
   2112 
   2113           add_string_to_rtattr(&request.mhdr, sizeof(request),
   2114               (idx ? RTA_DST : RTA_SRC), addr, len);
   2115         }
   2116         break;
   2117       case 2:
   2118       case 4:
   2119         { // e.g. Preference p# and fwmark MARK
   2120           uint32_t pref;
   2121           char *ptr;
   2122 
   2123           if (!*++argv)
   2124             error_exit("Missing %s", (idx == 2) ? "Preference" : "fwmark");
   2125           pref = strtoul(*argv, &ptr, 0);
   2126           if (!ptr || (ptr == *argv) || *ptr  || pref > 0xFFFFFFFFUL)
   2127             error_exit("Invalid %s",  (idx == 2) ? "Preference" : "fwmark");
   2128           add_string_to_rtattr(&request.mhdr, sizeof(request),
   2129               ((idx == 2) ? RTA_PRIORITY : RTA_PROTOINFO),
   2130               (void *)&pref, sizeof(uint32_t));
   2131         }
   2132         break;
   2133       case 3:
   2134         {
   2135           uint32_t tos;
   2136           if (!*++argv) error_exit("Missing TOS key");
   2137           if ((tos = idxfromRPDB(*argv, RPDB_rtdsfield)) < 0)
   2138             error_exit("Invalid TOS");
   2139           request.msg.rtm_tos = tos;
   2140         }
   2141         break;
   2142       case 5:
   2143         { // e.g. realms FROM_realm/TO_realm
   2144           uint32_t realms = 0;
   2145           int ret;
   2146           char *ptr;
   2147 
   2148           if (!*++argv) error_exit("Missing REALMSID");
   2149           if ((ptr = strchr(*argv, '/'))) {
   2150             *ptr = 0;
   2151             if ((ret = idxfromRPDB(*argv, RPDB_rtrealms)) < 0)
   2152               error_exit("Invalid realms");
   2153             realms = ret;
   2154             realms <<= 16;
   2155             *ptr++ = '/';
   2156           } else ptr = *argv;
   2157           if ((ret = idxfromRPDB(ptr, RPDB_rtrealms)) < 0)
   2158             error_exit("Invalid realms");
   2159           realms |= ret;
   2160           add_string_to_rtattr(&request.mhdr, sizeof(request),
   2161               RTA_FLOW, (void *)&realms, sizeof(uint32_t));
   2162         }
   2163         break;
   2164       case 6:
   2165         { // e.g. table tid/tableName
   2166           int tid;
   2167           if (!*++argv) error_exit("Missing TableID");
   2168           if ((tid = idxfromRPDB(*argv, RPDB_rttables)) < 0)
   2169             error_exit("Invalid TID");
   2170           request.msg.rtm_table = tid;
   2171           tflag = 1;
   2172         }
   2173         break;
   2174       case 7:
   2175         {
   2176           if (!*++argv) error_exit("Missing dev/iif NAME");
   2177           add_string_to_rtattr(&request.mhdr, sizeof(request),
   2178               RTA_IIF, *argv, strlen(*argv)+1);
   2179         }
   2180         break;
   2181       case 8:
   2182         {
   2183           uint32_t addr[4] = {0,};
   2184           uint8_t af = AF_UNSPEC;
   2185 
   2186           if (!*++argv) error_exit("Missing nat/map-to ADDRESS");
   2187           if (get_prefix(addr, &af /* Un-used variable */, *argv, AF_INET))
   2188             error_exit("Invalid mapping Address");
   2189 
   2190           add_string_to_rtattr(&request.mhdr, sizeof(request),
   2191               RTA_GATEWAY, addr, sizeof(uint32_t));
   2192           request.msg.rtm_type = RTN_NAT;
   2193         }
   2194         break;
   2195       case 9:
   2196         {
   2197           if (!*++argv) error_exit("TYPE Missing");
   2198           request.msg.rtm_type = rtmtype_str2idx(*argv);
   2199         }
   2200         break;
   2201       case 10:
   2202         show_iprule_help();
   2203         break; // Unreachable code.
   2204       default:
   2205         error_exit("Invalid argument '%s'", *argv);
   2206         break; // Unreachable code.
   2207     }
   2208   }
   2209 
   2210   if (!request.msg.rtm_family) request.msg.rtm_family = AF_INET;
   2211   if (!tflag && opt == RTM_NEWRULE) request.msg.rtm_table = RT_TABLE_MAIN;
   2212 
   2213   send_nlmesg(0, 0, 0, &request, sizeof(request));
   2214   return (filter_nlmesg(NULL, NULL));
   2215 }
   2216 
   2217 static int show_rules(struct nlmsghdr *mhdr,
   2218     char **argv __attribute__ ((__unused__)))
   2219 {
   2220   struct rtmsg *msg = NLMSG_DATA(mhdr);
   2221   struct rtattr *rta, *attr[RTA_MAX+1] = {0,};
   2222   int32_t tvar, msglen = mhdr->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
   2223   int hlen = ((msg->rtm_family == AF_INET) ? 32
   2224       : ((msg->rtm_family == AF_INET6) ? 128 : -1));
   2225 
   2226   if (mhdr->nlmsg_type != RTM_NEWRULE) return 0;
   2227   if (msglen < 0) return 1;
   2228 
   2229   tvar = msglen;
   2230   for (rta = RTM_RTA(msg); RTA_OK(rta, tvar); rta=RTA_NEXT(rta, tvar))
   2231     if (rta->rta_type <= RTA_MAX) attr[rta->rta_type] = rta;
   2232 
   2233   if (tvar) error_msg("deficit %d, rtalen = %d!", tvar, rta->rta_len);
   2234 
   2235   printf("%u:\tfrom ", attr[RTA_PRIORITY] ?
   2236       *(unsigned *)RTA_DATA(attr[RTA_PRIORITY]) : 0);
   2237 
   2238   if (attr[RTA_SRC]) {
   2239     printf("%s", (msg->rtm_family == AF_INET || msg->rtm_family == AF_INET6)
   2240         ? inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_SRC]),
   2241           toybuf, sizeof(toybuf))
   2242         : "???");
   2243     (msg->rtm_src_len != hlen) ? printf("/%u", msg->rtm_src_len) : 0;
   2244   } else msg->rtm_src_len ? printf("0/%d", msg->rtm_src_len) : printf("all");
   2245 
   2246   xputc(' ');
   2247   if (attr[RTA_DST]) {
   2248     printf("to %s", (msg->rtm_family == AF_INET || msg->rtm_family == AF_INET6)
   2249         ? inet_ntop(msg->rtm_family, RTA_DATA(attr[RTA_DST]),
   2250           toybuf, sizeof(toybuf))  : "???");
   2251     (msg->rtm_dst_len != hlen) ? printf("/%u", msg->rtm_dst_len) : xputc(' ');
   2252   } else if (msg->rtm_dst_len)
   2253     printf("to 0/%d ", msg->rtm_dst_len);
   2254 
   2255   if (msg->rtm_tos)
   2256     printf("tos %s ", namefromRPDB(msg->rtm_tos, RPDB_rtdsfield));
   2257 
   2258   if (attr[RTA_PROTOINFO])
   2259     printf("fwmark %#x ", *(uint32_t*)RTA_DATA(attr[RTA_PROTOINFO]));
   2260 
   2261   if (attr[RTA_IIF]) printf("iif %s ", (char*)RTA_DATA(attr[RTA_IIF]));
   2262 
   2263   if (msg->rtm_table)
   2264     printf("lookup %s ", namefromRPDB(msg->rtm_table, RPDB_rttables));
   2265 
   2266   if (attr[RTA_FLOW]) {
   2267     u_int32_t from, to = *(u_int32_t *)RTA_DATA(attr[RTA_FLOW]);
   2268     char *format = "realms %s/";
   2269 
   2270     to = (from = (to >> 16)) & 0xFFFF;
   2271     format = (from ? format: "%s");
   2272     printf(format, namefromRPDB((from ? from : to), RPDB_rtrealms));
   2273   }
   2274 
   2275   if (msg->rtm_type == RTN_NAT) {
   2276     if (!attr[RTA_GATEWAY]) printf("masquerade");
   2277     else printf("map-to %s ", inet_ntop(msg->rtm_family,
   2278           RTA_DATA(attr[RTA_GATEWAY]), toybuf, sizeof(toybuf)));
   2279   } else if (msg->rtm_type != RTN_UNICAST)
   2280     printf("%s", rtmtype_idx2str(msg->rtm_type));
   2281 
   2282   xputc('\n');
   2283   return 0;
   2284 }
   2285 
   2286 static int rulelist(char **argv)
   2287 {
   2288   if (*argv) {
   2289     error_msg("'ip rule show' does not take any arguments.");
   2290     return 1;
   2291   }
   2292   send_nlmesg(RTM_GETRULE, NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST,
   2293       ((TT.addressfamily != AF_UNSPEC) ? TT.addressfamily : AF_INET), NULL, 0);
   2294   return filter_nlmesg(show_rules, argv);
   2295 }
   2296 
   2297 static int iprule(char **argv)
   2298 {
   2299   int idx;
   2300   struct arglist options[] = {{"add", 0}, {"delete", 0}, {"list", 1},
   2301     {"show", 1}, {NULL, -1}};
   2302   cmdobj ipcmd, cmdobjlist[] = {ruleupdate, rulelist};
   2303 
   2304   if (!*argv) idx = 1;
   2305   else if ((idx = substring_to_idx(*argv++, options)) == -1)
   2306     show_iprule_help();
   2307   ipcmd = cmdobjlist[idx];
   2308   return ipcmd(argv);
   2309 }
   2310 //============================================================================
   2311 // code for ip tunnel.
   2312 //============================================================================
   2313 static void show_iptunnel_help(void)
   2314 {
   2315   char *errmsg = "usage: iptunnel { add | change | del | show } [NAME]\n"
   2316     "           [mode { ipip | gre | sit }] [remote ADDR] [local ADDR]\n"
   2317     "           [[i|o]seq] [[i|o]key KEY] [[i|o]csum] [ttl TTL]\n"
   2318     "           [tos TOS] [[no]pmtudisc] [dev PHYS_DEV]";
   2319 
   2320   error_exit(errmsg);
   2321 }
   2322 
   2323 static int tnl_ioctl(char *dev, int rtype, struct ip_tunnel_parm *ptnl)
   2324 {
   2325   struct ifreq req;
   2326   int fd, ret = 0;
   2327 
   2328   if ((rtype == SIOCCHGTUNNEL || rtype == SIOCDELTUNNEL) && *ptnl->name)
   2329     xstrncpy(req.ifr_name, ptnl->name, IF_NAMESIZE);
   2330   else xstrncpy(req.ifr_name, dev, IF_NAMESIZE);
   2331 
   2332   if (rtype != SIOCGIFHWADDR) req.ifr_ifru.ifru_data = (void*)ptnl;
   2333   fd = xsocket(AF_INET, SOCK_DGRAM, 0);
   2334 
   2335   if (rtype == SIOCGETTUNNEL) ret = ioctl(fd, rtype, &req);
   2336   else if (rtype == SIOCGIFHWADDR)
   2337     ret = (ioctl(fd, rtype, &req) < 0) ? -1 : req.ifr_addr.sa_family;
   2338   else xioctl(fd, rtype, &req);
   2339 
   2340   close(fd);
   2341   return ret;
   2342 }
   2343 
   2344 static int display_tunnel(struct ip_tunnel_parm *ptnl)
   2345 {
   2346   char rmt_addr[64], lcl_addr[64], ikey_str[64], okey_str[64];
   2347 
   2348   printf("%s: %s/ip", ptnl->name, ptnl->iph.protocol == IPPROTO_IPIP ? "ip" :
   2349       (ptnl->iph.protocol == IPPROTO_GRE ? "gre" :
   2350        (ptnl->iph.protocol == IPPROTO_IPV6 ? "ipv6" : "unknown")));
   2351   printf("  remote %s  local %s ", ptnl->iph.daddr ?
   2352       inet_ntop(AF_INET, &ptnl->iph.daddr, rmt_addr, sizeof(rmt_addr)) : "any",
   2353       ptnl->iph.saddr ? inet_ntop(AF_INET, &ptnl->iph.saddr, lcl_addr,
   2354         sizeof(lcl_addr)) : "any");
   2355   if (ptnl->link) {
   2356     struct ifreq req;
   2357     int fd;
   2358 
   2359     req.ifr_ifindex = ptnl->link;
   2360     fd = xsocket(AF_INET, SOCK_DGRAM, 0);
   2361     if (ioctl(fd, SIOCGIFNAME, &req) < 0) perror_msg("SIOCGIFNAME");
   2362     else printf(" dev %s ", req.ifr_name);
   2363     close(fd);
   2364   }
   2365   if (ptnl->iph.ttl) printf(" ttl %d ", ptnl->iph.ttl);
   2366   else printf(" ttl inherit ");
   2367 
   2368   if (ptnl->iph.tos) {
   2369     printf(" tos");
   2370     if (ptnl->iph.tos & 1) printf(" inherit");
   2371     if (ptnl->iph.tos & ~1) printf("%c%s ", ptnl->iph.tos & 1 ? '/' : ' ',
   2372         namefromRPDB((ptnl->iph.tos & ~1), RPDB_rtdsfield));
   2373   }
   2374   if (!(ptnl->iph.frag_off & htons(IP_DF))) printf(" nopmtudisc");
   2375   inet_ntop(AF_INET, &ptnl->i_key, ikey_str, sizeof(ikey_str));
   2376   if ((ptnl->i_flags & GRE_KEY) && (ptnl->o_flags & GRE_KEY)
   2377       && ptnl->o_key == ptnl->i_key) printf(" key %s", ikey_str);
   2378   else if ((ptnl->i_flags | ptnl->o_flags) & GRE_KEY) {
   2379     inet_ntop(AF_INET, &ptnl->o_key, okey_str, sizeof(okey_str));
   2380     if (ptnl->i_flags & GRE_KEY) printf(" ikey %s ", ikey_str);
   2381     if (ptnl->o_flags & GRE_KEY) printf(" okey %s ", okey_str);
   2382   }
   2383   if (ptnl->i_flags & GRE_SEQ) printf("\n  Drop packets out of sequence.\n");
   2384   if (ptnl->i_flags & GRE_CSUM)
   2385     printf("\n  Checksum in received packet is required.");
   2386   if (ptnl->o_flags & GRE_SEQ) printf("\n  Sequence packets on output.");
   2387   if (ptnl->o_flags & GRE_CSUM) printf("\n  Checksum output packets.");
   2388   xputc('\n');
   2389   return 0;
   2390 }
   2391 
   2392 static int read_tunnel(struct ip_tunnel_parm *ptnl)
   2393 {
   2394   int count = 0;
   2395   char iface[IF_NAMESIZE];
   2396   struct ip_tunnel_parm iptnl;
   2397   FILE *fp = xfopen("/proc/net/dev", "r");
   2398 
   2399   while (fgets(toybuf, sizeof(toybuf), fp)) {
   2400     char *ptr;
   2401     int ret;
   2402 
   2403     if (count++ < 2) continue; // 1st two lines are header.
   2404 
   2405     ptr = strchr(toybuf, ':');
   2406     if (!ptr || (*ptr++ = 0, sscanf(toybuf, "%s", iface) != 1))
   2407       error_exit("invalid format of '/proc/net/dev'");
   2408     if (*ptnl->name && strcmp(ptnl->name, iface)) continue;
   2409     if ((ret = tnl_ioctl(iface, SIOCGIFHWADDR, &iptnl)) < 0) {
   2410       error_msg("failed to get type of '%s'", iface);
   2411       continue;
   2412     }
   2413     if (ret != ARPHRD_TUNNEL && ret !=  ARPHRD_SIT &&
   2414         ret != ARPHRD_IPGRE) continue;
   2415 
   2416     memset(&iptnl, 0, sizeof(iptnl));
   2417     if (tnl_ioctl(iface, SIOCGETTUNNEL, &iptnl) < 0) continue;
   2418     if ((ptnl->link && iptnl.link != ptnl->link) || (*ptnl->name &&
   2419           strcmp(iptnl.name, ptnl->name)) || (ptnl->iph.daddr &&
   2420           iptnl.iph.daddr != ptnl->iph.daddr) || (ptnl->iph.saddr &&
   2421             iptnl.iph.saddr != ptnl->iph.saddr) || (ptnl->i_key &&
   2422               iptnl.i_key != ptnl->i_key)) continue;
   2423     display_tunnel(&iptnl);
   2424   }
   2425   fclose(fp);
   2426   return 0;
   2427 }
   2428 
   2429 static void parse_iptunnel_args(struct ip_tunnel_parm *ptnl, char **argv,
   2430     int ipt_opt_idx)
   2431 {
   2432   int idx;
   2433   uint8_t af = AF_INET;
   2434   uint32_t addr = 0;
   2435   struct arglist opts[] = { {"mode", 0}, {"key", 1}, {"ikey", 2},
   2436     {"okey", 3}, {"seq", 4}, {"iseq", 5}, {"oseq", 6}, {"csum", 7},
   2437     {"icsum", 8}, {"ocsum", 9}, {"nopmtudisc", 10}, {"pmtudisc", 11},
   2438     {"remote", 12}, {"local", 13},{"dev", 14}, {"ttl", 15}, {"tos", 16},
   2439     {"dsfield", 17}, {"name", 18}, {NULL, -1}
   2440   };
   2441 
   2442   ptnl->iph.version = 4; // The value indicates the version of IP (4 or 6)
   2443   ptnl->iph.ihl = 5; // Minimum Internet Header Length
   2444   // frag_off is measured in units of 8 octets (64 bits)
   2445   ptnl->iph.frag_off = htons(IP_DF);
   2446   if (*argv && ipt_opt_idx <= 2 && string_to_idx(*argv, opts) == -1) {
   2447     xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
   2448     if (ipt_opt_idx == 1) {
   2449       struct ip_tunnel_parm iptnl_old;
   2450 
   2451       memset(&iptnl_old, 0, sizeof(iptnl_old));
   2452       tnl_ioctl(ptnl->name, SIOCGETTUNNEL, &iptnl_old);
   2453       *ptnl = iptnl_old;
   2454     }
   2455     argv++;
   2456   }
   2457   for (; *argv; argv++, addr = 0) {
   2458     switch (idx = string_to_idx(*argv, opts)) {
   2459       case 0:
   2460         if (!*++argv) error_exit("mode is missing");
   2461         if ((!strcmp("ipip", *argv) || !strcmp("ip/ip", *argv)))
   2462           ptnl->iph.protocol = IPPROTO_IPIP;
   2463         else if ((!strcmp("gre", *argv) || !strcmp("gre/ip", *argv)))
   2464           ptnl->iph.protocol = IPPROTO_GRE;
   2465         else if ((!strcmp("sit", *argv) || !strcmp("ipv6/ip", *argv)))
   2466           ptnl->iph.protocol = IPPROTO_IPV6;
   2467         else show_iptunnel_help();
   2468         break;
   2469       case 1:
   2470       case 2:
   2471       case 3:
   2472         {
   2473           struct addrinfo *info, hint;
   2474           int ret;
   2475 
   2476           if (!*++argv) error_exit("key value is missing");
   2477           memset(&hint, 0, sizeof(hint));
   2478           hint.ai_family = AF_INET;
   2479           ret = getaddrinfo(*argv, NULL, &hint, &info);
   2480           if (ret || !info) error_exit("invalid argument to key");
   2481           freeaddrinfo(info);
   2482 
   2483           if (strchr(*argv, '.')) {
   2484             if (get_prefix(&addr, &af, *argv, AF_INET))
   2485               error_exit("invalid key '%s'", *argv);
   2486           } else {
   2487             unsigned key_val;
   2488 
   2489             sscanf(*argv, "%u", &key_val);
   2490             addr = htonl(key_val);
   2491           }
   2492           if (idx == 1) {
   2493             ptnl->i_flags |= GRE_KEY;
   2494             ptnl->o_flags |= GRE_KEY;
   2495             ptnl->i_key = ptnl->o_key = addr;
   2496           } else if (idx == 2) {
   2497             ptnl->i_flags |= GRE_KEY;
   2498             ptnl->i_key = addr;
   2499           } else {
   2500             ptnl->o_flags |= GRE_KEY;
   2501             ptnl->o_key = addr;
   2502           }
   2503         }
   2504         break;
   2505       case 4:
   2506         ptnl->i_flags |= GRE_SEQ;
   2507         ptnl->o_flags |= GRE_SEQ;
   2508         break;
   2509       case 5:
   2510         ptnl->i_flags |= GRE_SEQ;
   2511         break;
   2512       case 6:
   2513         ptnl->o_flags |= GRE_SEQ;
   2514         break;
   2515       case 7:
   2516         ptnl->i_flags |= GRE_CSUM;
   2517         ptnl->o_flags |= GRE_CSUM;
   2518         break;
   2519       case 8:
   2520         ptnl->i_flags |= GRE_CSUM;
   2521         break;
   2522       case 9:
   2523         ptnl->o_flags |= GRE_CSUM;
   2524         break;
   2525       case 10:
   2526         ptnl->iph.frag_off = 0;
   2527         break;
   2528       case 11:
   2529         ptnl->iph.frag_off = htons(IP_DF);
   2530         break;
   2531       case 12:
   2532       case 13:
   2533         if (!*++argv) error_exit("remote/local address is missing");
   2534         if (get_prefix(&addr, &af, *argv, AF_INET))
   2535           error_exit("invalid remote/local address '%s'", *argv);
   2536         (idx == 12) ? (ptnl->iph.daddr = addr) : (ptnl->iph.saddr = addr);
   2537         break;
   2538       case 14:
   2539         if (!*++argv) error_exit("device name is missing");
   2540         else {
   2541           struct ifreq req;
   2542           int fd;
   2543 
   2544           xstrncpy(req.ifr_name, *argv, IFNAMSIZ);
   2545           fd = xsocket(AF_INET, SOCK_DGRAM, 0);
   2546           xioctl(fd, SIOCGIFINDEX, &req);
   2547           close(fd);
   2548           ptnl->link = req.ifr_ifindex;
   2549         }
   2550         break;
   2551       case 15:
   2552         if (!*++argv) error_exit("ttl value is missing");
   2553         if (strcmp(*argv, "inherit"))
   2554           ptnl->iph.ttl = atolx_range(*argv, 0, 255);
   2555         break;
   2556       case 16:
   2557       case 17:
   2558         if (!*++argv) error_exit("tos value is missing");
   2559         if (strcmp(*argv, "inherit")) {
   2560           char *ptr;
   2561           unsigned long tval = strtoul(*argv, &ptr, 16);
   2562 
   2563           if (tval > 255) error_exit("invalid tos value '%s'", *argv);
   2564           if (*ptr) {
   2565             int ret;
   2566 
   2567             if ((ret = idxfromRPDB(*argv, RPDB_rtdsfield)) < 0)
   2568               error_exit("invalid tos value");
   2569             ptnl->iph.tos = ret;
   2570           } else ptnl->iph.tos = tval;
   2571         } else ptnl->iph.tos = 1;
   2572         break;
   2573       case 18:
   2574         if (*ptnl->name) error_exit("invalid tunnel");
   2575         else {
   2576           if (!*++argv) error_exit("name is missing");
   2577           xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
   2578         }
   2579         break;
   2580       default:
   2581         if (*ptnl->name) error_exit("invalid tunnel");
   2582         xstrncpy(ptnl->name, *argv, IF_NAMESIZE);
   2583         break;
   2584     }
   2585   }
   2586   if (ptnl->iph.protocol == IPPROTO_IPIP ||
   2587       ptnl->iph.protocol == IPPROTO_IPV6) {
   2588     if ((ptnl->i_flags & GRE_KEY) || (ptnl->o_flags & GRE_KEY))
   2589       error_exit("[i|o]key is allowed with gre only");
   2590     if ((ptnl->i_flags & GRE_SEQ) || (ptnl->o_flags & GRE_SEQ))
   2591       error_exit("[i|o]seq is allowed with gre only");
   2592     if ((ptnl->i_flags & GRE_CSUM) || (ptnl->o_flags & GRE_CSUM))
   2593       error_exit("[i|o]csum is allowed with gre only");
   2594   }
   2595   if (!ptnl->i_key && IN_MULTICAST(ntohl(ptnl->iph.daddr))) {
   2596     ptnl->i_key = ptnl->iph.daddr;
   2597     ptnl->i_flags |= GRE_KEY;
   2598   }
   2599   if (!ptnl->o_key && IN_MULTICAST(ntohl(ptnl->iph.daddr))) {
   2600     ptnl->o_key = ptnl->iph.daddr;
   2601     ptnl->o_flags |= GRE_KEY;
   2602   }
   2603   if (IN_MULTICAST(ntohl(ptnl->iph.daddr)) && !ptnl->iph.saddr)
   2604     error_exit("broadcast tunnel requires a source address");
   2605 }
   2606 
   2607 static int tunnellist(char **argv)
   2608 {
   2609   struct ip_tunnel_parm iptnl;
   2610   int ret = 0;
   2611 
   2612   memset(&iptnl, 0, sizeof(iptnl));
   2613   parse_iptunnel_args(&iptnl, argv, 3);
   2614 
   2615   if (iptnl.iph.protocol == IPPROTO_IPIP)
   2616     ret = tnl_ioctl(*iptnl.name ? iptnl.name : "tunl0", SIOCGETTUNNEL, &iptnl);
   2617   else if (iptnl.iph.protocol == IPPROTO_GRE)
   2618     ret = tnl_ioctl(*iptnl.name ? iptnl.name : "gre0", SIOCGETTUNNEL, &iptnl);
   2619   else if (iptnl.iph.protocol == IPPROTO_IPV6)
   2620     ret = tnl_ioctl(*iptnl.name ? iptnl.name : "sit0", SIOCGETTUNNEL, &iptnl);
   2621   else return read_tunnel(&iptnl);
   2622 
   2623   if (ret < 0) {
   2624     perror_msg("SIOCGETTUNNEL");
   2625     return ret;
   2626   } else return display_tunnel(&iptnl);
   2627 }
   2628 
   2629 // Performing add, change, & delete tunnel action, according to passed req_type
   2630 static int tunnelupdate(char **argv)
   2631 {
   2632   struct ip_tunnel_parm iptnl;
   2633   int idx = 2, rtype = SIOCDELTUNNEL;
   2634 
   2635   if (*argv[-1] == 'a') {
   2636     idx = 0;
   2637     rtype = SIOCADDTUNNEL;
   2638   } else if (*argv[-1] == 'c') {
   2639     idx = 1;
   2640     rtype = SIOCCHGTUNNEL;
   2641   }
   2642 
   2643   memset(&iptnl, 0, sizeof(iptnl));
   2644   parse_iptunnel_args(&iptnl, argv, idx);
   2645   if (idx != 2 && iptnl.iph.ttl && !(iptnl.iph.frag_off))
   2646     error_exit("ttl > 0 and nopmtudisc are incompatible");
   2647   if (iptnl.iph.protocol == IPPROTO_IPIP)
   2648     return (tnl_ioctl("tunl0", rtype, &iptnl) < 0) ? 1 : 0;
   2649   else if (iptnl.iph.protocol == IPPROTO_GRE)
   2650     return (tnl_ioctl("gre0", rtype, &iptnl) < 0) ? 1 : 0;
   2651   else if (iptnl.iph.protocol == IPPROTO_IPV6)
   2652     return (tnl_ioctl("sit0", rtype, &iptnl) < 0) ? 1 : 0;
   2653   else {
   2654     if (idx != 2) error_exit("invalid tunnel mode");
   2655     return (tnl_ioctl(iptnl.name, rtype, &iptnl) < 0) ? 1 : 0;
   2656   }
   2657 }
   2658 
   2659 static int iptunnel(char **argv)
   2660 {
   2661   int idx;
   2662   struct arglist opts[] = {{"add", 0}, {"change", 0}, {"del", 0},
   2663     {"delete", 0}, {"show", 1}, {"list", 1}, {"lst", 1}, {NULL, -1}
   2664   };
   2665   cmdobj ipcmd, cmdobjlist[] = {tunnelupdate, tunnellist};
   2666 
   2667   if (!*argv) idx = 1;
   2668   else if ((idx = substring_to_idx(*argv++, opts)) == -1)
   2669     show_iptunnel_help();
   2670   ipcmd = cmdobjlist[idx];
   2671   return ipcmd(argv);
   2672 }
   2673 
   2674 // ===========================================================================
   2675 // Common code, which is used for all ip options.
   2676 // ===========================================================================
   2677 
   2678 // Parse netlink messages and call input callback handler for action
   2679 static int filter_nlmesg(int (*fun)(struct nlmsghdr *mhdr, char **argv),
   2680     char **argv)
   2681 {
   2682   while (1) {
   2683     struct nlmsghdr *mhdr;
   2684     int msglen = recv(TT.sockfd, TT.gbuf, MESG_LEN, 0);
   2685 
   2686     if ((msglen < 0) && (errno == EINTR || errno == EAGAIN)) continue;
   2687     else if (msglen < 0) {
   2688       error_msg("netlink receive error %s", strerror(errno));
   2689       return 1;
   2690     } else if (!msglen) {
   2691       error_msg("EOF on netlink");
   2692       return 1;
   2693     }
   2694 
   2695     for (mhdr = (struct nlmsghdr*)TT.gbuf; NLMSG_OK(mhdr, msglen);
   2696         mhdr = NLMSG_NEXT(mhdr, msglen)) {
   2697       int err;
   2698       if (mhdr->nlmsg_pid != getpid())
   2699         continue;
   2700       switch (mhdr->nlmsg_type) {
   2701         case NLMSG_DONE:
   2702           return 0;
   2703         case NLMSG_ERROR:
   2704           {
   2705             struct nlmsgerr *merr = (struct nlmsgerr*)NLMSG_DATA(mhdr);
   2706 
   2707             if (merr->error == 0) return 0;
   2708             if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
   2709               error_msg("ERROR truncated");
   2710             else {
   2711               errno = -merr->error;
   2712               perror_msg("RTNETLINK answers");
   2713             }
   2714             return 1;
   2715           }
   2716         default:
   2717           if (fun && (err = fun(mhdr, argv))) return err;
   2718           break;
   2719       }
   2720     } // End of for loop.
   2721   } // End of while loop.
   2722   return 0;
   2723 }
   2724 
   2725 void ip_main(void)
   2726 {
   2727   char **optargv = toys.argv;
   2728   int idx, isip = !(toys.which->name[2]); //1 -> if only ip
   2729   cmdobj ipcmd, cmdobjlist[] = {ipaddr, iplink, iproute, iprule, iptunnel};
   2730 
   2731   for (++optargv; *optargv; ++optargv) {
   2732     char *ptr = *optargv;
   2733     struct arglist ip_options[] = {{"oneline", 0}, {"family",  1},
   2734       {"4", 1}, {"6", 1}, {"0", 1}, {"stats", 2}, {NULL, -1}};
   2735 
   2736     if (*ptr != '-') break;
   2737     else if ((*(ptr+1) == '-') && (*(ptr+2))) ptr +=2;
   2738     //escape "--" and stop ip arg parsing.
   2739     else if ((*(ptr+1) == '-') && (!*(ptr+2))) {
   2740       *ptr +=1;
   2741       break;
   2742     } else ptr +=1;
   2743     switch (substring_to_idx(ptr, ip_options)) {
   2744       case 0: TT.singleline = 1;
   2745               break;
   2746       case 1: {
   2747                 if (isdigit(*ptr)) {
   2748                   long num = atolx(ptr);
   2749                   if (num == 4) TT.addressfamily  = AF_INET;
   2750                   else if (num == 6) TT.addressfamily  = AF_INET6;
   2751                   else TT.addressfamily = AF_PACKET;
   2752                 } else {
   2753                   struct arglist ip_aflist[] = {{"inet", AF_INET},
   2754                     {"inet6", AF_INET6}, {"link", AF_PACKET}, {NULL, -1}};
   2755 
   2756                   if (!*++optargv) help_exit(0);
   2757                   if ((TT.addressfamily = string_to_idx(*optargv, ip_aflist)) == -1)
   2758                     error_exit("wrong family '%s'", *optargv);
   2759                 }
   2760               }
   2761               break;
   2762       case 2:
   2763               TT.stats++;
   2764               break;
   2765       default: help_exit(0);
   2766                break; // unreachable code.
   2767     }
   2768   }
   2769 
   2770   TT.sockfd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
   2771 
   2772   if (isip) {// only for ip
   2773     if (*optargv) {
   2774       struct arglist ip_objectlist[] = { {"address", 0}, {"link", 1},
   2775         {"route", 2}, {"rule", 3}, {"tunnel", 4}, {"tunl", 4}, {NULL, -1}};
   2776 
   2777       if ((idx = substring_to_idx(*optargv, ip_objectlist)) == -1) help_exit(0);
   2778       ipcmd = cmdobjlist[idx];
   2779       toys.exitval = ipcmd(++optargv);
   2780     } else help_exit(0);
   2781   } else {
   2782     struct arglist ip_objectlist[] = { {"ipaddr", 0}, {"iplink", 1},
   2783       {"iproute", 2}, {"iprule", 3}, {"iptunnel", 4}, {NULL, -1}};
   2784     if ((idx = string_to_idx(toys.which->name, ip_objectlist)) == -1)
   2785       help_exit(0);
   2786     ipcmd = cmdobjlist[idx];
   2787     toys.exitval = ipcmd(optargv);
   2788   }
   2789   xclose(TT.sockfd);
   2790   if (rtdsfield_init) free_alist(rt_dsfield);
   2791   if (rtrealms_init) free_alist(rt_realms);
   2792   if (rtscope_init) free_alist(rt_scope);
   2793   if (rttable_init) free_alist(rt_tables);
   2794   if (rtprotos_init) free_alist(rt_protos);
   2795 }
   2796