ip/iplink.c

   1 /*
   2  * iplink.c             "ip link".
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <syslog.h>
  17 #include <fcntl.h>
  18 #include <dlfcn.h>
  19 #include <errno.h>
  20 #include <sys/socket.h>
  21 #include <linux/if.h>
  22 #include <linux/if_packet.h>
  23 #include <linux/if_ether.h>
  24 #include <linux/sockios.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <linux/sockios.h>
  30 #include <stdbool.h>
  31
  32 #include "rt_names.h"
  33 #include "utils.h"
  34 #include "ip_common.h"
  35 #include "namespace.h"
  36
  37 #define IPLINK_IOCTL_COMPAT     1
  38 #ifndef LIBDIR
  39 #define LIBDIR "/usr/lib"
  40 #endif
  41
  42 static void usage(void) __attribute__((noreturn));
  43 static int iplink_have_newlink(void);
  44
  45 void iplink_usage(void)
  46 {
  47         if (iplink_have_newlink()) {
  48                 fprintf(stderr, "Usage: ip link add [link DEV] [ name ] NAME\n");
  49                 fprintf(stderr, "                   [ txqueuelen PACKETS ]\n");
  50                 fprintf(stderr, "                   [ address LLADDR ]\n");
  51                 fprintf(stderr, "                   [ broadcast LLADDR ]\n");
  52                 fprintf(stderr, "                   [ mtu MTU ] [index IDX ]\n");
  53                 fprintf(stderr, "                   [ numtxqueues QUEUE_COUNT ]\n");
  54                 fprintf(stderr, "                   [ numrxqueues QUEUE_COUNT ]\n");
  55                 fprintf(stderr, "                   type TYPE [ ARGS ]\n");
  56                 fprintf(stderr, "       ip link delete { DEVICE | dev DEVICE | group DEVGROUP } type TYPE [ ARGS ]\n");
  57                 fprintf(stderr, "\n");
  58                 fprintf(stderr, "       ip link set { DEVICE | dev DEVICE | group DEVGROUP }\n");
  59                 fprintf(stderr, "                         [ { up | down } ]\n");
  60                 fprintf(stderr, "                         [ type TYPE ARGS ]\n");
  61         } else
  62                 fprintf(stderr, "Usage: ip link set DEVICE [ { up | down } ]\n");
  63
  64         fprintf(stderr, "                         [ arp { on | off } ]\n");
  65         fprintf(stderr, "                         [ dynamic { on | off } ]\n");
  66         fprintf(stderr, "                         [ multicast { on | off } ]\n");
  67         fprintf(stderr, "                         [ allmulticast { on | off } ]\n");
  68         fprintf(stderr, "                         [ promisc { on | off } ]\n");
  69         fprintf(stderr, "                         [ trailers { on | off } ]\n");
  70         fprintf(stderr, "                         [ txqueuelen PACKETS ]\n");
  71         fprintf(stderr, "                         [ name NEWNAME ]\n");
  72         fprintf(stderr, "                         [ address LLADDR ]\n");
  73         fprintf(stderr, "                         [ broadcast LLADDR ]\n");
  74         fprintf(stderr, "                         [ mtu MTU ]\n");
  75         fprintf(stderr, "                         [ netns { PID | NAME } ]\n");
  76         fprintf(stderr, "                         [ link-netnsid ID ]\n");
  77         fprintf(stderr, "                         [ alias NAME ]\n");
  78         fprintf(stderr, "                         [ vf NUM [ mac LLADDR ]\n");
  79         fprintf(stderr, "                                  [ vlan VLANID [ qos VLAN-QOS ] ]\n");
  80
  81         fprintf(stderr, "                                  [ rate TXRATE ]\n");
  82
  83         fprintf(stderr, "                                  [ spoofchk { on | off} ]\n");
  84         fprintf(stderr, "                                  [ query_rss { on | off} ]\n");
  85         fprintf(stderr, "                                  [ state { auto | enable | disable} ] ]\n");
  86         fprintf(stderr, "                                  [ trust { on | off} ] ]\n");
  87         fprintf(stderr, "                         [ master DEVICE ][ vrf NAME ]\n");
  88         fprintf(stderr, "                         [ nomaster ]\n");
  89         fprintf(stderr, "                         [ addrgenmode { eui64 | none | stable_secret | random } ]\n");
  90         fprintf(stderr, "                         [ protodown { on | off } ]\n");
  91         fprintf(stderr, "       ip link show [ DEVICE | group GROUP ] [up] [master DEV] [vrf NAME] [type TYPE]\n");
  92
  93         if (iplink_have_newlink()) {
  94                 fprintf(stderr, "       ip link help [ TYPE ]\n");
  95                 fprintf(stderr, "\n");
  96                 fprintf(stderr, "TYPE := { vlan | veth | vcan | dummy | ifb | macvlan | macvtap |\n");
  97                 fprintf(stderr, "          bridge | bond | ipoib | ip6tnl | ipip | sit | vxlan |\n");
  98                 fprintf(stderr, "          gre | gretap | ip6gre | ip6gretap | vti | nlmon |\n");
  99                 fprintf(stderr, "          bond_slave | ipvlan | geneve | bridge_slave | vrf }\n");
 100         }
 101         exit(-1);
 102 }
 103
 104 static void usage(void)
 105 {
 106         iplink_usage();
 107 }
 108
 109 static int on_off(const char *msg, const char *realval)
 110 {
 111         fprintf(stderr,
 112                 "Error: argument of \"%s\" must be \"on\" or \"off\", not \"%s\"\n",
 113                 msg, realval);
 114         return -1;
 115 }
 116
 117 static void *BODY;              /* cached dlopen(NULL) handle */
 118 static struct link_util *linkutil_list;
 119
 120 static struct link_util *__get_link_kind(const char *id, bool slave)
 121 {
 122         void *dlh;
 123         char buf[256];
 124         struct link_util *l;
 125
 126         for (l = linkutil_list; l; l = l->next)
 127                 if (strcmp(l->id, id) == 0 &&
 128                     l->slave == slave)
 129                         return l;
 130
 131         snprintf(buf, sizeof(buf), LIBDIR "/ip/link_%s.so", id);
 132         dlh = dlopen(buf, RTLD_LAZY);
 133         if (dlh == NULL) {
 134                 /* look in current binary, only open once */
 135                 dlh = BODY;
 136                 if (dlh == NULL) {
 137                         dlh = BODY = dlopen(NULL, RTLD_LAZY);
 138                         if (dlh == NULL)
 139                                 return NULL;
 140                 }
 141         }
 142
 143         if (slave)
 144                 snprintf(buf, sizeof(buf), "%s_slave_link_util", id);
 145         else
 146                 snprintf(buf, sizeof(buf), "%s_link_util", id);
 147         l = dlsym(dlh, buf);
 148         if (l == NULL)
 149                 return NULL;
 150
 151         l->next = linkutil_list;
 152         linkutil_list = l;
 153         return l;
 154 }
 155
 156 struct link_util *get_link_kind(const char *id)
 157 {
 158         return __get_link_kind(id, false);
 159 }
 160
 161 struct link_util *get_link_slave_kind(const char *id)
 162 {
 163         return __get_link_kind(id, true);
 164 }
 165
 166 static int get_link_mode(const char *mode)
 167 {
 168         if (strcasecmp(mode, "default") == 0)
 169                 return IF_LINK_MODE_DEFAULT;
 170         if (strcasecmp(mode, "dormant") == 0)
 171                 return IF_LINK_MODE_DORMANT;
 172         return -1;
 173 }
 174
 175 static int get_addr_gen_mode(const char *mode)
 176 {
 177         if (strcasecmp(mode, "eui64") == 0)
 178                 return IN6_ADDR_GEN_MODE_EUI64;
 179         if (strcasecmp(mode, "none") == 0)
 180                 return IN6_ADDR_GEN_MODE_NONE;
 181         if (strcasecmp(mode, "stable_secret") == 0)
 182                 return IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
 183         if (strcasecmp(mode, "random") == 0)
 184                 return IN6_ADDR_GEN_MODE_RANDOM;
 185         return -1;
 186 }
 187
 188 #if IPLINK_IOCTL_COMPAT
 189 static int have_rtnl_newlink = -1;
 190
 191 static int accept_msg(const struct sockaddr_nl *who,
 192                       struct rtnl_ctrl_data *ctrl,
 193                       struct nlmsghdr *n, void *arg)
 194 {
 195         struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(n);
 196
 197         if (n->nlmsg_type == NLMSG_ERROR &&
 198             (err->error == -EOPNOTSUPP || err->error == -EINVAL))
 199                 have_rtnl_newlink = 0;
 200         else
 201                 have_rtnl_newlink = 1;
 202         return -1;
 203 }
 204
 205 static int iplink_have_newlink(void)
 206 {
 207         struct {
 208                 struct nlmsghdr         n;
 209                 struct ifinfomsg        i;
 210                 char                    buf[1024];
 211         } req = {
 212                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 213                 .n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
 214                 .n.nlmsg_type = RTM_NEWLINK,
 215                 .i.ifi_family = AF_UNSPEC,
 216         };
 217
 218         if (have_rtnl_newlink < 0) {
 219                 if (rtnl_send(&rth, &req.n, req.n.nlmsg_len) < 0) {
 220                         perror("request send failed");
 221                         exit(1);
 222                 }
 223                 rtnl_listen(&rth, accept_msg, NULL);
 224         }
 225         return have_rtnl_newlink;
 226 }
 227 #else /* IPLINK_IOCTL_COMPAT */
 228 static int iplink_have_newlink(void)
 229 {
 230         return 1;
 231 }
 232 #endif /* ! IPLINK_IOCTL_COMPAT */
 233
 234 struct iplink_req {
 235         struct nlmsghdr         n;
 236         struct ifinfomsg        i;
 237         char                    buf[1024];
 238 };
 239
 240 static int nl_get_ll_addr_len(unsigned int dev_index)
 241 {
 242         int len;
 243         struct iplink_req req = {
 244                 .n = {
 245                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 246                         .nlmsg_type = RTM_GETLINK,
 247                         .nlmsg_flags = NLM_F_REQUEST
 248                 },
 249                 .i = {
 250                         .ifi_family = preferred_family,
 251                         .ifi_index = dev_index,
 252                 }
 253         };
 254         struct rtattr *tb[IFLA_MAX+1];
 255
 256         if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0)
 257                 return -1;
 258
 259         len = req.n.nlmsg_len - NLMSG_LENGTH(sizeof(req.i));
 260         if (len < 0)
 261                 return -1;
 262
 263         parse_rtattr_flags(tb, IFLA_MAX, IFLA_RTA(&req.i), len, NLA_F_NESTED);
 264         if (!tb[IFLA_ADDRESS])
 265                 return -1;
 266
 267         return RTA_PAYLOAD(tb[IFLA_ADDRESS]);
 268 }
 269
 270 static int iplink_parse_vf(int vf, int *argcp, char ***argvp,
 271                            struct iplink_req *req, int dev_index)
 272 {
 273         char new_rate_api = 0, count = 0, override_legacy_rate = 0;
 274         struct ifla_vf_rate tivt;
 275         int len, argc = *argcp;
 276         char **argv = *argvp;
 277         struct rtattr *vfinfo;
 278
 279         tivt.min_tx_rate = -1;
 280         tivt.max_tx_rate = -1;
 281
 282         vfinfo = addattr_nest(&req->n, sizeof(*req), IFLA_VF_INFO);
 283
 284         while (NEXT_ARG_OK()) {
 285                 NEXT_ARG();
 286                 count++;
 287                 if (!matches(*argv, "max_tx_rate")) {
 288                         /* new API in use */
 289                         new_rate_api = 1;
 290                         /* override legacy rate */
 291                         override_legacy_rate = 1;
 292                 } else if (!matches(*argv, "min_tx_rate")) {
 293                         /* new API in use */
 294                         new_rate_api = 1;
 295                 }
 296         }
 297
 298         while (count--) {
 299                 /* rewind arg */
 300                 PREV_ARG();
 301         }
 302
 303         while (NEXT_ARG_OK()) {
 304                 NEXT_ARG();
 305                 if (matches(*argv, "mac") == 0) {
 306                         struct ifla_vf_mac ivm = { 0 };
 307                         int halen = nl_get_ll_addr_len(dev_index);
 308
 309                         NEXT_ARG();
 310                         ivm.vf = vf;
 311                         len = ll_addr_a2n((char *)ivm.mac, 32, *argv);
 312                         if (len < 0)
 313                                 return -1;
 314                         if (halen > 0 && len != halen) {
 315                                 fprintf(stderr,
 316                                         "Invalid address length %d - must be %d bytes\n",
 317                                         len, halen);
 318                                 return -1;
 319                         }
 320                         addattr_l(&req->n, sizeof(*req), IFLA_VF_MAC,
 321                                   &ivm, sizeof(ivm));
 322                 } else if (matches(*argv, "vlan") == 0) {
 323                         struct ifla_vf_vlan ivv;
 324
 325                         NEXT_ARG();
 326                         if (get_unsigned(&ivv.vlan, *argv, 0))
 327                                 invarg("Invalid \"vlan\" value\n", *argv);
 328
 329                         ivv.vf = vf;
 330                         ivv.qos = 0;
 331                         if (NEXT_ARG_OK()) {
 332                                 NEXT_ARG();
 333                                 if (matches(*argv, "qos") == 0) {
 334                                         NEXT_ARG();
 335                                         if (get_unsigned(&ivv.qos, *argv, 0))
 336                                                 invarg("Invalid \"qos\" value\n", *argv);
 337                                 } else {
 338                                         /* rewind arg */
 339                                         PREV_ARG();
 340                                 }
 341                         }
 342                         addattr_l(&req->n, sizeof(*req), IFLA_VF_VLAN,
 343                                   &ivv, sizeof(ivv));
 344                 } else if (matches(*argv, "rate") == 0) {
 345                         struct ifla_vf_tx_rate ivt;
 346
 347                         NEXT_ARG();
 348                         if (get_unsigned(&ivt.rate, *argv, 0))
 349                                 invarg("Invalid \"rate\" value\n", *argv);
 350
 351                         ivt.vf = vf;
 352                         if (!new_rate_api)
 353                                 addattr_l(&req->n, sizeof(*req),
 354                                           IFLA_VF_TX_RATE, &ivt, sizeof(ivt));
 355                         else if (!override_legacy_rate)
 356                                 tivt.max_tx_rate = ivt.rate;
 357
 358                 } else if (matches(*argv, "max_tx_rate") == 0) {
 359                         NEXT_ARG();
 360                         if (get_unsigned(&tivt.max_tx_rate, *argv, 0))
 361                                 invarg("Invalid \"max tx rate\" value\n",
 362                                        *argv);
 363                         tivt.vf = vf;
 364
 365                 } else if (matches(*argv, "min_tx_rate") == 0) {
 366                         NEXT_ARG();
 367                         if (get_unsigned(&tivt.min_tx_rate, *argv, 0))
 368                                 invarg("Invalid \"min tx rate\" value\n",
 369                                        *argv);
 370                         tivt.vf = vf;
 371
 372                 } else if (matches(*argv, "spoofchk") == 0) {
 373                         struct ifla_vf_spoofchk ivs;
 374
 375                         NEXT_ARG();
 376                         if (matches(*argv, "on") == 0)
 377                                 ivs.setting = 1;
 378                         else if (matches(*argv, "off") == 0)
 379                                 ivs.setting = 0;
 380                         else
 381                                 return on_off("spoofchk", *argv);
 382                         ivs.vf = vf;
 383                         addattr_l(&req->n, sizeof(*req), IFLA_VF_SPOOFCHK,
 384                                   &ivs, sizeof(ivs));
 385
 386                 } else if (matches(*argv, "query_rss") == 0) {
 387                         struct ifla_vf_rss_query_en ivs;
 388
 389                         NEXT_ARG();
 390                         if (matches(*argv, "on") == 0)
 391                                 ivs.setting = 1;
 392                         else if (matches(*argv, "off") == 0)
 393                                 ivs.setting = 0;
 394                         else
 395                                 return on_off("query_rss", *argv);
 396                         ivs.vf = vf;
 397                         addattr_l(&req->n, sizeof(*req), IFLA_VF_RSS_QUERY_EN,
 398                                   &ivs, sizeof(ivs));
 399
 400                 } else if (matches(*argv, "trust") == 0) {
 401                         struct ifla_vf_trust ivt;
 402
 403                         NEXT_ARG();
 404                         if (matches(*argv, "on") == 0)
 405                                 ivt.setting = 1;
 406                         else if (matches(*argv, "off") == 0)
 407                                 ivt.setting = 0;
 408                         else
 409                                 invarg("Invalid \"trust\" value\n", *argv);
 410                         ivt.vf = vf;
 411                         addattr_l(&req->n, sizeof(*req), IFLA_VF_TRUST,
 412                                   &ivt, sizeof(ivt));
 413
 414                 } else if (matches(*argv, "state") == 0) {
 415                         struct ifla_vf_link_state ivl;
 416
 417                         NEXT_ARG();
 418                         if (matches(*argv, "auto") == 0)
 419                                 ivl.link_state = IFLA_VF_LINK_STATE_AUTO;
 420                         else if (matches(*argv, "enable") == 0)
 421                                 ivl.link_state = IFLA_VF_LINK_STATE_ENABLE;
 422                         else if (matches(*argv, "disable") == 0)
 423                                 ivl.link_state = IFLA_VF_LINK_STATE_DISABLE;
 424                         else
 425                                 invarg("Invalid \"state\" value\n", *argv);
 426                         ivl.vf = vf;
 427                         addattr_l(&req->n, sizeof(*req), IFLA_VF_LINK_STATE,
 428                                   &ivl, sizeof(ivl));
 429                 } else if (matches(*argv, "node_guid") == 0) {
 430                         struct ifla_vf_guid ivg;
 431
 432                         NEXT_ARG();
 433                         ivg.vf = vf;
 434                         if (get_guid(&ivg.guid, *argv)) {
 435                                 invarg("Invalid GUID format\n", *argv);
 436                                 return -1;
 437                         }
 438                         addattr_l(&req->n, sizeof(*req), IFLA_VF_IB_NODE_GUID,
 439                                   &ivg, sizeof(ivg));
 440                 } else if (matches(*argv, "port_guid") == 0) {
 441                         struct ifla_vf_guid ivg;
 442
 443                         NEXT_ARG();
 444                         ivg.vf = vf;
 445                         if (get_guid(&ivg.guid, *argv)) {
 446                                 invarg("Invalid GUID format\n", *argv);
 447                                 return -1;
 448                         }
 449                         addattr_l(&req->n, sizeof(*req), IFLA_VF_IB_PORT_GUID,
 450                                   &ivg, sizeof(ivg));
 451                 } else {
 452                         /* rewind arg */
 453                         PREV_ARG();
 454                         break;
 455                 }
 456         }
 457
 458         if (new_rate_api) {
 459                 int tmin, tmax;
 460
 461                 if (tivt.min_tx_rate == -1 || tivt.max_tx_rate == -1) {
 462                         ipaddr_get_vf_rate(tivt.vf, &tmin, &tmax, dev_index);
 463                         if (tivt.min_tx_rate == -1)
 464                                 tivt.min_tx_rate = tmin;
 465                         if (tivt.max_tx_rate == -1)
 466                                 tivt.max_tx_rate = tmax;
 467                 }
 468                 addattr_l(&req->n, sizeof(*req), IFLA_VF_RATE, &tivt,
 469                           sizeof(tivt));
 470         }
 471
 472         if (argc == *argcp)
 473                 incomplete_command();
 474
 475         addattr_nest_end(&req->n, vfinfo);
 476
 477         *argcp = argc;
 478         *argvp = argv;
 479         return 0;
 480 }
 481
 482 int iplink_parse(int argc, char **argv, struct iplink_req *req,
 483                  char **name, char **type, char **link, char **dev,
 484                  int *group, int *index)
 485 {
 486         int ret, len;
 487         char abuf[32];
 488         int qlen = -1;
 489         int mtu = -1;
 490         int netns = -1;
 491         int vf = -1;
 492         int numtxqueues = -1;
 493         int numrxqueues = -1;
 494         int dev_index = 0;
 495         int link_netnsid = -1;
 496         int addr_len = 0;
 497
 498         *group = -1;
 499         ret = argc;
 500
 501         while (argc > 0) {
 502                 if (strcmp(*argv, "up") == 0) {
 503                         req->i.ifi_change |= IFF_UP;
 504                         req->i.ifi_flags |= IFF_UP;
 505                 } else if (strcmp(*argv, "down") == 0) {
 506                         req->i.ifi_change |= IFF_UP;
 507                         req->i.ifi_flags &= ~IFF_UP;
 508                 } else if (strcmp(*argv, "name") == 0) {
 509                         NEXT_ARG();
 510                         *name = *argv;
 511                 } else if (strcmp(*argv, "index") == 0) {
 512                         NEXT_ARG();
 513                         *index = atoi(*argv);
 514                         if (*index < 0)
 515                                 invarg("Invalid \"index\" value", *argv);
 516                 } else if (matches(*argv, "link") == 0) {
 517                         NEXT_ARG();
 518                         *link = *argv;
 519                 } else if (matches(*argv, "address") == 0) {
 520                         NEXT_ARG();
 521                         addr_len = ll_addr_a2n(abuf, sizeof(abuf), *argv);
 522                         if (addr_len < 0)
 523                                 return -1;
 524                         addattr_l(&req->n, sizeof(*req), IFLA_ADDRESS, abuf, addr_len);
 525                 } else if (matches(*argv, "broadcast") == 0 ||
 526                            strcmp(*argv, "brd") == 0) {
 527                         NEXT_ARG();
 528                         len = ll_addr_a2n(abuf, sizeof(abuf), *argv);
 529                         if (len < 0)
 530                                 return -1;
 531                         addattr_l(&req->n, sizeof(*req), IFLA_BROADCAST, abuf, len);
 532                 } else if (matches(*argv, "txqueuelen") == 0 ||
 533                            strcmp(*argv, "qlen") == 0 ||
 534                            matches(*argv, "txqlen") == 0) {
 535                         NEXT_ARG();
 536                         if (qlen != -1)
 537                                 duparg("txqueuelen", *argv);
 538                         if (get_integer(&qlen,  *argv, 0))
 539                                 invarg("Invalid \"txqueuelen\" value\n", *argv);
 540                         addattr_l(&req->n, sizeof(*req), IFLA_TXQLEN, &qlen, 4);
 541                 } else if (strcmp(*argv, "mtu") == 0) {
 542                         NEXT_ARG();
 543                         if (mtu != -1)
 544                                 duparg("mtu", *argv);
 545                         if (get_integer(&mtu, *argv, 0))
 546                                 invarg("Invalid \"mtu\" value\n", *argv);
 547                         addattr_l(&req->n, sizeof(*req), IFLA_MTU, &mtu, 4);
 548                 } else if (strcmp(*argv, "netns") == 0) {
 549                         NEXT_ARG();
 550                         if (netns != -1)
 551                                 duparg("netns", *argv);
 552                         netns = netns_get_fd(*argv);
 553                         if (netns >= 0)
 554                                 addattr_l(&req->n, sizeof(*req), IFLA_NET_NS_FD,
 555                                           &netns, 4);
 556                         else if (get_integer(&netns, *argv, 0) == 0)
 557                                 addattr_l(&req->n, sizeof(*req), IFLA_NET_NS_PID,
 558                                           &netns, 4);
 559                         else
 560                                 invarg("Invalid \"netns\" value\n", *argv);
 561                 } else if (strcmp(*argv, "multicast") == 0) {
 562                         NEXT_ARG();
 563                         req->i.ifi_change |= IFF_MULTICAST;
 564
 565                         if (strcmp(*argv, "on") == 0)
 566                                 req->i.ifi_flags |= IFF_MULTICAST;
 567                         else if (strcmp(*argv, "off") == 0)
 568                                 req->i.ifi_flags &= ~IFF_MULTICAST;
 569                         else
 570                                 return on_off("multicast", *argv);
 571                 } else if (strcmp(*argv, "allmulticast") == 0) {
 572                         NEXT_ARG();
 573                         req->i.ifi_change |= IFF_ALLMULTI;
 574
 575                         if (strcmp(*argv, "on") == 0)
 576                                 req->i.ifi_flags |= IFF_ALLMULTI;
 577                         else if (strcmp(*argv, "off") == 0)
 578                                 req->i.ifi_flags &= ~IFF_ALLMULTI;
 579                         else
 580                                 return on_off("allmulticast", *argv);
 581                 } else if (strcmp(*argv, "promisc") == 0) {
 582                         NEXT_ARG();
 583                         req->i.ifi_change |= IFF_PROMISC;
 584
 585                         if (strcmp(*argv, "on") == 0)
 586                                 req->i.ifi_flags |= IFF_PROMISC;
 587                         else if (strcmp(*argv, "off") == 0)
 588                                 req->i.ifi_flags &= ~IFF_PROMISC;
 589                         else
 590                                 return on_off("promisc", *argv);
 591                 } else if (strcmp(*argv, "trailers") == 0) {
 592                         NEXT_ARG();
 593                         req->i.ifi_change |= IFF_NOTRAILERS;
 594
 595                         if (strcmp(*argv, "off") == 0)
 596                                 req->i.ifi_flags |= IFF_NOTRAILERS;
 597                         else if (strcmp(*argv, "on") == 0)
 598                                 req->i.ifi_flags &= ~IFF_NOTRAILERS;
 599                         else
 600                                 return on_off("trailers", *argv);
 601                 } else if (strcmp(*argv, "arp") == 0) {
 602                         NEXT_ARG();
 603                         req->i.ifi_change |= IFF_NOARP;
 604
 605                         if (strcmp(*argv, "on") == 0)
 606                                 req->i.ifi_flags &= ~IFF_NOARP;
 607                         else if (strcmp(*argv, "off") == 0)
 608                                 req->i.ifi_flags |= IFF_NOARP;
 609                         else
 610                                 return on_off("arp", *argv);
 611                 } else if (strcmp(*argv, "vf") == 0) {
 612                         struct rtattr *vflist;
 613
 614                         NEXT_ARG();
 615                         if (get_integer(&vf,  *argv, 0))
 616                                 invarg("Invalid \"vf\" value\n", *argv);
 617
 618                         vflist = addattr_nest(&req->n, sizeof(*req),
 619                                               IFLA_VFINFO_LIST);
 620                         if (dev_index == 0)
 621                                 missarg("dev");
 622
 623                         len = iplink_parse_vf(vf, &argc, &argv, req, dev_index);
 624                         if (len < 0)
 625                                 return -1;
 626                         addattr_nest_end(&req->n, vflist);
 627                 } else if (matches(*argv, "master") == 0) {
 628                         int ifindex;
 629
 630                         NEXT_ARG();
 631                         ifindex = ll_name_to_index(*argv);
 632                         if (!ifindex)
 633                                 invarg("Device does not exist\n", *argv);
 634                         addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
 635                                   &ifindex, 4);
 636                 } else if (strcmp(*argv, "vrf") == 0) {
 637                         int ifindex;
 638
 639                         NEXT_ARG();
 640                         ifindex = ll_name_to_index(*argv);
 641                         if (!ifindex)
 642                                 invarg("Not a valid VRF name\n", *argv);
 643                         if (!name_is_vrf(*argv))
 644                                 invarg("Not a valid VRF name\n", *argv);
 645                         addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
 646                                   &ifindex, sizeof(ifindex));
 647                 } else if (matches(*argv, "nomaster") == 0) {
 648                         int ifindex = 0;
 649
 650                         addattr_l(&req->n, sizeof(*req), IFLA_MASTER,
 651                                   &ifindex, 4);
 652                 } else if (matches(*argv, "dynamic") == 0) {
 653                         NEXT_ARG();
 654                         req->i.ifi_change |= IFF_DYNAMIC;
 655
 656                         if (strcmp(*argv, "on") == 0)
 657                                 req->i.ifi_flags |= IFF_DYNAMIC;
 658                         else if (strcmp(*argv, "off") == 0)
 659                                 req->i.ifi_flags &= ~IFF_DYNAMIC;
 660                         else
 661                                 return on_off("dynamic", *argv);
 662                 } else if (matches(*argv, "type") == 0) {
 663                         NEXT_ARG();
 664                         *type = *argv;
 665                         argc--; argv++;
 666                         break;
 667                 } else if (matches(*argv, "alias") == 0) {
 668                         NEXT_ARG();
 669                         addattr_l(&req->n, sizeof(*req), IFLA_IFALIAS,
 670                                   *argv, strlen(*argv));
 671                         argc--; argv++;
 672                         break;
 673                 } else if (strcmp(*argv, "group") == 0) {
 674                         NEXT_ARG();
 675                         if (*group != -1)
 676                                 duparg("group", *argv);
 677                         if (rtnl_group_a2n(group, *argv))
 678                                 invarg("Invalid \"group\" value\n", *argv);
 679                 } else if (strcmp(*argv, "mode") == 0) {
 680                         int mode;
 681
 682                         NEXT_ARG();
 683                         mode = get_link_mode(*argv);
 684                         if (mode < 0)
 685                                 invarg("Invalid link mode\n", *argv);
 686                         addattr8(&req->n, sizeof(*req), IFLA_LINKMODE, mode);
 687                 } else if (strcmp(*argv, "state") == 0) {
 688                         int state;
 689
 690                         NEXT_ARG();
 691                         state = get_operstate(*argv);
 692                         if (state < 0)
 693                                 invarg("Invalid operstate\n", *argv);
 694
 695                         addattr8(&req->n, sizeof(*req), IFLA_OPERSTATE, state);
 696                 } else if (matches(*argv, "numtxqueues") == 0) {
 697                         NEXT_ARG();
 698                         if (numtxqueues != -1)
 699                                 duparg("numtxqueues", *argv);
 700                         if (get_integer(&numtxqueues, *argv, 0))
 701                                 invarg("Invalid \"numtxqueues\" value\n", *argv);
 702                         addattr_l(&req->n, sizeof(*req), IFLA_NUM_TX_QUEUES,
 703                                   &numtxqueues, 4);
 704                 } else if (matches(*argv, "numrxqueues") == 0) {
 705                         NEXT_ARG();
 706                         if (numrxqueues != -1)
 707                                 duparg("numrxqueues", *argv);
 708                         if (get_integer(&numrxqueues, *argv, 0))
 709                                 invarg("Invalid \"numrxqueues\" value\n", *argv);
 710                         addattr_l(&req->n, sizeof(*req), IFLA_NUM_RX_QUEUES,
 711                                   &numrxqueues, 4);
 712                 } else if (matches(*argv, "addrgenmode") == 0) {
 713                         struct rtattr *afs, *afs6;
 714                         int mode;
 715
 716                         NEXT_ARG();
 717                         mode = get_addr_gen_mode(*argv);
 718                         if (mode < 0)
 719                                 invarg("Invalid address generation mode\n", *argv);
 720                         afs = addattr_nest(&req->n, sizeof(*req), IFLA_AF_SPEC);
 721                         afs6 = addattr_nest(&req->n, sizeof(*req), AF_INET6);
 722                         addattr8(&req->n, sizeof(*req),
 723                                  IFLA_INET6_ADDR_GEN_MODE, mode);
 724                         addattr_nest_end(&req->n, afs6);
 725                         addattr_nest_end(&req->n, afs);
 726                 } else if (matches(*argv, "link-netnsid") == 0) {
 727                         NEXT_ARG();
 728                         if (link_netnsid != -1)
 729                                 duparg("link-netnsid", *argv);
 730                         if (get_integer(&link_netnsid, *argv, 0))
 731                                 invarg("Invalid \"link-netnsid\" value\n", *argv);
 732                         addattr32(&req->n, sizeof(*req), IFLA_LINK_NETNSID,
 733                                   link_netnsid);
 734                 } else if (strcmp(*argv, "protodown") == 0) {
 735                         unsigned int proto_down;
 736
 737                         NEXT_ARG();
 738                         if (strcmp(*argv, "on") == 0)
 739                                 proto_down = 1;
 740                         else if (strcmp(*argv, "off") == 0)
 741                                 proto_down = 0;
 742                         else
 743                                 return on_off("protodown", *argv);
 744                         addattr8(&req->n, sizeof(*req), IFLA_PROTO_DOWN,
 745                                  proto_down);
 746                 } else {
 747                         if (matches(*argv, "help") == 0)
 748                                 usage();
 749
 750                         if (strcmp(*argv, "dev") == 0)
 751                                 NEXT_ARG();
 752                         if (*dev)
 753                                 duparg2("dev", *argv);
 754                         *dev = *argv;
 755                         dev_index = ll_name_to_index(*dev);
 756                 }
 757                 argc--; argv++;
 758         }
 759
 760         if (dev_index && addr_len) {
 761                 int halen = nl_get_ll_addr_len(dev_index);
 762
 763                 if (halen >= 0 && halen != addr_len) {
 764                         fprintf(stderr,
 765                                 "Invalid address length %d - must be %d bytes\n",
 766                                 addr_len, halen);
 767                         return -1;
 768                 }
 769         }
 770
 771         return ret - argc;
 772 }
 773
 774 static int iplink_modify(int cmd, unsigned int flags, int argc, char **argv)
 775 {
 776         int len;
 777         char *dev = NULL;
 778         char *name = NULL;
 779         char *link = NULL;
 780         char *type = NULL;
 781         int index = -1;
 782         int group;
 783         struct link_util *lu = NULL;
 784         struct iplink_req req = {
 785                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 786                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 787                 .n.nlmsg_type = cmd,
 788                 .i.ifi_family = preferred_family,
 789         };
 790         int ret;
 791
 792         ret = iplink_parse(argc, argv,
 793                            &req, &name, &type, &link, &dev, &group, &index);
 794         if (ret < 0)
 795                 return ret;
 796
 797         argc -= ret;
 798         argv += ret;
 799
 800         if (group != -1) {
 801                 if (dev)
 802                         addattr_l(&req.n, sizeof(req), IFLA_GROUP,
 803                                         &group, sizeof(group));
 804                 else {
 805                         if (argc) {
 806                                 fprintf(stderr, "Garbage instead of arguments \"%s ...\". Try \"ip link help\".\n",
 807                                                 *argv);
 808                                 return -1;
 809                         }
 810                         if (flags & NLM_F_CREATE) {
 811                                 fprintf(stderr, "group cannot be used when creating devices.\n");
 812                                 return -1;
 813                         }
 814
 815                         req.i.ifi_index = 0;
 816                         addattr32(&req.n, sizeof(req), IFLA_GROUP, group);
 817                         if (rtnl_talk(&rth, &req.n, NULL, 0) < 0)
 818                                 return -2;
 819                         return 0;
 820                 }
 821         }
 822
 823         if (!(flags & NLM_F_CREATE)) {
 824                 if (!dev) {
 825                         fprintf(stderr, "Not enough information: \"dev\" argument is required.\n");
 826                         exit(-1);
 827                 }
 828                 if (cmd == RTM_NEWLINK && index != -1) {
 829                         fprintf(stderr, "index can be used only when creating devices.\n");
 830                         exit(-1);
 831                 }
 832
 833                 req.i.ifi_index = ll_name_to_index(dev);
 834                 if (req.i.ifi_index == 0) {
 835                         fprintf(stderr, "Cannot find device \"%s\"\n", dev);
 836                         return -1;
 837                 }
 838         } else {
 839                 /* Allow "ip link add dev" and "ip link add name" */
 840                 if (!name)
 841                         name = dev;
 842
 843                 if (link) {
 844                         int ifindex;
 845
 846                         ifindex = ll_name_to_index(link);
 847                         if (ifindex == 0) {
 848                                 fprintf(stderr, "Cannot find device \"%s\"\n",
 849                                         link);
 850                                 return -1;
 851                         }
 852                         addattr_l(&req.n, sizeof(req), IFLA_LINK, &ifindex, 4);
 853                 }
 854
 855                 if (index == -1)
 856                         req.i.ifi_index = 0;
 857                 else
 858                         req.i.ifi_index = index;
 859         }
 860
 861         if (name) {
 862                 len = strlen(name) + 1;
 863                 if (len == 1)
 864                         invarg("\"\" is not a valid device identifier\n",
 865                                "name");
 866                 if (len > IFNAMSIZ)
 867                         invarg("\"name\" too long\n", name);
 868                 addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name, len);
 869         }
 870
 871         if (type) {
 872                 struct rtattr *linkinfo;
 873                 char slavebuf[128], *ulinep = strchr(type, '_');
 874                 int iflatype;
 875
 876                 linkinfo = addattr_nest(&req.n, sizeof(req), IFLA_LINKINFO);
 877                 addattr_l(&req.n, sizeof(req), IFLA_INFO_KIND, type,
 878                          strlen(type));
 879
 880                 if (ulinep && !strcmp(ulinep, "_slave")) {
 881                         strncpy(slavebuf, type, sizeof(slavebuf));
 882                         slavebuf[sizeof(slavebuf) - 1] = '\0';
 883                         ulinep = strchr(slavebuf, '_');
 884                         /* check in case it was after sizeof(slavebuf) - 1*/
 885                         if (ulinep)
 886                                 *ulinep = '\0';
 887                         lu = get_link_slave_kind(slavebuf);
 888                         iflatype = IFLA_INFO_SLAVE_DATA;
 889                 } else {
 890                         lu = get_link_kind(type);
 891                         iflatype = IFLA_INFO_DATA;
 892                 }
 893                 if (lu && argc) {
 894                         struct rtattr *data = addattr_nest(&req.n,
 895                                                            sizeof(req), iflatype);
 896
 897                         if (lu->parse_opt &&
 898                             lu->parse_opt(lu, argc, argv, &req.n))
 899                                 return -1;
 900
 901                         addattr_nest_end(&req.n, data);
 902                 } else if (argc) {
 903                         if (matches(*argv, "help") == 0)
 904                                 usage();
 905                         fprintf(stderr, "Garbage instead of arguments \"%s ...\". Try \"ip link help\".\n",
 906                                         *argv);
 907                         return -1;
 908                 }
 909                 addattr_nest_end(&req.n, linkinfo);
 910         } else if (flags & NLM_F_CREATE) {
 911                 fprintf(stderr, "Not enough information: \"type\" argument is required\n");
 912                 return -1;
 913         }
 914
 915         if (rtnl_talk(&rth, &req.n, NULL, 0) < 0)
 916                 return -2;
 917
 918         return 0;
 919 }
 920
 921 int iplink_get(unsigned int flags, char *name, __u32 filt_mask)
 922 {
 923         int len;
 924         struct iplink_req req = {
 925                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 926                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 927                 .n.nlmsg_type = RTM_GETLINK,
 928                 .i.ifi_family = preferred_family,
 929         };
 930         struct {
 931                 struct nlmsghdr n;
 932                 char buf[16384];
 933         } answer;
 934
 935         if (name) {
 936                 len = strlen(name) + 1;
 937                 if (len == 1)
 938                         invarg("\"\" is not a valid device identifier\n",
 939                                    "name");
 940                 if (len > IFNAMSIZ)
 941                         invarg("\"name\" too long\n", name);
 942                 addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name, len);
 943         }
 944         addattr32(&req.n, sizeof(req), IFLA_EXT_MASK, filt_mask);
 945
 946         if (rtnl_talk(&rth, &req.n, &answer.n, sizeof(answer)) < 0)
 947                 return -2;
 948
 949         if (brief)
 950                 print_linkinfo_brief(NULL, &answer.n, stdout);
 951         else
 952                 print_linkinfo(NULL, &answer.n, stdout);
 953
 954         return 0;
 955 }
 956
 957 #if IPLINK_IOCTL_COMPAT
 958 static int get_ctl_fd(void)
 959 {
 960         int s_errno;
 961         int fd;
 962
 963         fd = socket(PF_INET, SOCK_DGRAM, 0);
 964         if (fd >= 0)
 965                 return fd;
 966         s_errno = errno;
 967         fd = socket(PF_PACKET, SOCK_DGRAM, 0);
 968         if (fd >= 0)
 969                 return fd;
 970         fd = socket(PF_INET6, SOCK_DGRAM, 0);
 971         if (fd >= 0)
 972                 return fd;
 973         errno = s_errno;
 974         perror("Cannot create control socket");
 975         return -1;
 976 }
 977
 978 static int do_chflags(const char *dev, __u32 flags, __u32 mask)
 979 {
 980         struct ifreq ifr;
 981         int fd;
 982         int err;
 983
 984         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
 985         fd = get_ctl_fd();
 986         if (fd < 0)
 987                 return -1;
 988         err = ioctl(fd, SIOCGIFFLAGS, &ifr);
 989         if (err) {
 990                 perror("SIOCGIFFLAGS");
 991                 close(fd);
 992                 return -1;
 993         }
 994         if ((ifr.ifr_flags^flags)&mask) {
 995                 ifr.ifr_flags &= ~mask;
 996                 ifr.ifr_flags |= mask&flags;
 997                 err = ioctl(fd, SIOCSIFFLAGS, &ifr);
 998                 if (err)
 999                         perror("SIOCSIFFLAGS");
1000         }
1001         close(fd);
1002         return err;
1003 }
1004
1005 static int do_changename(const char *dev, const char *newdev)
1006 {
1007         struct ifreq ifr;
1008         int fd;
1009         int err;
1010
1011         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
1012         strncpy(ifr.ifr_newname, newdev, IFNAMSIZ);
1013         fd = get_ctl_fd();
1014         if (fd < 0)
1015                 return -1;
1016         err = ioctl(fd, SIOCSIFNAME, &ifr);
1017         if (err) {
1018                 perror("SIOCSIFNAME");
1019                 close(fd);
1020                 return -1;
1021         }
1022         close(fd);
1023         return err;
1024 }
1025
1026 static int set_qlen(const char *dev, int qlen)
1027 {
1028         struct ifreq ifr = { .ifr_qlen = qlen };
1029         int s;
1030
1031         s = get_ctl_fd();
1032         if (s < 0)
1033                 return -1;
1034
1035         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
1036         if (ioctl(s, SIOCSIFTXQLEN, &ifr) < 0) {
1037                 perror("SIOCSIFXQLEN");
1038                 close(s);
1039                 return -1;
1040         }
1041         close(s);
1042
1043         return 0;
1044 }
1045
1046 static int set_mtu(const char *dev, int mtu)
1047 {
1048         struct ifreq ifr = { .ifr_mtu = mtu };
1049         int s;
1050
1051         s = get_ctl_fd();
1052         if (s < 0)
1053                 return -1;
1054
1055         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
1056         if (ioctl(s, SIOCSIFMTU, &ifr) < 0) {
1057                 perror("SIOCSIFMTU");
1058                 close(s);
1059                 return -1;
1060         }
1061         close(s);
1062
1063         return 0;
1064 }
1065
1066 static int get_address(const char *dev, int *htype)
1067 {
1068         struct ifreq ifr = {};
1069         struct sockaddr_ll me = {
1070                 .sll_family = AF_PACKET,
1071                 .sll_protocol = htons(ETH_P_LOOP),
1072         };
1073         socklen_t alen;
1074         int s;
1075
1076         s = socket(PF_PACKET, SOCK_DGRAM, 0);
1077         if (s < 0) {
1078                 perror("socket(PF_PACKET)");
1079                 return -1;
1080         }
1081
1082         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
1083         if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
1084                 perror("SIOCGIFINDEX");
1085                 close(s);
1086                 return -1;
1087         }
1088
1089         me.sll_ifindex = ifr.ifr_ifindex;
1090         if (bind(s, (struct sockaddr *)&me, sizeof(me)) == -1) {
1091                 perror("bind");
1092                 close(s);
1093                 return -1;
1094         }
1095
1096         alen = sizeof(me);
1097         if (getsockname(s, (struct sockaddr *)&me, &alen) == -1) {
1098                 perror("getsockname");
1099                 close(s);
1100                 return -1;
1101         }
1102         close(s);
1103         *htype = me.sll_hatype;
1104         return me.sll_halen;
1105 }
1106
1107 static int parse_address(const char *dev, int hatype, int halen,
1108                 char *lla, struct ifreq *ifr)
1109 {
1110         int alen;
1111
1112         memset(ifr, 0, sizeof(*ifr));
1113         strncpy(ifr->ifr_name, dev, IFNAMSIZ);
1114         ifr->ifr_hwaddr.sa_family = hatype;
1115         alen = ll_addr_a2n(ifr->ifr_hwaddr.sa_data, 14, lla);
1116         if (alen < 0)
1117                 return -1;
1118         if (alen != halen) {
1119                 fprintf(stderr, "Wrong address (%s) length: expected %d bytes\n",
1120                         lla, halen);
1121                 return -1;
1122         }
1123         return 0;
1124 }
1125
1126 static int set_address(struct ifreq *ifr, int brd)
1127 {
1128         int s;
1129
1130         s = get_ctl_fd();
1131         if (s < 0)
1132                 return -1;
1133         if (ioctl(s, brd?SIOCSIFHWBROADCAST:SIOCSIFHWADDR, ifr) < 0) {
1134                 perror(brd?"SIOCSIFHWBROADCAST":"SIOCSIFHWADDR");
1135                 close(s);
1136                 return -1;
1137         }
1138         close(s);
1139         return 0;
1140 }
1141
1142 static int do_set(int argc, char **argv)
1143 {
1144         char *dev = NULL;
1145         __u32 mask = 0;
1146         __u32 flags = 0;
1147         int qlen = -1;
1148         int mtu = -1;
1149         char *newaddr = NULL;
1150         char *newbrd = NULL;
1151         struct ifreq ifr0, ifr1;
1152         char *newname = NULL;
1153         int htype, halen;
1154
1155         while (argc > 0) {
1156                 if (strcmp(*argv, "up") == 0) {
1157                         mask |= IFF_UP;
1158                         flags |= IFF_UP;
1159                 } else if (strcmp(*argv, "down") == 0) {
1160                         mask |= IFF_UP;
1161                         flags &= ~IFF_UP;
1162                 } else if (strcmp(*argv, "name") == 0) {
1163                         NEXT_ARG();
1164                         newname = *argv;
1165                 } else if (matches(*argv, "address") == 0) {
1166                         NEXT_ARG();
1167                         newaddr = *argv;
1168                 } else if (matches(*argv, "broadcast") == 0 ||
1169                            strcmp(*argv, "brd") == 0) {
1170                         NEXT_ARG();
1171                         newbrd = *argv;
1172                 } else if (matches(*argv, "txqueuelen") == 0 ||
1173                            strcmp(*argv, "qlen") == 0 ||
1174                            matches(*argv, "txqlen") == 0) {
1175                         NEXT_ARG();
1176                         if (qlen != -1)
1177                                 duparg("txqueuelen", *argv);
1178                         if (get_integer(&qlen,  *argv, 0))
1179                                 invarg("Invalid \"txqueuelen\" value\n", *argv);
1180                 } else if (strcmp(*argv, "mtu") == 0) {
1181                         NEXT_ARG();
1182                         if (mtu != -1)
1183                                 duparg("mtu", *argv);
1184                         if (get_integer(&mtu, *argv, 0))
1185                                 invarg("Invalid \"mtu\" value\n", *argv);
1186                 } else if (strcmp(*argv, "multicast") == 0) {
1187                         NEXT_ARG();
1188                         mask |= IFF_MULTICAST;
1189
1190                         if (strcmp(*argv, "on") == 0)
1191                                 flags |= IFF_MULTICAST;
1192                         else if (strcmp(*argv, "off") == 0)
1193                                 flags &= ~IFF_MULTICAST;
1194                         else
1195                                 return on_off("multicast", *argv);
1196                 } else if (strcmp(*argv, "allmulticast") == 0) {
1197                         NEXT_ARG();
1198                         mask |= IFF_ALLMULTI;
1199
1200                         if (strcmp(*argv, "on") == 0)
1201                                 flags |= IFF_ALLMULTI;
1202                         else if (strcmp(*argv, "off") == 0)
1203                                 flags &= ~IFF_ALLMULTI;
1204                         else
1205                                 return on_off("allmulticast", *argv);
1206                 } else if (strcmp(*argv, "promisc") == 0) {
1207                         NEXT_ARG();
1208                         mask |= IFF_PROMISC;
1209
1210                         if (strcmp(*argv, "on") == 0)
1211                                 flags |= IFF_PROMISC;
1212                         else if (strcmp(*argv, "off") == 0)
1213                                 flags &= ~IFF_PROMISC;
1214                         else
1215                                 return on_off("promisc", *argv);
1216                 } else if (strcmp(*argv, "trailers") == 0) {
1217                         NEXT_ARG();
1218                         mask |= IFF_NOTRAILERS;
1219
1220                         if (strcmp(*argv, "off") == 0)
1221                                 flags |= IFF_NOTRAILERS;
1222                         else if (strcmp(*argv, "on") == 0)
1223                                 flags &= ~IFF_NOTRAILERS;
1224                         else
1225                                 return on_off("trailers", *argv);
1226                 } else if (strcmp(*argv, "arp") == 0) {
1227                         NEXT_ARG();
1228                         mask |= IFF_NOARP;
1229
1230                         if (strcmp(*argv, "on") == 0)
1231                                 flags &= ~IFF_NOARP;
1232                         else if (strcmp(*argv, "off") == 0)
1233                                 flags |= IFF_NOARP;
1234                         else
1235                                 return on_off("arp", *argv);
1236                 } else if (matches(*argv, "dynamic") == 0) {
1237                         NEXT_ARG();
1238                         mask |= IFF_DYNAMIC;
1239
1240                         if (strcmp(*argv, "on") == 0)
1241                                 flags |= IFF_DYNAMIC;
1242                         else if (strcmp(*argv, "off") == 0)
1243                                 flags &= ~IFF_DYNAMIC;
1244                         else
1245                                 return on_off("dynamic", *argv);
1246                 } else {
1247                         if (strcmp(*argv, "dev") == 0)
1248                                 NEXT_ARG();
1249                         else if (matches(*argv, "help") == 0)
1250                                 usage();
1251
1252                         if (dev)
1253                                 duparg2("dev", *argv);
1254                         dev = *argv;
1255                 }
1256                 argc--; argv++;
1257         }
1258
1259         if (!dev) {
1260                 fprintf(stderr,
1261                         "Not enough of information: \"dev\" argument is required.\n");
1262                 exit(-1);
1263         }
1264
1265         if (newaddr || newbrd) {
1266                 halen = get_address(dev, &htype);
1267                 if (halen < 0)
1268                         return -1;
1269                 if (newaddr) {
1270                         if (parse_address(dev, htype, halen, newaddr, &ifr0) < 0)
1271                                 return -1;
1272                 }
1273                 if (newbrd) {
1274                         if (parse_address(dev, htype, halen, newbrd, &ifr1) < 0)
1275                                 return -1;
1276                 }
1277         }
1278
1279         if (newname && strcmp(dev, newname)) {
1280                 if (strlen(newname) == 0)
1281                         invarg("\"\" is not a valid device identifier\n", "name");
1282                 if (do_changename(dev, newname) < 0)
1283                         return -1;
1284                 dev = newname;
1285         }
1286         if (qlen != -1) {
1287                 if (set_qlen(dev, qlen) < 0)
1288                         return -1;
1289         }
1290         if (mtu != -1) {
1291                 if (set_mtu(dev, mtu) < 0)
1292                         return -1;
1293         }
1294         if (newaddr || newbrd) {
1295                 if (newbrd) {
1296                         if (set_address(&ifr1, 1) < 0)
1297                                 return -1;
1298                 }
1299                 if (newaddr) {
1300                         if (set_address(&ifr0, 0) < 0)
1301                                 return -1;
1302                 }
1303         }
1304         if (mask)
1305                 return do_chflags(dev, flags, mask);
1306         return 0;
1307 }
1308 #endif /* IPLINK_IOCTL_COMPAT */
1309
1310 static void do_help(int argc, char **argv)
1311 {
1312         struct link_util *lu = NULL;
1313
1314         if (argc <= 0) {
1315                 usage();
1316                 return;
1317         }
1318
1319         lu = get_link_kind(*argv);
1320         if (lu && lu->print_help)
1321                 lu->print_help(lu, argc-1, argv+1, stdout);
1322         else
1323                 usage();
1324 }
1325
1326 int do_iplink(int argc, char **argv)
1327 {
1328         if (argc < 1)
1329                 return ipaddr_list_link(0, NULL);
1330
1331         if (iplink_have_newlink()) {
1332                 if (matches(*argv, "add") == 0)
1333                         return iplink_modify(RTM_NEWLINK,
1334                                              NLM_F_CREATE|NLM_F_EXCL,
1335                                              argc-1, argv+1);
1336                 if (matches(*argv, "set") == 0 ||
1337                     matches(*argv, "change") == 0)
1338                         return iplink_modify(RTM_NEWLINK, 0,
1339                                              argc-1, argv+1);
1340                 if (matches(*argv, "replace") == 0)
1341                         return iplink_modify(RTM_NEWLINK,
1342                                              NLM_F_CREATE|NLM_F_REPLACE,
1343                                              argc-1, argv+1);
1344                 if (matches(*argv, "delete") == 0)
1345                         return iplink_modify(RTM_DELLINK, 0,
1346                                              argc-1, argv+1);
1347         } else {
1348 #if IPLINK_IOCTL_COMPAT
1349                 if (matches(*argv, "set") == 0)
1350                         return do_set(argc-1, argv+1);
1351 #endif
1352         }
1353
1354         if (matches(*argv, "show") == 0 ||
1355             matches(*argv, "lst") == 0 ||
1356             matches(*argv, "list") == 0)
1357                 return ipaddr_list_link(argc-1, argv+1);
1358
1359         if (matches(*argv, "help") == 0) {
1360                 do_help(argc-1, argv+1);
1361                 return 0;
1362         }
1363
1364         fprintf(stderr, "Command \"%s\" is unknown, try \"ip link help\".\n",
1365                 *argv);
1366         exit(-1);
1367 }