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_INET); 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 print_entry(&neigh, &link); 376 if (cflag) { 377 char dst_str[INET6_ADDRSTRLEN]; 378 379 inet_ntop(AF_INET6, &dst->sin6_addr, dst_str, sizeof(dst_str)); 380 delete_nl(neigh.nda_ifindex, dst_str); 381 } 382 count++; 383 snl_clear_lb(&ss_req); 384 } 385 xo_close_list("neighbor-cache"); 386 387 snl_free(&ss_req); 388 snl_free(&ss_cmd); 389 390 return (count); 391 } 392 393 int 394 delete_nl(uint32_t ifindex, char *host) 395 { 396 struct snl_state ss = {}; 397 struct snl_writer nw; 398 struct sockaddr_in6 dst; 399 400 int gai_error = getaddr(host, &dst); 401 if (gai_error) { 402 xo_warnx("%s: %s", host, gai_strerror(gai_error)); 403 return 1; 404 } 405 406 nl_init_socket(&ss); 407 408 ifindex = fix_ifindex(&ss, ifindex, &dst); 409 if (ifindex == 0) { 410 xo_warnx("delete: cannot locate %s", host); 411 snl_free(&ss); 412 return (0); 413 } 414 415 snl_init_writer(&ss, &nw); 416 struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_DELNEIGH); 417 struct ndmsg *ndmsg = snl_reserve_msg_object(&nw, struct ndmsg); 418 if (ndmsg != NULL) { 419 ndmsg->ndm_family = AF_INET6; 420 ndmsg->ndm_ifindex = ifindex; 421 } 422 snl_add_msg_attr_ip(&nw, NDA_DST, (struct sockaddr *)&dst); 423 424 if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(&ss, hdr)) { 425 snl_free(&ss); 426 return (1); 427 } 428 429 struct snl_errmsg_data e = {}; 430 snl_read_reply_code(&ss, hdr->nlmsg_seq, &e); 431 if (e.error != 0) { 432 if (e.error_str != NULL) 433 xo_warnx("delete %s: %s (%s)", host, strerror(e.error), e.error_str); 434 else 435 xo_warnx("delete %s: %s", host, strerror(e.error)); 436 } else { 437 char host_buf[NI_MAXHOST]; 438 char ifix_buf[IFNAMSIZ]; 439 440 getnameinfo((struct sockaddr *)&dst, 441 dst.sin6_len, host_buf, 442 sizeof(host_buf), NULL, 0, 443 (opts.nflag ? NI_NUMERICHOST : 0)); 444 445 char *ifname = if_indextoname(ifindex, ifix_buf); 446 if (ifname == NULL) { 447 strlcpy(ifix_buf, "?", sizeof(ifix_buf)); 448 ifname = ifix_buf; 449 } 450 char abuf[INET6_ADDRSTRLEN]; 451 inet_ntop(AF_INET6, &dst.sin6_addr, abuf, sizeof(abuf)); 452 453 xo_open_instance("neighbor-cache"); 454 xo_emit("{:hostname/%s}{d:/ (%s) deleted\n}", host, host_buf); 455 xo_emit("{e:address/%s}{e:interface/%s}", abuf, ifname); 456 xo_close_instance("neighbor-cache"); 457 } 458 snl_free(&ss); 459 460 return (e.error != 0); 461 } 462 463 int 464 set_nl(uint32_t ifindex, struct sockaddr_in6 *dst, struct sockaddr_dl *sdl, char *host) 465 { 466 struct snl_state ss = {}; 467 struct snl_writer nw; 468 469 nl_init_socket(&ss); 470 471 ifindex = fix_ifindex(&ss, ifindex, dst); 472 if (ifindex == 0) { 473 xo_warnx("delete: cannot locate %s", host); 474 snl_free(&ss); 475 return (0); 476 } 477 478 snl_init_writer(&ss, &nw); 479 struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_NEWNEIGH); 480 hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE; 481 struct ndmsg *ndmsg = snl_reserve_msg_object(&nw, struct ndmsg); 482 if (ndmsg != NULL) { 483 uint8_t nl_flags = NTF_STICKY; 484 485 ndmsg->ndm_family = AF_INET6; 486 ndmsg->ndm_ifindex = ifindex; 487 ndmsg->ndm_state = NUD_PERMANENT; 488 489 if (opts.flags & RTF_ANNOUNCE) 490 nl_flags |= NTF_PROXY; 491 ndmsg->ndm_flags = nl_flags; 492 } 493 snl_add_msg_attr_ip(&nw, NDA_DST, (struct sockaddr *)dst); 494 snl_add_msg_attr(&nw, NDA_LLADDR, sdl->sdl_alen, LLADDR(sdl)); 495 496 if (! (hdr = snl_finalize_msg(&nw)) || !snl_send_message(&ss, hdr)) { 497 snl_free(&ss); 498 return (1); 499 } 500 501 struct snl_errmsg_data e = {}; 502 snl_read_reply_code(&ss, hdr->nlmsg_seq, &e); 503 if (e.error != 0) { 504 if (e.error_str != NULL) 505 xo_warnx("set: %s: %s (%s)", host, strerror(e.error), e.error_str); 506 else 507 xo_warnx("set %s: %s", host, strerror(e.error)); 508 } 509 snl_free(&ss); 510 511 return (e.error != 0); 512 } 513 514