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