1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <err.h> 5 #include <errno.h> 6 7 #include <sys/bitcount.h> 8 #include <sys/param.h> 9 #include <sys/linker.h> 10 #include <sys/module.h> 11 #include <sys/socket.h> 12 #include <sys/sysctl.h> 13 #include <sys/time.h> 14 #include <sys/types.h> 15 16 #include <netinet/in.h> 17 #include <arpa/inet.h> 18 19 #include <net/ethernet.h> 20 #include <net/if.h> 21 #include <net/if_dl.h> 22 #include <net/if_types.h> 23 #include <netlink/netlink.h> 24 #include <netlink/netlink_route.h> 25 #include <netlink/netlink_snl.h> 26 #include <netlink/netlink_snl_route.h> 27 #include <netlink/netlink_snl_route_compat.h> 28 #include <netlink/netlink_snl_route_parsers.h> 29 30 const char *routename(struct sockaddr *); 31 const char *netname(struct sockaddr *); 32 void printb(int, const char *); 33 extern const char routeflags[]; 34 extern int verbose, debugonly; 35 36 int rtmsg_nl(int cmd, int rtm_flags, int fib, int rtm_addrs, struct sockaddr_storage *so, 37 struct rt_metrics *rt_metrics); 38 int flushroutes_fib_nl(int fib, int af); 39 void monitor_nl(int fib); 40 41 struct nl_helper; 42 struct snl_msg_info; 43 static void print_getmsg(struct nl_helper *h, struct nlmsghdr *hdr, 44 struct sockaddr *dst); 45 static void print_nlmsg(struct nl_helper *h, struct nlmsghdr *hdr, 46 struct snl_msg_info *cinfo); 47 48 #define s6_addr32 __u6_addr.__u6_addr32 49 #define bitcount32(x) __bitcount32((uint32_t)(x)) 50 static int 51 inet6_get_plen(const struct in6_addr *addr) 52 { 53 54 return (bitcount32(addr->s6_addr32[0]) + bitcount32(addr->s6_addr32[1]) + 55 bitcount32(addr->s6_addr32[2]) + bitcount32(addr->s6_addr32[3])); 56 } 57 58 static void 59 ip6_writemask(struct in6_addr *addr6, uint8_t mask) 60 { 61 uint32_t *cp; 62 63 for (cp = (uint32_t *)addr6; mask >= 32; mask -= 32) 64 *cp++ = 0xFFFFFFFF; 65 if (mask > 0) 66 *cp = htonl(mask ? ~((1 << (32 - mask)) - 1) : 0); 67 } 68 69 static struct sockaddr * 70 get_netmask(struct snl_state *ss, int family, int plen) 71 { 72 if (family == AF_INET) { 73 if (plen == 32) 74 return (NULL); 75 76 struct sockaddr_in *sin = snl_allocz(ss, sizeof(*sin)); 77 78 sin->sin_len = sizeof(*sin); 79 sin->sin_family = family; 80 sin->sin_addr.s_addr = htonl(plen ? ~((1 << (32 - plen)) - 1) : 0); 81 82 return (struct sockaddr *)sin; 83 } else if (family == AF_INET6) { 84 if (plen == 128) 85 return (NULL); 86 87 struct sockaddr_in6 *sin6 = snl_allocz(ss, sizeof(*sin6)); 88 89 sin6->sin6_len = sizeof(*sin6); 90 sin6->sin6_family = family; 91 ip6_writemask(&sin6->sin6_addr, plen); 92 93 return (struct sockaddr *)sin6; 94 } 95 return (NULL); 96 } 97 98 static void 99 nl_init_socket(struct snl_state *ss) 100 { 101 if (snl_init(ss, NETLINK_ROUTE)) 102 return; 103 104 if (modfind("netlink") == -1 && errno == ENOENT) { 105 /* Try to load */ 106 if (kldload("netlink") == -1) 107 err(1, "netlink is not loaded and load attempt failed"); 108 if (snl_init(ss, NETLINK_ROUTE)) 109 return; 110 } 111 112 err(1, "unable to open netlink socket"); 113 } 114 115 struct nl_helper { 116 struct snl_state ss_cmd; 117 }; 118 119 static void 120 nl_helper_init(struct nl_helper *h) 121 { 122 nl_init_socket(&h->ss_cmd); 123 } 124 125 static void 126 nl_helper_free(struct nl_helper *h) 127 { 128 snl_free(&h->ss_cmd); 129 } 130 131 static struct sockaddr * 132 get_addr(struct sockaddr_storage *so, int rtm_addrs, int addr_type) 133 { 134 struct sockaddr *sa = NULL; 135 136 if (rtm_addrs & (1 << addr_type)) 137 sa = (struct sockaddr *)&so[addr_type]; 138 return (sa); 139 } 140 141 static int 142 rtmsg_nl_int(struct nl_helper *h, int cmd, int rtm_flags, int fib, int rtm_addrs, 143 struct sockaddr_storage *so, struct rt_metrics *rt_metrics) 144 { 145 struct snl_state *ss = &h->ss_cmd; 146 struct snl_writer nw; 147 int nl_type = 0, nl_flags = 0; 148 149 snl_init_writer(ss, &nw); 150 151 switch (cmd) { 152 case RTSOCK_RTM_ADD: 153 nl_type = RTM_NEWROUTE; 154 nl_flags = NLM_F_CREATE | NLM_F_APPEND; /* Do append by default */ 155 break; 156 case RTSOCK_RTM_CHANGE: 157 nl_type = RTM_NEWROUTE; 158 nl_flags = NLM_F_REPLACE; 159 break; 160 case RTSOCK_RTM_DELETE: 161 nl_type = RTM_DELROUTE; 162 break; 163 case RTSOCK_RTM_GET: 164 nl_type = RTM_GETROUTE; 165 break; 166 default: 167 exit(1); 168 } 169 170 struct sockaddr *dst = get_addr(so, rtm_addrs, RTAX_DST); 171 struct sockaddr *mask = get_addr(so, rtm_addrs, RTAX_NETMASK); 172 struct sockaddr *gw = get_addr(so, rtm_addrs, RTAX_GATEWAY); 173 174 if (dst == NULL) 175 return (EINVAL); 176 177 struct nlmsghdr *hdr = snl_create_msg_request(&nw, nl_type); 178 hdr->nlmsg_flags |= nl_flags; 179 180 int plen = 0; 181 int rtm_type = RTN_UNICAST; 182 183 switch (dst->sa_family) { 184 case AF_INET: 185 { 186 struct sockaddr_in *mask4 = (struct sockaddr_in *)mask; 187 188 if ((rtm_flags & RTF_HOST) == 0 && mask4 != NULL) 189 plen = bitcount32(mask4->sin_addr.s_addr); 190 else 191 plen = 32; 192 break; 193 } 194 case AF_INET6: 195 { 196 struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *)mask; 197 198 if ((rtm_flags & RTF_HOST) == 0 && mask6 != NULL) 199 plen = inet6_get_plen(&mask6->sin6_addr); 200 else 201 plen = 128; 202 break; 203 } 204 default: 205 return (ENOTSUP); 206 } 207 208 if (rtm_flags & RTF_REJECT) 209 rtm_type = RTN_PROHIBIT; 210 else if (rtm_flags & RTF_BLACKHOLE) 211 rtm_type = RTN_BLACKHOLE; 212 213 struct rtmsg *rtm = snl_reserve_msg_object(&nw, struct rtmsg); 214 rtm->rtm_family = dst->sa_family; 215 rtm->rtm_protocol = RTPROT_STATIC; 216 rtm->rtm_type = rtm_type; 217 rtm->rtm_dst_len = plen; 218 219 /* Request exact prefix match if mask is set */ 220 if ((cmd == RTSOCK_RTM_GET) && (mask != NULL)) 221 rtm->rtm_flags = RTM_F_PREFIX; 222 223 snl_add_msg_attr_ip(&nw, RTA_DST, dst); 224 snl_add_msg_attr_u32(&nw, RTA_TABLE, fib); 225 226 uint32_t rta_oif = 0; 227 228 if (gw != NULL) { 229 if (rtm_flags & RTF_GATEWAY) { 230 if (gw->sa_family == dst->sa_family) 231 snl_add_msg_attr_ip(&nw, RTA_GATEWAY, gw); 232 else 233 snl_add_msg_attr_ipvia(&nw, RTA_VIA, gw); 234 if (gw->sa_family == AF_INET6) { 235 struct sockaddr_in6 *gw6 = (struct sockaddr_in6 *)gw; 236 237 if (IN6_IS_ADDR_LINKLOCAL(&gw6->sin6_addr)) 238 rta_oif = gw6->sin6_scope_id; 239 } 240 } else { 241 /* Should be AF_LINK */ 242 struct sockaddr_dl *sdl = (struct sockaddr_dl *)gw; 243 if (sdl->sdl_index != 0) 244 rta_oif = sdl->sdl_index; 245 } 246 } 247 248 if (dst->sa_family == AF_INET6 && rta_oif == 0) { 249 struct sockaddr_in6 *dst6 = (struct sockaddr_in6 *)dst; 250 251 if (IN6_IS_ADDR_LINKLOCAL(&dst6->sin6_addr)) 252 rta_oif = dst6->sin6_scope_id; 253 } 254 255 if (rta_oif != 0) 256 snl_add_msg_attr_u32(&nw, RTA_OIF, rta_oif); 257 if (rtm_flags != 0) 258 snl_add_msg_attr_u32(&nw, NL_RTA_RTFLAGS, rtm_flags); 259 260 if (rt_metrics->rmx_mtu > 0) { 261 int off = snl_add_msg_attr_nested(&nw, RTA_METRICS); 262 snl_add_msg_attr_u32(&nw, RTAX_MTU, rt_metrics->rmx_mtu); 263 snl_end_attr_nested(&nw, off); 264 } 265 266 if (rt_metrics->rmx_weight > 0) 267 snl_add_msg_attr_u32(&nw, NL_RTA_WEIGHT, rt_metrics->rmx_weight); 268 269 if (snl_finalize_msg(&nw) && snl_send_message(ss, hdr)) { 270 struct snl_errmsg_data e = {}; 271 272 hdr = snl_read_reply(ss, hdr->nlmsg_seq); 273 if (nl_type == NL_RTM_GETROUTE) { 274 if (hdr->nlmsg_type == NL_RTM_NEWROUTE) 275 print_getmsg(h, hdr, dst); 276 else { 277 snl_parse_errmsg(ss, hdr, &e); 278 if (e.error == ESRCH) 279 warn("route has not been found"); 280 else 281 warn("message indicates error %d", e.error); 282 } 283 284 return (0); 285 } 286 287 if (snl_parse_errmsg(ss, hdr, &e)) 288 return (e.error); 289 } 290 return (EINVAL); 291 } 292 293 int 294 rtmsg_nl(int cmd, int rtm_flags, int fib, int rtm_addrs, 295 struct sockaddr_storage *so, struct rt_metrics *rt_metrics) 296 { 297 struct nl_helper h = {}; 298 299 nl_helper_init(&h); 300 int error = rtmsg_nl_int(&h, cmd, rtm_flags, fib, rtm_addrs, so, rt_metrics); 301 nl_helper_free(&h); 302 303 return (error); 304 } 305 306 static void 307 get_ifdata(struct nl_helper *h, uint32_t ifindex, struct snl_parsed_link_simple *link) 308 { 309 struct snl_state *ss = &h->ss_cmd; 310 struct snl_writer nw; 311 312 snl_init_writer(ss, &nw); 313 struct nlmsghdr *hdr = snl_create_msg_request(&nw, NL_RTM_GETLINK); 314 struct ifinfomsg *ifmsg = snl_reserve_msg_object(&nw, struct ifinfomsg); 315 if (ifmsg != NULL) 316 ifmsg->ifi_index = ifindex; 317 if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr)) 318 return; 319 320 hdr = snl_read_reply(ss, hdr->nlmsg_seq); 321 322 if (hdr != NULL && hdr->nlmsg_type == RTM_NEWLINK) { 323 snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser_simple, link); 324 } 325 326 if (link->ifla_ifname == NULL) { 327 char ifname[16]; 328 329 snprintf(ifname, sizeof(ifname), "if#%u", ifindex); 330 int len = strlen(ifname); 331 char *buf = snl_allocz(ss, len + 1); 332 strlcpy(buf, ifname, len + 1); 333 link->ifla_ifname = buf; 334 } 335 } 336 337 static void 338 print_getmsg(struct nl_helper *h, struct nlmsghdr *hdr, struct sockaddr *dst) 339 { 340 struct snl_state *ss = &h->ss_cmd; 341 struct timespec ts; 342 struct snl_parsed_route r = { .rtax_weight = RT_DEFAULT_WEIGHT }; 343 344 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_route_parser, &r)) 345 return; 346 347 struct snl_parsed_link_simple link = {}; 348 get_ifdata(h, r.rta_oif, &link); 349 350 if (r.rtax_mtu == 0) 351 r.rtax_mtu = link.ifla_mtu; 352 r.rta_rtflags |= (RTF_UP | RTF_DONE); 353 354 (void)printf(" route to: %s\n", routename(dst)); 355 356 if (r.rta_dst) 357 (void)printf("destination: %s\n", routename(r.rta_dst)); 358 struct sockaddr *mask = get_netmask(ss, r.rtm_family, r.rtm_dst_len); 359 if (mask) 360 (void)printf(" mask: %s\n", routename(mask)); 361 if (r.rta_gw && (r.rta_rtflags & RTF_GATEWAY)) 362 (void)printf(" gateway: %s\n", routename(r.rta_gw)); 363 (void)printf(" fib: %u\n", (unsigned int)r.rta_table); 364 if (link.ifla_ifname) 365 (void)printf(" interface: %s\n", link.ifla_ifname); 366 (void)printf(" flags: "); 367 printb(r.rta_rtflags, routeflags); 368 369 struct rt_metrics rmx = { 370 .rmx_mtu = r.rtax_mtu, 371 .rmx_weight = r.rtax_weight, 372 .rmx_expire = r.rta_expire, 373 }; 374 375 printf("\n%9s %9s %9s %9s %9s %10s %9s\n", "recvpipe", 376 "sendpipe", "ssthresh", "rtt,msec", "mtu ", "weight", "expire"); 377 printf("%8lu ", rmx.rmx_recvpipe); 378 printf("%8lu ", rmx.rmx_sendpipe); 379 printf("%8lu ", rmx.rmx_ssthresh); 380 printf("%8lu ", 0UL); 381 printf("%8lu ", rmx.rmx_mtu); 382 printf("%8lu ", rmx.rmx_weight); 383 if (rmx.rmx_expire > 0) 384 clock_gettime(CLOCK_REALTIME_FAST, &ts); 385 else 386 ts.tv_sec = 0; 387 printf("%8ld \n", (long)(rmx.rmx_expire - ts.tv_sec)); 388 } 389 390 static void 391 print_prefix(struct nl_helper *h, char *buf, int bufsize, struct sockaddr *sa, int plen) 392 { 393 int sz = 0; 394 395 if (sa == NULL) { 396 snprintf(buf, bufsize, "<NULL>"); 397 return; 398 } 399 400 switch (sa->sa_family) { 401 case AF_INET: 402 { 403 struct sockaddr_in *sin = (struct sockaddr_in *)sa; 404 char abuf[INET_ADDRSTRLEN]; 405 406 inet_ntop(AF_INET, &sin->sin_addr, abuf, sizeof(abuf)); 407 sz = snprintf(buf, bufsize, "%s", abuf); 408 break; 409 } 410 case AF_INET6: 411 { 412 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; 413 char abuf[INET6_ADDRSTRLEN]; 414 char *ifname = NULL; 415 416 inet_ntop(AF_INET6, &sin6->sin6_addr, abuf, sizeof(abuf)); 417 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { 418 struct snl_parsed_link_simple link = {}; 419 420 if (sin6->sin6_scope_id != 0) { 421 get_ifdata(h, sin6->sin6_scope_id, &link); 422 ifname = link.ifla_ifname; 423 } 424 } 425 if (ifname == NULL) 426 sz = snprintf(buf, bufsize, "%s", abuf); 427 else 428 sz = snprintf(buf, bufsize, "%s%%%s", abuf, ifname); 429 break; 430 } 431 default: 432 snprintf(buf, bufsize, "unknown_af#%d", sa->sa_family); 433 plen = -1; 434 } 435 436 if (plen >= 0) 437 snprintf(buf + sz, bufsize - sz, "/%d", plen); 438 } 439 440 static int 441 print_line_prefix(struct nlmsghdr *hdr, struct snl_msg_info *cinfo, 442 const char *cmd, const char *name) 443 { 444 struct timespec tp; 445 struct tm tm; 446 char buf[32]; 447 448 clock_gettime(CLOCK_REALTIME, &tp); 449 localtime_r(&tp.tv_sec, &tm); 450 451 strftime(buf, sizeof(buf), "%T", &tm); 452 int len = printf("%s.%03ld PID %4u %s %s ", buf, tp.tv_nsec / 1000000, 453 cinfo->process_id, cmd, name); 454 455 return (len); 456 } 457 458 static const char * 459 get_action_name(struct nlmsghdr *hdr, int new_cmd) 460 { 461 if (hdr->nlmsg_type == new_cmd) { 462 //return ((hdr->nlmsg_flags & NLM_F_REPLACE) ? "replace" : "add"); 463 return ("add/repl"); 464 } else 465 return ("delete"); 466 } 467 468 static void 469 print_nlmsg_route_nhop(struct nl_helper *h, struct snl_parsed_route *r, 470 struct rta_mpath_nh *nh, bool first) 471 { 472 // gw 10.0.0.1 ifp vtnet0 mtu 1500 table inet.0 473 if (nh->gw != NULL) { 474 char gwbuf[128]; 475 print_prefix(h, gwbuf, sizeof(gwbuf), nh->gw, -1); 476 printf("gw %s ", gwbuf); 477 } 478 479 if (nh->ifindex != 0) { 480 struct snl_parsed_link_simple link = {}; 481 482 get_ifdata(h, nh->ifindex, &link); 483 if (nh->rtax_mtu == 0) 484 nh->rtax_mtu = link.ifla_mtu; 485 printf("iface %s ", link.ifla_ifname); 486 if (nh->rtax_mtu != 0) 487 printf("mtu %d ", nh->rtax_mtu); 488 } 489 490 if (first) { 491 switch (r->rtm_family) { 492 case AF_INET: 493 printf("table inet.%d", r->rta_table); 494 break; 495 case AF_INET6: 496 printf("table inet6.%d", r->rta_table); 497 break; 498 } 499 } 500 501 printf("\n"); 502 } 503 504 static void 505 print_nlmsg_route(struct nl_helper *h, struct nlmsghdr *hdr, 506 struct snl_msg_info *cinfo) 507 { 508 struct snl_parsed_route r = { .rtax_weight = RT_DEFAULT_WEIGHT }; 509 struct snl_state *ss = &h->ss_cmd; 510 511 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_route_parser, &r)) 512 return; 513 514 // 20:19:41.333 add route 10.0.0.0/24 gw 10.0.0.1 ifp vtnet0 mtu 1500 table inet.0 515 516 const char *cmd = get_action_name(hdr, RTM_NEWROUTE); 517 int len = print_line_prefix(hdr, cinfo, cmd, "route"); 518 519 char buf[128]; 520 print_prefix(h, buf, sizeof(buf), r.rta_dst, r.rtm_dst_len); 521 len += strlen(buf) + 1; 522 printf("%s ", buf); 523 524 switch (r.rtm_type) { 525 case RTN_BLACKHOLE: 526 printf("blackhole\n"); 527 return; 528 case RTN_UNREACHABLE: 529 printf("unreach(reject)\n"); 530 return; 531 case RTN_PROHIBIT: 532 printf("prohibit(reject)\n"); 533 return; 534 } 535 536 if (r.rta_multipath.num_nhops != 0) { 537 bool first = true; 538 539 memset(buf, ' ', sizeof(buf)); 540 buf[len] = '\0'; 541 542 for (uint32_t i = 0; i < r.rta_multipath.num_nhops; i++) { 543 struct rta_mpath_nh *nh = r.rta_multipath.nhops[i]; 544 545 if (!first) 546 printf("%s", buf); 547 print_nlmsg_route_nhop(h, &r, nh, first); 548 first = false; 549 } 550 } else { 551 struct rta_mpath_nh nh = { 552 .gw = r.rta_gw, 553 .ifindex = r.rta_oif, 554 .rtax_mtu = r.rtax_mtu, 555 }; 556 557 print_nlmsg_route_nhop(h, &r, &nh, true); 558 } 559 } 560 561 static const char *operstate[] = { 562 "UNKNOWN", /* 0, IF_OPER_UNKNOWN */ 563 "NOTPRESENT", /* 1, IF_OPER_NOTPRESENT */ 564 "DOWN", /* 2, IF_OPER_DOWN */ 565 "LLDOWN", /* 3, IF_OPER_LOWERLAYERDOWN */ 566 "TESTING", /* 4, IF_OPER_TESTING */ 567 "DORMANT", /* 5, IF_OPER_DORMANT */ 568 "UP", /* 6, IF_OPER_UP */ 569 }; 570 571 static void 572 print_nlmsg_link(struct nl_helper *h, struct nlmsghdr *hdr, 573 struct snl_msg_info *cinfo) 574 { 575 struct snl_parsed_link l = {}; 576 struct snl_state *ss = &h->ss_cmd; 577 578 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser, &l)) 579 return; 580 581 // 20:19:41.333 add iface#3 vtnet0 admin UP oper UP mtu 1500 table inet.0 582 const char *cmd = get_action_name(hdr, RTM_NEWLINK); 583 print_line_prefix(hdr, cinfo, cmd, "iface"); 584 585 printf("iface#%u %s ", l.ifi_index, l.ifla_ifname); 586 printf("admin %s ", (l.ifi_flags & IFF_UP) ? "UP" : "DOWN"); 587 if (l.ifla_operstate < NL_ARRAY_LEN(operstate)) 588 printf("oper %s ", operstate[l.ifla_operstate]); 589 if (l.ifla_mtu > 0) 590 printf("mtu %u ", l.ifla_mtu); 591 592 printf("\n"); 593 } 594 595 static void 596 print_nlmsg_addr(struct nl_helper *h, struct nlmsghdr *hdr, 597 struct snl_msg_info *cinfo) 598 { 599 struct snl_parsed_addr attrs = {}; 600 struct snl_state *ss = &h->ss_cmd; 601 602 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_addr_parser, &attrs)) 603 return; 604 605 // add addr 192.168.1.1/24 iface vtnet0 606 const char *cmd = get_action_name(hdr, RTM_NEWADDR); 607 print_line_prefix(hdr, cinfo, cmd, "addr"); 608 609 char buf[128]; 610 struct sockaddr *addr = attrs.ifa_local ? attrs.ifa_local : attrs.ifa_address; 611 print_prefix(h, buf, sizeof(buf), addr, attrs.ifa_prefixlen); 612 printf("%s ", buf); 613 614 struct snl_parsed_link_simple link = {}; 615 get_ifdata(h, attrs.ifa_index, &link); 616 617 if (link.ifi_flags & IFF_POINTOPOINT) { 618 char buf[64]; 619 print_prefix(h, buf, sizeof(buf), attrs.ifa_address, -1); 620 printf("-> %s ", buf); 621 } 622 623 printf("iface %s ", link.ifla_ifname); 624 625 printf("\n"); 626 } 627 628 static const char *nudstate[] = { 629 "INCOMPLETE", /* 0x01(0) */ 630 "REACHABLE", /* 0x02(1) */ 631 "STALE", /* 0x04(2) */ 632 "DELAY", /* 0x08(3) */ 633 "PROBE", /* 0x10(4) */ 634 "FAILED", /* 0x20(5) */ 635 }; 636 637 #define NUD_INCOMPLETE 0x01 /* No lladdr, address resolution in progress */ 638 #define NUD_REACHABLE 0x02 /* reachable & recently resolved */ 639 #define NUD_STALE 0x04 /* has lladdr but it's stale */ 640 #define NUD_DELAY 0x08 /* has lladdr, is stale, probes delayed */ 641 #define NUD_PROBE 0x10 /* has lladdr, is stale, probes sent */ 642 #define NUD_FAILED 0x20 /* unused */ 643 644 645 static void 646 print_nlmsg_neigh(struct nl_helper *h, struct nlmsghdr *hdr, 647 struct snl_msg_info *cinfo) 648 { 649 struct snl_parsed_neigh attrs = {}; 650 struct snl_state *ss = &h->ss_cmd; 651 652 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_neigh_parser, &attrs)) 653 return; 654 655 // add addr 192.168.1.1 state %s lladdr %s iface vtnet0 656 const char *cmd = get_action_name(hdr, RTM_NEWNEIGH); 657 print_line_prefix(hdr, cinfo, cmd, "neigh"); 658 659 char buf[128]; 660 print_prefix(h, buf, sizeof(buf), attrs.nda_dst, -1); 661 printf("%s ", buf); 662 663 struct snl_parsed_link_simple link = {}; 664 get_ifdata(h, attrs.nda_ifindex, &link); 665 666 for (unsigned int i = 0; i < NL_ARRAY_LEN(nudstate); i++) { 667 if ((1 << i) & attrs.ndm_state) { 668 printf("state %s ", nudstate[i]); 669 break; 670 } 671 } 672 673 if (attrs.nda_lladdr != NULL) { 674 int if_type = link.ifi_type; 675 676 if ((if_type == IFT_ETHER || if_type == IFT_L2VLAN || if_type == IFT_BRIDGE) && 677 NLA_DATA_LEN(attrs.nda_lladdr) == ETHER_ADDR_LEN) { 678 struct ether_addr *ll; 679 680 ll = (struct ether_addr *)NLA_DATA(attrs.nda_lladdr); 681 printf("lladdr %s ", ether_ntoa(ll)); 682 } else { 683 struct sockaddr_dl sdl = { 684 .sdl_len = sizeof(sdl), 685 .sdl_family = AF_LINK, 686 .sdl_index = attrs.nda_ifindex, 687 .sdl_type = if_type, 688 .sdl_alen = NLA_DATA_LEN(attrs.nda_lladdr), 689 }; 690 if (sdl.sdl_alen < sizeof(sdl.sdl_data)) { 691 void *ll = NLA_DATA(attrs.nda_lladdr); 692 693 memcpy(sdl.sdl_data, ll, sdl.sdl_alen); 694 printf("lladdr %s ", link_ntoa(&sdl)); 695 } 696 } 697 } 698 699 if (link.ifla_ifname != NULL) 700 printf("iface %s ", link.ifla_ifname); 701 printf("\n"); 702 } 703 704 static void 705 print_nlmsg_generic(struct nl_helper *h, struct nlmsghdr *hdr, struct snl_msg_info *cinfo) 706 { 707 const char *cmd = get_action_name(hdr, 0); 708 print_line_prefix(hdr, cinfo, cmd, "unknown message"); 709 printf(" type %u\n", hdr->nlmsg_type); 710 } 711 712 static void 713 print_nlmsg(struct nl_helper *h, struct nlmsghdr *hdr, struct snl_msg_info *cinfo) 714 { 715 switch (hdr->nlmsg_type) { 716 case RTM_NEWLINK: 717 case RTM_DELLINK: 718 print_nlmsg_link(h, hdr, cinfo); 719 break; 720 case RTM_NEWADDR: 721 case RTM_DELADDR: 722 print_nlmsg_addr(h, hdr, cinfo); 723 break; 724 case RTM_NEWROUTE: 725 case RTM_DELROUTE: 726 print_nlmsg_route(h, hdr, cinfo); 727 break; 728 case RTM_NEWNEIGH: 729 case RTM_DELNEIGH: 730 print_nlmsg_neigh(h, hdr, cinfo); 731 break; 732 default: 733 print_nlmsg_generic(h, hdr, cinfo); 734 } 735 736 snl_clear_lb(&h->ss_cmd); 737 } 738 739 void 740 monitor_nl(int fib) 741 { 742 struct snl_state ss_event = {}; 743 struct nl_helper h; 744 745 nl_init_socket(&ss_event); 746 nl_helper_init(&h); 747 748 int groups[] = { 749 RTNLGRP_LINK, 750 RTNLGRP_NEIGH, 751 RTNLGRP_NEXTHOP, 752 #ifdef INET 753 RTNLGRP_IPV4_IFADDR, 754 RTNLGRP_IPV4_ROUTE, 755 #endif 756 #ifdef INET6 757 RTNLGRP_IPV6_IFADDR, 758 RTNLGRP_IPV6_ROUTE, 759 #endif 760 }; 761 762 int optval = 1; 763 socklen_t optlen = sizeof(optval); 764 setsockopt(ss_event.fd, SOL_NETLINK, NETLINK_MSG_INFO, &optval, optlen); 765 766 for (unsigned int i = 0; i < NL_ARRAY_LEN(groups); i++) { 767 int error; 768 int optval = groups[i]; 769 socklen_t optlen = sizeof(optval); 770 error = setsockopt(ss_event.fd, SOL_NETLINK, 771 NETLINK_ADD_MEMBERSHIP, &optval, optlen); 772 if (error != 0) 773 warn("Unable to subscribe to group %d", optval); 774 } 775 776 struct snl_msg_info attrs = {}; 777 struct nlmsghdr *hdr; 778 while ((hdr = snl_read_message_dbg(&ss_event, &attrs)) != NULL) 779 { 780 print_nlmsg(&h, hdr, &attrs); 781 snl_clear_lb(&h.ss_cmd); 782 snl_clear_lb(&ss_event); 783 } 784 785 snl_free(&ss_event); 786 nl_helper_free(&h); 787 exit(0); 788 } 789 790 static void 791 print_flushed_route(struct snl_parsed_route *r, struct sockaddr *gw) 792 { 793 struct sockaddr *sa = r->rta_dst; 794 795 printf("%-20.20s ", r->rta_rtflags & RTF_HOST ? 796 routename(sa) : netname(sa)); 797 sa = gw; 798 printf("%-20.20s ", routename(sa)); 799 printf("-fib %-3d ", r->rta_table); 800 printf("done\n"); 801 } 802 803 static int 804 flushroute_one(struct nl_helper *h, struct snl_parsed_route *r) 805 { 806 struct snl_state *ss = &h->ss_cmd; 807 struct snl_errmsg_data e = {}; 808 struct snl_writer nw; 809 810 snl_init_writer(ss, &nw); 811 812 struct nlmsghdr *hdr = snl_create_msg_request(&nw, NL_RTM_DELROUTE); 813 struct rtmsg *rtm = snl_reserve_msg_object(&nw, struct rtmsg); 814 rtm->rtm_family = r->rtm_family; 815 rtm->rtm_dst_len = r->rtm_dst_len; 816 817 snl_add_msg_attr_u32(&nw, RTA_TABLE, r->rta_table); 818 snl_add_msg_attr_ip(&nw, RTA_DST, r->rta_dst); 819 820 if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr)) 821 return (ENOMEM); 822 823 if (!snl_read_reply_code(ss, hdr->nlmsg_seq, &e)) { 824 return (e.error); 825 if (e.error == EPERM) 826 errc(1, e.error, "RTM_DELROUTE failed:"); 827 else 828 warnc(e.error, "RTM_DELROUTE failed:"); 829 return (true); 830 }; 831 832 if (verbose) { 833 struct snl_msg_info attrs = {}; 834 print_nlmsg(h, hdr, &attrs); 835 } 836 else { 837 if (r->rta_multipath.num_nhops != 0) { 838 for (uint32_t i = 0; i < r->rta_multipath.num_nhops; i++) { 839 struct rta_mpath_nh *nh = r->rta_multipath.nhops[i]; 840 841 print_flushed_route(r, nh->gw); 842 } 843 844 } else 845 print_flushed_route(r, r->rta_gw); 846 } 847 848 return (0); 849 } 850 851 int 852 flushroutes_fib_nl(int fib, int af) 853 { 854 struct snl_state ss = {}; 855 struct snl_writer nw; 856 struct nl_helper h = {}; 857 858 nl_init_socket(&ss); 859 snl_init_writer(&ss, &nw); 860 861 struct nlmsghdr *hdr = snl_create_msg_request(&nw, NL_RTM_GETROUTE); 862 hdr->nlmsg_flags |= NLM_F_DUMP; 863 struct rtmsg *rtm = snl_reserve_msg_object(&nw, struct rtmsg); 864 rtm->rtm_family = af; 865 snl_add_msg_attr_u32(&nw, RTA_TABLE, fib); 866 867 if (!snl_finalize_msg(&nw) || !snl_send_message(&ss, hdr)) { 868 snl_free(&ss); 869 return (EINVAL); 870 } 871 872 struct snl_errmsg_data e = {}; 873 uint32_t nlm_seq = hdr->nlmsg_seq; 874 875 nl_helper_init(&h); 876 877 while ((hdr = snl_read_reply_multi(&ss, nlm_seq, &e)) != NULL) { 878 struct snl_parsed_route r = { .rtax_weight = RT_DEFAULT_WEIGHT }; 879 int error; 880 881 if (!snl_parse_nlmsg(&ss, hdr, &snl_rtm_route_parser, &r)) 882 continue; 883 if (verbose) { 884 struct snl_msg_info attrs = {}; 885 print_nlmsg(&h, hdr, &attrs); 886 } 887 if (r.rta_table != (uint32_t)fib || r.rtm_family != af) 888 continue; 889 if ((r.rta_rtflags & RTF_GATEWAY) == 0) 890 continue; 891 if (debugonly) 892 continue; 893 894 if ((error = flushroute_one(&h, &r)) != 0) { 895 if (error == EPERM) 896 errc(1, error, "RTM_DELROUTE failed:"); 897 else 898 warnc(error, "RTM_DELROUTE failed:"); 899 } 900 snl_clear_lb(&h.ss_cmd); 901 } 902 903 snl_free(&ss); 904 nl_helper_free(&h); 905 906 return (e.error); 907 } 908 909