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 * $FreeBSD$
32 */
33
34#include <sys/cdefs.h>
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 <net/route.h>
47#include <net/route/nhop.h>
48
49#include <netinet/in.h>
50#include <netgraph/ng_socket.h>
51
52#include <arpa/inet.h>
53#include <ifaddrs.h>
54#include <libutil.h>
55#include <netdb.h>
56#include <stdbool.h>
57#include <stdint.h>
58#include <stdio.h>
59#include <stdlib.h>
60#include <stdbool.h>
61#include <string.h>
62#include <sysexits.h>
63#include <unistd.h>
64#include <err.h>
65#include <libxo/xo.h>
66#include "netstat.h"
67#include "common.h"
68
69/* column widths; each followed by one space */
70#ifndef INET6
71#define	WID_DST_DEFAULT(af) 	18	/* width of destination column */
72#define	WID_GW_DEFAULT(af)	18	/* width of gateway column */
73#define	WID_IF_DEFAULT(af)	(Wflag ? 10 : 8) /* width of netif column */
74#else
75#define	WID_DST_DEFAULT(af) \
76	((af) == AF_INET6 ? (numeric_addr ? 33: 18) : 18)
77#define	WID_GW_DEFAULT(af) \
78	((af) == AF_INET6 ? (numeric_addr ? 29 : 18) : 18)
79#define	WID_IF_DEFAULT(af)	((af) == AF_INET6 ? 8 : (Wflag ? 10 : 8))
80#endif /*INET6*/
81static int wid_dst;
82static int wid_gw;
83static int wid_flags;
84static int wid_pksent;
85static int wid_mtu;
86static int wid_if;
87static int wid_nhidx;
88static int wid_nhtype;
89static int wid_refcnt;
90static int wid_prepend;
91
92static struct bits nh_bits[] = {
93	{ NHF_REJECT,	'R', "reject" },
94	{ NHF_BLACKHOLE,'B', "blackhole" },
95	{ NHF_REDIRECT,	'r', "redirect" },
96	{ NHF_GATEWAY,	'G', "gateway" },
97	{ NHF_DEFAULT,	'd', "default" },
98	{ NHF_BROADCAST,'b', "broadcast" },
99	{ 0 , 0, NULL }
100};
101
102static char *nh_types[] = {
103	"empty", /* 0 */
104	"v4/resolve", /* 1 */
105	"v4/gw",
106	"v6/resolve",
107	"v6/gw"
108};
109
110struct nhop_entry {
111	char	gw[64];
112	char	ifname[IFNAMSIZ];
113};
114
115struct nhop_map {
116	struct nhop_entry	*ptr;
117	size_t			size;
118};
119static struct nhop_map global_nhop_map;
120
121static struct nhop_entry *nhop_get(struct nhop_map *map, uint32_t idx);
122
123
124static struct ifmap_entry *ifmap;
125static size_t ifmap_size;
126
127static void
128print_sockaddr_buf(char *buf, size_t bufsize, const struct sockaddr *sa)
129{
130
131	switch (sa->sa_family) {
132	case AF_INET:
133		inet_ntop(AF_INET, &((struct sockaddr_in *)sa)->sin_addr,
134		    buf, bufsize);
135		break;
136	case AF_INET6:
137		inet_ntop(AF_INET6, &((struct sockaddr_in6 *)sa)->sin6_addr,
138		    buf, bufsize);
139		break;
140	default:
141		snprintf(buf, bufsize, "unknown:%d", sa->sa_family);
142		break;
143	}
144}
145
146static int
147print_addr(const char *name, const char *addr, int width)
148{
149	char buf[128];
150	int protrusion;
151
152	if (width < 0) {
153		snprintf(buf, sizeof(buf), "{:%s/%%s} ", name);
154		xo_emit(buf, addr);
155		protrusion = 0;
156	} else {
157		if (Wflag != 0 || numeric_addr) {
158			snprintf(buf, sizeof(buf), "{[:%d}{:%s/%%s}{]:} ",
159			    -width, name);
160			xo_emit(buf, addr);
161			protrusion = strlen(addr) - width;
162			if (protrusion < 0)
163				protrusion = 0;
164		} else {
165			snprintf(buf, sizeof(buf), "{[:%d}{:%s/%%-.*s}{]:} ",
166			    -width, name);
167			xo_emit(buf, width, addr);
168			protrusion = 0;
169		}
170	}
171	return (protrusion);
172}
173
174
175static void
176print_nhop_header(int af1 __unused)
177{
178
179	if (Wflag) {
180		xo_emit("{T:/%-*.*s} {T:/%-*.*s} {T:/%-*.*s} {T:/%-*.*s} {T:/%*.*s} "
181		    "{T:/%*.*s} {T:/%-*.*s} {T:/%*.*s} {T:/%*.*s} {T:/%*.*s} {T:/%*s}\n",
182			wid_nhidx,	wid_nhidx,	"Idx",
183			wid_nhtype,	wid_nhtype,	"Type",
184			wid_dst,	wid_dst,	"IFA",
185			wid_gw,		wid_gw,		"Gateway",
186			wid_flags,	wid_flags,	"Flags",
187			wid_pksent,	wid_pksent,	"Use",
188			wid_mtu,	wid_mtu,	"Mtu",
189			wid_if,		wid_if,		"Netif",
190			wid_if,		wid_if,		"Addrif",
191			wid_refcnt,	wid_refcnt,	"Refcnt",
192			wid_prepend,			"Prepend");
193	} else {
194		xo_emit("{T:/%-*.*s} {T:/%-*.*s} {T:/%-*.*s} {T:/%-*.*s} {T:/%*.*s} "
195		    " {T:/%*s}\n",
196			wid_nhidx,	wid_nhidx,	"Idx",
197			wid_dst,	wid_dst,	"IFA",
198			wid_gw,		wid_gw,		"Gateway",
199			wid_flags,	wid_flags,	"Flags",
200			wid_if,		wid_if,		"Netif",
201			wid_prepend,			"Refcnt");
202	}
203}
204
205void
206nhop_map_update(struct nhop_map *map, uint32_t idx, char *gw, char *ifname)
207{
208	if (idx >= map->size) {
209		uint32_t new_size;
210		size_t sz;
211		if (map->size  == 0)
212			new_size = 32;
213		else
214			new_size = map->size * 2;
215		if (new_size <= idx)
216			new_size = roundup2(idx + 1, 32);
217
218		sz = new_size * (sizeof(struct nhop_entry));
219		if ((map->ptr = realloc(map->ptr, sz)) == NULL)
220			errx(2, "realloc(%zu) failed", sz);
221
222		memset(&map->ptr[map->size], 0, (new_size - map->size) * sizeof(struct nhop_entry));
223		map->size = new_size;
224	}
225
226	strlcpy(map->ptr[idx].ifname, ifname, sizeof(map->ptr[idx].ifname));
227	strlcpy(map->ptr[idx].gw, gw, sizeof(map->ptr[idx].gw));
228}
229
230static struct nhop_entry *
231nhop_get(struct nhop_map *map, uint32_t idx)
232{
233
234	if (idx >= map->size)
235		return (NULL);
236	if (*map->ptr[idx].ifname == '\0')
237		return (NULL);
238	return &map->ptr[idx];
239}
240
241static void
242print_nhop_entry_sysctl(const char *name, struct rt_msghdr *rtm, struct nhop_external *nh)
243{
244	char buffer[128];
245	char iface_name[128];
246	int protrusion;
247	char gw_addr[64];
248	struct nhop_addrs *na;
249	struct sockaddr *sa_gw, *sa_ifa;
250
251	xo_open_instance(name);
252
253	snprintf(buffer, sizeof(buffer), "{[:-%d}{:index/%%lu}{]:} ", wid_nhidx);
254	//xo_emit("{t:index/%-lu} ", wid_nhidx, nh->nh_idx);
255	xo_emit(buffer, nh->nh_idx);
256
257	if (Wflag) {
258		char *cp = nh_types[nh->nh_type];
259		xo_emit("{t:type_str/%*s} ", wid_nhtype, cp);
260	}
261	memset(iface_name, 0, sizeof(iface_name));
262	if (nh->ifindex < (uint32_t)ifmap_size) {
263		strlcpy(iface_name, ifmap[nh->ifindex].ifname,
264		    sizeof(iface_name));
265		if (*iface_name == '\0')
266			strlcpy(iface_name, "---", sizeof(iface_name));
267	}
268
269	na = (struct nhop_addrs *)((char *)nh + nh->nh_len);
270	//inet_ntop(nh->nh_family, &nh->nh_src, src_addr, sizeof(src_addr));
271	//protrusion = p_addr("ifa", src_addr, wid_dst);
272	sa_gw = (struct sockaddr *)((char *)na + na->gw_sa_off);
273	sa_ifa = (struct sockaddr *)((char *)na + na->src_sa_off);
274	protrusion = p_sockaddr("ifa", sa_ifa, NULL, RTF_HOST, wid_dst);
275
276	if (nh->nh_flags & NHF_GATEWAY) {
277		const char *cp;
278		cp = fmt_sockaddr(sa_gw, NULL, RTF_HOST);
279		strlcpy(gw_addr, cp, sizeof(gw_addr));
280	} else
281		snprintf(gw_addr, sizeof(gw_addr), "%s/resolve", iface_name);
282	protrusion = print_addr("gateway", gw_addr, wid_dst - protrusion);
283
284	nhop_map_update(&global_nhop_map, nh->nh_idx, gw_addr, iface_name);
285
286	snprintf(buffer, sizeof(buffer), "{[:-%d}{:flags/%%s}{]:} ",
287	    wid_flags - protrusion);
288
289	//p_nhflags(nh->nh_flags, buffer);
290	print_flags_generic(rtm->rtm_flags, rt_bits, buffer, "rt_flags_pretty");
291
292	if (Wflag) {
293		xo_emit("{t:use/%*lu} ", wid_pksent, nh->nh_pksent);
294		xo_emit("{t:mtu/%*lu} ", wid_mtu, nh->nh_mtu);
295	}
296	//printf("IDX: %d IFACE: %s FAMILY: %d TYPE: %d FLAGS: %X GW \n");
297
298	if (Wflag)
299		xo_emit("{t:interface-name/%*s}", wid_if, iface_name);
300	else
301		xo_emit("{t:interface-name/%*.*s}", wid_if, wid_if, iface_name);
302
303	memset(iface_name, 0, sizeof(iface_name));
304	if (nh->aifindex < (uint32_t)ifmap_size && nh->ifindex != nh->aifindex) {
305		strlcpy(iface_name, ifmap[nh->aifindex].ifname,
306		    sizeof(iface_name));
307		if (*iface_name == '\0')
308			strlcpy(iface_name, "---", sizeof(iface_name));
309	}
310	if (Wflag)
311		xo_emit("{t:address-interface-name/%*s}", wid_if, iface_name);
312
313	xo_emit("{t:refcount/%*lu} ", wid_refcnt, nh->nh_refcount);
314	if (Wflag && nh->prepend_len) {
315		char *prepend_hex = "AABBCCDDEE";
316		xo_emit(" {:nhop-prepend/%*s}", wid_prepend, prepend_hex);
317	}
318
319	xo_emit("\n");
320	xo_close_instance(name);
321}
322
323static int
324cmp_nh_idx(const void *_a, const void *_b)
325{
326	const struct nhops_map *a, *b;
327
328	a = _a;
329	b = _b;
330
331	if (a->idx > b->idx)
332		return (1);
333	else if (a->idx < b->idx)
334		return (-1);
335	return (0);
336}
337
338void
339dump_nhops_sysctl(int fibnum, int af, struct nhops_dump *nd)
340{
341	size_t needed;
342	int mib[7];
343	char *buf, *next, *lim;
344	struct rt_msghdr *rtm;
345	struct nhop_external *nh;
346	struct nhops_map *nh_map;
347	size_t nh_count, nh_size;
348
349	mib[0] = CTL_NET;
350	mib[1] = PF_ROUTE;
351	mib[2] = 0;
352	mib[3] = af;
353	mib[4] = NET_RT_NHOP;
354	mib[5] = 0;
355	mib[6] = fibnum;
356	if (sysctl(mib, nitems(mib), NULL, &needed, NULL, 0) < 0)
357		err(EX_OSERR, "sysctl: net.route.0.%d.nhdump.%d estimate", af,
358		    fibnum);
359	if ((buf = malloc(needed)) == NULL)
360		errx(2, "malloc(%lu)", (unsigned long)needed);
361	if (sysctl(mib, nitems(mib), buf, &needed, NULL, 0) < 0)
362		err(1, "sysctl: net.route.0.%d.nhdump.%d", af, fibnum);
363	lim  = buf + needed;
364
365	/*
366	 * nexhops are received unsorted. Collect everything first, sort and then display
367	 * sorted.
368	 */
369	nh_count = 0;
370	nh_size = 16;
371	nh_map = calloc(nh_size, sizeof(struct nhops_map));
372	for (next = buf; next < lim; next += rtm->rtm_msglen) {
373		rtm = (struct rt_msghdr *)next;
374		if (rtm->rtm_version != RTM_VERSION)
375			continue;
376
377		if (nh_count >= nh_size) {
378			nh_size *= 2;
379			nh_map = realloc(nh_map, nh_size * sizeof(struct nhops_map));
380		}
381
382		nh = (struct nhop_external *)(rtm + 1);
383		nh_map[nh_count].idx = nh->nh_idx;
384		nh_map[nh_count].rtm = rtm;
385		nh_count++;
386	}
387
388	if (nh_count > 0)
389		qsort(nh_map, nh_count, sizeof(struct nhops_map), cmp_nh_idx);
390	nd->nh_buf = buf;
391	nd->nh_count = nh_count;
392	nd->nh_map = nh_map;
393}
394
395static void
396print_nhops_sysctl(int fibnum, int af)
397{
398	struct nhops_dump nd;
399	struct nhop_external *nh;
400	int fam;
401	struct rt_msghdr *rtm;
402
403	dump_nhops_sysctl(fibnum, af, &nd);
404
405	xo_open_container("nhop-table");
406	xo_open_list("rt-family");
407	if (nd.nh_count > 0) {
408		nh = (struct nhop_external *)(nd.nh_map[0].rtm + 1);
409		fam = nh->nh_family;
410
411		wid_dst = WID_GW_DEFAULT(fam);
412		wid_gw = WID_GW_DEFAULT(fam);
413		wid_nhidx = 5;
414		wid_nhtype = 12;
415		wid_refcnt = 6;
416		wid_flags = 6;
417		wid_pksent = 8;
418		wid_mtu = 6;
419		wid_if = WID_IF_DEFAULT(fam);
420		xo_open_instance("rt-family");
421		pr_family(fam);
422		xo_open_list("nh-entry");
423
424		print_nhop_header(fam);
425
426		for (size_t i = 0; i < nd.nh_count; i++) {
427			rtm = nd.nh_map[i].rtm;
428			nh = (struct nhop_external *)(rtm + 1);
429			print_nhop_entry_sysctl("nh-entry", rtm, nh);
430		}
431
432		xo_close_list("nh-entry");
433		xo_close_instance("rt-family");
434	}
435	xo_close_list("rt-family");
436	xo_close_container("nhop-table");
437	free(nd.nh_buf);
438}
439
440static void
441p_nhflags(int f, const char *format)
442{
443	struct bits *p;
444	char *pretty_name = "nh_flags_pretty";
445
446	xo_emit(format, fmt_flags(nh_bits, f));
447
448	xo_open_list(pretty_name);
449	for (p = nh_bits; p->b_mask; p++)
450		if (p->b_mask & f)
451			xo_emit("{le:nh_flags_pretty/%s}", p->b_name);
452	xo_close_list(pretty_name);
453}
454
455void
456nhops_print(int fibnum, int af)
457{
458	size_t intsize;
459	int numfibs;
460
461	intsize = sizeof(int);
462	if (fibnum == -1 &&
463	    sysctlbyname("net.my_fibnum", &fibnum, &intsize, NULL, 0) == -1)
464		fibnum = 0;
465	if (sysctlbyname("net.fibs", &numfibs, &intsize, NULL, 0) == -1)
466		numfibs = 1;
467	if (fibnum < 0 || fibnum > numfibs - 1)
468		errx(EX_USAGE, "%d: invalid fib", fibnum);
469
470	ifmap = prepare_ifmap(&ifmap_size);
471
472	xo_open_container("route-nhop-information");
473	xo_emit("{T:Nexthop data}");
474	if (fibnum)
475		xo_emit(" ({L:fib}: {:fib/%d})", fibnum);
476	xo_emit("\n");
477	print_nhops_sysctl(fibnum, af);
478	xo_close_container("route-nhop-information");
479}
480
481