ip/ipneigh.c

   1 /*
   2  * ipneigh.c            "ip neigh".
   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 <fcntl.h>
  17 #include <string.h>
  18 #include <sys/time.h>
  19 #include <sys/socket.h>
  20 #include <netinet/in.h>
  21 #include <netinet/ip.h>
  22
  23 #include "rt_names.h"
  24 #include "utils.h"
  25 #include "ip_common.h"
  26 #include "json_print.h"
  27
  28 #define NUD_VALID       (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
  29 #define MAX_ROUNDS      10
  30
  31 static struct
  32 {
  33         int family;
  34         int index;
  35         int state;
  36         int unused_only;
  37         inet_prefix pfx;
  38         int flushed;
  39         char *flushb;
  40         int flushp;
  41         int flushe;
  42         int master;
  43         int protocol;
  44         __u8 ndm_flags;
  45 } filter;
  46
  47 static void usage(void) __attribute__((noreturn));
  48
  49 static void usage(void)
  50 {
  51         fprintf(stderr,
  52                 "Usage: ip neigh { add | del | change | replace }\n"
  53                 "               { ADDR [ lladdr LLADDR ] [ nud STATE ] | proxy ADDR } [ dev DEV ]\n"
  54                 "               [ router ] [ extern_learn ] [ protocol PROTO ]\n"
  55                 "\n"
  56                 "       ip neigh { show | flush } [ proxy ] [ to PREFIX ] [ dev DEV ] [ nud STATE ]\n"
  57                 "                                 [ vrf NAME ]\n"
  58                 "\n"
  59                 "STATE := { permanent | noarp | stale | reachable | none |\n"
  60                 "           incomplete | delay | probe | failed }\n");
  61         exit(-1);
  62 }
  63
  64 static int nud_state_a2n(unsigned int *state, const char *arg)
  65 {
  66         if (matches(arg, "permanent") == 0)
  67                 *state = NUD_PERMANENT;
  68         else if (matches(arg, "reachable") == 0)
  69                 *state = NUD_REACHABLE;
  70         else if (strcmp(arg, "noarp") == 0)
  71                 *state = NUD_NOARP;
  72         else if (strcmp(arg, "none") == 0)
  73                 *state = NUD_NONE;
  74         else if (strcmp(arg, "stale") == 0)
  75                 *state = NUD_STALE;
  76         else if (strcmp(arg, "incomplete") == 0)
  77                 *state = NUD_INCOMPLETE;
  78         else if (strcmp(arg, "delay") == 0)
  79                 *state = NUD_DELAY;
  80         else if (strcmp(arg, "probe") == 0)
  81                 *state = NUD_PROBE;
  82         else if (matches(arg, "failed") == 0)
  83                 *state = NUD_FAILED;
  84         else {
  85                 if (get_unsigned(state, arg, 0))
  86                         return -1;
  87                 if (*state >= 0x100 || (*state&((*state)-1)))
  88                         return -1;
  89         }
  90         return 0;
  91 }
  92
  93 static int flush_update(void)
  94 {
  95         if (rtnl_send_check(&rth, filter.flushb, filter.flushp) < 0) {
  96                 perror("Failed to send flush request");
  97                 return -1;
  98         }
  99         filter.flushp = 0;
 100         return 0;
 101 }
 102
 103
 104 static int ipneigh_modify(int cmd, int flags, int argc, char **argv)
 105 {
 106         struct {
 107                 struct nlmsghdr n;
 108                 struct ndmsg            ndm;
 109                 char                    buf[256];
 110         } req = {
 111                 .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
 112                 .n.nlmsg_flags = NLM_F_REQUEST | flags,
 113                 .n.nlmsg_type = cmd,
 114                 .ndm.ndm_family = preferred_family,
 115                 .ndm.ndm_state = NUD_PERMANENT,
 116         };
 117         char  *dev = NULL;
 118         int dst_ok = 0;
 119         int dev_ok = 0;
 120         int lladdr_ok = 0;
 121         char *lla = NULL;
 122         inet_prefix dst;
 123
 124         while (argc > 0) {
 125                 if (matches(*argv, "lladdr") == 0) {
 126                         NEXT_ARG();
 127                         if (lladdr_ok)
 128                                 duparg("lladdr", *argv);
 129                         lla = *argv;
 130                         lladdr_ok = 1;
 131                 } else if (strcmp(*argv, "nud") == 0) {
 132                         unsigned int state;
 133
 134                         NEXT_ARG();
 135                         if (nud_state_a2n(&state, *argv))
 136                                 invarg("nud state is bad", *argv);
 137                         req.ndm.ndm_state = state;
 138                 } else if (matches(*argv, "proxy") == 0) {
 139                         NEXT_ARG();
 140                         if (matches(*argv, "help") == 0)
 141                                 usage();
 142                         if (dst_ok)
 143                                 duparg("address", *argv);
 144                         get_addr(&dst, *argv, preferred_family);
 145                         dst_ok = 1;
 146                         dev_ok = 1;
 147                         req.ndm.ndm_flags |= NTF_PROXY;
 148                 } else if (strcmp(*argv, "router") == 0) {
 149                         req.ndm.ndm_flags |= NTF_ROUTER;
 150                 } else if (matches(*argv, "extern_learn") == 0) {
 151                         req.ndm.ndm_flags |= NTF_EXT_LEARNED;
 152                 } else if (strcmp(*argv, "dev") == 0) {
 153                         NEXT_ARG();
 154                         dev = *argv;
 155                         dev_ok = 1;
 156                 } else if (matches(*argv, "protocol") == 0) {
 157                         __u32 proto;
 158
 159                         NEXT_ARG();
 160                         if (rtnl_rtprot_a2n(&proto, *argv))
 161                                 invarg("\"protocol\" value is invalid\n", *argv);
 162                         if (addattr8(&req.n, sizeof(req), NDA_PROTOCOL, proto))
 163                                 return -1;
 164                 } else {
 165                         if (strcmp(*argv, "to") == 0) {
 166                                 NEXT_ARG();
 167                         }
 168                         if (matches(*argv, "help") == 0) {
 169                                 NEXT_ARG();
 170                         }
 171                         if (dst_ok)
 172                                 duparg2("to", *argv);
 173                         get_addr(&dst, *argv, preferred_family);
 174                         dst_ok = 1;
 175                 }
 176                 argc--; argv++;
 177         }
 178         if (!dev_ok || !dst_ok || dst.family == AF_UNSPEC) {
 179                 fprintf(stderr, "Device and destination are required arguments.\n");
 180                 exit(-1);
 181         }
 182         req.ndm.ndm_family = dst.family;
 183         if (addattr_l(&req.n, sizeof(req), NDA_DST, &dst.data, dst.bytelen) < 0)
 184                 return -1;
 185
 186         if (lla && strcmp(lla, "null")) {
 187                 char llabuf[20];
 188                 int l;
 189
 190                 l = ll_addr_a2n(llabuf, sizeof(llabuf), lla);
 191                 if (l < 0)
 192                         return -1;
 193
 194                 if (addattr_l(&req.n, sizeof(req), NDA_LLADDR, llabuf, l) < 0)
 195                         return -1;
 196         }
 197
 198         ll_init_map(&rth);
 199
 200         if (dev) {
 201                 req.ndm.ndm_ifindex = ll_name_to_index(dev);
 202                 if (!req.ndm.ndm_ifindex)
 203                         return nodev(dev);
 204         }
 205
 206         if (rtnl_talk(&rth, &req.n, NULL) < 0)
 207                 exit(2);
 208
 209         return 0;
 210 }
 211
 212 static void print_cacheinfo(const struct nda_cacheinfo *ci)
 213 {
 214         static int hz;
 215
 216         if (!hz)
 217                 hz = get_user_hz();
 218
 219         if (ci->ndm_refcnt)
 220                 print_uint(PRINT_ANY, "refcnt",
 221                                 " ref %u", ci->ndm_refcnt);
 222
 223         print_uint(PRINT_ANY, "used", " used %u", ci->ndm_used / hz);
 224         print_uint(PRINT_ANY, "confirmed", "/%u", ci->ndm_confirmed / hz);
 225         print_uint(PRINT_ANY, "updated", "/%u", ci->ndm_updated / hz);
 226 }
 227
 228 static void print_neigh_state(unsigned int nud)
 229 {
 230
 231         open_json_array(PRINT_JSON,
 232                         is_json_context() ?  "state" : "");
 233
 234 #define PRINT_FLAG(f)                                           \
 235         if (nud & NUD_##f) {                                    \
 236                 nud &= ~NUD_##f;                                \
 237                 print_string(PRINT_ANY, NULL, " %s", #f);       \
 238         }
 239
 240         PRINT_FLAG(INCOMPLETE);
 241         PRINT_FLAG(REACHABLE);
 242         PRINT_FLAG(STALE);
 243         PRINT_FLAG(DELAY);
 244         PRINT_FLAG(PROBE);
 245         PRINT_FLAG(FAILED);
 246         PRINT_FLAG(NOARP);
 247         PRINT_FLAG(PERMANENT);
 248 #undef PRINT_FLAG
 249
 250         close_json_array(PRINT_JSON, NULL);
 251 }
 252
 253 int print_neigh(struct nlmsghdr *n, void *arg)
 254 {
 255         FILE *fp = (FILE *)arg;
 256         struct ndmsg *r = NLMSG_DATA(n);
 257         int len = n->nlmsg_len;
 258         struct rtattr *tb[NDA_MAX+1];
 259         static int logit = 1;
 260         __u8 protocol = 0;
 261
 262         if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH &&
 263             n->nlmsg_type != RTM_GETNEIGH) {
 264                 fprintf(stderr, "Not RTM_NEWNEIGH: %08x %08x %08x\n",
 265                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
 266
 267                 return 0;
 268         }
 269         len -= NLMSG_LENGTH(sizeof(*r));
 270         if (len < 0) {
 271                 fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
 272                 return -1;
 273         }
 274
 275         if (filter.flushb && n->nlmsg_type != RTM_NEWNEIGH)
 276                 return 0;
 277
 278         if (filter.family && filter.family != r->ndm_family)
 279                 return 0;
 280         if (filter.index && filter.index != r->ndm_ifindex)
 281                 return 0;
 282         if (!(filter.state&r->ndm_state) &&
 283             !(r->ndm_flags & NTF_PROXY) &&
 284             !(r->ndm_flags & NTF_EXT_LEARNED) &&
 285             (r->ndm_state || !(filter.state&0x100)) &&
 286             (r->ndm_family != AF_DECnet))
 287                 return 0;
 288
 289         if (filter.master && !(n->nlmsg_flags & NLM_F_DUMP_FILTERED)) {
 290                 if (logit) {
 291                         logit = 0;
 292                         fprintf(fp,
 293                                 "\nWARNING: Kernel does not support filtering by master device\n\n");
 294                 }
 295         }
 296
 297         parse_rtattr(tb, NDA_MAX, NDA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
 298
 299         if (inet_addr_match_rta(&filter.pfx, tb[NDA_DST]))
 300                 return 0;
 301
 302         if (tb[NDA_PROTOCOL])
 303                 protocol = rta_getattr_u8(tb[NDA_PROTOCOL]);
 304
 305         if (filter.protocol && filter.protocol != protocol)
 306                 return 0;
 307
 308         if (filter.unused_only && tb[NDA_CACHEINFO]) {
 309                 struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
 310
 311                 if (ci->ndm_refcnt)
 312                         return 0;
 313         }
 314
 315         if (filter.flushb) {
 316                 struct nlmsghdr *fn;
 317
 318                 if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
 319                         if (flush_update())
 320                                 return -1;
 321                 }
 322                 fn = (struct nlmsghdr *)(filter.flushb + NLMSG_ALIGN(filter.flushp));
 323                 memcpy(fn, n, n->nlmsg_len);
 324                 fn->nlmsg_type = RTM_DELNEIGH;
 325                 fn->nlmsg_flags = NLM_F_REQUEST;
 326                 fn->nlmsg_seq = ++rth.seq;
 327                 filter.flushp = (((char *)fn) + n->nlmsg_len) - filter.flushb;
 328                 filter.flushed++;
 329                 if (show_stats < 2)
 330                         return 0;
 331         }
 332
 333         open_json_object(NULL);
 334         if (n->nlmsg_type == RTM_DELNEIGH)
 335                 print_bool(PRINT_ANY, "deleted", "Deleted ", true);
 336         else if (n->nlmsg_type == RTM_GETNEIGH)
 337                 print_null(PRINT_ANY, "miss", "%s ", "miss");
 338
 339         if (tb[NDA_DST]) {
 340                 const char *dst;
 341                 int family = r->ndm_family;
 342
 343                 if (family == AF_BRIDGE) {
 344                         if (RTA_PAYLOAD(tb[NDA_DST]) == sizeof(struct in6_addr))
 345                                 family = AF_INET6;
 346                         else
 347                                 family = AF_INET;
 348                 }
 349
 350                 dst = format_host_rta(family, tb[NDA_DST]);
 351                 print_color_string(PRINT_ANY,
 352                                    ifa_family_color(family),
 353                                    "dst", "%s ", dst);
 354         }
 355
 356         if (!filter.index && r->ndm_ifindex) {
 357                 if (!is_json_context())
 358                         fprintf(fp, "dev ");
 359
 360                 print_color_string(PRINT_ANY, COLOR_IFNAME,
 361                                    "dev", "%s ",
 362                                    ll_index_to_name(r->ndm_ifindex));
 363         }
 364
 365         if (tb[NDA_LLADDR]) {
 366                 const char *lladdr;
 367                 SPRINT_BUF(b1);
 368
 369                 lladdr = ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
 370                                      RTA_PAYLOAD(tb[NDA_LLADDR]),
 371                                      ll_index_to_type(r->ndm_ifindex),
 372                                      b1, sizeof(b1));
 373
 374                 if (!is_json_context())
 375                         fprintf(fp, "lladdr ");
 376
 377                 print_color_string(PRINT_ANY, COLOR_MAC,
 378                                    "lladdr", "%s", lladdr);
 379         }
 380
 381         if (r->ndm_flags & NTF_ROUTER)
 382                 print_null(PRINT_ANY, "router", " %s", "router");
 383
 384         if (r->ndm_flags & NTF_PROXY)
 385                 print_null(PRINT_ANY, "proxy", " %s", "proxy");
 386
 387         if (r->ndm_flags & NTF_EXT_LEARNED)
 388                 print_null(PRINT_ANY, "extern_learn", " %s ", "extern_learn");
 389
 390         if (r->ndm_flags & NTF_OFFLOADED)
 391                 print_null(PRINT_ANY, "offload", " %s", "offload");
 392
 393         if (show_stats) {
 394                 if (tb[NDA_CACHEINFO])
 395                         print_cacheinfo(RTA_DATA(tb[NDA_CACHEINFO]));
 396
 397                 if (tb[NDA_PROBES])
 398                         print_uint(PRINT_ANY, "probes", " probes %u",
 399                                    rta_getattr_u32(tb[NDA_PROBES]));
 400         }
 401
 402         if (r->ndm_state)
 403                 print_neigh_state(r->ndm_state);
 404
 405         if (protocol) {
 406                 SPRINT_BUF(b1);
 407
 408                 print_string(PRINT_ANY, "protocol", " proto %s ",
 409                              rtnl_rtprot_n2a(protocol, b1, sizeof(b1)));
 410         }
 411
 412         print_string(PRINT_FP, NULL, "\n", "");
 413         close_json_object();
 414         fflush(stdout);
 415
 416         return 0;
 417 }
 418
 419 void ipneigh_reset_filter(int ifindex)
 420 {
 421         memset(&filter, 0, sizeof(filter));
 422         filter.state = ~0;
 423         filter.index = ifindex;
 424 }
 425
 426 static int ipneigh_dump_filter(struct nlmsghdr *nlh, int reqlen)
 427 {
 428         struct ndmsg *ndm = NLMSG_DATA(nlh);
 429         int err;
 430
 431         ndm->ndm_flags = filter.ndm_flags;
 432
 433         if (filter.index) {
 434                 err = addattr32(nlh, reqlen, NDA_IFINDEX, filter.index);
 435                 if (err)
 436                         return err;
 437         }
 438         if (filter.master) {
 439                 err = addattr32(nlh, reqlen, NDA_MASTER, filter.master);
 440                 if (err)
 441                         return err;
 442         }
 443
 444         return 0;
 445 }
 446
 447 static int do_show_or_flush(int argc, char **argv, int flush)
 448 {
 449         char *filter_dev = NULL;
 450         int state_given = 0;
 451
 452         ipneigh_reset_filter(0);
 453
 454         if (!filter.family)
 455                 filter.family = preferred_family;
 456
 457         if (flush) {
 458                 if (argc <= 0) {
 459                         fprintf(stderr, "Flush requires arguments.\n");
 460                         return -1;
 461                 }
 462                 filter.state = ~(NUD_PERMANENT|NUD_NOARP);
 463         } else
 464                 filter.state = 0xFF & ~NUD_NOARP;
 465
 466         while (argc > 0) {
 467                 if (strcmp(*argv, "dev") == 0) {
 468                         NEXT_ARG();
 469                         if (filter_dev)
 470                                 duparg("dev", *argv);
 471                         filter_dev = *argv;
 472                 } else if (strcmp(*argv, "master") == 0) {
 473                         int ifindex;
 474
 475                         NEXT_ARG();
 476                         ifindex = ll_name_to_index(*argv);
 477                         if (!ifindex)
 478                                 invarg("Device does not exist\n", *argv);
 479                         filter.master = ifindex;
 480                 } else if (strcmp(*argv, "vrf") == 0) {
 481                         int ifindex;
 482
 483                         NEXT_ARG();
 484                         ifindex = ll_name_to_index(*argv);
 485                         if (!ifindex)
 486                                 invarg("Not a valid VRF name\n", *argv);
 487                         if (!name_is_vrf(*argv))
 488                                 invarg("Not a valid VRF name\n", *argv);
 489                         filter.master = ifindex;
 490                 } else if (strcmp(*argv, "unused") == 0) {
 491                         filter.unused_only = 1;
 492                 } else if (strcmp(*argv, "nud") == 0) {
 493                         unsigned int state;
 494
 495                         NEXT_ARG();
 496                         if (!state_given) {
 497                                 state_given = 1;
 498                                 filter.state = 0;
 499                         }
 500                         if (nud_state_a2n(&state, *argv)) {
 501                                 if (strcmp(*argv, "all") != 0)
 502                                         invarg("nud state is bad", *argv);
 503                                 state = ~0;
 504                                 if (flush)
 505                                         state &= ~NUD_NOARP;
 506                         }
 507                         if (state == 0)
 508                                 state = 0x100;
 509                         filter.state |= state;
 510                 } else if (strcmp(*argv, "proxy") == 0) {
 511                         filter.ndm_flags = NTF_PROXY;
 512                 } else if (matches(*argv, "protocol") == 0) {
 513                         __u32 prot;
 514
 515                         NEXT_ARG();
 516                         if (rtnl_rtprot_a2n(&prot, *argv)) {
 517                                 if (strcmp(*argv, "all"))
 518                                         invarg("invalid \"protocol\"\n", *argv);
 519                                 prot = 0;
 520                         }
 521                         filter.protocol = prot;
 522                 } else {
 523                         if (strcmp(*argv, "to") == 0) {
 524                                 NEXT_ARG();
 525                         }
 526                         if (matches(*argv, "help") == 0)
 527                                 usage();
 528                         if (get_prefix(&filter.pfx, *argv, filter.family))
 529                                 invarg("to value is invalid\n", *argv);
 530                         if (filter.family == AF_UNSPEC)
 531                                 filter.family = filter.pfx.family;
 532                 }
 533                 argc--; argv++;
 534         }
 535
 536         ll_init_map(&rth);
 537
 538         if (filter_dev) {
 539                 filter.index = ll_name_to_index(filter_dev);
 540                 if (!filter.index)
 541                         return nodev(filter_dev);
 542         }
 543
 544         if (flush) {
 545                 int round = 0;
 546                 char flushb[4096-512];
 547
 548                 filter.flushb = flushb;
 549                 filter.flushp = 0;
 550                 filter.flushe = sizeof(flushb);
 551
 552                 while (round < MAX_ROUNDS) {
 553                         if (rtnl_neighdump_req(&rth, filter.family,
 554                                                ipneigh_dump_filter) < 0) {
 555                                 perror("Cannot send dump request");
 556                                 exit(1);
 557                         }
 558                         filter.flushed = 0;
 559                         if (rtnl_dump_filter(&rth, print_neigh, stdout) < 0) {
 560                                 fprintf(stderr, "Flush terminated\n");
 561                                 exit(1);
 562                         }
 563                         if (filter.flushed == 0) {
 564                                 if (show_stats) {
 565                                         if (round == 0)
 566                                                 printf("Nothing to flush.\n");
 567                                         else
 568                                                 printf("*** Flush is complete after %d round%s ***\n", round, round > 1?"s":"");
 569                                 }
 570                                 fflush(stdout);
 571                                 return 0;
 572                         }
 573                         round++;
 574                         if (flush_update() < 0)
 575                                 exit(1);
 576                         if (show_stats) {
 577                                 printf("\n*** Round %d, deleting %d entries ***\n", round, filter.flushed);
 578                                 fflush(stdout);
 579                         }
 580                         filter.state &= ~NUD_FAILED;
 581                 }
 582                 printf("*** Flush not complete bailing out after %d rounds\n",
 583                         MAX_ROUNDS);
 584                 return 1;
 585         }
 586
 587         if (rtnl_neighdump_req(&rth, filter.family, ipneigh_dump_filter) < 0) {
 588                 perror("Cannot send dump request");
 589                 exit(1);
 590         }
 591
 592         new_json_obj(json);
 593         if (rtnl_dump_filter(&rth, print_neigh, stdout) < 0) {
 594                 fprintf(stderr, "Dump terminated\n");
 595                 exit(1);
 596         }
 597         delete_json_obj();
 598
 599         return 0;
 600 }
 601
 602 int do_ipneigh(int argc, char **argv)
 603 {
 604         if (argc > 0) {
 605                 if (matches(*argv, "add") == 0)
 606                         return ipneigh_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_EXCL, argc-1, argv+1);
 607                 if (matches(*argv, "change") == 0 ||
 608                     strcmp(*argv, "chg") == 0)
 609                         return ipneigh_modify(RTM_NEWNEIGH, NLM_F_REPLACE, argc-1, argv+1);
 610                 if (matches(*argv, "replace") == 0)
 611                         return ipneigh_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_REPLACE, argc-1, argv+1);
 612                 if (matches(*argv, "delete") == 0)
 613                         return ipneigh_modify(RTM_DELNEIGH, 0, argc-1, argv+1);
 614                 if (matches(*argv, "get") == 0) {
 615                         fprintf(stderr, "Sorry, \"neigh get\" is not implemented :-(\n");
 616                         return -1;
 617                 }
 618                 if (matches(*argv, "show") == 0 ||
 619                     matches(*argv, "lst") == 0 ||
 620                     matches(*argv, "list") == 0)
 621                         return do_show_or_flush(argc-1, argv+1, 0);
 622                 if (matches(*argv, "flush") == 0)
 623                         return do_show_or_flush(argc-1, argv+1, 1);
 624                 if (matches(*argv, "help") == 0)
 625                         usage();
 626         } else
 627                 return do_show_or_flush(0, NULL, 0);
 628
 629         fprintf(stderr, "Command \"%s\" is unknown, try \"ip neigh help\".\n", *argv);
 630         exit(-1);
 631 }