usr.bin/netstat/route_netlink.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1983, 1988, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/protosw.h>
  37 #include <sys/socket.h>
  38 #include <sys/socketvar.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/time.h>
  41
  42 #include <net/ethernet.h>
  43 #include <net/if.h>
  44 #include <net/if_dl.h>
  45 #include <net/if_types.h>
  46 #include <netlink/netlink.h>
  47 #include <netlink/netlink_route.h>
  48 #include <netlink/netlink_snl.h>
  49 #include <netlink/netlink_snl_route.h>
  50 #include <netlink/netlink_snl_route_parsers.h>
  51 #include <netlink/netlink_snl_route_compat.h>
  52
  53 #include <netinet/in.h>
  54 #include <netgraph/ng_socket.h>
  55
  56 #include <arpa/inet.h>
  57 #include <ifaddrs.h>
  58 #include <libutil.h>
  59 #include <netdb.h>
  60 #include <stdbool.h>
  61 #include <stdint.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <stdbool.h>
  65 #include <string.h>
  66 #include <sysexits.h>
  67 #include <unistd.h>
  68 #include <err.h>
  69 #include <libxo/xo.h>
  70 #include "netstat.h"
  71 #include "common.h"
  72 #include "nl_defs.h"
  73
  74
  75 static void p_rtentry_netlink(struct snl_state *ss, const char *name, struct nlmsghdr *hdr);
  76
  77 static struct ifmap_entry *ifmap;
  78 static size_t ifmap_size;
  79
  80 /* Generate ifmap using netlink */
  81 static struct ifmap_entry *
  82 prepare_ifmap_netlink(struct snl_state *ss, size_t *pifmap_size)
  83 {
  84         struct {
  85                 struct nlmsghdr hdr;
  86                 struct ifinfomsg ifmsg;
  87         } msg = {
  88                 .hdr.nlmsg_type = RTM_GETLINK,
  89                 .hdr.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
  90                 .hdr.nlmsg_seq = snl_get_seq(ss),
  91         };
  92         msg.hdr.nlmsg_len = sizeof(msg);
  93
  94         if (!snl_send_message(ss, &msg.hdr))
  95                 return (NULL);
  96
  97         struct ifmap_entry *ifmap = NULL;
  98         uint32_t ifmap_size = 0;
  99         struct nlmsghdr *hdr;
 100         struct snl_errmsg_data e = {};
 101
 102         while ((hdr = snl_read_reply_multi(ss, msg.hdr.nlmsg_seq, &e)) != NULL) {
 103                 struct snl_parsed_link_simple link = {};
 104
 105                 if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_link_parser_simple, &link))
 106                         continue;
 107                 if (link.ifi_index >= ifmap_size) {
 108                         size_t size = roundup2(link.ifi_index + 1, 32) * sizeof(struct ifmap_entry);
 109                         if ((ifmap = realloc(ifmap, size)) == NULL)
 110                                 errx(2, "realloc(%zu) failed", size);
 111                         memset(&ifmap[ifmap_size], 0,
 112                             size - ifmap_size *
 113                             sizeof(struct ifmap_entry));
 114                         ifmap_size = roundup2(link.ifi_index + 1, 32);
 115                 }
 116                 if (*ifmap[link.ifi_index].ifname != '\0')
 117                         continue;
 118                 strlcpy(ifmap[link.ifi_index].ifname, link.ifla_ifname, IFNAMSIZ);
 119                 ifmap[link.ifi_index].mtu = link.ifla_mtu;
 120         }
 121         *pifmap_size = ifmap_size;
 122         return (ifmap);
 123 }
 124
 125 static void
 126 ip6_writemask(struct in6_addr *addr6, uint8_t mask)
 127 {
 128         uint32_t *cp;
 129
 130         for (cp = (uint32_t *)addr6; mask >= 32; mask -= 32)
 131                 *cp++ = 0xFFFFFFFF;
 132         if (mask > 0)
 133                 *cp = htonl(mask ? ~((1 << (32 - mask)) - 1) : 0);
 134 }
 135
 136 static void
 137 gen_mask(int family, int plen, struct sockaddr *sa)
 138 {
 139         if (family == AF_INET6) {
 140                 struct sockaddr_in6 sin6 = {
 141                         .sin6_family = AF_INET6,
 142                         .sin6_len = sizeof(struct sockaddr_in6),
 143                 };
 144                 ip6_writemask(&sin6.sin6_addr, plen);
 145                 *((struct sockaddr_in6 *)sa) = sin6;
 146         } else if (family == AF_INET) {
 147                 struct sockaddr_in sin = {
 148                         .sin_family = AF_INET,
 149                         .sin_len = sizeof(struct sockaddr_in),
 150                         .sin_addr.s_addr = htonl(plen ? ~((1 << (32 - plen)) - 1) : 0),
 151                 };
 152                 *((struct sockaddr_in *)sa) = sin;
 153         }
 154 }
 155
 156 static void
 157 add_scopeid(struct sockaddr *sa, int ifindex)
 158 {
 159         if (sa->sa_family == AF_INET6) {
 160                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 161                 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
 162                         sin6->sin6_scope_id = ifindex;
 163         }
 164 }
 165
 166 static void
 167 p_path(struct snl_parsed_route *rt, bool is_mpath)
 168 {
 169         struct sockaddr_in6 mask6;
 170         struct sockaddr *pmask = (struct sockaddr *)&mask6;
 171         char buffer[128];
 172         char prettyname[128];
 173         int protrusion;
 174
 175         gen_mask(rt->rtm_family, rt->rtm_dst_len, pmask);
 176         add_scopeid(rt->rta_dst, rt->rta_oif);
 177         add_scopeid(rt->rta_gw, rt->rta_oif);
 178         protrusion = p_sockaddr("destination", rt->rta_dst, pmask, rt->rta_rtflags, wid.dst);
 179         protrusion = p_sockaddr("gateway", rt->rta_gw, NULL, RTF_HOST,
 180             wid.gw - protrusion);
 181         snprintf(buffer, sizeof(buffer), "{[:-%d}{:flags/%%s}{]:} ",
 182             wid.flags - protrusion);
 183         p_flags(rt->rta_rtflags | RTF_UP, buffer);
 184         /* Output path weight as non-visual property */
 185         xo_emit("{e:weight/%u}", rt->rtax_weight);
 186         if (is_mpath)
 187                 xo_emit("{e:nhg-kidx/%u}", rt->rta_knh_id);
 188         else
 189                 xo_emit("{e:nhop-kidx/%u}", rt->rta_knh_id);
 190         if (rt->rta_nh_id != 0) {
 191                 if (is_mpath)
 192                         xo_emit("{e:nhg-uidx/%u}", rt->rta_nh_id);
 193                 else
 194                         xo_emit("{e:nhop-uidx/%u}", rt->rta_nh_id);
 195         }
 196
 197         memset(prettyname, 0, sizeof(prettyname));
 198         if (rt->rta_oif < ifmap_size) {
 199                 strlcpy(prettyname, ifmap[rt->rta_oif].ifname,
 200                     sizeof(prettyname));
 201                 if (*prettyname == '\0')
 202                         strlcpy(prettyname, "---", sizeof(prettyname));
 203                 if (rt->rtax_mtu == 0)
 204                         rt->rtax_mtu = ifmap[rt->rta_oif].mtu;
 205         }
 206
 207         if (Wflag) {
 208                 /* XXX: use=0? */
 209                 xo_emit("{t:nhop/%*lu} ", wid.mtu, is_mpath ? 0 : rt->rta_knh_id);
 210
 211                 if (rt->rtax_mtu != 0)
 212                         xo_emit("{t:mtu/%*lu} ", wid.mtu, rt->rtax_mtu);
 213                 else {
 214                         /* use interface mtu */
 215                         xo_emit("{P:/%*s} ", wid.mtu, "");
 216                 }
 217
 218         }
 219
 220         if (Wflag)
 221                 xo_emit("{t:interface-name/%*s}", wid.iface, prettyname);
 222         else
 223                 xo_emit("{t:interface-name/%*.*s}", wid.iface, wid.iface,
 224                     prettyname);
 225         if (rt->rta_expires > 0) {
 226                 xo_emit(" {:expire-time/%*u}", wid.expire, rt->rta_expires);
 227         }
 228 }
 229
 230 static void
 231 p_rtentry_netlink(struct snl_state *ss, const char *name, struct nlmsghdr *hdr)
 232 {
 233
 234         struct snl_parsed_route rt = {};
 235         if (!snl_parse_nlmsg(ss, hdr, &snl_rtm_route_parser, &rt))
 236                 return;
 237         if (rt.rtax_weight == 0)
 238                 rt.rtax_weight = rt_default_weight;
 239
 240         if (rt.rta_multipath.num_nhops != 0) {
 241                 uint32_t orig_rtflags = rt.rta_rtflags;
 242                 uint32_t orig_mtu = rt.rtax_mtu;
 243                 for (uint32_t i = 0; i < rt.rta_multipath.num_nhops; i++) {
 244                         struct rta_mpath_nh *nhop = rt.rta_multipath.nhops[i];
 245
 246                         rt.rta_gw = nhop->gw;
 247                         rt.rta_oif = nhop->ifindex;
 248                         rt.rtax_weight = nhop->rtnh_weight;
 249                         rt.rta_rtflags = nhop->rta_rtflags ? nhop->rta_rtflags : orig_rtflags;
 250                         rt.rtax_mtu = nhop->rtax_mtu ? nhop->rtax_mtu : orig_mtu;
 251
 252                         xo_open_instance(name);
 253                         p_path(&rt, true);
 254                         xo_emit("\n");
 255                         xo_close_instance(name);
 256                 }
 257                 return;
 258         }
 259
 260         struct sockaddr_dl sdl_gw = {
 261                 .sdl_family = AF_LINK,
 262                 .sdl_len = sizeof(struct sockaddr_dl),
 263                 .sdl_index = rt.rta_oif,
 264         };
 265         if (rt.rta_gw == NULL)
 266                 rt.rta_gw = (struct sockaddr *)&sdl_gw;
 267
 268         xo_open_instance(name);
 269         p_path(&rt, false);
 270         xo_emit("\n");
 271         xo_close_instance(name);
 272 }
 273
 274 bool
 275 p_rtable_netlink(int fibnum, int af)
 276 {
 277         int fam = AF_UNSPEC;
 278         int need_table_close = false;
 279         struct nlmsghdr *hdr;
 280         struct snl_errmsg_data e = {};
 281         struct snl_state ss = {};
 282
 283         if (!snl_init(&ss, NETLINK_ROUTE))
 284                 return (false);
 285
 286         ifmap = prepare_ifmap_netlink(&ss, &ifmap_size);
 287         if (ifmap == NULL) {
 288                 snl_free(&ss);
 289                 return (false);
 290         }
 291
 292         struct {
 293                 struct nlmsghdr hdr;
 294                 struct rtmsg rtmsg;
 295                 struct nlattr nla_fibnum;
 296                 uint32_t fibnum;
 297         } msg = {
 298                 .hdr.nlmsg_type = RTM_GETROUTE,
 299                 .hdr.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 300                 .hdr.nlmsg_seq = snl_get_seq(&ss),
 301                 .rtmsg.rtm_family = af,
 302                 .nla_fibnum.nla_len = sizeof(struct nlattr) + sizeof(uint32_t),
 303                 .nla_fibnum.nla_type = RTA_TABLE,
 304                 .fibnum = fibnum,
 305         };
 306         msg.hdr.nlmsg_len = sizeof(msg);
 307
 308         if (!snl_send_message(&ss, &msg.hdr)) {
 309                 snl_free(&ss);
 310                 return (false);
 311         }
 312
 313         xo_open_container("route-table");
 314         xo_open_list("rt-family");
 315         while ((hdr = snl_read_reply_multi(&ss, msg.hdr.nlmsg_seq, &e)) != NULL) {
 316                 struct rtmsg *rtm = (struct rtmsg *)(hdr + 1);
 317                 /* Only print family first time. */
 318                 if (fam != rtm->rtm_family) {
 319                         if (need_table_close) {
 320                                 xo_close_list("rt-entry");
 321                                 xo_close_instance("rt-family");
 322                         }
 323                         need_table_close = true;
 324                         fam = rtm->rtm_family;
 325                         set_wid(fam);
 326                         xo_open_instance("rt-family");
 327                         pr_family(fam);
 328                         xo_open_list("rt-entry");
 329                         pr_rthdr(fam);
 330                 }
 331                 p_rtentry_netlink(&ss, "rt-entry", hdr);
 332                 snl_clear_lb(&ss);
 333         }
 334         if (need_table_close) {
 335                 xo_close_list("rt-entry");
 336                 xo_close_instance("rt-family");
 337         }
 338         xo_close_list("rt-family");
 339         xo_close_container("route-table");
 340         snl_free(&ss);
 341         return (true);
 342 }
 343
 344