xref: /titanic_41/usr/src/cmd/ptools/pfiles/pfiles.c (revision dfc0fed81813380fb526f1a003d3be17ab26ce3b)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2012 DEY Storage Systems, Inc.  All rights reserved.
25  */
26 /*
27  * Copyright (c) 2013 Joyent, Inc.  All Rights reserved.
28  */
29 
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <ctype.h>
35 #include <string.h>
36 #include <signal.h>
37 #include <dirent.h>
38 #include <limits.h>
39 #include <door.h>
40 #include <sys/types.h>
41 #include <sys/socket.h>
42 #include <sys/stat.h>
43 #include <sys/mkdev.h>
44 #include <sys/stropts.h>
45 #include <sys/timod.h>
46 #include <sys/un.h>
47 #include <libproc.h>
48 #include <netinet/in.h>
49 #include <netinet/udp.h>
50 #include <arpa/inet.h>
51 #include <ucred.h>
52 #include <zone.h>
53 
54 #define	copyflock(dst, src) \
55 	(dst).l_type = (src).l_type;		\
56 	(dst).l_whence = (src).l_whence;	\
57 	(dst).l_start = (src).l_start;		\
58 	(dst).l_len = (src).l_len;		\
59 	(dst).l_sysid = (src).l_sysid;		\
60 	(dst).l_pid = (src).l_pid;
61 
62 static char *command;
63 static volatile int interrupt;
64 static int Fflag;
65 static boolean_t nflag = B_FALSE;
66 
67 static	void	intr(int);
68 static	void	dofcntl(struct ps_prochandle *, prfdinfo_t *, int, int);
69 static	void	dosocket(struct ps_prochandle *, int);
70 static	void	dofifo(struct ps_prochandle *, int);
71 static	void	dotli(struct ps_prochandle *, int);
72 static	void	show_files(struct ps_prochandle *);
73 static	void	show_fileflags(int);
74 static	void	show_door(struct ps_prochandle *, int);
75 static	int	getflock(struct ps_prochandle *, int, struct flock *);
76 
77 int
main(int argc,char ** argv)78 main(int argc, char **argv)
79 {
80 	int retc = 0;
81 	int opt;
82 	int errflg = 0;
83 	struct ps_prochandle *Pr;
84 
85 	if ((command = strrchr(argv[0], '/')) != NULL)
86 		command++;
87 	else
88 		command = argv[0];
89 
90 	/* options */
91 	while ((opt = getopt(argc, argv, "Fn")) != EOF) {
92 		switch (opt) {
93 		case 'F':		/* force grabbing (no O_EXCL) */
94 			Fflag = PGRAB_FORCE;
95 			break;
96 		case 'n':
97 			nflag = B_TRUE;
98 			break;
99 		default:
100 			errflg = 1;
101 			break;
102 		}
103 	}
104 
105 	argc -= optind;
106 	argv += optind;
107 
108 	if (errflg || argc <= 0) {
109 		(void) fprintf(stderr, "usage:\t%s [-F] { pid | core } ...\n",
110 		    command);
111 		(void) fprintf(stderr,
112 		    "  (report open files of each process)\n");
113 		(void) fprintf(stderr,
114 		    "  -F: force grabbing of the target process\n");
115 		exit(2);
116 	}
117 
118 	/* catch signals from terminal */
119 	if (sigset(SIGHUP, SIG_IGN) == SIG_DFL)
120 		(void) sigset(SIGHUP, intr);
121 	if (sigset(SIGINT, SIG_IGN) == SIG_DFL)
122 		(void) sigset(SIGINT, intr);
123 	if (sigset(SIGQUIT, SIG_IGN) == SIG_DFL)
124 		(void) sigset(SIGQUIT, intr);
125 	(void) sigset(SIGPIPE, intr);
126 	(void) sigset(SIGTERM, intr);
127 
128 	(void) proc_initstdio();
129 
130 
131 	while (--argc >= 0 && !interrupt) {
132 		char *arg;
133 		psinfo_t psinfo;
134 		pid_t pid;
135 		int gret;
136 
137 		(void) proc_flushstdio();
138 
139 		arg = *argv++;
140 
141 		/* get the specified pid and the psinfo struct */
142 		if ((pid = proc_arg_psinfo(arg, PR_ARG_PIDS,
143 		    &psinfo, &gret)) == -1) {
144 
145 			if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_CORES,
146 			    Fflag, &gret, NULL)) == NULL) {
147 				(void) fprintf(stderr,
148 				    "%s: cannot examine %s: %s\n",
149 				    command, arg, Pgrab_error(gret));
150 				retc++;
151 				continue;
152 			}
153 			if (proc_arg_psinfo(arg, PR_ARG_ANY, &psinfo,
154 			    &gret) < 0) {
155 				(void) fprintf(stderr,
156 				    "%s: cannot examine %s: %s\n",
157 				    command, arg, Pgrab_error(gret));
158 				retc++;
159 				Prelease(Pr, 0);
160 				continue;
161 			}
162 			(void) printf("core '%s' of %d:\t%.70s\n",
163 			    arg, (int)psinfo.pr_pid, psinfo.pr_psargs);
164 
165 			show_files(Pr);
166 			Prelease(Pr, 0);
167 
168 		} else if ((Pr = Pgrab(pid, Fflag, &gret)) != NULL) {
169 			if (Pcreate_agent(Pr) == 0) {
170 				proc_unctrl_psinfo(&psinfo);
171 				(void) printf("%d:\t%.70s\n",
172 				    (int)pid, psinfo.pr_psargs);
173 				show_files(Pr);
174 				Pdestroy_agent(Pr);
175 			} else {
176 				(void) fprintf(stderr,
177 				    "%s: cannot control process %d\n",
178 				    command, (int)pid);
179 				retc++;
180 			}
181 			Prelease(Pr, 0);
182 			Pr = NULL;
183 		} else {
184 			switch (gret) {
185 			case G_SYS:
186 				proc_unctrl_psinfo(&psinfo);
187 				(void) printf("%d:\t%.70s\n", (int)pid,
188 				    psinfo.pr_psargs);
189 				(void) printf("  [system process]\n");
190 				break;
191 			default:
192 				(void) fprintf(stderr, "%s: %s: %d\n",
193 				    command, Pgrab_error(gret), (int)pid);
194 				retc++;
195 				break;
196 			}
197 		}
198 	}
199 
200 	(void) proc_finistdio();
201 
202 	if (interrupt && retc == 0)
203 		retc++;
204 	return (retc);
205 }
206 
207 /* ARGSUSED */
208 static void
intr(int sig)209 intr(int sig)
210 {
211 	interrupt = 1;
212 }
213 
214 /* ------ begin specific code ------ */
215 
216 static int
show_file(void * data,prfdinfo_t * info)217 show_file(void *data, prfdinfo_t *info)
218 {
219 	struct ps_prochandle *Pr = data;
220 	char unknown[12];
221 	char *s;
222 	mode_t mode;
223 
224 	if (interrupt)
225 		return (1);
226 
227 	mode = info->pr_mode;
228 
229 	switch (mode & S_IFMT) {
230 	case S_IFCHR: s = "S_IFCHR"; break;
231 	case S_IFBLK: s = "S_IFBLK"; break;
232 	case S_IFIFO: s = "S_IFIFO"; break;
233 	case S_IFDIR: s = "S_IFDIR"; break;
234 	case S_IFREG: s = "S_IFREG"; break;
235 	case S_IFLNK: s = "S_IFLNK"; break;
236 	case S_IFSOCK: s = "S_IFSOCK"; break;
237 	case S_IFDOOR: s = "S_IFDOOR"; break;
238 	case S_IFPORT: s = "S_IFPORT"; break;
239 	default:
240 		s = unknown;
241 		(void) sprintf(s, "0x%.4x ", (int)mode & S_IFMT);
242 		break;
243 	}
244 
245 	(void) printf("%4d: %s mode:0%.3o", info->pr_fd, s,
246 	    (int)mode & ~S_IFMT);
247 
248 	(void) printf(" dev:%u,%u",
249 	    (unsigned)info->pr_major, (unsigned)info->pr_minor);
250 
251 	if ((mode & S_IFMT) == S_IFPORT) {
252 		(void) printf(" uid:%d gid:%d",
253 		    (int)info->pr_uid, (int)info->pr_gid);
254 		(void) printf(" size:%lld\n", (longlong_t)info->pr_size);
255 		return (0);
256 	}
257 
258 	(void) printf(" ino:%llu uid:%d gid:%d",
259 	    (u_longlong_t)info->pr_ino, (int)info->pr_uid, (int)info->pr_gid);
260 
261 	if ((info->pr_rmajor == (major_t)NODEV) &&
262 	    (info->pr_rminor == (minor_t)NODEV))
263 		(void) printf(" size:%lld\n", (longlong_t)info->pr_size);
264 	else
265 		(void) printf(" rdev:%u,%u\n",
266 		    (unsigned)info->pr_rmajor, (unsigned)info->pr_rminor);
267 
268 	if (!nflag) {
269 		dofcntl(Pr, info,
270 		    (mode & (S_IFMT|S_ENFMT|S_IXGRP)) == (S_IFREG|S_ENFMT),
271 		    (mode & S_IFMT) == S_IFDOOR);
272 
273 		if (Pstate(Pr) != PS_DEAD) {
274 			char *dev;
275 
276 			if ((mode & S_IFMT) == S_IFSOCK)
277 				dosocket(Pr, info->pr_fd);
278 			else if ((mode & S_IFMT) == S_IFIFO)
279 				dofifo(Pr, info->pr_fd);
280 
281 			if ((mode & S_IFMT) == S_IFCHR &&
282 			    (dev = strrchr(info->pr_path, ':')) != NULL) {
283 				/*
284 				 * There's no elegant way to determine
285 				 * if a character device supports TLI,
286 				 * so we lame out and just check a
287 				 * hardcoded list of known TLI devices.
288 				 */
289 				int i;
290 				const char *tlidevs[] = {
291 				    "tcp", "tcp6", "udp", "udp6", NULL
292 				};
293 
294 				dev++; /* skip past the `:' */
295 				for (i = 0; tlidevs[i] != NULL; i++) {
296 					if (strcmp(dev, tlidevs[i]) == 0) {
297 						dotli(Pr, info->pr_fd);
298 						break;
299 					}
300 				}
301 			}
302 		}
303 
304 		if (info->pr_path[0] != '\0')
305 			(void) printf("      %s\n", info->pr_path);
306 
307 		if (info->pr_offset != -1) {
308 			(void) printf("      offset:%lld\n",
309 			    (long long)info->pr_offset);
310 		}
311 	}
312 	return (0);
313 }
314 
315 static void
show_files(struct ps_prochandle * Pr)316 show_files(struct ps_prochandle *Pr)
317 {
318 	struct rlimit rlim;
319 
320 	if (pr_getrlimit(Pr, RLIMIT_NOFILE, &rlim) == 0) {
321 		ulong_t nfd = rlim.rlim_cur;
322 		if (nfd == RLIM_INFINITY)
323 			(void) printf(
324 			    "  Current rlimit: unlimited file descriptors\n");
325 		else
326 			(void) printf(
327 			    "  Current rlimit: %lu file descriptors\n", nfd);
328 	}
329 
330 	(void) Pfdinfo_iter(Pr, show_file, Pr);
331 }
332 
333 
334 static int
getflock(struct ps_prochandle * Pr,int fd,struct flock * flock_native)335 getflock(struct ps_prochandle *Pr, int fd, struct flock *flock_native)
336 {
337 	int ret;
338 #ifdef _LP64
339 	struct flock64_32 flock_target;
340 
341 	if (Pstatus(Pr)->pr_dmodel == PR_MODEL_ILP32) {
342 		copyflock(flock_target, *flock_native);
343 		ret = pr_fcntl(Pr, fd, F_GETLK, &flock_target);
344 		copyflock(*flock_native, flock_target);
345 		return (ret);
346 	}
347 #endif /* _LP64 */
348 	ret = pr_fcntl(Pr, fd, F_GETLK, flock_native);
349 	return (ret);
350 }
351 
352 /* examine open file with fcntl() */
353 static void
dofcntl(struct ps_prochandle * Pr,prfdinfo_t * info,int mandatory,int isdoor)354 dofcntl(struct ps_prochandle *Pr, prfdinfo_t *info, int mandatory, int isdoor)
355 {
356 	struct flock flock;
357 	int fileflags;
358 	int fdflags;
359 	int fd;
360 
361 	fd = info->pr_fd;
362 
363 	fileflags = info->pr_fileflags;
364 	fdflags = info->pr_fdflags;
365 
366 	if (fileflags != -1 || fdflags != -1) {
367 		(void) printf("      ");
368 		if (fileflags != -1)
369 			show_fileflags(fileflags);
370 		if (fdflags != -1 && (fdflags & FD_CLOEXEC))
371 			(void) printf(" FD_CLOEXEC");
372 		if (isdoor && (Pstate(Pr) != PS_DEAD))
373 			show_door(Pr, fd);
374 		(void) fputc('\n', stdout);
375 	} else if (isdoor && (Pstate(Pr) != PS_DEAD)) {
376 		(void) printf("    ");
377 		show_door(Pr, fd);
378 		(void) fputc('\n', stdout);
379 	}
380 
381 	flock.l_type = F_WRLCK;
382 	flock.l_whence = 0;
383 	flock.l_start = 0;
384 	flock.l_len = 0;
385 	flock.l_sysid = 0;
386 	flock.l_pid = 0;
387 	if ((Pstate(Pr) != PS_DEAD) && (getflock(Pr, fd, &flock) != -1)) {
388 		if (flock.l_type != F_UNLCK && (flock.l_sysid || flock.l_pid)) {
389 			unsigned long sysid = flock.l_sysid;
390 
391 			(void) printf("      %s %s lock set by",
392 			    mandatory ? "mandatory" : "advisory",
393 			    flock.l_type == F_RDLCK? "read" : "write");
394 			if (sysid)
395 				(void) printf(" system 0x%lX", sysid);
396 			if (flock.l_pid)
397 				(void) printf(" process %d", (int)flock.l_pid);
398 			(void) fputc('\n', stdout);
399 		}
400 	}
401 }
402 
403 #define	ALL_O_FLAGS	O_ACCMODE | O_NDELAY | O_NONBLOCK | O_APPEND | \
404 			O_SYNC | O_DSYNC | O_RSYNC | O_XATTR | \
405 			O_CREAT | O_TRUNC | O_EXCL | O_NOCTTY | O_LARGEFILE
406 
407 static void
show_fileflags(int flags)408 show_fileflags(int flags)
409 {
410 	char buffer[136];
411 	char *str = buffer;
412 
413 	switch (flags & O_ACCMODE) {
414 	case O_RDONLY:
415 		(void) strcpy(str, "O_RDONLY");
416 		break;
417 	case O_WRONLY:
418 		(void) strcpy(str, "O_WRONLY");
419 		break;
420 	case O_RDWR:
421 		(void) strcpy(str, "O_RDWR");
422 		break;
423 	case O_SEARCH:
424 		(void) strcpy(str, "O_SEARCH");
425 		break;
426 	case O_EXEC:
427 		(void) strcpy(str, "O_EXEC");
428 		break;
429 	default:
430 		(void) sprintf(str, "0x%x", flags & O_ACCMODE);
431 		break;
432 	}
433 
434 	if (flags & O_NDELAY)
435 		(void) strcat(str, "|O_NDELAY");
436 	if (flags & O_NONBLOCK)
437 		(void) strcat(str, "|O_NONBLOCK");
438 	if (flags & O_APPEND)
439 		(void) strcat(str, "|O_APPEND");
440 	if (flags & O_SYNC)
441 		(void) strcat(str, "|O_SYNC");
442 	if (flags & O_DSYNC)
443 		(void) strcat(str, "|O_DSYNC");
444 	if (flags & O_RSYNC)
445 		(void) strcat(str, "|O_RSYNC");
446 	if (flags & O_CREAT)
447 		(void) strcat(str, "|O_CREAT");
448 	if (flags & O_TRUNC)
449 		(void) strcat(str, "|O_TRUNC");
450 	if (flags & O_EXCL)
451 		(void) strcat(str, "|O_EXCL");
452 	if (flags & O_NOCTTY)
453 		(void) strcat(str, "|O_NOCTTY");
454 	if (flags & O_LARGEFILE)
455 		(void) strcat(str, "|O_LARGEFILE");
456 	if (flags & O_XATTR)
457 		(void) strcat(str, "|O_XATTR");
458 	if (flags & ~(ALL_O_FLAGS))
459 		(void) sprintf(str + strlen(str), "|0x%x",
460 		    flags & ~(ALL_O_FLAGS));
461 
462 	(void) printf("%s", str);
463 }
464 
465 /* show process on the other end of a door, socket or fifo */
466 static void
show_peer_process(pid_t ppid)467 show_peer_process(pid_t ppid)
468 {
469 	psinfo_t psinfo;
470 
471 	if (proc_get_psinfo(ppid, &psinfo) == 0)
472 		(void) printf(" %s[%d]", psinfo.pr_fname, (int)ppid);
473 	else
474 		(void) printf(" pid %d", (int)ppid);
475 }
476 
477 /* show door info */
478 static void
show_door(struct ps_prochandle * Pr,int fd)479 show_door(struct ps_prochandle *Pr, int fd)
480 {
481 	door_info_t door_info;
482 
483 	if (pr_door_info(Pr, fd, &door_info) != 0)
484 		return;
485 
486 	(void) printf("  door to");
487 	show_peer_process(door_info.di_target);
488 }
489 
490 /*
491  * Print out the socket address pointed to by `sa'.  `len' is only
492  * needed for AF_UNIX sockets.
493  */
494 static void
show_sockaddr(const char * str,struct sockaddr * sa,socklen_t len)495 show_sockaddr(const char *str, struct sockaddr *sa, socklen_t len)
496 {
497 	struct sockaddr_in *so_in = (struct sockaddr_in *)(void *)sa;
498 	struct sockaddr_in6 *so_in6 = (struct sockaddr_in6 *)(void *)sa;
499 	struct sockaddr_un *so_un = (struct sockaddr_un *)sa;
500 	char  abuf[INET6_ADDRSTRLEN];
501 	const char *p;
502 
503 	if (len == 0)
504 		return;
505 
506 	switch (sa->sa_family) {
507 	default:
508 		return;
509 	case AF_INET:
510 		(void) printf("\t%s: AF_INET %s  port: %u\n", str,
511 		    inet_ntop(AF_INET, &so_in->sin_addr, abuf, sizeof (abuf)),
512 		    ntohs(so_in->sin_port));
513 		return;
514 	case AF_INET6:
515 		(void) printf("\t%s: AF_INET6 %s  port: %u\n", str,
516 		    inet_ntop(AF_INET6, &so_in6->sin6_addr,
517 		    abuf, sizeof (abuf)),
518 		    ntohs(so_in->sin_port));
519 		return;
520 	case AF_UNIX:
521 		if (len >= sizeof (so_un->sun_family)) {
522 			/* Null terminate */
523 			len -= sizeof (so_un->sun_family);
524 			so_un->sun_path[len] = '\0';
525 			(void) printf("\t%s: AF_UNIX %s\n",
526 			    str, so_un->sun_path);
527 		}
528 		return;
529 	case AF_IMPLINK:	p = "AF_IMPLINK";	break;
530 	case AF_PUP:		p = "AF_PUP";		break;
531 	case AF_CHAOS:		p = "AF_CHAOS";		break;
532 	case AF_NS:		p = "AF_NS";		break;
533 	case AF_NBS:		p = "AF_NBS";		break;
534 	case AF_ECMA:		p = "AF_ECMA";		break;
535 	case AF_DATAKIT:	p = "AF_DATAKIT";	break;
536 	case AF_CCITT:		p = "AF_CCITT";		break;
537 	case AF_SNA:		p = "AF_SNA";		break;
538 	case AF_DECnet:		p = "AF_DECnet";	break;
539 	case AF_DLI:		p = "AF_DLI";		break;
540 	case AF_LAT:		p = "AF_LAT";		break;
541 	case AF_HYLINK:		p = "AF_HYLINK";	break;
542 	case AF_APPLETALK:	p = "AF_APPLETALK";	break;
543 	case AF_NIT:		p = "AF_NIT";		break;
544 	case AF_802:		p = "AF_802";		break;
545 	case AF_OSI:		p = "AF_OSI";		break;
546 	case AF_X25:		p = "AF_X25";		break;
547 	case AF_OSINET:		p = "AF_OSINET";	break;
548 	case AF_GOSIP:		p = "AF_GOSIP";		break;
549 	case AF_IPX:		p = "AF_IPX";		break;
550 	case AF_ROUTE:		p = "AF_ROUTE";		break;
551 	case AF_LINK:		p = "AF_LINK";		break;
552 	}
553 
554 	(void) printf("\t%s: %s\n", str, p);
555 }
556 
557 /*
558  * Print out the process information for the other end of local sockets
559  * and fifos
560  */
561 static void
show_ucred(const char * str,ucred_t * cred)562 show_ucred(const char *str, ucred_t *cred)
563 {
564 	pid_t upid = ucred_getpid(cred);
565 	zoneid_t uzid = ucred_getzoneid(cred);
566 	char zonename[ZONENAME_MAX];
567 
568 	if ((upid != -1) || (uzid != -1)) {
569 		(void) printf("\t%s:", str);
570 		if (upid != -1) {
571 			show_peer_process(upid);
572 		}
573 		if (uzid != -1) {
574 			if (getzonenamebyid(uzid, zonename, sizeof (zonename))
575 			    != -1) {
576 				(void) printf(" zone: %s[%d]", zonename,
577 				    (int)uzid);
578 			} else {
579 				(void) printf(" zoneid: %d", (int)uzid);
580 			}
581 		}
582 		(void) printf("\n");
583 	}
584 }
585 
586 static void
show_socktype(uint_t type)587 show_socktype(uint_t type)
588 {
589 	static const char *types[] = {
590 		NULL, "DGRAM", "STREAM", NULL, "RAW", "RDM", "SEQPACKET"
591 	};
592 
593 	if (type < sizeof (types) / sizeof (*types) && types[type] != NULL)
594 		(void) printf("\tSOCK_%s\n", types[type]);
595 	else
596 		(void) printf("\tunknown socket type %u\n", type);
597 }
598 
599 #define	BUFSIZE	200
600 static void
show_sockopts(struct ps_prochandle * Pr,int fd)601 show_sockopts(struct ps_prochandle *Pr, int fd)
602 {
603 	int val, vlen;
604 	char buf[BUFSIZE];
605 	char buf1[32];
606 	char ipaddr[INET_ADDRSTRLEN];
607 	int i;
608 	in_addr_t nexthop_val;
609 	struct boolopt {
610 		int		level;
611 		int		opt;
612 		const char	*name;
613 	};
614 	static struct boolopt boolopts[] = {
615 	    { SOL_SOCKET, SO_DEBUG,		"SO_DEBUG,"	},
616 	    { SOL_SOCKET, SO_REUSEADDR,		"SO_REUSEADDR,"	},
617 	    { SOL_SOCKET, SO_KEEPALIVE,		"SO_KEEPALIVE,"	},
618 	    { SOL_SOCKET, SO_DONTROUTE,		"SO_DONTROUTE,"	},
619 	    { SOL_SOCKET, SO_BROADCAST,		"SO_BROADCAST,"	},
620 	    { SOL_SOCKET, SO_OOBINLINE,		"SO_OOBINLINE,"	},
621 	    { SOL_SOCKET, SO_DGRAM_ERRIND,	"SO_DGRAM_ERRIND,"},
622 	    { SOL_SOCKET, SO_ALLZONES,		"SO_ALLZONES,"	},
623 	    { SOL_SOCKET, SO_MAC_EXEMPT,	"SO_MAC_EXEMPT," },
624 	    { SOL_SOCKET, SO_MAC_IMPLICIT,	"SO_MAC_IMPLICIT," },
625 	    { SOL_SOCKET, SO_EXCLBIND,		"SO_EXCLBIND," },
626 	    { SOL_SOCKET, SO_VRRP,		"SO_VRRP," },
627 	    { IPPROTO_UDP, UDP_NAT_T_ENDPOINT,	"UDP_NAT_T_ENDPOINT," },
628 	};
629 	struct linger l;
630 
631 	buf[0] = '!';		/* sentinel value, never printed */
632 	buf[1] = '\0';
633 
634 	for (i = 0; i < sizeof (boolopts) / sizeof (boolopts[0]); i++) {
635 		vlen = sizeof (val);
636 		if (pr_getsockopt(Pr, fd, boolopts[i].level, boolopts[i].opt,
637 		    &val, &vlen) == 0 && val != 0)
638 			(void) strlcat(buf, boolopts[i].name, sizeof (buf));
639 	}
640 
641 	vlen = sizeof (l);
642 	if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_LINGER, &l, &vlen) == 0 &&
643 	    l.l_onoff != 0) {
644 		(void) snprintf(buf1, sizeof (buf1), "SO_LINGER(%d),",
645 		    l.l_linger);
646 		(void) strlcat(buf, buf1, sizeof (buf));
647 	}
648 
649 	vlen = sizeof (val);
650 	if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_SNDBUF, &val, &vlen) == 0) {
651 		(void) snprintf(buf1, sizeof (buf1), "SO_SNDBUF(%d),", val);
652 		(void) strlcat(buf, buf1, sizeof (buf));
653 	}
654 	vlen = sizeof (val);
655 	if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_RCVBUF, &val, &vlen) == 0) {
656 		(void) snprintf(buf1, sizeof (buf1), "SO_RCVBUF(%d),", val);
657 		(void) strlcat(buf, buf1, sizeof (buf));
658 	}
659 	vlen = sizeof (nexthop_val);
660 	if (pr_getsockopt(Pr, fd, IPPROTO_IP, IP_NEXTHOP, &nexthop_val,
661 	    &vlen) == 0) {
662 		if (vlen > 0) {
663 			(void) inet_ntop(AF_INET, (void *) &nexthop_val,
664 			    ipaddr, sizeof (ipaddr));
665 			(void) snprintf(buf1, sizeof (buf1), "IP_NEXTHOP(%s),",
666 			    ipaddr);
667 			(void) strlcat(buf, buf1, sizeof (buf));
668 		}
669 	}
670 
671 	buf[strlen(buf) - 1] = '\0'; /* overwrites sentinel if no options */
672 	if (buf[1] != '\0')
673 		(void) printf("\t%s\n", buf+1);
674 }
675 
676 #define	MAXNALLOC	32
677 static void
show_sockfilters(struct ps_prochandle * Pr,int fd)678 show_sockfilters(struct ps_prochandle *Pr, int fd)
679 {
680 	struct fil_info *fi;
681 	int i = 0, nalloc = 2, len = nalloc * sizeof (*fi);
682 	boolean_t printhdr = B_TRUE;
683 
684 	fi = calloc(nalloc, sizeof (*fi));
685 	if (fi == NULL) {
686 		perror("calloc");
687 		return;
688 	}
689 	/* CONSTCOND */
690 	while (1) {
691 		if (pr_getsockopt(Pr, fd, SOL_FILTER, FIL_LIST, fi, &len) != 0)
692 			break;
693 		/* No filters */
694 		if (len == 0)
695 			break;
696 		/* Make sure buffer was large enough */
697 		if (fi->fi_pos >= nalloc) {
698 			struct fil_info *new;
699 
700 			nalloc = fi->fi_pos + 1;
701 			if (nalloc > MAXNALLOC)
702 				break;
703 			len = nalloc * sizeof (*fi);
704 			new = realloc(fi, nalloc * sizeof (*fi));
705 			if (new == NULL) {
706 				perror("realloc");
707 				break;
708 			}
709 			fi = new;
710 			continue;
711 		}
712 
713 		for (i = 0; (i + 1) * sizeof (*fi) <= len; i++) {
714 			if (fi[i].fi_flags & FILF_BYPASS)
715 				continue;
716 			if (printhdr) {
717 				(void) printf("\tfilters: ");
718 				printhdr = B_FALSE;
719 			}
720 			(void) printf("%s", fi[i].fi_name);
721 			if (fi[i].fi_flags != 0) {
722 				(void) printf("(");
723 				if (fi[i].fi_flags & FILF_AUTO)
724 					(void) printf("auto,");
725 				if (fi[i].fi_flags & FILF_PROG)
726 					(void) printf("prog,");
727 				(void) printf("\b)");
728 			}
729 			if (fi[i].fi_pos == 0) /* last one */
730 				break;
731 			(void) printf(",");
732 		}
733 		if (!printhdr)
734 			(void) printf("\n");
735 		break;
736 	}
737 	free(fi);
738 }
739 
740 /* print peer credentials for sockets and named pipes */
741 static void
dopeerucred(struct ps_prochandle * Pr,int fd)742 dopeerucred(struct ps_prochandle *Pr, int fd)
743 {
744 	ucred_t *peercred = NULL;	/* allocated by getpeerucred */
745 
746 	if (pr_getpeerucred(Pr, fd, &peercred) == 0) {
747 		show_ucred("peer", peercred);
748 		ucred_free(peercred);
749 	}
750 }
751 
752 /* the file is a socket */
753 static void
dosocket(struct ps_prochandle * Pr,int fd)754 dosocket(struct ps_prochandle *Pr, int fd)
755 {
756 	/* A buffer large enough for PATH_MAX size AF_UNIX address */
757 	long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1)
758 	    / sizeof (long)];
759 	struct sockaddr *sa = (struct sockaddr *)buf;
760 	socklen_t len;
761 	int type, tlen;
762 
763 	tlen = sizeof (type);
764 	if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_TYPE, &type, &tlen) == 0)
765 		show_socktype((uint_t)type);
766 
767 	show_sockopts(Pr, fd);
768 	show_sockfilters(Pr, fd);
769 
770 	len = sizeof (buf);
771 	if (pr_getsockname(Pr, fd, sa, &len) == 0)
772 		show_sockaddr("sockname", sa, len);
773 
774 	len = sizeof (buf);
775 	if (pr_getpeername(Pr, fd, sa, &len) == 0)
776 		show_sockaddr("peername", sa, len);
777 
778 	dopeerucred(Pr, fd);
779 }
780 
781 /* the file is a fifo (aka "named pipe") */
782 static void
dofifo(struct ps_prochandle * Pr,int fd)783 dofifo(struct ps_prochandle *Pr, int fd)
784 {
785 	dopeerucred(Pr, fd);
786 }
787 
788 /* the file is a TLI endpoint */
789 static void
dotli(struct ps_prochandle * Pr,int fd)790 dotli(struct ps_prochandle *Pr, int fd)
791 {
792 	struct strcmd strcmd;
793 
794 	strcmd.sc_len = STRCMDBUFSIZE;
795 	strcmd.sc_timeout = 5;
796 
797 	strcmd.sc_cmd = TI_GETMYNAME;
798 	if (pr_ioctl(Pr, fd, _I_CMD, &strcmd, sizeof (strcmd)) == 0)
799 		show_sockaddr("sockname", (void *)&strcmd.sc_buf, 0);
800 
801 	strcmd.sc_cmd = TI_GETPEERNAME;
802 	if (pr_ioctl(Pr, fd, _I_CMD, &strcmd, sizeof (strcmd)) == 0)
803 		show_sockaddr("peername", (void *)&strcmd.sc_buf, 0);
804 }
805