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