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