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