usr.sbin/ndp/ndp_netlink.c

   1 #include <sys/param.h>
   2 #include <sys/module.h>
   3 #include <sys/file.h>
   4 #include <sys/ioctl.h>
   5 #include <sys/linker.h>
   6 #include <sys/socket.h>
   7 #include <sys/sysctl.h>
   8 #include <sys/time.h>
   9 #include <sys/queue.h>
  10
  11 #include <net/if.h>
  12 #include <net/if_dl.h>
  13 #include <net/if_types.h>
  14
  15 #include <netinet/in.h>
  16 #include <netinet/if_ether.h>
  17
  18 #include <netinet/icmp6.h>
  19 #include <netinet6/in6_var.h>
  20 #include <netinet6/nd6.h>
  21
  22 #include <arpa/inet.h>
  23
  24 #include <ctype.h>
  25 #include <netdb.h>
  26 #include <errno.h>
  27 #include <nlist.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <paths.h>
  31 #include <err.h>
  32 #include <stdlib.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <libxo/xo.h>
  36
  37
  38 #include <netlink/netlink.h>
  39 #include <netlink/netlink_route.h>
  40 #include <netlink/netlink_snl.h>
  41 #include <netlink/netlink_snl_route.h>
  42 #include <netlink/netlink_snl_route_compat.h>
  43 #include <netlink/netlink_snl_route_parsers.h>
  44
  45 #include <libxo/xo.h>
  46 #include "ndp.h"
  47
  48 #define RTF_ANNOUNCE    RTF_PROTO2
  49
  50 static void
  51 nl_init_socket(struct snl_state *ss)
  52 {
  53         if (snl_init(ss, NETLINK_ROUTE))
  54                 return;
  55
  56         if (modfind("netlink") == -1 && errno == ENOENT) {
  57                 /* Try to load */
  58                 if (kldload("netlink") == -1)
  59                         err(1, "netlink is not loaded and load attempt failed");
  60                 if (snl_init(ss, NETLINK_ROUTE))
  61                         return;
  62         }
  63
  64         err(1, "unable to open netlink socket");
  65 }
  66
  67 static bool
  68 get_link_info(struct snl_state *ss, uint32_t ifindex,
  69     struct snl_parsed_link_simple *link)
  70 {
  71         struct snl_writer nw;
  72
  73         snl_init_writer(ss, &nw);
  74
  75         struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETLINK);
  76         struct ifinfomsg *ifmsg = snl_reserve_msg_object(&nw, struct ifinfomsg);
  77         if (ifmsg != NULL)
  78                 ifmsg->ifi_index = ifindex;
  79         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(ss, hdr))
  80                 return (false);
  81
  82         hdr = snl_read_reply(ss, hdr->nlmsg_seq);
  83
  84         if (hdr == NULL || hdr->nlmsg_type != RTM_NEWLINK)
  85                 return (false);
  86
  87         if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser_simple, link))
  88                 return (false);
  89
  90         return (true);
  91 }
  92
  93
  94
  95 static bool
  96 has_l2(struct snl_state *ss, uint32_t ifindex)
  97 {
  98         struct snl_parsed_link_simple link = {};
  99
 100         if (!get_link_info(ss, ifindex, &link))
 101                 return (false);
 102
 103         return (valid_type(link.ifi_type) != 0);
 104 }
 105
 106 static uint32_t
 107 get_myfib(void)
 108 {
 109         uint32_t fibnum = 0;
 110         size_t len = sizeof(fibnum);
 111
 112         sysctlbyname("net.my_fibnum", (void *)&fibnum, &len, NULL, 0);
 113
 114         return (fibnum);
 115 }
 116
 117 static void
 118 ip6_writemask(struct in6_addr *addr6, uint8_t mask)
 119 {
 120         uint32_t *cp;
 121
 122         for (cp = (uint32_t *)addr6; mask >= 32; mask -= 32)
 123                 *cp++ = 0xFFFFFFFF;
 124         if (mask > 0)
 125                 *cp = htonl(mask ? ~((1 << (32 - mask)) - 1) : 0);
 126 }
 127 #define s6_addr32 __u6_addr.__u6_addr32
 128 #define IN6_MASK_ADDR(a, m)     do { \
 129         (a)->s6_addr32[0] &= (m)->s6_addr32[0]; \
 130         (a)->s6_addr32[1] &= (m)->s6_addr32[1]; \
 131         (a)->s6_addr32[2] &= (m)->s6_addr32[2]; \
 132         (a)->s6_addr32[3] &= (m)->s6_addr32[3]; \
 133 } while (0)
 134
 135 static int
 136 guess_ifindex(struct snl_state *ss, uint32_t fibnum, const struct sockaddr_in6 *dst)
 137 {
 138         struct snl_writer nw;
 139
 140         if (IN6_IS_ADDR_LINKLOCAL(&dst->sin6_addr))
 141                 return (dst->sin6_scope_id);
 142         else if (IN6_IS_ADDR_MULTICAST(&dst->sin6_addr))
 143                 return (0);
 144
 145
 146         snl_init_writer(ss, &nw);
 147
 148         struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETROUTE);
 149         struct rtmsg *rtm = snl_reserve_msg_object(&nw, struct rtmsg);
 150         rtm->rtm_family = AF_INET6;
 151
 152         snl_add_msg_attr_ip(&nw, RTA_DST, (struct sockaddr *)dst);
 153         snl_add_msg_attr_u32(&nw, RTA_TABLE, fibnum);
 154
 155         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(ss, hdr))
 156                 return (0);
 157
 158         hdr = snl_read_reply(ss, hdr->nlmsg_seq);
 159
 160         if (hdr->nlmsg_type != NL_RTM_NEWROUTE) {
 161                 /* No route found, unable to guess ifindex */
 162                 return (0);
 163         }
 164
 165         struct snl_parsed_route r = {};
 166         if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_route_parser, &r))
 167                 return (0);
 168
 169         if (r.rta_multipath.num_nhops > 0 || (r.rta_rtflags & RTF_GATEWAY))
 170                 return (0);
 171
 172         /* Check if the interface is of supported type */
 173         if (has_l2(ss, r.rta_oif))
 174                 return (r.rta_oif);
 175
 176         /* Check the case when we matched the loopback route for P2P */
 177         snl_init_writer(ss, &nw);
 178         hdr = snl_create_msg_request(&nw, RTM_GETNEXTHOP);
 179         snl_reserve_msg_object(&nw, struct nhmsg);
 180
 181         int off = snl_add_msg_attr_nested(&nw, NHA_FREEBSD);
 182         snl_add_msg_attr_u32(&nw, NHAF_KID, r.rta_knh_id);
 183         snl_add_msg_attr_u8(&nw, NHAF_FAMILY, AF_INET6);
 184         snl_add_msg_attr_u32(&nw, NHAF_TABLE, fibnum);
 185         snl_end_attr_nested(&nw, off);
 186
 187         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(ss, hdr))
 188                 return (0);
 189
 190         hdr = snl_read_reply(ss, hdr->nlmsg_seq);
 191
 192         if (hdr->nlmsg_type != NL_RTM_NEWNEXTHOP) {
 193                 /* No nexthop found, unable to guess ifindex */
 194                 return (0);
 195         }
 196
 197         struct snl_parsed_nhop nh = {};
 198         if (!snl_parse_nlmsg(ss, hdr, &snl_nhmsg_parser, &nh))
 199                 return (0);
 200
 201         return (nh.nhaf_aif);
 202 }
 203
 204 static uint32_t
 205 fix_ifindex(struct snl_state *ss, uint32_t ifindex, const struct sockaddr_in6 *sa)
 206 {
 207         if (ifindex == 0)
 208                 ifindex = guess_ifindex(ss, get_myfib(), sa);
 209         return (ifindex);
 210 }
 211
 212 static void
 213 print_entry(struct snl_parsed_neigh *neigh, struct snl_parsed_link_simple *link)
 214 {
 215         struct timeval now;
 216         char host_buf[NI_MAXHOST];
 217         int addrwidth;
 218         int llwidth;
 219         int ifwidth;
 220         char *ifname;
 221
 222         getnameinfo(neigh->nda_dst, sizeof(struct sockaddr_in6), host_buf,
 223             sizeof(host_buf), NULL, 0, (opts.nflag ? NI_NUMERICHOST : 0));
 224
 225         gettimeofday(&now, 0);
 226         if (opts.tflag)
 227                 ts_print(&now);
 228
 229         struct sockaddr_dl sdl = {
 230                 .sdl_family = AF_LINK,
 231                 .sdl_type = link->ifi_type,
 232                 .sdl_len = sizeof(struct sockaddr_dl),
 233         };
 234
 235         if (neigh->nda_lladdr) {
 236                 sdl.sdl_alen = NLA_DATA_LEN(neigh->nda_lladdr),
 237                 memcpy(sdl.sdl_data, NLA_DATA(neigh->nda_lladdr), sdl.sdl_alen);
 238         }
 239
 240         addrwidth = strlen(host_buf);
 241         if (addrwidth < W_ADDR)
 242                 addrwidth = W_ADDR;
 243         llwidth = strlen(ether_str(&sdl));
 244         if (W_ADDR + W_LL - addrwidth > llwidth)
 245                 llwidth = W_ADDR + W_LL - addrwidth;
 246         ifname = link->ifla_ifname;
 247         ifwidth = strlen(ifname);
 248         if (W_ADDR + W_LL + W_IF - addrwidth - llwidth > ifwidth)
 249                 ifwidth = W_ADDR + W_LL + W_IF - addrwidth - llwidth;
 250
 251         xo_open_instance("neighbor-cache");
 252         /* Compose format string for libxo, as it doesn't support *.* */
 253         char xobuf[200];
 254         snprintf(xobuf, sizeof(xobuf),
 255             "{:address/%%-%d.%ds/%%s} {:mac-address/%%-%d.%ds/%%s} {:interface/%%%d.%ds/%%s}",
 256             addrwidth, addrwidth, llwidth, llwidth, ifwidth, ifwidth);
 257         xo_emit(xobuf, host_buf, ether_str(&sdl), ifname);
 258
 259         /* Print neighbor discovery specific information */
 260         time_t expire = (time_t)neigh->ndaf_next_ts;
 261         int expire_in = expire - now.tv_sec;
 262         if (expire > now.tv_sec)
 263                 xo_emit("{d:/ %-9.9s}{e:expires_sec/%d}", sec2str(expire_in), expire_in);
 264         else if (expire == 0)
 265                 xo_emit("{d:/ %-9.9s}{en:permanent/true}", "permanent");
 266         else
 267                 xo_emit("{d:/ %-9.9s}{e:expires_sec/%d}", "expired", expire_in);
 268
 269         const char *lle_state = "";
 270         switch (neigh->ndm_state) {
 271         case NUD_INCOMPLETE:
 272                 lle_state = "I";
 273                 break;
 274         case NUD_REACHABLE:
 275                 lle_state = "R";
 276                 break;
 277         case NUD_STALE:
 278                 lle_state = "S";
 279                 break;
 280         case NUD_DELAY:
 281                 lle_state = "D";
 282                 break;
 283         case NUD_PROBE:
 284                 lle_state = "P";
 285                 break;
 286         case NUD_FAILED:
 287                 lle_state = "F";
 288                 break;
 289         default:
 290                 lle_state = "N";
 291                 break;
 292         }
 293         xo_emit(" {:neighbor-state/%s}", lle_state);
 294
 295         bool isrouter = neigh->ndm_flags & NTF_ROUTER;
 296
 297         /*
 298          * other flags. R: router, P: proxy, W: ??
 299          */
 300         char flgbuf[8];
 301         snprintf(flgbuf, sizeof(flgbuf), "%s%s",
 302             isrouter ? "R" : "",
 303             (neigh->ndm_flags & NTF_PROXY) ? "p" : "");
 304         xo_emit(" {:nd-flags/%s}", flgbuf);
 305
 306         if (neigh->nda_probes != 0)
 307                 xo_emit("{u:/ %d}", neigh->nda_probes);
 308
 309         xo_emit("\n");
 310         xo_close_instance("neighbor-cache");
 311 }
 312
 313 int
 314 print_entries_nl(uint32_t ifindex, struct sockaddr_in6 *addr, bool cflag)
 315 {
 316         struct snl_state ss_req = {}, ss_cmd = {};
 317         struct snl_parsed_link_simple link = {};
 318         struct snl_writer nw;
 319
 320         nl_init_socket(&ss_req);
 321         snl_init_writer(&ss_req, &nw);
 322
 323         struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETNEIGH);
 324         struct ndmsg *ndmsg = snl_reserve_msg_object(&nw, struct ndmsg);
 325         if (ndmsg != NULL) {
 326                 ndmsg->ndm_family = AF_INET6;
 327                 ndmsg->ndm_ifindex = ifindex;
 328         }
 329
 330         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(&ss_req, hdr)) {
 331                 snl_free(&ss_req);
 332                 return (0);
 333         }
 334
 335         uint32_t nlmsg_seq = hdr->nlmsg_seq;
 336         struct snl_errmsg_data e = {};
 337         int count = 0;
 338         nl_init_socket(&ss_cmd);
 339
 340         /* Print header */
 341         if (!opts.tflag && !cflag) {
 342                 char xobuf[200];
 343                 snprintf(xobuf, sizeof(xobuf),
 344                     "{T:/%%-%d.%ds} {T:/%%-%d.%ds} {T:/%%%d.%ds} {T:/%%-9.9s} {T:%%1s} {T:%%5s}\n",
 345                     W_ADDR, W_ADDR, W_LL, W_LL, W_IF, W_IF);
 346                 xo_emit(xobuf, "Neighbor", "Linklayer Address", "Netif", "Expire", "S", "Flags");
 347         }
 348         xo_open_list("neighbor-cache");
 349
 350         while ((hdr = snl_read_reply_multi(&ss_req, nlmsg_seq, &e)) != NULL) {
 351                 struct snl_parsed_neigh neigh = {};
 352
 353                 if (!snl_parse_nlmsg(&ss_req, hdr, &snl_rtm_neigh_parser, &neigh))
 354                         continue;
 355
 356                 if (neigh.nda_ifindex != link.ifi_index) {
 357                         snl_clear_lb(&ss_cmd);
 358                         memset(&link, 0, sizeof(link));
 359                         if (!get_link_info(&ss_cmd, neigh.nda_ifindex, &link))
 360                                 continue;
 361                 }
 362
 363                 /* TODO: embed LL in the parser */
 364                 struct sockaddr_in6 *dst = (struct sockaddr_in6 *)neigh.nda_dst;
 365                 if (IN6_IS_ADDR_LINKLOCAL(&dst->sin6_addr))
 366                         dst->sin6_scope_id = neigh.nda_ifindex;
 367
 368                 if (addr != NULL) {
 369                         if (IN6_ARE_ADDR_EQUAL(&addr->sin6_addr,
 370                             &dst->sin6_addr) == 0 ||
 371                             addr->sin6_scope_id != dst->sin6_scope_id)
 372                                 continue;
 373                 }
 374
 375                 if (cflag) {
 376                         char dst_str[INET6_ADDRSTRLEN];
 377
 378                         inet_ntop(AF_INET6, &dst->sin6_addr, dst_str, sizeof(dst_str));
 379                         delete_nl(neigh.nda_ifindex, dst_str, false); /* no warn */
 380                 } else
 381                         print_entry(&neigh, &link);
 382
 383                 count++;
 384                 snl_clear_lb(&ss_req);
 385         }
 386         xo_close_list("neighbor-cache");
 387
 388         snl_free(&ss_req);
 389         snl_free(&ss_cmd);
 390
 391         return (count);
 392 }
 393
 394 int
 395 delete_nl(uint32_t ifindex, char *host, bool warn)
 396 {
 397 #define xo_warnx(...) do { if (warn) { xo_warnx(__VA_ARGS__); } } while(0)
 398         struct snl_state ss = {};
 399         struct snl_writer nw;
 400         struct sockaddr_in6 dst;
 401
 402         int gai_error = getaddr(host, &dst);
 403         if (gai_error) {
 404                 xo_warnx("%s: %s", host, gai_strerror(gai_error));
 405                 return 1;
 406         }
 407
 408         nl_init_socket(&ss);
 409
 410         ifindex = fix_ifindex(&ss, ifindex, &dst);
 411         if (ifindex == 0) {
 412                 xo_warnx("delete: cannot locate %s", host);
 413                 snl_free(&ss);
 414                 return (0);
 415         }
 416
 417         snl_init_writer(&ss, &nw);
 418         struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_DELNEIGH);
 419         struct ndmsg *ndmsg = snl_reserve_msg_object(&nw, struct ndmsg);
 420         if (ndmsg != NULL) {
 421                 ndmsg->ndm_family = AF_INET6;
 422                 ndmsg->ndm_ifindex = ifindex;
 423         }
 424         snl_add_msg_attr_ip(&nw, NDA_DST, (struct sockaddr *)&dst);
 425
 426         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(&ss, hdr)) {
 427                 snl_free(&ss);
 428                 return (1);
 429         }
 430
 431         struct snl_errmsg_data e = {};
 432         snl_read_reply_code(&ss, hdr->nlmsg_seq, &e);
 433         if (e.error != 0) {
 434                 if (e.error_str != NULL)
 435                         xo_warnx("delete %s: %s (%s)", host, strerror(e.error), e.error_str);
 436                 else
 437                         xo_warnx("delete %s: %s", host, strerror(e.error));
 438         } else {
 439                 char host_buf[NI_MAXHOST];
 440                 char ifix_buf[IFNAMSIZ];
 441
 442                 getnameinfo((struct sockaddr *)&dst,
 443                     dst.sin6_len, host_buf,
 444                     sizeof(host_buf), NULL, 0,
 445                     (opts.nflag ? NI_NUMERICHOST : 0));
 446
 447                 char *ifname = if_indextoname(ifindex, ifix_buf);
 448                 if (ifname == NULL) {
 449                         strlcpy(ifix_buf, "?", sizeof(ifix_buf));
 450                         ifname = ifix_buf;
 451                 }
 452                 char abuf[INET6_ADDRSTRLEN];
 453                 inet_ntop(AF_INET6, &dst.sin6_addr, abuf, sizeof(abuf));
 454
 455                 xo_open_instance("neighbor-cache");
 456                 xo_emit("{:hostname/%s}{d:/ (%s) deleted\n}", host, host_buf);
 457                 xo_emit("{e:address/%s}{e:interface/%s}", abuf, ifname);
 458                 xo_close_instance("neighbor-cache");
 459         }
 460         snl_free(&ss);
 461
 462         return (e.error != 0);
 463 #undef xo_warnx /* see above */
 464 }
 465
 466 int
 467 set_nl(uint32_t ifindex, struct sockaddr_in6 *dst, struct sockaddr_dl *sdl, char *host)
 468 {
 469         struct snl_state ss = {};
 470         struct snl_writer nw;
 471
 472         nl_init_socket(&ss);
 473
 474         ifindex = fix_ifindex(&ss, ifindex, dst);
 475         if (ifindex == 0) {
 476                 xo_warnx("delete: cannot locate %s", host);
 477                 snl_free(&ss);
 478                 return (0);
 479         }
 480
 481         snl_init_writer(&ss, &nw);
 482         struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_NEWNEIGH);
 483         hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
 484         struct ndmsg *ndmsg = snl_reserve_msg_object(&nw, struct ndmsg);
 485         if (ndmsg != NULL) {
 486                 uint8_t nl_flags = NTF_STICKY;
 487
 488                 ndmsg->ndm_family = AF_INET6;
 489                 ndmsg->ndm_ifindex = ifindex;
 490                 ndmsg->ndm_state = NUD_PERMANENT;
 491
 492                 if (opts.flags & RTF_ANNOUNCE)
 493                         nl_flags |= NTF_PROXY;
 494                 ndmsg->ndm_flags = nl_flags;
 495         }
 496         snl_add_msg_attr_ip(&nw, NDA_DST, (struct sockaddr *)dst);
 497         snl_add_msg_attr(&nw, NDA_LLADDR, sdl->sdl_alen, LLADDR(sdl));
 498
 499         if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(&ss, hdr)) {
 500                 snl_free(&ss);
 501                 return (1);
 502         }
 503
 504         struct snl_errmsg_data e = {};
 505         snl_read_reply_code(&ss, hdr->nlmsg_seq, &e);
 506         if (e.error != 0) {
 507                 if (e.error_str != NULL)
 508                         xo_warnx("set: %s: %s (%s)", host, strerror(e.error), e.error_str);
 509                 else
 510                         xo_warnx("set %s: %s", host, strerror(e.error));
 511         }
 512         snl_free(&ss);
 513
 514         return (e.error != 0);
 515 }
 516