networking/libiproute/ipaddress.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * ipaddress.c          "ip address".
   4  *
   5  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
   6  *
   7  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   8  *
   9  * Changes:
  10  *      Laszlo Valko <valko@linux.karinthy.hu> 990223: address label must be zero terminated
  11  */
  12
  13 #include <fnmatch.h>
  14 #include <net/if.h>
  15 #include <net/if_arp.h>
  16
  17 #include "ip_common.h"  /* #include "libbb.h" is inside */
  18 #include "rt_names.h"
  19 #include "utils.h"
  20
  21 #ifndef IFF_LOWER_UP
  22 /* from linux/if.h */
  23 #define IFF_LOWER_UP    0x10000         /* driver signals L1 up*/
  24 #endif
  25
  26 struct filter_t {
  27         char *label;
  28         char *flushb;
  29         struct rtnl_handle *rth;
  30         int scope, scopemask;
  31         int flags, flagmask;
  32         int flushp;
  33         int flushe;
  34         int ifindex;
  35         family_t family;
  36         smallint showqueue;
  37         smallint oneline;
  38         smallint up;
  39         smallint flushed;
  40         inet_prefix pfx;
  41 } FIX_ALIASING;
  42 typedef struct filter_t filter_t;
  43
  44 #define G_filter (*(filter_t*)&bb_common_bufsiz1)
  45
  46
  47 static void print_link_flags(unsigned flags, unsigned mdown)
  48 {
  49         static const int flag_masks[] = {
  50                 IFF_LOOPBACK, IFF_BROADCAST, IFF_POINTOPOINT,
  51                 IFF_MULTICAST, IFF_NOARP, IFF_UP, IFF_LOWER_UP };
  52         static const char flag_labels[] ALIGN1 =
  53                 "LOOPBACK\0""BROADCAST\0""POINTOPOINT\0"
  54                 "MULTICAST\0""NOARP\0""UP\0""LOWER_UP\0";
  55
  56         bb_putchar('<');
  57         flags &= ~IFF_RUNNING;
  58 #if 0
  59         _PF(ALLMULTI);
  60         _PF(PROMISC);
  61         _PF(MASTER);
  62         _PF(SLAVE);
  63         _PF(DEBUG);
  64         _PF(DYNAMIC);
  65         _PF(AUTOMEDIA);
  66         _PF(PORTSEL);
  67         _PF(NOTRAILERS);
  68 #endif
  69         flags = print_flags_separated(flag_masks, flag_labels, flags, ",");
  70         if (flags)
  71                 printf("%x", flags);
  72         if (mdown)
  73                 printf(",M-DOWN");
  74         printf("> ");
  75 }
  76
  77 static void print_queuelen(char *name)
  78 {
  79         struct ifreq ifr;
  80         int s;
  81
  82         s = socket(AF_INET, SOCK_STREAM, 0);
  83         if (s < 0)
  84                 return;
  85
  86         memset(&ifr, 0, sizeof(ifr));
  87         strncpy_IFNAMSIZ(ifr.ifr_name, name);
  88         if (ioctl_or_warn(s, SIOCGIFTXQLEN, &ifr) < 0) {
  89                 close(s);
  90                 return;
  91         }
  92         close(s);
  93
  94         if (ifr.ifr_qlen)
  95                 printf("qlen %d", ifr.ifr_qlen);
  96 }
  97
  98 static NOINLINE int print_linkinfo(const struct nlmsghdr *n)
  99 {
 100         struct ifinfomsg *ifi = NLMSG_DATA(n);
 101         struct rtattr *tb[IFLA_MAX+1];
 102         int len = n->nlmsg_len;
 103
 104         if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK)
 105                 return 0;
 106
 107         len -= NLMSG_LENGTH(sizeof(*ifi));
 108         if (len < 0)
 109                 return -1;
 110
 111         if (G_filter.ifindex && ifi->ifi_index != G_filter.ifindex)
 112                 return 0;
 113         if (G_filter.up && !(ifi->ifi_flags & IFF_UP))
 114                 return 0;
 115
 116         memset(tb, 0, sizeof(tb));
 117         parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
 118         if (tb[IFLA_IFNAME] == NULL) {
 119                 bb_error_msg("nil ifname");
 120                 return -1;
 121         }
 122         if (G_filter.label
 123          && (!G_filter.family || G_filter.family == AF_PACKET)
 124          && fnmatch(G_filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0)
 125         ) {
 126                 return 0;
 127         }
 128
 129         if (n->nlmsg_type == RTM_DELLINK)
 130                 printf("Deleted ");
 131
 132         printf("%d: %s", ifi->ifi_index,
 133                 /*tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>" - we checked tb[IFLA_IFNAME] above*/
 134                 (char*)RTA_DATA(tb[IFLA_IFNAME])
 135         );
 136
 137         {
 138                 unsigned m_flag = 0;
 139                 if (tb[IFLA_LINK]) {
 140                         SPRINT_BUF(b1);
 141                         int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
 142                         if (iflink == 0)
 143                                 printf("@NONE: ");
 144                         else {
 145                                 printf("@%s: ", ll_idx_n2a(iflink, b1));
 146                                 m_flag = ll_index_to_flags(iflink);
 147                                 m_flag = !(m_flag & IFF_UP);
 148                         }
 149                 } else {
 150                         printf(": ");
 151                 }
 152                 print_link_flags(ifi->ifi_flags, m_flag);
 153         }
 154
 155         if (tb[IFLA_MTU])
 156                 printf("mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
 157         if (tb[IFLA_QDISC])
 158                 printf("qdisc %s ", (char*)RTA_DATA(tb[IFLA_QDISC]));
 159 #ifdef IFLA_MASTER
 160         if (tb[IFLA_MASTER]) {
 161                 SPRINT_BUF(b1);
 162                 printf("master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
 163         }
 164 #endif
 165         if (G_filter.showqueue)
 166                 print_queuelen((char*)RTA_DATA(tb[IFLA_IFNAME]));
 167
 168         if (!G_filter.family || G_filter.family == AF_PACKET) {
 169                 SPRINT_BUF(b1);
 170                 printf("%c    link/%s ", _SL_, ll_type_n2a(ifi->ifi_type, b1));
 171
 172                 if (tb[IFLA_ADDRESS]) {
 173                         fputs(ll_addr_n2a(RTA_DATA(tb[IFLA_ADDRESS]),
 174                                                       RTA_PAYLOAD(tb[IFLA_ADDRESS]),
 175                                                       ifi->ifi_type,
 176                                                       b1, sizeof(b1)), stdout);
 177                 }
 178                 if (tb[IFLA_BROADCAST]) {
 179                         if (ifi->ifi_flags & IFF_POINTOPOINT)
 180                                 printf(" peer ");
 181                         else
 182                                 printf(" brd ");
 183                         fputs(ll_addr_n2a(RTA_DATA(tb[IFLA_BROADCAST]),
 184                                                       RTA_PAYLOAD(tb[IFLA_BROADCAST]),
 185                                                       ifi->ifi_type,
 186                                                       b1, sizeof(b1)), stdout);
 187                 }
 188         }
 189         bb_putchar('\n');
 190         /*fflush_all();*/
 191         return 0;
 192 }
 193
 194 static int flush_update(void)
 195 {
 196         if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
 197                 bb_perror_msg("failed to send flush request");
 198                 return -1;
 199         }
 200         G_filter.flushp = 0;
 201         return 0;
 202 }
 203
 204 static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
 205                 struct nlmsghdr *n, void *arg UNUSED_PARAM)
 206 {
 207         struct ifaddrmsg *ifa = NLMSG_DATA(n);
 208         int len = n->nlmsg_len;
 209         struct rtattr * rta_tb[IFA_MAX+1];
 210         char abuf[256];
 211         SPRINT_BUF(b1);
 212
 213         if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR)
 214                 return 0;
 215         len -= NLMSG_LENGTH(sizeof(*ifa));
 216         if (len < 0) {
 217                 bb_error_msg("wrong nlmsg len %d", len);
 218                 return -1;
 219         }
 220
 221         if (G_filter.flushb && n->nlmsg_type != RTM_NEWADDR)
 222                 return 0;
 223
 224         memset(rta_tb, 0, sizeof(rta_tb));
 225         parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa), n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
 226
 227         if (!rta_tb[IFA_LOCAL])
 228                 rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
 229         if (!rta_tb[IFA_ADDRESS])
 230                 rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
 231
 232         if (G_filter.ifindex && G_filter.ifindex != ifa->ifa_index)
 233                 return 0;
 234         if ((G_filter.scope ^ ifa->ifa_scope) & G_filter.scopemask)
 235                 return 0;
 236         if ((G_filter.flags ^ ifa->ifa_flags) & G_filter.flagmask)
 237                 return 0;
 238         if (G_filter.label) {
 239                 const char *label;
 240                 if (rta_tb[IFA_LABEL])
 241                         label = RTA_DATA(rta_tb[IFA_LABEL]);
 242                 else
 243                         label = ll_idx_n2a(ifa->ifa_index, b1);
 244                 if (fnmatch(G_filter.label, label, 0) != 0)
 245                         return 0;
 246         }
 247         if (G_filter.pfx.family) {
 248                 if (rta_tb[IFA_LOCAL]) {
 249                         inet_prefix dst;
 250                         memset(&dst, 0, sizeof(dst));
 251                         dst.family = ifa->ifa_family;
 252                         memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL]));
 253                         if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
 254                                 return 0;
 255                 }
 256         }
 257
 258         if (G_filter.flushb) {
 259                 struct nlmsghdr *fn;
 260                 if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
 261                         if (flush_update())
 262                                 return -1;
 263                 }
 264                 fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
 265                 memcpy(fn, n, n->nlmsg_len);
 266                 fn->nlmsg_type = RTM_DELADDR;
 267                 fn->nlmsg_flags = NLM_F_REQUEST;
 268                 fn->nlmsg_seq = ++G_filter.rth->seq;
 269                 G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
 270                 G_filter.flushed = 1;
 271                 return 0;
 272         }
 273
 274         if (n->nlmsg_type == RTM_DELADDR)
 275                 printf("Deleted ");
 276
 277         if (G_filter.oneline)
 278                 printf("%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));
 279         if (ifa->ifa_family == AF_INET)
 280                 printf("    inet ");
 281         else if (ifa->ifa_family == AF_INET6)
 282                 printf("    inet6 ");
 283         else
 284                 printf("    family %d ", ifa->ifa_family);
 285
 286         if (rta_tb[IFA_LOCAL]) {
 287                 fputs(rt_addr_n2a(ifa->ifa_family,
 288                                               RTA_DATA(rta_tb[IFA_LOCAL]),
 289                                               abuf, sizeof(abuf)), stdout);
 290
 291                 if (rta_tb[IFA_ADDRESS] == NULL
 292                  || memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), 4) == 0
 293                 ) {
 294                         printf("/%d ", ifa->ifa_prefixlen);
 295                 } else {
 296                         printf(" peer %s/%d ",
 297                                 rt_addr_n2a(ifa->ifa_family,
 298                                             RTA_DATA(rta_tb[IFA_ADDRESS]),
 299                                             abuf, sizeof(abuf)),
 300                                 ifa->ifa_prefixlen);
 301                 }
 302         }
 303
 304         if (rta_tb[IFA_BROADCAST]) {
 305                 printf("brd %s ",
 306                         rt_addr_n2a(ifa->ifa_family,
 307                                     RTA_DATA(rta_tb[IFA_BROADCAST]),
 308                                     abuf, sizeof(abuf)));
 309         }
 310         if (rta_tb[IFA_ANYCAST]) {
 311                 printf("any %s ",
 312                         rt_addr_n2a(ifa->ifa_family,
 313                                     RTA_DATA(rta_tb[IFA_ANYCAST]),
 314                                     abuf, sizeof(abuf)));
 315         }
 316         printf("scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope, b1));
 317         if (ifa->ifa_flags & IFA_F_SECONDARY) {
 318                 ifa->ifa_flags &= ~IFA_F_SECONDARY;
 319                 printf("secondary ");
 320         }
 321         if (ifa->ifa_flags & IFA_F_TENTATIVE) {
 322                 ifa->ifa_flags &= ~IFA_F_TENTATIVE;
 323                 printf("tentative ");
 324         }
 325         if (ifa->ifa_flags & IFA_F_DEPRECATED) {
 326                 ifa->ifa_flags &= ~IFA_F_DEPRECATED;
 327                 printf("deprecated ");
 328         }
 329         if (!(ifa->ifa_flags & IFA_F_PERMANENT)) {
 330                 printf("dynamic ");
 331         } else
 332                 ifa->ifa_flags &= ~IFA_F_PERMANENT;
 333         if (ifa->ifa_flags)
 334                 printf("flags %02x ", ifa->ifa_flags);
 335         if (rta_tb[IFA_LABEL])
 336                 fputs((char*)RTA_DATA(rta_tb[IFA_LABEL]), stdout);
 337         if (rta_tb[IFA_CACHEINFO]) {
 338                 struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
 339                 char buf[128];
 340                 bb_putchar(_SL_);
 341                 if (ci->ifa_valid == 0xFFFFFFFFU)
 342                         sprintf(buf, "valid_lft forever");
 343                 else
 344                         sprintf(buf, "valid_lft %dsec", ci->ifa_valid);
 345                 if (ci->ifa_prefered == 0xFFFFFFFFU)
 346                         sprintf(buf+strlen(buf), " preferred_lft forever");
 347                 else
 348                         sprintf(buf+strlen(buf), " preferred_lft %dsec", ci->ifa_prefered);
 349                 printf("       %s", buf);
 350         }
 351         bb_putchar('\n');
 352         /*fflush_all();*/
 353         return 0;
 354 }
 355
 356
 357 struct nlmsg_list {
 358         struct nlmsg_list *next;
 359         struct nlmsghdr   h;
 360 };
 361
 362 static int print_selected_addrinfo(int ifindex, struct nlmsg_list *ainfo)
 363 {
 364         for (; ainfo; ainfo = ainfo->next) {
 365                 struct nlmsghdr *n = &ainfo->h;
 366                 struct ifaddrmsg *ifa = NLMSG_DATA(n);
 367
 368                 if (n->nlmsg_type != RTM_NEWADDR)
 369                         continue;
 370                 if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifa)))
 371                         return -1;
 372                 if (ifa->ifa_index != ifindex
 373                  || (G_filter.family && G_filter.family != ifa->ifa_family)
 374                 ) {
 375                         continue;
 376                 }
 377                 print_addrinfo(NULL, n, NULL);
 378         }
 379         return 0;
 380 }
 381
 382
 383 static int FAST_FUNC store_nlmsg(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
 384 {
 385         struct nlmsg_list **linfo = (struct nlmsg_list**)arg;
 386         struct nlmsg_list *h;
 387         struct nlmsg_list **lp;
 388
 389         h = xzalloc(n->nlmsg_len + sizeof(void*));
 390
 391         memcpy(&h->h, n, n->nlmsg_len);
 392         /*h->next = NULL; - xzalloc did it */
 393
 394         for (lp = linfo; *lp; lp = &(*lp)->next)
 395                 continue;
 396         *lp = h;
 397
 398         ll_remember_index(who, n, NULL);
 399         return 0;
 400 }
 401
 402 static void ipaddr_reset_filter(int _oneline)
 403 {
 404         memset(&G_filter, 0, sizeof(G_filter));
 405         G_filter.oneline = _oneline;
 406 }
 407
 408 /* Return value becomes exitcode. It's okay to not return at all */
 409 int ipaddr_list_or_flush(char **argv, int flush)
 410 {
 411         static const char option[] ALIGN1 = "to\0""scope\0""up\0""label\0""dev\0";
 412
 413         struct nlmsg_list *linfo = NULL;
 414         struct nlmsg_list *ainfo = NULL;
 415         struct nlmsg_list *l;
 416         struct rtnl_handle rth;
 417         char *filter_dev = NULL;
 418         int no_link = 0;
 419
 420         ipaddr_reset_filter(oneline);
 421         G_filter.showqueue = 1;
 422
 423         if (G_filter.family == AF_UNSPEC)
 424                 G_filter.family = preferred_family;
 425
 426         if (flush) {
 427                 if (!*argv) {
 428                         bb_error_msg_and_die(bb_msg_requires_arg, "flush");
 429                 }
 430                 if (G_filter.family == AF_PACKET) {
 431                         bb_error_msg_and_die("can't flush link addresses");
 432                 }
 433         }
 434
 435         while (*argv) {
 436                 const int option_num = index_in_strings(option, *argv);
 437                 switch (option_num) {
 438                         case 0: /* to */
 439                                 NEXT_ARG();
 440                                 get_prefix(&G_filter.pfx, *argv, G_filter.family);
 441                                 if (G_filter.family == AF_UNSPEC) {
 442                                         G_filter.family = G_filter.pfx.family;
 443                                 }
 444                                 break;
 445                         case 1: { /* scope */
 446                                 uint32_t scope = 0;
 447                                 NEXT_ARG();
 448                                 G_filter.scopemask = -1;
 449                                 if (rtnl_rtscope_a2n(&scope, *argv)) {
 450                                         if (strcmp(*argv, "all") != 0) {
 451                                                 invarg(*argv, "scope");
 452                                         }
 453                                         scope = RT_SCOPE_NOWHERE;
 454                                         G_filter.scopemask = 0;
 455                                 }
 456                                 G_filter.scope = scope;
 457                                 break;
 458                         }
 459                         case 2: /* up */
 460                                 G_filter.up = 1;
 461                                 break;
 462                         case 3: /* label */
 463                                 NEXT_ARG();
 464                                 G_filter.label = *argv;
 465                                 break;
 466                         case 4: /* dev */
 467                                 NEXT_ARG();
 468                         default:
 469                                 if (filter_dev) {
 470                                         duparg2("dev", *argv);
 471                                 }
 472                                 filter_dev = *argv;
 473                 }
 474                 argv++;
 475         }
 476
 477         xrtnl_open(&rth);
 478
 479         xrtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK);
 480         xrtnl_dump_filter(&rth, store_nlmsg, &linfo);
 481
 482         if (filter_dev) {
 483                 G_filter.ifindex = xll_name_to_index(filter_dev);
 484         }
 485
 486         if (flush) {
 487                 char flushb[4096-512];
 488
 489                 G_filter.flushb = flushb;
 490                 G_filter.flushp = 0;
 491                 G_filter.flushe = sizeof(flushb);
 492                 G_filter.rth = &rth;
 493
 494                 for (;;) {
 495                         xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETADDR);
 496                         G_filter.flushed = 0;
 497                         xrtnl_dump_filter(&rth, print_addrinfo, NULL);
 498                         if (G_filter.flushed == 0) {
 499                                 return 0;
 500                         }
 501                         if (flush_update() < 0) {
 502                                 return 1;
 503                         }
 504                 }
 505         }
 506
 507         if (G_filter.family != AF_PACKET) {
 508                 xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETADDR);
 509                 xrtnl_dump_filter(&rth, store_nlmsg, &ainfo);
 510         }
 511
 512
 513         if (G_filter.family && G_filter.family != AF_PACKET) {
 514                 struct nlmsg_list **lp;
 515                 lp = &linfo;
 516
 517                 if (G_filter.oneline)
 518                         no_link = 1;
 519
 520                 while ((l = *lp) != NULL) {
 521                         int ok = 0;
 522                         struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
 523                         struct nlmsg_list *a;
 524
 525                         for (a = ainfo; a; a = a->next) {
 526                                 struct nlmsghdr *n = &a->h;
 527                                 struct ifaddrmsg *ifa = NLMSG_DATA(n);
 528
 529                                 if (ifa->ifa_index != ifi->ifi_index
 530                                  || (G_filter.family && G_filter.family != ifa->ifa_family)
 531                                 ) {
 532                                         continue;
 533                                 }
 534                                 if ((G_filter.scope ^ ifa->ifa_scope) & G_filter.scopemask)
 535                                         continue;
 536                                 if ((G_filter.flags ^ ifa->ifa_flags) & G_filter.flagmask)
 537                                         continue;
 538                                 if (G_filter.pfx.family || G_filter.label) {
 539                                         struct rtattr *tb[IFA_MAX+1];
 540                                         memset(tb, 0, sizeof(tb));
 541                                         parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(n));
 542                                         if (!tb[IFA_LOCAL])
 543                                                 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
 544
 545                                         if (G_filter.pfx.family && tb[IFA_LOCAL]) {
 546                                                 inet_prefix dst;
 547                                                 memset(&dst, 0, sizeof(dst));
 548                                                 dst.family = ifa->ifa_family;
 549                                                 memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));
 550                                                 if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
 551                                                         continue;
 552                                         }
 553                                         if (G_filter.label) {
 554                                                 SPRINT_BUF(b1);
 555                                                 const char *label;
 556                                                 if (tb[IFA_LABEL])
 557                                                         label = RTA_DATA(tb[IFA_LABEL]);
 558                                                 else
 559                                                         label = ll_idx_n2a(ifa->ifa_index, b1);
 560                                                 if (fnmatch(G_filter.label, label, 0) != 0)
 561                                                         continue;
 562                                         }
 563                                 }
 564
 565                                 ok = 1;
 566                                 break;
 567                         }
 568                         if (!ok)
 569                                 *lp = l->next;
 570                         else
 571                                 lp = &l->next;
 572                 }
 573         }
 574
 575         for (l = linfo; l; l = l->next) {
 576                 if (no_link || print_linkinfo(&l->h) == 0) {
 577                         struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
 578                         if (G_filter.family != AF_PACKET)
 579                                 print_selected_addrinfo(ifi->ifi_index, ainfo);
 580                 }
 581         }
 582
 583         return 0;
 584 }
 585
 586 static int default_scope(inet_prefix *lcl)
 587 {
 588         if (lcl->family == AF_INET) {
 589                 if (lcl->bytelen >= 1 && *(uint8_t*)&lcl->data == 127)
 590                         return RT_SCOPE_HOST;
 591         }
 592         return 0;
 593 }
 594
 595 /* Return value becomes exitcode. It's okay to not return at all */
 596 static int ipaddr_modify(int cmd, char **argv)
 597 {
 598         static const char option[] ALIGN1 =
 599                 "peer\0""remote\0""broadcast\0""brd\0"
 600                 "anycast\0""scope\0""dev\0""label\0""local\0";
 601         struct rtnl_handle rth;
 602         struct {
 603                 struct nlmsghdr  n;
 604                 struct ifaddrmsg ifa;
 605                 char             buf[256];
 606         } req;
 607         char *d = NULL;
 608         char *l = NULL;
 609         inet_prefix lcl;
 610         inet_prefix peer;
 611         int local_len = 0;
 612         int peer_len = 0;
 613         int brd_len = 0;
 614         int any_len = 0;
 615         bool scoped = 0;
 616
 617         memset(&req, 0, sizeof(req));
 618
 619         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
 620         req.n.nlmsg_flags = NLM_F_REQUEST;
 621         req.n.nlmsg_type = cmd;
 622         req.ifa.ifa_family = preferred_family;
 623
 624         while (*argv) {
 625                 const int option_num = index_in_strings(option, *argv);
 626                 switch (option_num) {
 627                         case 0: /* peer */
 628                         case 1: /* remote */
 629                                 NEXT_ARG();
 630
 631                                 if (peer_len) {
 632                                         duparg("peer", *argv);
 633                                 }
 634                                 get_prefix(&peer, *argv, req.ifa.ifa_family);
 635                                 peer_len = peer.bytelen;
 636                                 if (req.ifa.ifa_family == AF_UNSPEC) {
 637                                         req.ifa.ifa_family = peer.family;
 638                                 }
 639                                 addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &peer.data, peer.bytelen);
 640                                 req.ifa.ifa_prefixlen = peer.bitlen;
 641                                 break;
 642                         case 2: /* broadcast */
 643                         case 3: /* brd */
 644                         {
 645                                 inet_prefix addr;
 646                                 NEXT_ARG();
 647                                 if (brd_len) {
 648                                         duparg("broadcast", *argv);
 649                                 }
 650                                 if (LONE_CHAR(*argv, '+')) {
 651                                         brd_len = -1;
 652                                 } else if (LONE_DASH(*argv)) {
 653                                         brd_len = -2;
 654                                 } else {
 655                                         get_addr(&addr, *argv, req.ifa.ifa_family);
 656                                         if (req.ifa.ifa_family == AF_UNSPEC)
 657                                                 req.ifa.ifa_family = addr.family;
 658                                         addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &addr.data, addr.bytelen);
 659                                         brd_len = addr.bytelen;
 660                                 }
 661                                 break;
 662                         }
 663                         case 4: /* anycast */
 664                         {
 665                                 inet_prefix addr;
 666                                 NEXT_ARG();
 667                                 if (any_len) {
 668                                         duparg("anycast", *argv);
 669                                 }
 670                                 get_addr(&addr, *argv, req.ifa.ifa_family);
 671                                 if (req.ifa.ifa_family == AF_UNSPEC) {
 672                                         req.ifa.ifa_family = addr.family;
 673                                 }
 674                                 addattr_l(&req.n, sizeof(req), IFA_ANYCAST, &addr.data, addr.bytelen);
 675                                 any_len = addr.bytelen;
 676                                 break;
 677                         }
 678                         case 5: /* scope */
 679                         {
 680                                 uint32_t scope = 0;
 681                                 NEXT_ARG();
 682                                 if (rtnl_rtscope_a2n(&scope, *argv)) {
 683                                         invarg(*argv, "scope");
 684                                 }
 685                                 req.ifa.ifa_scope = scope;
 686                                 scoped = 1;
 687                                 break;
 688                         }
 689                         case 6: /* dev */
 690                                 NEXT_ARG();
 691                                 d = *argv;
 692                                 break;
 693                         case 7: /* label */
 694                                 NEXT_ARG();
 695                                 l = *argv;
 696                                 addattr_l(&req.n, sizeof(req), IFA_LABEL, l, strlen(l)+1);
 697                                 break;
 698                         case 8: /* local */
 699                                 NEXT_ARG();
 700                         default:
 701                                 if (local_len) {
 702                                         duparg2("local", *argv);
 703                                 }
 704                                 get_prefix(&lcl, *argv, req.ifa.ifa_family);
 705                                 if (req.ifa.ifa_family == AF_UNSPEC) {
 706                                         req.ifa.ifa_family = lcl.family;
 707                                 }
 708                                 addattr_l(&req.n, sizeof(req), IFA_LOCAL, &lcl.data, lcl.bytelen);
 709                                 local_len = lcl.bytelen;
 710                 }
 711                 argv++;
 712         }
 713
 714         if (d == NULL) {
 715                 bb_error_msg(bb_msg_requires_arg, "\"dev\"");
 716                 return -1;
 717         }
 718         if (l && strncmp(d, l, strlen(d)) != 0) {
 719                 bb_error_msg_and_die("\"dev\" (%s) must match \"label\" (%s)", d, l);
 720         }
 721
 722         if (peer_len == 0 && local_len && cmd != RTM_DELADDR) {
 723                 peer = lcl;
 724                 addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &lcl.data, lcl.bytelen);
 725         }
 726         if (req.ifa.ifa_prefixlen == 0)
 727                 req.ifa.ifa_prefixlen = lcl.bitlen;
 728
 729         if (brd_len < 0 && cmd != RTM_DELADDR) {
 730                 inet_prefix brd;
 731                 int i;
 732                 if (req.ifa.ifa_family != AF_INET) {
 733                         bb_error_msg_and_die("broadcast can be set only for IPv4 addresses");
 734                 }
 735                 brd = peer;
 736                 if (brd.bitlen <= 30) {
 737                         for (i=31; i>=brd.bitlen; i--) {
 738                                 if (brd_len == -1)
 739                                         brd.data[0] |= htonl(1<<(31-i));
 740                                 else
 741                                         brd.data[0] &= ~htonl(1<<(31-i));
 742                         }
 743                         addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &brd.data, brd.bytelen);
 744                         brd_len = brd.bytelen;
 745                 }
 746         }
 747         if (!scoped && cmd != RTM_DELADDR)
 748                 req.ifa.ifa_scope = default_scope(&lcl);
 749
 750         xrtnl_open(&rth);
 751
 752         ll_init_map(&rth);
 753
 754         req.ifa.ifa_index = xll_name_to_index(d);
 755
 756         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
 757                 return 2;
 758
 759         return 0;
 760 }
 761
 762 /* Return value becomes exitcode. It's okay to not return at all */
 763 int do_ipaddr(char **argv)
 764 {
 765         static const char commands[] ALIGN1 =
 766                 "add\0""delete\0""list\0""show\0""lst\0""flush\0";
 767
 768         int command_num = 2; /* default command is list */
 769
 770         if (*argv) {
 771                 command_num = index_in_substrings(commands, *argv);
 772                 if (command_num < 0 || command_num > 5)
 773                         bb_error_msg_and_die("unknown command %s", *argv);
 774                 argv++;
 775         }
 776         if (command_num == 0) /* add */
 777                 return ipaddr_modify(RTM_NEWADDR, argv);
 778         if (command_num == 1) /* delete */
 779                 return ipaddr_modify(RTM_DELADDR, argv);
 780         if (command_num == 5) /* flush */
 781                 return ipaddr_list_or_flush(argv, 1);
 782         /* 2 == list, 3 == show, 4 == lst */
 783         return ipaddr_list_or_flush(argv, 0);
 784 }