/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2012 DEY Storage Systems, Inc.  All rights reserved.
 */
/*
 * Copyright (c) 2017 Joyent, Inc.  All Rights reserved.
 * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
 * Copyright 2024 Oxide Computer Company
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>
#include <limits.h>
#include <door.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <sys/stropts.h>
#include <sys/timod.h>
#include <sys/un.h>
#include <libproc.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include <ucred.h>
#include <zone.h>

static char *command;
static volatile int interrupt;
static int Fflag;
static boolean_t nflag = B_FALSE;

static  void    intr(int);
static  void    dofcntl(struct ps_prochandle *, const prfdinfo_t *, int, int);
static  void    dosocket(struct ps_prochandle *, const prfdinfo_t *);
static  void    dosocknames(struct ps_prochandle *, const prfdinfo_t *);
static  void    dofifo(struct ps_prochandle *, const prfdinfo_t *);
static  void    show_files(struct ps_prochandle *);
static  void    show_fileflags(int);
static  void    show_door(struct ps_prochandle *, const prfdinfo_t *);

int
main(int argc, char **argv)
{
        int retc = 0;
        int opt;
        int errflg = 0;
        struct ps_prochandle *Pr;

        if ((command = strrchr(argv[0], '/')) != NULL)
                command++;
        else
                command = argv[0];

        /* options */
        while ((opt = getopt(argc, argv, "Fn")) != EOF) {
                switch (opt) {
                case 'F':               /* force grabbing (no O_EXCL) */
                        Fflag = PGRAB_FORCE;
                        break;
                case 'n':
                        nflag = B_TRUE;
                        break;
                default:
                        errflg = 1;
                        break;
                }
        }

        argc -= optind;
        argv += optind;

        if (errflg || argc <= 0) {
                (void) fprintf(stderr, "usage:\t%s [-F] { pid | core } ...\n",
                    command);
                (void) fprintf(stderr,
                    "  (report open files of each process)\n");
                (void) fprintf(stderr,
                    "  -F: force grabbing of the target process\n");
                exit(2);
        }

        /* catch signals from terminal */
        if (sigset(SIGHUP, SIG_IGN) == SIG_DFL)
                (void) sigset(SIGHUP, intr);
        if (sigset(SIGINT, SIG_IGN) == SIG_DFL)
                (void) sigset(SIGINT, intr);
        if (sigset(SIGQUIT, SIG_IGN) == SIG_DFL)
                (void) sigset(SIGQUIT, intr);
        (void) sigset(SIGPIPE, intr);
        (void) sigset(SIGTERM, intr);

        (void) proc_initstdio();


        while (--argc >= 0 && !interrupt) {
                char *arg;
                psinfo_t psinfo;
                pid_t pid;
                int gret;

                (void) proc_flushstdio();

                arg = *argv++;

                /* get the specified pid and the psinfo struct */
                if ((pid = proc_arg_psinfo(arg, PR_ARG_PIDS,
                    &psinfo, &gret)) == -1) {

                        if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_CORES,
                            Fflag, &gret, NULL)) == NULL) {
                                (void) fprintf(stderr,
                                    "%s: cannot examine %s: %s\n",
                                    command, arg, Pgrab_error(gret));
                                retc++;
                                continue;
                        }
                        if (proc_arg_psinfo(arg, PR_ARG_ANY, &psinfo,
                            &gret) < 0) {
                                (void) fprintf(stderr,
                                    "%s: cannot examine %s: %s\n",
                                    command, arg, Pgrab_error(gret));
                                retc++;
                                Prelease(Pr, 0);
                                continue;
                        }
                        (void) printf("core '%s' of %d:\t%.70s\n",
                            arg, (int)psinfo.pr_pid, psinfo.pr_psargs);

                        show_files(Pr);
                        Prelease(Pr, 0);

                } else if ((Pr = Pgrab(pid, Fflag, &gret)) != NULL) {
                        if (Pcreate_agent(Pr) == 0) {
                                proc_unctrl_psinfo(&psinfo);
                                (void) printf("%d:\t%.70s\n",
                                    (int)pid, psinfo.pr_psargs);
                                show_files(Pr);
                                Pdestroy_agent(Pr);
                        } else {
                                (void) fprintf(stderr,
                                    "%s: cannot control process %d\n",
                                    command, (int)pid);
                                retc++;
                        }
                        Prelease(Pr, 0);
                        Pr = NULL;
                } else {
                        switch (gret) {
                        case G_SYS:
                                proc_unctrl_psinfo(&psinfo);
                                (void) printf("%d:\t%.70s\n", (int)pid,
                                    psinfo.pr_psargs);
                                (void) printf("  [system process]\n");
                                break;
                        default:
                                (void) fprintf(stderr, "%s: %s: %d\n",
                                    command, Pgrab_error(gret), (int)pid);
                                retc++;
                                break;
                        }
                }
        }

        (void) proc_finistdio();

        if (interrupt && retc == 0)
                retc++;
        return (retc);
}

/* ARGSUSED */
static void
intr(int sig)
{
        interrupt = 1;
}

/* ------ begin specific code ------ */

static int
show_paths(uint_t type, const void *data, size_t len, void *arg __unused)
{
        if (type == PR_PATHNAME)
                (void) printf("      %.*s\n", len, data);
        return (0);
}

static int
show_file(void *data, const prfdinfo_t *info)
{
        struct ps_prochandle *Pr = data;
        char unknown[12];
        char *s;
        mode_t mode;

        if (interrupt)
                return (1);

        mode = info->pr_mode;

        switch (mode & S_IFMT) {
        case S_IFCHR: s = "S_IFCHR"; break;
        case S_IFBLK: s = "S_IFBLK"; break;
        case S_IFIFO: s = "S_IFIFO"; break;
        case S_IFDIR: s = "S_IFDIR"; break;
        case S_IFREG: s = "S_IFREG"; break;
        case S_IFLNK: s = "S_IFLNK"; break;
        case S_IFSOCK: s = "S_IFSOCK"; break;
        case S_IFDOOR: s = "S_IFDOOR"; break;
        case S_IFPORT: s = "S_IFPORT"; break;
        default:
                s = unknown;
                (void) sprintf(s, "0x%.4x ", (int)mode & S_IFMT);
                break;
        }

        (void) printf("%4d: %s mode:0%.3o", info->pr_fd, s,
            (int)mode & ~S_IFMT);

        (void) printf(" dev:%u,%u",
            (unsigned)info->pr_major, (unsigned)info->pr_minor);

        if ((mode & S_IFMT) == S_IFPORT) {
                (void) printf(" uid:%d gid:%d",
                    (int)info->pr_uid, (int)info->pr_gid);
                (void) printf(" size:%lld\n", (longlong_t)info->pr_size);
                return (0);
        }

        (void) printf(" ino:%llu uid:%d gid:%d",
            (u_longlong_t)info->pr_ino, (int)info->pr_uid, (int)info->pr_gid);

        if ((info->pr_rmajor == (major_t)NODEV) &&
            (info->pr_rminor == (minor_t)NODEV))
                (void) printf(" size:%lld\n", (longlong_t)info->pr_size);
        else
                (void) printf(" rdev:%u,%u\n",
                    (unsigned)info->pr_rmajor, (unsigned)info->pr_rminor);

        if (!nflag) {
                dofcntl(Pr, info,
                    (mode & (S_IFMT|S_ENFMT|S_IXGRP)) == (S_IFREG|S_ENFMT),
                    (mode & S_IFMT) == S_IFDOOR);

                if (Pstate(Pr) != PS_DEAD) {
                        switch (mode & S_IFMT) {
                        case S_IFSOCK:
                                dosocket(Pr, info);
                                break;
                        case S_IFIFO:
                                dofifo(Pr, info);
                                break;
                        case S_IFCHR:
                                /*
                                 * This may be a TLI endpoint. If so, it will
                                 * have socket names in the fdinfo and this
                                 * will print them.
                                 */
                                dosocknames(Pr, info);
                                break;
                        }
                }

                (void) proc_fdinfowalk(info, show_paths, NULL);

                if (info->pr_offset != -1) {
                        (void) printf("      offset:%lld\n",
                            (long long)info->pr_offset);
                }
        }

        return (0);
}

static void
show_files(struct ps_prochandle *Pr)
{
        struct rlimit rlim;

        if (pr_getrlimit(Pr, RLIMIT_NOFILE, &rlim) == 0) {
                ulong_t nfd = rlim.rlim_cur;
                if (nfd == RLIM_INFINITY)
                        (void) printf(
                            "  Current rlimit: unlimited file descriptors\n");
                else
                        (void) printf(
                            "  Current rlimit: %lu file descriptors\n", nfd);
        }

        (void) Pfdinfo_iter(Pr, show_file, Pr);
}

static void
show_fdflags(int fdflags)
{
        if (fdflags <= 0)
                return;

        /*
         * show_fileflags() already has printed content here. We translate these
         * back to the O_ versions for consistency with the flags that were
         * already printed.
         */
        if ((fdflags & FD_CLOEXEC) != 0) {
                (void) printf("|O_CLOEXEC");
        }

        if ((fdflags & FD_CLOFORK) != 0) {
                (void) printf("|O_CLOFORK");
        }
}

/* examine open file with fcntl() */
static void
dofcntl(struct ps_prochandle *Pr, const prfdinfo_t *info, int mandatory,
    int isdoor)
{
        int fileflags;
        int fdflags;

        fileflags = info->pr_fileflags;
        fdflags = info->pr_fdflags;

        if (fileflags != -1 || fdflags != -1) {
                (void) printf("      ");
                if (fileflags != -1)
                        show_fileflags(fileflags);
                if (fdflags != -1)
                        show_fdflags(fdflags);
                if (isdoor && (Pstate(Pr) != PS_DEAD))
                        show_door(Pr, info);
                (void) fputc('\n', stdout);
        } else if (isdoor && (Pstate(Pr) != PS_DEAD)) {
                (void) printf("    ");
                show_door(Pr, info);
                (void) fputc('\n', stdout);
        }

        if (Pstate(Pr) != PS_DEAD) {
                if (info->pr_locktype != F_UNLCK &&
                    (info->pr_locksysid != -1 || info->pr_lockpid != -1)) {
                        unsigned long sysid = info->pr_locksysid;

                        (void) printf("      %s %s lock set",
                            mandatory ? "mandatory" : "advisory",
                            info->pr_locktype == F_RDLCK? "read" : "write");
                        if (sysid)
                                (void) printf(" by system 0x%lX", sysid);
                        if (info->pr_lockpid != -1)
                                (void) printf(" by process %d",
                                    (int)info->pr_lockpid);
                        (void) fputc('\n', stdout);
                }
        }
}

#define ALL_O_FLAGS     O_ACCMODE | O_NDELAY | O_NONBLOCK | O_APPEND | \
                        O_SYNC | O_DSYNC | O_RSYNC | O_XATTR | \
                        O_CREAT | O_TRUNC | O_EXCL | O_NOCTTY | O_LARGEFILE

static void
show_fileflags(int flags)
{
        char buffer[136];
        char *str = buffer;

        switch (flags & O_ACCMODE) {
        case O_RDONLY:
                (void) strcpy(str, "O_RDONLY");
                break;
        case O_WRONLY:
                (void) strcpy(str, "O_WRONLY");
                break;
        case O_RDWR:
                (void) strcpy(str, "O_RDWR");
                break;
        case O_SEARCH:
                (void) strcpy(str, "O_SEARCH");
                break;
        case O_EXEC:
                (void) strcpy(str, "O_EXEC");
                break;
        default:
                (void) sprintf(str, "0x%x", flags & O_ACCMODE);
                break;
        }

        if (flags & O_NDELAY)
                (void) strcat(str, "|O_NDELAY");
        if (flags & O_NONBLOCK)
                (void) strcat(str, "|O_NONBLOCK");
        if (flags & O_APPEND)
                (void) strcat(str, "|O_APPEND");
        if (flags & O_SYNC)
                (void) strcat(str, "|O_SYNC");
        if (flags & O_DSYNC)
                (void) strcat(str, "|O_DSYNC");
        if (flags & O_RSYNC)
                (void) strcat(str, "|O_RSYNC");
        if (flags & O_CREAT)
                (void) strcat(str, "|O_CREAT");
        if (flags & O_TRUNC)
                (void) strcat(str, "|O_TRUNC");
        if (flags & O_EXCL)
                (void) strcat(str, "|O_EXCL");
        if (flags & O_NOCTTY)
                (void) strcat(str, "|O_NOCTTY");
        if (flags & O_LARGEFILE)
                (void) strcat(str, "|O_LARGEFILE");
        if (flags & O_XATTR)
                (void) strcat(str, "|O_XATTR");
        if (flags & ~(ALL_O_FLAGS))
                (void) sprintf(str + strlen(str), "|0x%x",
                    flags & ~(ALL_O_FLAGS));

        (void) printf("%s", str);
}

/* show process on the other end of a door, socket or fifo */
static void
show_peer_process(pid_t ppid)
{
        psinfo_t psinfo;

        if (proc_get_psinfo(ppid, &psinfo) == 0)
                (void) printf(" %s[%d]", psinfo.pr_fname, (int)ppid);
        else
                (void) printf(" pid %d", (int)ppid);
}

/* show door info */
static void
show_door(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        door_info_t door_info;

        if (pr_door_info(Pr, info->pr_fd, &door_info) != 0)
                return;

        (void) printf("  door to");
        show_peer_process(door_info.di_target);
}

/*
 * Print out the socket address pointed to by `sa'.  `len' is only
 * needed for AF_UNIX sockets.
 */
static void
show_sockaddr(const char *str, const struct sockaddr *sa, socklen_t len)
{
        struct sockaddr_in *so_in = (struct sockaddr_in *)(void *)sa;
        struct sockaddr_in6 *so_in6 = (struct sockaddr_in6 *)(void *)sa;
        struct sockaddr_un *so_un = (struct sockaddr_un *)sa;
        char  abuf[INET6_ADDRSTRLEN];
        const char *p;

        if (len == 0)
                return;

        switch (sa->sa_family) {
        default:
                return;
        case AF_INET:
                (void) printf("\t%s: AF_INET %s  port: %u\n", str,
                    inet_ntop(AF_INET, &so_in->sin_addr, abuf, sizeof (abuf)),
                    ntohs(so_in->sin_port));
                return;
        case AF_INET6:
                (void) printf("\t%s: AF_INET6 %s  port: %u\n", str,
                    inet_ntop(AF_INET6, &so_in6->sin6_addr,
                    abuf, sizeof (abuf)),
                    ntohs(so_in->sin_port));
                return;
        case AF_UNIX:
                if (len >= sizeof (so_un->sun_family)) {
                        (void) printf("\t%s: AF_UNIX %.*s\n",
                            str, len - sizeof (so_un->sun_family),
                            so_un->sun_path);
                }
                return;
        case AF_IMPLINK:        p = "AF_IMPLINK";       break;
        case AF_PUP:            p = "AF_PUP";           break;
        case AF_CHAOS:          p = "AF_CHAOS";         break;
        case AF_NS:             p = "AF_NS";            break;
        case AF_NBS:            p = "AF_NBS";           break;
        case AF_ECMA:           p = "AF_ECMA";          break;
        case AF_DATAKIT:        p = "AF_DATAKIT";       break;
        case AF_CCITT:          p = "AF_CCITT";         break;
        case AF_SNA:            p = "AF_SNA";           break;
        case AF_DECnet:         p = "AF_DECnet";        break;
        case AF_DLI:            p = "AF_DLI";           break;
        case AF_LAT:            p = "AF_LAT";           break;
        case AF_HYLINK:         p = "AF_HYLINK";        break;
        case AF_APPLETALK:      p = "AF_APPLETALK";     break;
        case AF_NIT:            p = "AF_NIT";           break;
        case AF_802:            p = "AF_802";           break;
        case AF_OSI:            p = "AF_OSI";           break;
        case AF_X25:            p = "AF_X25";           break;
        case AF_OSINET:         p = "AF_OSINET";        break;
        case AF_GOSIP:          p = "AF_GOSIP";         break;
        case AF_IPX:            p = "AF_IPX";           break;
        case AF_ROUTE:          p = "AF_ROUTE";         break;
        case AF_KEY:            p = "AF_KEY";           break;
        case AF_POLICY:         p = "AF_POLICY";        break;
        case AF_LINK:           p = "AF_LINK";          break;
        }

        (void) printf("\t%s: %s\n", str, p);
}

/*
 * Print out the process information for the other end of local sockets
 * and fifos
 */
static void
show_ucred(const char *str, ucred_t *cred)
{
        pid_t upid = ucred_getpid(cred);
        zoneid_t uzid = ucred_getzoneid(cred);
        char zonename[ZONENAME_MAX];

        if ((upid != -1) || (uzid != -1)) {
                (void) printf("\t%s:", str);
                if (upid != -1) {
                        show_peer_process(upid);
                }
                if (uzid != -1) {
                        if (getzonenamebyid(uzid, zonename, sizeof (zonename))
                            != -1) {
                                (void) printf(" zone: %s[%d]", zonename,
                                    (int)uzid);
                        } else {
                                (void) printf(" zoneid: %d", (int)uzid);
                        }
                }
                (void) printf("\n");
        }
}

static void
show_socktype(uint_t type)
{
        static const char *types[] = {
                NULL, "DGRAM", "STREAM", NULL, "RAW", "RDM", "SEQPACKET"
        };

        if (type < sizeof (types) / sizeof (*types) && types[type] != NULL)
                (void) printf("\tSOCK_%s\n", types[type]);
        else
                (void) printf("\tunknown socket type %u\n", type);
}

#define BUFSIZE 200
static void
show_sockopts(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        const int *val;
        size_t vlen;
        char buf[BUFSIZE];
        char buf1[32];
        char ipaddr[INET_ADDRSTRLEN];
        int i;
        const in_addr_t *nexthop_val;
        const prsockopts_bool_opts_t *opts;
        struct boolopt {
                int             opt;
                const char      *name;
        };
        static struct boolopt boolopts[] = {
            { PR_SO_DEBUG,              "SO_DEBUG,"     },
            { PR_SO_REUSEADDR,          "SO_REUSEADDR," },
            { PR_SO_KEEPALIVE,          "SO_KEEPALIVE," },
            { PR_SO_DONTROUTE,          "SO_DONTROUTE," },
            { PR_SO_BROADCAST,          "SO_BROADCAST," },
            { PR_SO_OOBINLINE,          "SO_OOBINLINE," },
            { PR_SO_DGRAM_ERRIND,       "SO_DGRAM_ERRIND,"},
            { PR_SO_ALLZONES,           "SO_ALLZONES,"  },
            { PR_SO_MAC_EXEMPT,         "SO_MAC_EXEMPT," },
            { PR_SO_MAC_IMPLICIT,       "SO_MAC_IMPLICIT," },
            { PR_SO_EXCLBIND,           "SO_EXCLBIND," },
            { PR_SO_VRRP,               "SO_VRRP," },
            { PR_UDP_NAT_T_ENDPOINT,    "UDP_NAT_T_ENDPOINT," },
        };
        const struct linger *l;

        opts = proc_fdinfo_misc(info, PR_SOCKOPTS_BOOL_OPTS, NULL);

        buf[0] = '!';           /* sentinel value, never printed */
        buf[1] = '\0';

        for (i = 0; i < sizeof (boolopts) / sizeof (boolopts[0]); i++) {
                if (opts != NULL && opts->prsock_bool_opts & boolopts[i].opt)
                        (void) strlcat(buf, boolopts[i].name, sizeof (buf));
        }

        l = proc_fdinfo_misc(info, PR_SOCKOPT_LINGER, NULL);
        if (l != NULL && l->l_onoff != 0) {
                (void) snprintf(buf1, sizeof (buf1), "SO_LINGER(%d),",
                    l->l_linger);
                (void) strlcat(buf, buf1, sizeof (buf));
        }

        val = proc_fdinfo_misc(info, PR_SOCKOPT_SNDBUF, NULL);
        if (val != NULL) {
                (void) snprintf(buf1, sizeof (buf1), "SO_SNDBUF(%d),", *val);
                (void) strlcat(buf, buf1, sizeof (buf));
        }

        val = proc_fdinfo_misc(info, PR_SOCKOPT_RCVBUF, NULL);
        if (val != NULL) {
                (void) snprintf(buf1, sizeof (buf1), "SO_RCVBUF(%d),", *val);
                (void) strlcat(buf, buf1, sizeof (buf));
        }


        nexthop_val = proc_fdinfo_misc(info, PR_SOCKOPT_IP_NEXTHOP, &vlen);
        if (nexthop_val != NULL && vlen > 0) {
                (void) inet_ntop(AF_INET, (void *) nexthop_val,
                    ipaddr, sizeof (ipaddr));
                (void) snprintf(buf1, sizeof (buf1), "IP_NEXTHOP(%s),",
                    ipaddr);
                (void) strlcat(buf, buf1, sizeof (buf));
        }

        buf[strlen(buf) - 1] = '\0'; /* overwrites sentinel if no options */
        if (buf[1] != '\0')
                (void) printf("\t%s\n", buf+1);
}

#define MAXNALLOC       32
static void
show_sockfilters(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        struct fil_info *fi;
        int i = 0, nalloc = 2, len = nalloc * sizeof (*fi);
        boolean_t printhdr = B_TRUE;
        int fd = info->pr_fd;

        fi = calloc(nalloc, sizeof (*fi));
        if (fi == NULL) {
                perror("calloc");
                return;
        }
        /* CONSTCOND */
        while (1) {
                if (pr_getsockopt(Pr, fd, SOL_FILTER, FIL_LIST, fi, &len) != 0)
                        break;
                /* No filters */
                if (len == 0)
                        break;
                /* Make sure buffer was large enough */
                if (fi->fi_pos >= nalloc) {
                        struct fil_info *new;

                        nalloc = fi->fi_pos + 1;
                        if (nalloc > MAXNALLOC)
                                break;
                        len = nalloc * sizeof (*fi);
                        new = realloc(fi, nalloc * sizeof (*fi));
                        if (new == NULL) {
                                perror("realloc");
                                break;
                        }
                        fi = new;
                        continue;
                }

                for (i = 0; (i + 1) * sizeof (*fi) <= len; i++) {
                        if (fi[i].fi_flags & FILF_BYPASS)
                                continue;
                        if (printhdr) {
                                (void) printf("\tfilters: ");
                                printhdr = B_FALSE;
                        }
                        (void) printf("%s", fi[i].fi_name);
                        if (fi[i].fi_flags != 0) {
                                (void) printf("(");
                                if (fi[i].fi_flags & FILF_AUTO)
                                        (void) printf("auto,");
                                if (fi[i].fi_flags & FILF_PROG)
                                        (void) printf("prog,");
                                (void) printf("\b)");
                        }
                        if (fi[i].fi_pos == 0) /* last one */
                                break;
                        (void) printf(",");
                }
                if (!printhdr)
                        (void) printf("\n");
                break;
        }
        free(fi);
}

/* print peer credentials for sockets and named pipes */
static void
dopeerucred(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        ucred_t *peercred = NULL;       /* allocated by getpeerucred */

        if (pr_getpeerucred(Pr, info->pr_fd, &peercred) == 0) {
                show_ucred("peer", peercred);
                ucred_free(peercred);
        }
}

static void
dosocknames(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        const struct sockaddr *sa;
        size_t vlen;

        sa = proc_fdinfo_misc(info, PR_SOCKETNAME, &vlen);
        if (sa != NULL)
                show_sockaddr("sockname", sa, vlen);

        sa = proc_fdinfo_misc(info, PR_PEERSOCKNAME, &vlen);
        if (sa != NULL)
                show_sockaddr("peername", sa, vlen);
}

/* the file is a socket */
static void
dosocket(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        const int *type;

        type = proc_fdinfo_misc(info, PR_SOCKOPT_TYPE, NULL);
        if (type != NULL)
                show_socktype((uint_t)*type);

        show_sockopts(Pr, info);
        show_sockfilters(Pr, info);
        dosocknames(Pr, info);
        dopeerucred(Pr, info);
}

/* the file is a fifo (aka "named pipe") */
static void
dofifo(struct ps_prochandle *Pr, const prfdinfo_t *info)
{
        dopeerucred(Pr, info);
}