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