xref: /netbsd-src/usr.bin/systat/netstat.c (revision b1c86f5f087524e68db12794ee9c3e3da1ab17a0) 
1 /*	$NetBSD: netstat.c,v 1.28 2006/10/22 16:43:24 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 1980, 1992, 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 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)netstat.c	8.1 (Berkeley) 6/6/93";
36 #endif
37 __RCSID("$NetBSD: netstat.c,v 1.28 2006/10/22 16:43:24 christos Exp $");
38 #endif /* not lint */
39 
40 /*
41  * netstat
42  */
43 #include <sys/param.h>
44 #include <sys/socketvar.h>
45 #include <sys/mbuf.h>
46 #include <sys/protosw.h>
47 
48 #include <netinet/in.h>
49 
50 #include <arpa/inet.h>
51 #include <net/route.h>
52 
53 #include <netinet/in_systm.h>
54 #include <netinet/ip.h>
55 #include <netinet/in_pcb.h>
56 #include <netinet/ip_icmp.h>
57 #include <netinet/icmp_var.h>
58 #include <netinet/ip_var.h>
59 #ifdef INET6
60 #include <netinet/ip6.h>
61 #include <netinet6/in6_pcb.h>
62 #endif
63 #include <netinet/tcp.h>
64 #include <netinet/tcpip.h>
65 #include <netinet/tcp_seq.h>
66 #define TCPSTATES
67 #include <netinet/tcp_fsm.h>
68 #include <netinet/tcp_timer.h>
69 #include <netinet/tcp_var.h>
70 #include <netinet/tcp_debug.h>
71 #include <netinet/udp.h>
72 #include <netinet/udp_var.h>
73 
74 #include <netdb.h>
75 #include <stdlib.h>
76 #include <string.h>
77 
78 #include "systat.h"
79 #include "extern.h"
80 
81 static void fetchnetstat4(void *, int);
82 static void enter(struct inpcb *, struct socket *, int, const char *);
83 static const char *inetname(struct in_addr);
84 static void inetprint(struct in_addr *, int, const char *);
85 #ifdef INET6
86 static void fetchnetstat6(void *, int);
87 static void enter6(struct in6pcb *, struct socket *, int, const char *);
88 static const char *inet6name(struct in6_addr *);
89 static void inet6print(struct in6_addr *, int, const char *);
90 #endif
91 
92 #define	streq(a,b)	(strcmp(a,b)==0)
93 
94 struct netinfo {
95 	struct	netinfo *ni_forw, *ni_prev;
96 	int	ni_family;
97 	short	ni_line;		/* line on screen */
98 	short	ni_seen;		/* 0 when not present in list */
99 	short	ni_flags;
100 #define	NIF_LACHG	0x1		/* local address changed */
101 #define	NIF_FACHG	0x2		/* foreign address changed */
102 	short	ni_state;		/* tcp state */
103 	const char	*ni_proto;		/* protocol */
104 	struct	in_addr ni_laddr;	/* local address */
105 #ifdef INET6
106 	struct	in6_addr ni_laddr6;	/* local address */
107 #endif
108 	long	ni_lport;		/* local port */
109 	struct	in_addr	ni_faddr;	/* foreign address */
110 #ifdef INET6
111 	struct	in6_addr ni_faddr6;	/* foreign address */
112 #endif
113 	long	ni_fport;		/* foreign port */
114 	long	ni_rcvcc;		/* rcv buffer character count */
115 	long	ni_sndcc;		/* snd buffer character count */
116 };
117 
118 static struct {
119 	struct	netinfo *ni_forw, *ni_prev;
120 } netcb;
121 
122 struct netinfo *nhead;
123 
124 static	int aflag = 0;
125 int nflag = 0;
126 static	int lastrow = 1;
127 
128 WINDOW *
129 opennetstat(void)
130 {
131 
132 	sethostent(1);
133 	setnetent(1);
134 	return (subwin(stdscr, -1, 0, 5, 0));
135 }
136 
137 void
138 closenetstat(WINDOW *w)
139 {
140 	struct netinfo *p;
141 
142 	endhostent();
143 	endnetent();
144 	p = netcb.ni_forw;
145 	while (p != nhead) {
146 		if (p->ni_line != -1)
147 			lastrow--;
148 		p->ni_line = -1;
149 		p = p->ni_forw;
150 	}
151 	if (w != NULL) {
152 		wclear(w);
153 		wrefresh(w);
154 		delwin(w);
155 	}
156 }
157 
158 static struct nlist namelist[] = {
159 #define	X_TCBTABLE	0
160 	{ .n_name = "_tcbtable" },
161 #define	X_UDBTABLE	1
162 	{ .n_name = "_udbtable" },
163 	{ .n_name = NULL },
164 };
165 
166 int
167 initnetstat(void)
168 {
169 	int n;
170 
171 	n = kvm_nlist(kd, namelist);
172 	if (n < 0) {
173 		nlisterr(namelist);
174 		return(0);
175 	} else if (n == sizeof(namelist) / sizeof(namelist[0]) - 1) {
176 		error("No symbols in namelist");
177 		return(0);
178 	}
179 
180 	nhead = (struct netinfo *)(void *)&netcb;
181 
182 	netcb.ni_forw = netcb.ni_prev = nhead;
183 	protos = TCP|UDP;
184 	return(1);
185 }
186 
187 void
188 fetchnetstat(void)
189 {
190 	struct netinfo *p;
191 
192 	if (namelist[X_TCBTABLE].n_value == 0)
193 		return;
194 	for (p = netcb.ni_forw; p != nhead; p = p->ni_forw)
195 		p->ni_seen = 0;
196 
197 	if ((protos & (TCP | UDP)) == 0) {
198 		error("No protocols to display");
199 		return;
200 	}
201 	if ((protos & TCP) && namelist[X_TCBTABLE].n_type)
202 		fetchnetstat4(NPTR(X_TCBTABLE), 1);
203 	if ((protos & UDP) && namelist[X_UDBTABLE].n_type)
204 		fetchnetstat4(NPTR(X_UDBTABLE), 0);
205 #ifdef INET6
206 	if ((protos & TCP) && namelist[X_TCBTABLE].n_type)
207 		fetchnetstat6(NPTR(X_TCBTABLE), 1);
208 	if ((protos & UDP) && namelist[X_UDBTABLE].n_type)
209 		fetchnetstat6(NPTR(X_UDBTABLE), 0);
210 #endif
211 }
212 
213 static void
214 fetchnetstat4(void *off, int istcp)
215 {
216 	struct inpcbtable pcbtable;
217 	struct inpcb *head, *prev, *next;
218 	struct netinfo *p;
219 	struct inpcb inpcb;
220 	struct socket sockb;
221 	struct tcpcb tcpcb;
222 
223 	KREAD(off, &pcbtable, sizeof pcbtable);
224 	prev = head = (struct inpcb *)&((struct inpcbtable *)off)->inpt_queue;
225 	next = (struct inpcb *)pcbtable.inpt_queue.cqh_first;
226 	while (next != head) {
227 		KREAD(next, &inpcb, sizeof (inpcb));
228 		if ((struct inpcb *)inpcb.inp_queue.cqe_prev != prev) {
229 			for (p = netcb.ni_forw; p != nhead; p = p->ni_forw)
230 				p->ni_seen = 1;
231 			error("Kernel state in transition");
232 			return;
233 		}
234 		prev = next;
235 		next = (struct inpcb *)inpcb.inp_queue.cqe_next;
236 
237 		if (inpcb.inp_af != AF_INET)
238 			continue;
239 		if (!aflag && inet_lnaof(inpcb.inp_laddr) == INADDR_ANY)
240 			continue;
241 		if (nhosts && !checkhost(&inpcb))
242 			continue;
243 		if (nports && !checkport(&inpcb))
244 			continue;
245 		KREAD(inpcb.inp_socket, &sockb, sizeof (sockb));
246 		if (istcp) {
247 			KREAD(inpcb.inp_ppcb, &tcpcb, sizeof (tcpcb));
248 			enter(&inpcb, &sockb, tcpcb.t_state, "tcp");
249 		} else
250 			enter(&inpcb, &sockb, 0, "udp");
251 	}
252 }
253 
254 #ifdef INET6
255 static void
256 fetchnetstat6(void *off, int istcp)
257 {
258 	struct inpcbtable pcbtable;
259 	struct in6pcb *head6, *prev6, *next6;
260 	struct netinfo *p;
261 	struct socket sockb;
262 	struct tcpcb tcpcb;
263 	struct in6pcb in6pcb;
264 
265 	KREAD(off, &pcbtable, sizeof pcbtable);
266 	prev6 = head6 = (struct in6pcb *)&((struct inpcbtable *)off)->inpt_queue;
267 	next6 = (struct in6pcb *)pcbtable.inpt_queue.cqh_first;
268 	while (next6 != head6) {
269 		KREAD(next6, &in6pcb, sizeof (in6pcb));
270 		if ((struct in6pcb *)in6pcb.in6p_queue.cqe_prev != prev6) {
271 			for (p = netcb.ni_forw; p != nhead; p = p->ni_forw)
272 				p->ni_seen = 1;
273 			error("Kernel state in transition");
274 			return;
275 		}
276 		prev6 = next6;
277 		next6 = (struct in6pcb *)in6pcb.in6p_queue.cqe_next;
278 
279 		if (in6pcb.in6p_af != AF_INET6)
280 			continue;
281 		if (!aflag && IN6_IS_ADDR_UNSPECIFIED(&in6pcb.in6p_laddr))
282 			continue;
283 		if (nhosts && !checkhost6(&in6pcb))
284 			continue;
285 		if (nports && !checkport6(&in6pcb))
286 			continue;
287 		KREAD(in6pcb.in6p_socket, &sockb, sizeof (sockb));
288 		if (istcp) {
289 			KREAD(in6pcb.in6p_ppcb, &tcpcb, sizeof (tcpcb));
290 			enter6(&in6pcb, &sockb, tcpcb.t_state, "tcp");
291 		} else
292 			enter6(&in6pcb, &sockb, 0, "udp");
293 	}
294 }
295 #endif /*INET6*/
296 
297 static void
298 enter(struct inpcb *inp, struct socket *so, int state, const char *proto)
299 {
300 	struct netinfo *p;
301 
302 	/*
303 	 * Only take exact matches, any sockets with
304 	 * previously unbound addresses will be deleted
305 	 * below in the display routine because they
306 	 * will appear as ``not seen'' in the kernel
307 	 * data structures.
308 	 */
309 	for (p = netcb.ni_forw; p != nhead; p = p->ni_forw) {
310 		if (p->ni_family != AF_INET)
311 			continue;
312 		if (!streq(proto, p->ni_proto))
313 			continue;
314 		if (p->ni_lport != inp->inp_lport ||
315 		    p->ni_laddr.s_addr != inp->inp_laddr.s_addr)
316 			continue;
317 		if (p->ni_faddr.s_addr == inp->inp_faddr.s_addr &&
318 		    p->ni_fport == inp->inp_fport)
319 			break;
320 	}
321 	if (p == nhead) {
322 		if ((p = malloc(sizeof(*p))) == NULL) {
323 			error("Out of memory");
324 			return;
325 		}
326 		p->ni_prev = nhead;
327 		p->ni_forw = netcb.ni_forw;
328 		netcb.ni_forw->ni_prev = p;
329 		netcb.ni_forw = p;
330 		p->ni_line = -1;
331 		p->ni_laddr = inp->inp_laddr;
332 		p->ni_lport = inp->inp_lport;
333 		p->ni_faddr = inp->inp_faddr;
334 		p->ni_fport = inp->inp_fport;
335 		p->ni_proto = proto;
336 		p->ni_flags = NIF_LACHG | NIF_FACHG;
337 		p->ni_family = AF_INET;
338 	}
339 	p->ni_rcvcc = so->so_rcv.sb_cc;
340 	p->ni_sndcc = so->so_snd.sb_cc;
341 	p->ni_state = state;
342 	p->ni_seen = 1;
343 }
344 
345 #ifdef INET6
346 static void
347 enter6(struct in6pcb *in6p, struct socket *so, int state, const char *proto)
348 {
349 	struct netinfo *p;
350 
351 	/*
352 	 * Only take exact matches, any sockets with
353 	 * previously unbound addresses will be deleted
354 	 * below in the display routine because they
355 	 * will appear as ``not seen'' in the kernel
356 	 * data structures.
357 	 */
358 	for (p = netcb.ni_forw; p != nhead; p = p->ni_forw) {
359 		if (p->ni_family != AF_INET6)
360 			continue;
361 		if (!streq(proto, p->ni_proto))
362 			continue;
363 		if (p->ni_lport != in6p->in6p_lport ||
364 		    !IN6_ARE_ADDR_EQUAL(&p->ni_laddr6, &in6p->in6p_laddr))
365 			continue;
366 		if (IN6_ARE_ADDR_EQUAL(&p->ni_faddr6, &in6p->in6p_faddr) &&
367 		    p->ni_fport == in6p->in6p_fport)
368 			break;
369 	}
370 	if (p == nhead) {
371 		if ((p = malloc(sizeof(*p))) == NULL) {
372 			error("Out of memory");
373 			return;
374 		}
375 		p->ni_prev = nhead;
376 		p->ni_forw = netcb.ni_forw;
377 		netcb.ni_forw->ni_prev = p;
378 		netcb.ni_forw = p;
379 		p->ni_line = -1;
380 		p->ni_laddr6 = in6p->in6p_laddr;
381 		p->ni_lport = in6p->in6p_lport;
382 		p->ni_faddr6 = in6p->in6p_faddr;
383 		p->ni_fport = in6p->in6p_fport;
384 		p->ni_proto = proto;
385 		p->ni_flags = NIF_LACHG | NIF_FACHG;
386 		p->ni_family = AF_INET6;
387 	}
388 	p->ni_rcvcc = so->so_rcv.sb_cc;
389 	p->ni_sndcc = so->so_snd.sb_cc;
390 	p->ni_state = state;
391 	p->ni_seen = 1;
392 }
393 #endif
394 
395 /* column locations */
396 #define	LADDR	0
397 #define	FADDR	LADDR+23
398 #define	PROTO	FADDR+23
399 #define	RCVCC	PROTO+6
400 #define	SNDCC	RCVCC+7
401 #define	STATE	SNDCC+7
402 
403 void
404 labelnetstat(void)
405 {
406 	struct netinfo *p;
407 
408 	if (namelist[X_TCBTABLE].n_type == 0)
409 		return;
410 	wmove(wnd, 0, 0); wclrtobot(wnd);
411 	mvwaddstr(wnd, 0, LADDR, "Local Address");
412 	mvwaddstr(wnd, 0, FADDR, "Foreign Address");
413 	mvwaddstr(wnd, 0, PROTO, "Proto");
414 	mvwaddstr(wnd, 0, RCVCC, "Recv-Q");
415 	mvwaddstr(wnd, 0, SNDCC, "Send-Q");
416 	mvwaddstr(wnd, 0, STATE, "(state)");
417 
418 	for (p = netcb.ni_forw; p != nhead; p = p->ni_forw) {
419 		if (p->ni_line == -1)
420 			continue;
421 		p->ni_flags |= NIF_LACHG | NIF_FACHG;
422 	}
423 }
424 
425 void
426 shownetstat(void)
427 {
428 	struct netinfo *p, *q;
429 
430 	/*
431 	 * First, delete any connections that have gone
432 	 * away and adjust the position of connections
433 	 * below to reflect the deleted line.
434 	 */
435 	p = netcb.ni_forw;
436 	while (p != nhead) {
437 		if (p->ni_line == -1 || p->ni_seen) {
438 			p = p->ni_forw;
439 			continue;
440 		}
441 		wmove(wnd, p->ni_line, 0);
442 		wdeleteln(wnd);
443 		for (q = netcb.ni_forw; q != nhead; q = q->ni_forw)
444 			if (q != p && q->ni_line > p->ni_line) {
445 				q->ni_line--;
446 				/* this shouldn't be necessary */
447 				q->ni_flags |= NIF_LACHG | NIF_FACHG;
448 			}
449 		lastrow--;
450 		q = p->ni_forw;
451 		p->ni_prev->ni_forw = p->ni_forw;
452 		p->ni_forw->ni_prev = p->ni_prev;
453 		free(p);
454 		p = q;
455 	}
456 	/*
457 	 * Update existing connections and add new ones.
458 	 */
459 	for (p = netcb.ni_forw; p != nhead; p = p->ni_forw) {
460 		if (p->ni_line == -1) {
461 			/*
462 			 * Add a new entry if possible.
463 			 */
464 			if (lastrow > getmaxy(wnd))
465 				continue;
466 			p->ni_line = lastrow++;
467 			p->ni_flags |= NIF_LACHG | NIF_FACHG;
468 		}
469 		if (p->ni_flags & NIF_LACHG) {
470 			wmove(wnd, p->ni_line, LADDR);
471 			switch (p->ni_family) {
472 			case AF_INET:
473 				inetprint(&p->ni_laddr, p->ni_lport,
474 					p->ni_proto);
475 				break;
476 #ifdef INET6
477 			case AF_INET6:
478 				inet6print(&p->ni_laddr6, p->ni_lport,
479 					p->ni_proto);
480 				break;
481 #endif
482 			}
483 			p->ni_flags &= ~NIF_LACHG;
484 		}
485 		if (p->ni_flags & NIF_FACHG) {
486 			wmove(wnd, p->ni_line, FADDR);
487 			switch (p->ni_family) {
488 			case AF_INET:
489 				inetprint(&p->ni_faddr, p->ni_fport,
490 					p->ni_proto);
491 				break;
492 #ifdef INET6
493 			case AF_INET6:
494 				inet6print(&p->ni_faddr6, p->ni_fport,
495 					p->ni_proto);
496 				break;
497 #endif
498 			}
499 			p->ni_flags &= ~NIF_FACHG;
500 		}
501 		mvwaddstr(wnd, p->ni_line, PROTO, p->ni_proto);
502 #ifdef INET6
503 		if (p->ni_family == AF_INET6)
504 			waddstr(wnd, "6");
505 #endif
506 		mvwprintw(wnd, p->ni_line, RCVCC, "%6ld", p->ni_rcvcc);
507 		mvwprintw(wnd, p->ni_line, SNDCC, "%6ld", p->ni_sndcc);
508 		if (streq(p->ni_proto, "tcp")) {
509 			if (p->ni_state < 0 || p->ni_state >= TCP_NSTATES)
510 				mvwprintw(wnd, p->ni_line, STATE, "%d",
511 				    p->ni_state);
512 			else
513 				mvwaddstr(wnd, p->ni_line, STATE,
514 				    tcpstates[p->ni_state]);
515 		}
516 		wclrtoeol(wnd);
517 	}
518 	if (lastrow < getmaxy(wnd)) {
519 		wmove(wnd, lastrow, 0); wclrtobot(wnd);
520 		wmove(wnd, getmaxy(wnd), 0); wdeleteln(wnd);	/* XXX */
521 	}
522 }
523 
524 /*
525  * Pretty print an Internet address (net address + port).
526  * If the nflag was specified, use numbers instead of names.
527  */
528 static void
529 inetprint(struct in_addr *in, int port, const char *proto)
530 {
531 	struct servent *sp = 0;
532 	char line[80], *cp;
533 
534 	(void)snprintf(line, sizeof line, "%.*s.", 16, inetname(*in));
535 	cp = strchr(line, '\0');
536 	if (!nflag && port)
537 		sp = getservbyport(port, proto);
538 	if (sp || port == 0)
539 		(void)snprintf(cp, line + sizeof line - cp, "%.8s",
540 		     sp ? sp->s_name : "*");
541 	else
542 		(void)snprintf(cp, line + sizeof line - cp, "%d",
543 		     ntohs((u_short)port));
544 	/* pad to full column to clear any garbage */
545 	cp = strchr(line, '\0');
546 	while (cp - line < 22)
547 		*cp++ = ' ';
548 	*cp = '\0';
549 	waddstr(wnd, line);
550 }
551 
552 #ifdef INET6
553 static void
554 inet6print(struct in6_addr *in6, int port, const char *proto)
555 {
556 	struct servent *sp = 0;
557 	char line[80], *cp;
558 
559 	(void)snprintf(line, sizeof line, "%.*s.", 16, inet6name(in6));
560 	cp = strchr(line, '\0');
561 	if (!nflag && port)
562 		sp = getservbyport(port, proto);
563 	if (sp || port == 0)
564 		(void)snprintf(cp, line + sizeof line - cp, "%.8s",
565 		     sp ? sp->s_name : "*");
566 	else
567 		(void)snprintf(cp, line + sizeof line - cp, "%d",
568 		     ntohs((u_short)port));
569 	/* pad to full column to clear any garbage */
570 	cp = strchr(line, '\0');
571 	while (cp - line < 22)
572 		*cp++ = ' ';
573 	*cp = '\0';
574 	waddstr(wnd, line);
575 }
576 #endif
577 
578 /*
579  * Construct an Internet address representation.
580  * If the nflag has been supplied, give
581  * numeric value, otherwise try for symbolic name.
582  */
583 static const char *
584 inetname(struct in_addr in)
585 {
586 	char *cp = 0;
587 	static char line[50];
588 	struct hostent *hp;
589 	struct netent *np;
590 
591 	if (!nflag && in.s_addr != INADDR_ANY) {
592 		int net = inet_netof(in);
593 		int lna = inet_lnaof(in);
594 
595 		if (lna == INADDR_ANY) {
596 			np = getnetbyaddr(net, AF_INET);
597 			if (np)
598 				cp = np->n_name;
599 		}
600 		if (cp == 0) {
601 			hp = gethostbyaddr((char *)&in, sizeof (in), AF_INET);
602 			if (hp)
603 				cp = hp->h_name;
604 		}
605 	}
606 	if (in.s_addr == INADDR_ANY)
607 		strlcpy(line, "*", sizeof(line));
608 	else if (cp)
609 		strlcpy(line, cp, sizeof(line));
610 	else {
611 		in.s_addr = ntohl(in.s_addr);
612 #define C(x)	((x) & 0xff)
613 		(void)snprintf(line, sizeof line, "%u.%u.%u.%u",
614 		    C(in.s_addr >> 24), C(in.s_addr >> 16),
615 		    C(in.s_addr >> 8), C(in.s_addr));
616 #undef C
617 	}
618 	return (line);
619 }
620 
621 #ifdef INET6
622 static const char *
623 inet6name(struct in6_addr *in6)
624 {
625 	static char line[NI_MAXHOST];
626 	struct sockaddr_in6 sin6;
627 	int flags;
628 
629 	if (nflag)
630 		flags = NI_NUMERICHOST;
631 	else
632 		flags = 0;
633 	if (IN6_IS_ADDR_UNSPECIFIED(in6))
634 		return "*";
635 	memset(&sin6, 0, sizeof(sin6));
636 	sin6.sin6_family = AF_INET6;
637 	sin6.sin6_len = sizeof(struct sockaddr_in6);
638 	sin6.sin6_addr = *in6;
639 	if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
640 			line, sizeof(line), NULL, 0, flags) == 0)
641 		return line;
642 	return "?";
643 }
644 #endif
645 
646 /* please note: there are also some netstat commands in netcmds.c */
647 
648 void
649 netstat_all(char *args)
650 {
651 	aflag = !aflag;
652 	fetchnetstat();
653 	shownetstat();
654 	refresh();
655 }
656 
657 void
658 netstat_names(char *args)
659 {
660 
661 	if (nflag == 0)
662 		return;
663 
664 	nflag = 0;
665 	wclear(wnd);
666 	labelnetstat();
667 	shownetstat();
668 	refresh();
669 }
670 
671 void
672 netstat_numbers(char *args)
673 {
674 
675 	if (nflag != 0)
676 		return;
677 
678 	nflag = 1;
679 	wclear(wnd);
680 	labelnetstat();
681 	shownetstat();
682 	refresh();
683 }
684