unix.c revision 311670 
1/*-
2 * Copyright (c) 1983, 1988, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if 0
31#ifndef lint
32static char sccsid[] = "@(#)unix.c	8.1 (Berkeley) 6/6/93";
33#endif /* not lint */
34#endif
35
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: stable/11/usr.bin/netstat/unix.c 311670 2017-01-08 07:25:22Z delphij $");
38
39/*
40 * Display protocol blocks in the unix domain.
41 */
42#include <sys/param.h>
43#include <sys/queue.h>
44#include <sys/protosw.h>
45#include <sys/socket.h>
46#include <sys/socketvar.h>
47#include <sys/mbuf.h>
48#include <sys/sysctl.h>
49#include <sys/un.h>
50#include <sys/unpcb.h>
51
52#include <netinet/in.h>
53
54#include <errno.h>
55#include <err.h>
56#include <stddef.h>
57#include <stdint.h>
58#include <stdio.h>
59#include <stdlib.h>
60#include <stdbool.h>
61#include <strings.h>
62#include <kvm.h>
63#include <libxo/xo.h>
64#include "netstat.h"
65
66static	void unixdomainpr(struct xunpcb *, struct xsocket *);
67
68static	const char *const socktype[] =
69    { "#0", "stream", "dgram", "raw", "rdm", "seqpacket" };
70
71static int
72pcblist_sysctl(int type, char **bufp)
73{
74	char 	*buf;
75	size_t	len;
76	char mibvar[sizeof "net.local.seqpacket.pcblist"];
77
78	snprintf(mibvar, sizeof(mibvar), "net.local.%s.pcblist", socktype[type]);
79
80	len = 0;
81	if (sysctlbyname(mibvar, 0, &len, 0, 0) < 0) {
82		if (errno != ENOENT)
83			xo_warn("sysctl: %s", mibvar);
84		return (-1);
85	}
86	if ((buf = malloc(len)) == NULL) {
87		xo_warnx("malloc %lu bytes", (u_long)len);
88		return (-2);
89	}
90	if (sysctlbyname(mibvar, buf, &len, 0, 0) < 0) {
91		xo_warn("sysctl: %s", mibvar);
92		free(buf);
93		return (-2);
94	}
95	*bufp = buf;
96	return (0);
97}
98
99static int
100pcblist_kvm(u_long count_off, u_long gencnt_off, u_long head_off, char **bufp)
101{
102	struct unp_head head;
103	struct unpcb *unp, unp_conn;
104	u_char sun_len;
105	struct socket so;
106	struct xunpgen xug;
107	struct xunpcb xu;
108	unp_gen_t unp_gencnt;
109	u_int	unp_count;
110	char 	*buf, *p;
111	size_t	len;
112
113	if (count_off == 0 || gencnt_off == 0)
114		return (-2);
115	if (head_off == 0)
116		return (-1);
117	kread(count_off, &unp_count, sizeof(unp_count));
118	len = 2 * sizeof(xug) + (unp_count + unp_count / 8) * sizeof(xu);
119	if ((buf = malloc(len)) == NULL) {
120		xo_warnx("malloc %lu bytes", (u_long)len);
121		return (-2);
122	}
123	p = buf;
124
125#define	COPYOUT(obj, size) do {						\
126	if (len < (size)) {						\
127		xo_warnx("buffer size exceeded");			\
128		goto fail;						\
129	}								\
130	bcopy((obj), p, (size));					\
131	len -= (size);							\
132	p += (size);							\
133} while (0)
134
135#define	KREAD(off, buf, len) do {					\
136	if (kread((uintptr_t)(off), (buf), (len)) != 0)			\
137		goto fail;						\
138} while (0)
139
140	/* Write out header. */
141	kread(gencnt_off, &unp_gencnt, sizeof(unp_gencnt));
142	xug.xug_len = sizeof xug;
143	xug.xug_count = unp_count;
144	xug.xug_gen = unp_gencnt;
145	xug.xug_sogen = 0;
146	COPYOUT(&xug, sizeof xug);
147
148	/* Walk the PCB list. */
149	xu.xu_len = sizeof xu;
150	KREAD(head_off, &head, sizeof(head));
151	LIST_FOREACH(unp, &head, unp_link) {
152		xu.xu_unpp = unp;
153		KREAD(unp, &xu.xu_unp, sizeof (*unp));
154		unp = &xu.xu_unp;
155
156		if (unp->unp_gencnt > unp_gencnt)
157			continue;
158		if (unp->unp_addr != NULL) {
159			KREAD(unp->unp_addr, &sun_len, sizeof(sun_len));
160			KREAD(unp->unp_addr, &xu.xu_addr, sun_len);
161		}
162		if (unp->unp_conn != NULL) {
163			KREAD(unp->unp_conn, &unp_conn, sizeof(unp_conn));
164			if (unp_conn.unp_addr != NULL) {
165				KREAD(unp_conn.unp_addr, &sun_len,
166				    sizeof(sun_len));
167				KREAD(unp_conn.unp_addr, &xu.xu_caddr, sun_len);
168			}
169		}
170		KREAD(unp->unp_socket, &so, sizeof(so));
171		if (sotoxsocket(&so, &xu.xu_socket) != 0)
172			goto fail;
173		COPYOUT(&xu, sizeof(xu));
174	}
175
176	/* Reread the counts and write the footer. */
177	kread(count_off, &unp_count, sizeof(unp_count));
178	kread(gencnt_off, &unp_gencnt, sizeof(unp_gencnt));
179	xug.xug_count = unp_count;
180	xug.xug_gen = unp_gencnt;
181	COPYOUT(&xug, sizeof xug);
182
183	*bufp = buf;
184	return (0);
185
186fail:
187	free(buf);
188	return (-1);
189#undef COPYOUT
190#undef KREAD
191}
192
193void
194unixpr(u_long count_off, u_long gencnt_off, u_long dhead_off, u_long shead_off,
195    u_long sphead_off, bool *first)
196{
197	char 	*buf;
198	int	ret, type;
199	struct	xsocket *so;
200	struct	xunpgen *xug, *oxug;
201	struct	xunpcb *xunp;
202	u_long	head_off;
203
204	buf = NULL;
205	for (type = SOCK_STREAM; type <= SOCK_SEQPACKET; type++) {
206		if (live)
207			ret = pcblist_sysctl(type, &buf);
208		else {
209			head_off = 0;
210			switch (type) {
211			case SOCK_STREAM:
212				head_off = shead_off;
213				break;
214
215			case SOCK_DGRAM:
216				head_off = dhead_off;
217				break;
218
219			case SOCK_SEQPACKET:
220				head_off = sphead_off;
221				break;
222			}
223			ret = pcblist_kvm(count_off, gencnt_off, head_off,
224			    &buf);
225		}
226		if (ret == -1)
227			continue;
228		if (ret < 0)
229			return;
230
231		oxug = xug = (struct xunpgen *)buf;
232		for (xug = (struct xunpgen *)((char *)xug + xug->xug_len);
233		    xug->xug_len > sizeof(struct xunpgen);
234		    xug = (struct xunpgen *)((char *)xug + xug->xug_len)) {
235			xunp = (struct xunpcb *)xug;
236			so = &xunp->xu_socket;
237
238			/* Ignore PCBs which were freed during copyout. */
239			if (xunp->xu_unp.unp_gencnt > oxug->xug_gen)
240				continue;
241			if (*first) {
242				xo_open_list("socket");
243				*first = false;
244			}
245			xo_open_instance("socket");
246			unixdomainpr(xunp, so);
247			xo_close_instance("socket");
248		}
249		if (xug != oxug && xug->xug_gen != oxug->xug_gen) {
250			if (oxug->xug_count > xug->xug_count) {
251				xo_emit("Some {:type/%s} sockets may have "
252				    "been {:action/deleted}.\n",
253				    socktype[type]);
254			} else if (oxug->xug_count < xug->xug_count) {
255				xo_emit("Some {:type/%s} sockets may have "
256				    "been {:action/created}.\n",
257				    socktype[type]);
258			} else {
259				xo_emit("Some {:type/%s} sockets may have "
260				    "been {:action/created or deleted}",
261				    socktype[type]);
262			}
263		}
264		free(buf);
265	}
266}
267
268static void
269unixdomainpr(struct xunpcb *xunp, struct xsocket *so)
270{
271	struct unpcb *unp;
272	struct sockaddr_un *sa;
273	static int first = 1;
274	char buf1[33];
275	static const char *titles[2] = {
276	    "{T:/%-8.8s} {T:/%-6.6s} {T:/%-6.6s} {T:/%-6.6s} {T:/%8.8s} "
277	    "{T:/%8.8s} {T:/%8.8s} {T:/%8.8s} {T:Addr}\n",
278	    "{T:/%-16.16s} {T:/%-6.6s} {T:/%-6.6s} {T:/%-6.6s} {T:/%16.16s} "
279	    "{T:/%16.16s} {T:/%16.16s} {T:/%16.16s} {T:Addr}\n"
280	};
281	static const char *format[2] = {
282	    "{q:address/%8lx} {t:type/%-6.6s} "
283	    "{:receive-bytes-waiting/%6u} "
284	    "{:send-bytes-waiting/%6u} "
285	    "{q:vnode/%8lx} {q:connection/%8lx} "
286	    "{q:first-reference/%8lx} {q:next-reference/%8lx}",
287	    "{q:address/%16lx} {t:type/%-6.6s} "
288	    "{:receive-bytes-waiting/%6u} "
289	    "{:send-bytes-waiting/%6u} "
290	    "{q:vnode/%16lx} {q:connection/%16lx} "
291	    "{q:first-reference/%16lx} {q:next-reference/%16lx}"
292	};
293	int fmt = (sizeof(void *) == 8) ? 1 : 0;
294
295	unp = &xunp->xu_unp;
296	if (unp->unp_addr)
297		sa = &xunp->xu_addr;
298	else
299		sa = (struct sockaddr_un *)0;
300
301	if (first && !Lflag) {
302		xo_emit("{T:Active UNIX domain sockets}\n");
303		xo_emit(titles[fmt],
304		    "Address", "Type", "Recv-Q", "Send-Q",
305		    "Inode", "Conn", "Refs", "Nextref");
306		first = 0;
307	}
308
309	if (Lflag && so->so_qlimit == 0)
310		return;
311
312	if (Lflag) {
313		snprintf(buf1, sizeof buf1, "%u/%u/%u", so->so_qlen,
314		    so->so_incqlen, so->so_qlimit);
315		xo_emit("unix  {d:socket/%-32.32s}{e:queue-length/%u}"
316		    "{e:incomplete-queue-length/%u}{e:queue-limit/%u}",
317		    buf1, so->so_qlen, so->so_incqlen, so->so_qlimit);
318	} else {
319		xo_emit(format[fmt],
320		    (long)so->so_pcb, socktype[so->so_type], so->so_rcv.sb_cc,
321		    so->so_snd.sb_cc, (long)unp->unp_vnode,
322		    (long)unp->unp_conn,
323		    (long)LIST_FIRST(&unp->unp_refs),
324		    (long)LIST_NEXT(unp, unp_reflink));
325	}
326	if (sa)
327		xo_emit(" {:path/%.*s}",
328		    (int)(sa->sun_len - offsetof(struct sockaddr_un, sun_path)),
329		    sa->sun_path);
330	xo_emit("\n");
331}
332