Adding upstream version 23.7.upstream/23.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2237 insertions, 0 deletions

diff --git a/src/fuser.c b/src/fuser.c
new file mode 100644
index 0000000..0c14128
--- /dev/null
+++ b/src/fuser.c
@@ -0,0 +1,2237 @@
+/*
+ * fuser.c - identify processes using files
+ *
+ * Based on fuser.c Copyright (C) 1993-2005 Werner Almesberger and Craig Small
+ *
+ * Completely re-written
+ * Copyright (C) 2005-2024 Craig Small <csmall@dropbear.xyz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/sysmacros.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <pwd.h>
+#include <netdb.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <mntent.h>
+#include <signal.h>
+#include <getopt.h>
+#include <setjmp.h>
+#include <limits.h>
+/* MAXSYMLINKS is a BSDism.  If it doesn't exist, fall back to SYMLINK_MAX,
+   which is the POSIX name. */
+#ifndef MAXSYMLINKS
+#define MAXSYMLINKS SYMLINK_MAX
+#endif
+
+#ifdef ENABLE_NLS
+#include <locale.h>
+#endif
+
+#include "fuser.h"
+#include "signals.h"
+#include "i18n.h"
+#include "statx.h"
+#include "comm.h"
+
+//#define DEBUG 1
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif /* PATH_MAX */
+
+#define NAME_FIELD 20        /* space reserved for file name */
+/* Function defines */
+static void add_matched_proc(struct names *name_list, const pid_t pid,
+                             const uid_t uid, const char access);
+static void add_special_proc(struct names *name_list, const char ptype,
+                             const uid_t uid, const char *command);
+static void check_dir(const pid_t pid, const char *dirname,
+                      struct device_list *dev_head,
+                      struct inode_list *ino_head, const uid_t uid,
+                      const char access, struct unixsocket_list *sockets,
+                      dev_t netdev);
+static void check_map(const pid_t pid, const char *filename,
+                      struct device_list *dev_head,
+                      struct inode_list *ino_head, const uid_t uid,
+                      const char access);
+static struct stat *get_pidstat(const pid_t pid, const char *filename);
+static uid_t getpiduid(const pid_t pid);
+static int print_matches(struct names *names_head, const opt_type opts,
+                         const int sig_number);
+static int kill_matched_proc(struct procs *pptr, const opt_type opts,
+                             const int sig_number);
+
+/*int parse_mount(struct names *this_name, struct device_list **dev_list);*/
+static void add_device(struct device_list **dev_list,
+                       struct names *this_name, dev_t device);
+void fill_unix_cache(struct unixsocket_list **unixsocket_head);
+void clear_unix_cache(struct unixsocket_list **unixsocket_head);
+static void atexit_clear_unix_cache();
+static dev_t find_net_dev(void);
+static void scan_procs(
+    struct names *names_head, struct inode_list *ino_head,
+    struct device_list *dev_head,
+    struct unixsocket_list *sockets, dev_t netdev);
+static void scan_knfsd(
+    struct names *names_head, struct inode_list *ino_head,
+    struct device_list *dev_head);
+static void scan_mounts(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head);
+static void scan_swaps(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head);
+#ifdef DEBUG
+static void debug_match_lists(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head);
+#endif
+
+static char *expandpath(const char *path);
+static struct unixsocket_list *unixsockets = NULL;
+static struct names *names_head = NULL, *names_tail = NULL;
+static struct ip_connections *tcp_connection_list = NULL;
+static struct ip_connections *udp_connection_list = NULL;
+#ifdef WITH_IPV6
+static struct ip6_connections *tcp6_connection_list = NULL;
+static struct ip6_connections *udp6_connection_list = NULL;
+#endif
+static struct device_list *match_devices = NULL;
+static struct inode_list *match_inodes = NULL;
+
+static void usage(
+    const char *errormsg)
+{
+    if (errormsg != NULL)
+        fprintf(stderr, "%s\n", errormsg);
+
+    fprintf(stderr,
+        _
+        ("Usage: fuser [-fIMuvw] [-a|-s] [-4|-6] [-c|-m|-n SPACE]\n"
+         "             [-k [-i] [-SIGNAL]] NAME...\n"
+         "       fuser -l\n"
+         "       fuser -V\n"
+         "Show which processes use the named files, sockets, or filesystems.\n\n"
+         "  -a,--all              display unused files too\n"
+         "  -i,--interactive      ask before killing (ignored without -k)\n"
+         "  -I,--inode            use always inodes to compare files\n"
+         "  -k,--kill             kill processes accessing the named file\n"
+         "  -l,--list-signals     list available signal names\n"
+         "  -m,--mount            show all processes using the named filesystems or\n"
+         "                        block device\n"
+         "  -M,--ismountpoint     fulfill request only if NAME is a mount point\n"
+         "  -n,--namespace SPACE  search in this name space (file, udp, or tcp)\n"
+         "  -s,--silent           silent operation\n"
+         "  -SIGNAL               send this signal instead of SIGKILL\n"
+         "  -u,--user             display user IDs\n"
+         "  -v,--verbose          verbose output\n"
+         "  -w,--writeonly        kill only processes with write access\n"
+         "  -V,--version          display version information\n"));
+#ifdef WITH_IPV6
+    fprintf(stderr, _("  -4,--ipv4             search IPv4 sockets only\n"
+                      "  -6,--ipv6             search IPv6 sockets only\n"));
+#endif
+    fprintf(stderr, _("  udp/tcp names: [local_port][,[rmt_host][,[rmt_port]]]\n\n"));
+    exit(1);
+}
+
+void print_version()
+{
+    fprintf(stderr, _("fuser (PSmisc) %s\n"), VERSION);
+    fprintf(stderr,
+        _("Copyright (C) 1993-2024 Werner Almesberger and Craig Small\n\n"));
+    fprintf(stderr,
+        _("PSmisc comes with ABSOLUTELY NO WARRANTY.\n"
+          "This is free software, and you are welcome to redistribute it under\n"
+          "the terms of the GNU General Public License.\n"
+          "For more information about these matters, see the files named COPYING.\n"));
+}
+
+static void scan_procs(
+    struct names *names_head, struct inode_list *ino_head,
+    struct device_list *dev_head, struct unixsocket_list *sockets,
+    dev_t netdev)
+{
+    DIR *topproc_dir;
+    struct dirent *topproc_dent;
+    struct inode_list *ino_tmp;
+    struct device_list *dev_tmp;
+    pid_t pid, my_pid;
+    uid_t uid;
+
+    if ( (ino_head == NULL) && (dev_head == NULL) )
+        return;
+
+    if ((topproc_dir = opendir("/proc")) == NULL) {
+        fprintf(stderr, _("Cannot open /proc directory: %s\n"),
+            strerror(errno));
+        exit(1);
+    }
+    my_pid = getpid();
+    while ((topproc_dent = readdir(topproc_dir)) != NULL) {
+        dev_t cwd_dev, exe_dev, root_dev;
+        struct stat *cwd_stat = NULL;
+        struct stat *exe_stat = NULL;
+        struct stat *root_stat = NULL;
+
+        if (topproc_dent->d_name[0] < '0' || topproc_dent->d_name[0] > '9')    /* Not a process */
+            continue;
+        pid = atoi(topproc_dent->d_name);
+        /* Dont print myself */
+        if (pid == my_pid)
+            continue;
+        uid = getpiduid(pid);
+
+        cwd_stat = get_pidstat(pid, "cwd");
+        exe_stat = get_pidstat(pid, "exe");
+        root_stat = get_pidstat(pid, "root");
+        cwd_dev = cwd_stat ? cwd_stat->st_dev : 0;
+        exe_dev = exe_stat ? exe_stat->st_dev : 0;
+        root_dev = root_stat ? root_stat->st_dev : 0;
+
+        /* Scan the devices */
+        for (dev_tmp = dev_head; dev_tmp != NULL;
+             dev_tmp = dev_tmp->next) {
+            if (exe_dev == dev_tmp->device)
+                add_matched_proc(dev_tmp->name, pid, uid,
+                         ACCESS_EXE);
+            if (root_dev == dev_tmp->device)
+                add_matched_proc(dev_tmp->name, pid, uid,
+                         ACCESS_ROOT);
+            if (cwd_dev == dev_tmp->device)
+                add_matched_proc(dev_tmp->name, pid, uid,
+                         ACCESS_CWD);
+        }
+        for (ino_tmp = ino_head; ino_tmp != NULL;
+             ino_tmp = ino_tmp->next) {
+            if (exe_dev == ino_tmp->device) {
+                if (!exe_stat)
+                    exe_stat = get_pidstat(pid, "exe");
+                if (exe_stat
+                    && exe_stat->st_dev == ino_tmp->device
+                    && exe_stat->st_ino == ino_tmp->inode)
+                    add_matched_proc(ino_tmp->name, pid,
+                             uid, ACCESS_EXE);
+            }
+            if (root_dev == ino_tmp->device) {
+                if (!root_stat)
+                    root_stat = get_pidstat(pid, "root");
+                if (root_stat
+                    && root_stat->st_dev == ino_tmp->device
+                    && root_stat->st_ino == ino_tmp->inode)
+                    add_matched_proc(ino_tmp->name, pid,
+                             uid, ACCESS_ROOT);
+            }
+            if (cwd_dev == ino_tmp->device) {
+                if (!cwd_stat)
+                    cwd_stat = get_pidstat(pid, "cwd");
+                if (cwd_stat
+                    && cwd_stat->st_dev == ino_tmp->device
+                    && cwd_stat->st_ino == ino_tmp->inode)
+                    add_matched_proc(ino_tmp->name, pid,
+                             uid, ACCESS_CWD);
+            }
+        }
+        if (root_stat)
+            free(root_stat);
+        if (cwd_stat)
+            free(cwd_stat);
+        if (exe_stat)
+            free(exe_stat);
+#if !defined (__linux__) && !defined (__CYGWIN__)
+        check_dir(pid, "lib", dev_head, ino_head, uid, ACCESS_MMAP,
+              sockets, netdev);
+        check_dir(pid, "mmap", dev_head, ino_head, uid, ACCESS_MMAP,
+              sockets, netdev);
+#endif
+        check_dir(pid, "fd", dev_head, ino_head, uid, ACCESS_FILE,
+              sockets, netdev);
+        check_map(pid, "maps", dev_head, ino_head, uid, ACCESS_MMAP);
+
+    } /* while topproc_dent */
+    closedir(topproc_dir);
+}
+
+static void add_inode(
+    struct inode_list **ino_list,
+    struct names *this_name,
+    dev_t device, ino_t inode)
+{
+    struct inode_list *ino_tmp, *ino_head;
+
+    if ((ino_tmp =
+         (struct inode_list *)malloc(sizeof(struct inode_list))) == NULL)
+        return;
+    ino_head = *ino_list;
+    ino_tmp->name = this_name;
+    ino_tmp->device = device;
+    ino_tmp->inode = inode;
+    ino_tmp->next = ino_head;
+    *ino_list = ino_tmp;
+}
+
+static void add_device(
+    struct device_list **dev_list,
+    struct names *this_name,
+    dev_t device)
+{
+    struct device_list *dev_tmp, *dev_head;
+#ifdef DEBUG
+    fprintf(stderr, "add_device(%s %u\n", this_name->filename,
+            (unsigned int)device);
+#endif /* DEBUG */
+
+    if ((dev_tmp =
+         (struct device_list *)malloc(sizeof(struct device_list))) == NULL)
+        return;
+    dev_head = *dev_list;
+    dev_tmp->name = this_name;
+    dev_tmp->device = device;
+    dev_tmp->next = dev_head;
+    *dev_list = dev_tmp;
+}
+
+static void add_ip_conn(
+    struct ip_connections **ip_list, const char *protocol,
+    struct names *this_name, const int lcl_port, const int rmt_port,
+    unsigned long rmt_address)
+{
+    struct ip_connections *ip_tmp, *ip_head;
+
+    if ((ip_tmp =
+         (struct ip_connections *)malloc(sizeof(struct ip_connections))) ==
+        NULL)
+        return;
+    ip_head = *ip_list;
+    ip_tmp->name = this_name;
+    ip_tmp->lcl_port = lcl_port;
+    ip_tmp->rmt_port = rmt_port;
+    ip_tmp->rmt_address.s_addr = rmt_address;
+    ip_tmp->next = ip_head;
+
+    *ip_list = ip_tmp;
+}
+
+#ifdef WITH_IPV6
+static void add_ip6_conn(
+    struct ip6_connections **ip_list,
+    const char *protocol,
+    struct names *this_name,
+    const int lcl_port,
+    const int rmt_port,
+    struct in6_addr rmt_address)
+{
+    struct ip6_connections *ip_tmp, *ip_head;
+
+    if ((ip_tmp =
+         (struct ip6_connections *)malloc(sizeof(struct ip6_connections)))
+        == NULL)
+        return;
+    ip_head = *ip_list;
+    ip_tmp->name = this_name;
+    ip_tmp->lcl_port = lcl_port;
+    ip_tmp->rmt_port = rmt_port;
+    memcpy(&(ip_tmp->rmt_address), &(rmt_address), sizeof(struct in6_addr));
+    ip_tmp->next = ip_head;
+
+    *ip_list = ip_tmp;
+}
+#endif
+
+/* Adds a normal process only */
+static void add_matched_proc(
+    struct names *name_list,
+    const pid_t pid,
+    const uid_t uid,
+    const char access)
+{
+    struct procs *pptr, *last_proc;
+    char *pathname;
+    char cmdname[101], *cptr;
+    int cmdlen;
+    FILE *fp;
+
+    last_proc = NULL;
+    for (pptr = name_list->matched_procs; pptr != NULL; pptr = pptr->next)
+    {
+        last_proc = pptr;
+        if (pptr->pid == pid)
+        {
+            pptr->access |= access;
+            return;
+        }
+    }
+    /* Not found */
+    if ((pptr = (struct procs *)malloc(sizeof(struct procs))) == NULL)
+    {
+        fprintf(stderr,
+            _("Cannot allocate memory for matched proc: %s\n"),
+            strerror(errno));
+        return;
+    }
+    pptr->pid = pid;
+    pptr->uid = uid;
+    pptr->access = access;
+    pptr->proc_type = PTYPE_NORMAL;
+    pptr->next = NULL;
+    /* set command name */
+    pptr->command = NULL;
+
+    fp = NULL;
+    pathname = NULL;
+    if ((asprintf(&pathname, "/proc/%d/stat", pid) > 0) &&
+        ((fp = fopen(pathname, "r")) != NULL) &&
+        (fscanf(fp, "%*d (%100[^)]", cmdname) == 1))
+        if ((pptr->command = (char *)malloc(COMM_LEN + 1)) != NULL)
+        {
+            cmdlen = 0;
+            for (cptr = cmdname; cmdlen < COMM_LEN && *cptr;
+                 cptr++)
+            {
+                if (isprint(*cptr))
+                    pptr->command[cmdlen++] = *cptr;
+                else if (cmdlen < (COMM_LEN - 4))
+                    cmdlen +=
+                        sprintf(&(pptr->command[cmdlen]),
+                                "\\%03o", *cptr);
+            }
+            pptr->command[cmdlen] = '\0';
+        }
+    if (last_proc == NULL)
+        name_list->matched_procs = pptr;
+    else
+        last_proc->next = pptr;
+    if (pathname)
+        free(pathname);
+    if (fp)
+        fclose(fp);
+}
+
+/* Adds a knfsd etc process */
+static void add_special_proc(
+    struct names *name_list,
+    const char ptype,
+    const uid_t uid,
+    const char *command)
+{
+    struct procs *pptr;
+
+    for (pptr = name_list->matched_procs; pptr != NULL; pptr = pptr->next)
+    {
+        if (pptr->proc_type == ptype)
+            return;
+    }
+    if ((pptr = malloc(sizeof(struct procs))) == NULL)
+    {
+        fprintf(stderr,
+            _("Cannot allocate memory for matched proc: %s\n"),
+            strerror(errno));
+        return;
+    }
+    pptr->pid = 0;
+    pptr->uid = uid;
+    pptr->access = 0;
+    pptr->proc_type = ptype;
+    /* Append the special processes */
+    pptr->next = name_list->matched_procs;
+    name_list->matched_procs = pptr;
+    /* set command name */
+    pptr->command = strdup(command);
+}
+
+int parse_file(
+    struct names *this_name,
+    struct inode_list **ino_list,
+    const opt_type opts)
+{
+    char *new = expandpath(this_name->filename);
+    if (new)
+    {
+        if (this_name->filename)
+            free(this_name->filename);
+        this_name->filename = strdup(new);
+    }
+    if (statn(this_name->filename, STATX_INO|STATX_TYPE, &(this_name->st)) != 0 )
+    {
+        if (errno == ENOENT)
+            fprintf(stderr,
+                _("Specified filename %s does not exist.\n"),
+                this_name->filename);
+        else
+            fprintf(stderr, _("Cannot stat %s: %s\n"),
+                this_name->filename, strerror(errno));
+        return -1;
+    }
+#ifdef DEBUG
+    printf("adding file %s %lX %lX\n", this_name->filename,
+           (unsigned long)this_name->st.st_dev,
+           (unsigned long)this_name->st.st_ino);
+#endif                /* DEBUG */
+    add_inode(ino_list, this_name, this_name->st.st_dev,
+              this_name->st.st_ino);
+    return 0;
+}
+
+int parse_unixsockets(
+    struct names *this_name,
+    struct inode_list **ino_list,
+    struct unixsocket_list *sun_head)
+{
+    struct unixsocket_list *sun_tmp;
+    dev_t net_dev;
+
+    net_dev = find_net_dev();
+
+    for (sun_tmp = sun_head; sun_tmp != NULL; sun_tmp = sun_tmp->next)
+    {
+        if (sun_tmp->dev == this_name->st.st_dev
+            && sun_tmp->inode == this_name->st.st_ino)
+        {
+            add_inode(ino_list, this_name, net_dev,
+                      sun_tmp->net_inode);
+            return 0;
+        }
+    }
+    return 0;
+}
+
+int parse_mounts(
+    struct names *this_name,
+    struct device_list **dev_list,
+    const opt_type opts)
+{
+    dev_t match_device;
+
+    if (S_ISBLK(this_name->st.st_mode))
+        match_device = this_name->st.st_rdev;
+    else
+        match_device = this_name->st.st_dev;
+    add_device(dev_list, this_name, match_device);
+    return 0;
+}
+
+#ifdef WITH_IPV6
+int parse_inet(
+    struct names *this_name,
+    const int ipv4_only,
+    const int ipv6_only,
+    struct ip_connections **ip_list,
+    struct ip6_connections **ip6_list)
+#else
+int parse_inet(
+    struct names *this_name,
+    struct ip_connections **ip_list)
+#endif
+{
+    struct addrinfo *res, *resptr;
+    struct addrinfo hints;
+    int errcode;
+    char *lcl_port_str, *rmt_addr_str, *rmt_port_str, *tmpstr, *tmpstr2;
+    in_port_t lcl_port;
+    struct sockaddr_in *sin;
+#ifdef WITH_IPV6
+    struct sockaddr_in6 *sin6;
+#endif
+    char hostspec[100];
+    char *protocol;
+    int i;
+
+    if ((protocol = strchr(this_name->filename, '/')) == NULL)
+        return -1;
+    protocol++;
+    if (protocol[0] == '\0')
+        return -1;
+    for (i = 0;
+         i < 99 && this_name->filename[i] != '\0'
+         && this_name->filename[i] != '/'; i++)
+        hostspec[i] = this_name->filename[i];
+    hostspec[i] = '\0';
+
+    lcl_port_str = rmt_addr_str = rmt_port_str = NULL;
+    /* Split out the names */
+    if ((tmpstr = strchr(hostspec, ',')) == NULL)
+    {
+        /* Single option */
+        lcl_port_str = strdup(hostspec);
+    } else {
+        if (tmpstr == hostspec)
+            lcl_port_str = NULL;
+        else {
+            *tmpstr = '\0';
+            lcl_port_str = strdup(hostspec);
+        }
+        tmpstr++;
+        if (*tmpstr != '\0') {
+            if ((tmpstr2 = strchr(tmpstr, ',')) == NULL)
+            {
+                /* Only 2 options */
+                rmt_addr_str = tmpstr;
+            } else {
+                if (tmpstr2 == tmpstr)
+                    rmt_addr_str = NULL;
+                else {
+                    rmt_addr_str = tmpstr;
+                    *tmpstr2 = '\0';
+                }
+                tmpstr2++;
+                if (*tmpstr2 != '\0')
+                    rmt_port_str = tmpstr2;
+            }
+        }
+    }
+#ifdef DEBUG
+    printf("parsed to lp %s rh %s rp %s\n", lcl_port_str, rmt_addr_str,
+           rmt_port_str);
+#endif
+
+    memset(&hints, 0, sizeof(hints));
+#ifdef WITH_IPV6
+    if (ipv6_only)
+    {
+        hints.ai_family = PF_INET6;
+    } else if (ipv4_only)
+    {
+        hints.ai_family = PF_INET;
+    } else
+        hints.ai_family = PF_UNSPEC;
+#else
+    hints.ai_family = PF_INET;
+#endif
+    if (strcmp(protocol, "tcp") == 0)
+        hints.ai_socktype = SOCK_STREAM;
+    else
+        hints.ai_socktype = SOCK_DGRAM;
+
+    if (lcl_port_str == NULL)
+    {
+        lcl_port = 0;
+    } else {
+        /* Resolve local port first */
+        if ((errcode =
+             getaddrinfo(NULL, lcl_port_str, &hints, &res)) != 0)
+        {
+            fprintf(stderr, _("Cannot resolve local port %s: %s\n"),
+                    lcl_port_str, gai_strerror(errcode));
+            free(lcl_port_str);
+            return -1;
+        }
+        free(lcl_port_str);
+        if (res == NULL)
+            return -1;
+        switch (res->ai_family)
+        {
+        case AF_INET:
+            lcl_port =
+                ((struct sockaddr_in *)(res->ai_addr))->sin_port;
+            break;
+#ifdef WITH_IPV6
+        case AF_INET6:
+            lcl_port =
+                ((struct sockaddr_in6 *)(res->ai_addr))->sin6_port;
+            break;
+#endif
+        default:
+            fprintf(stderr, _("Unknown local port AF %d\n"),
+                    res->ai_family);
+            freeaddrinfo(res);
+            return -1;
+        }
+        freeaddrinfo(res);
+    }
+    res = NULL;
+    if (rmt_addr_str == NULL && rmt_port_str == NULL)
+    {
+        add_ip_conn(ip_list, protocol, this_name, ntohs(lcl_port), 0,
+                    INADDR_ANY);
+#ifdef WITH_IPV6
+        add_ip6_conn(ip6_list, protocol, this_name, ntohs(lcl_port), 0,
+                     in6addr_any);
+#endif
+        return 0;
+    } else {
+        /* Resolve remote address and port */
+        if (getaddrinfo(rmt_addr_str, rmt_port_str, &hints, &res) == 0)
+        {
+            for (resptr = res; resptr != NULL;
+                 resptr = resptr->ai_next)
+            {
+                switch (resptr->ai_family)
+                {
+                case AF_INET:
+                    sin = (struct sockaddr_in *)
+                        resptr->ai_addr;
+                    if (rmt_addr_str == NULL)
+                    {
+                        add_ip_conn(ip_list, protocol, this_name,
+                                    ntohs(lcl_port), ntohs(sin->sin_port),
+                                    INADDR_ANY);
+                    } else {
+                        add_ip_conn(ip_list, protocol, this_name,
+                                    ntohs(lcl_port), ntohs(sin->sin_port),
+                                    sin->sin_addr.s_addr);
+                    }
+                    break;
+#ifdef WITH_IPV6
+                case AF_INET6:
+                    sin6 = (struct sockaddr_in6 *) resptr->ai_addr;
+                    if (rmt_addr_str == NULL)
+                    {
+                        add_ip6_conn(ip6_list, protocol, this_name,
+                                     ntohs(lcl_port), ntohs(sin6->sin6_port),
+                                     in6addr_any);
+                    } else {
+                        add_ip6_conn(ip6_list, protocol, this_name,
+                                     ntohs(lcl_port), ntohs(sin6->sin6_port),
+                                     sin6->sin6_addr);
+                    }
+                    break;
+#endif
+                }
+            }    /*while */
+            freeaddrinfo(res);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void find_net_sockets(
+    struct inode_list **ino_list,
+    struct ip_connections *conn_list,
+    const char *protocol,
+    dev_t netdev)
+{
+    FILE *fp;
+    char pathname[200], line[BUFSIZ];
+    unsigned long loc_port, rmt_port;
+    unsigned long rmt_addr;
+    unsigned long long scanned_inode;
+    ino_t inode;
+    struct ip_connections *conn_tmp;
+
+    if (snprintf(pathname, 200, "/proc/net/%s", protocol) < 0)
+        return;
+
+    if ((fp = fopen(pathname, "r")) == NULL)
+    {
+        fprintf(stderr, _("Cannot open protocol file \"%s\": %s\n"),
+                pathname, strerror(errno));
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if (sscanf
+            (line,
+             "%*u: %*x:%lx %08lx:%lx %*x %*x:%*x %*x:%*x %*x %*d %*d %llu",
+             &loc_port, &rmt_addr, &rmt_port, &scanned_inode) != 4)
+            continue;
+#ifdef DEBUG
+        printf("Found IPv4 *:%lu with %s:%lu\n", loc_port,
+               inet_ntoa(*((struct in_addr *)&rmt_addr)), rmt_port);
+#endif                /* DEBUG */
+        inode = scanned_inode;
+        for (conn_tmp = conn_list; conn_tmp != NULL;
+             conn_tmp = conn_tmp->next)
+        {
+#ifdef DEBUG
+            printf("  Comparing with *.%lu %s:%lu\n",
+                   conn_tmp->lcl_port,
+                   inet_ntoa(conn_tmp->rmt_address),
+                   conn_tmp->rmt_port);
+#endif
+            if ((conn_tmp->lcl_port == 0
+                 || conn_tmp->lcl_port == loc_port)
+                && (conn_tmp->rmt_port == 0
+                || conn_tmp->rmt_port == rmt_port)
+                && (conn_tmp->rmt_address.s_addr == INADDR_ANY
+                ||
+                (memcmp
+                 (&(conn_tmp->rmt_address), &(rmt_addr),
+                  4) == 0)))
+            {
+                /* add inode to list */
+#ifdef DEBUG
+                printf("Added inode!\n");
+#endif                /* DEBUG */
+                add_inode(ino_list, conn_tmp->name, netdev, inode);
+            }
+        }
+
+    }
+    fclose(fp);
+}
+
+#ifdef WITH_IPV6
+void find_net6_sockets(
+    struct inode_list **ino_list,
+    struct ip6_connections *conn_list,
+    const char *protocol,
+    const dev_t netdev)
+{
+    FILE *fp;
+    char pathname[200], line[BUFSIZ];
+    unsigned long loc_port, rmt_port;
+    struct in6_addr rmt_addr;
+    unsigned int tmp_addr[4];
+    char rmt_addr6str[INET6_ADDRSTRLEN];
+    struct ip6_connections *conn_tmp;
+    unsigned long long scanned_inode;
+    ino_t inode;
+
+    if (snprintf(pathname, 200, "/proc/net/%s6", protocol) < 0)
+        return;
+
+    if ((fp = fopen(pathname, "r")) == NULL)
+    {
+#ifdef DEBUG
+        printf("Cannot open protocol file \"%s\": %s\n", pathname,
+               strerror(errno));
+#endif                /* DEBUG */
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if (sscanf
+            (line,
+             "%*u: %*x:%lx %08x%08x%08x%08x:%lx %*x %*x:%*x %*x:%*x %*x %*d %*d %llu",
+             &loc_port, &(tmp_addr[0]), &(tmp_addr[1]), &(tmp_addr[2]),
+             &(tmp_addr[3]), &rmt_port, &scanned_inode) != 7)
+            continue;
+        inode = scanned_inode;
+        rmt_addr.s6_addr32[0] = tmp_addr[0];
+        rmt_addr.s6_addr32[1] = tmp_addr[1];
+        rmt_addr.s6_addr32[2] = tmp_addr[2];
+        rmt_addr.s6_addr32[3] = tmp_addr[3];
+        inet_ntop(AF_INET6, &rmt_addr, rmt_addr6str, INET6_ADDRSTRLEN);
+#ifdef DEBUG
+        printf("Found IPv6 %ld with %s:%ld\n", loc_port, rmt_addr6str,
+               rmt_port);
+#endif                /* DEBUG */
+        for (conn_tmp = conn_list; conn_tmp != NULL;
+             conn_tmp = conn_tmp->next)
+        {
+            inet_ntop(AF_INET6, &conn_tmp->rmt_address,
+                      rmt_addr6str, INET6_ADDRSTRLEN);
+#ifdef DEBUG
+            printf("  Comparing with *.%lu %s:%lu ...\n",
+                   conn_tmp->lcl_port, rmt_addr6str,
+                   conn_tmp->rmt_port);
+#endif                /* DEBUG */
+            if ((conn_tmp->lcl_port == 0
+                 || conn_tmp->lcl_port == loc_port)
+                && (conn_tmp->rmt_port == 0
+                || conn_tmp->rmt_port == rmt_port)
+                &&
+                (memcmp(&(conn_tmp->rmt_address), &in6addr_any, 16)
+                 == 0
+                 ||
+                 (memcmp(&(conn_tmp->rmt_address), &(rmt_addr), 16)
+                  == 0)))
+            {
+                add_inode(ino_list, conn_tmp->name, netdev, inode);
+            }
+        }
+    }
+    fclose(fp);
+}
+#endif
+
+static void read_proc_mounts(
+    struct mount_list **mnt_list)
+{
+    FILE *fp;
+    char line[BUFSIZ];
+    char *find_mountp;
+    char *find_space;
+    struct mount_list *mnt_tmp;
+
+    if ((fp = fopen(PROC_MOUNTS, "r")) == NULL)
+    {
+        fprintf(stderr, "Cannot open %s\n", PROC_MOUNTS);
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if ((find_mountp = strchr(line, ' ')) == NULL)
+            continue;
+        find_mountp++;
+        if ((find_space = strchr(find_mountp, ' ')) == NULL)
+            continue;
+        *find_space = '\0';
+        if ((mnt_tmp = malloc(sizeof(struct mount_list))) == NULL)
+            continue;
+        if ((mnt_tmp->mountpoint = strdup(find_mountp)) == NULL)
+        {
+            free(mnt_tmp);
+            continue;
+        }
+        mnt_tmp->next = *mnt_list;
+        *mnt_list = mnt_tmp;
+    }
+    fclose(fp);
+}
+
+static void free_proc_mounts(
+    struct mount_list *mnt_list)
+{
+    struct mount_list *mnt_tmp, *mnt_next;
+
+    mnt_tmp = mnt_list;
+    while (mnt_tmp != NULL)
+    {
+        mnt_next = mnt_tmp->next;
+        free(mnt_tmp->mountpoint);
+        free(mnt_tmp);
+        mnt_tmp = mnt_next;
+    }
+}
+
+/*
+ * Free up structures allocated in add_matched_proc and add_special_proc
+ */
+static void free_matched_procs(
+    struct procs *matched_procs)
+{
+    struct procs *procs_tmp, *procs_next;
+
+    procs_tmp = matched_procs;
+    while (procs_tmp != NULL)
+    {
+        procs_next = procs_tmp->next;
+        if (procs_tmp->command)
+            free(procs_tmp->command);
+        free(procs_tmp);
+        procs_tmp = procs_next;
+    }
+}
+
+static void free_names()
+{
+    while(names_head != NULL)
+    {
+        struct names *this_name = names_head;
+        names_head = this_name->next;
+        free_matched_procs(this_name->matched_procs);
+        free(this_name->filename);
+        free(this_name);
+    }
+    names_tail = NULL;
+}
+
+/*
+ * Free up structures allocated in add_ip_conn and add_ip6_conn
+ */
+static void free_connection(
+    struct ip_connections **conn)
+{
+    struct ip_connections *conn_tmp, *conn_next;
+
+    conn_tmp = *conn;
+    while(conn_tmp != NULL)
+    {
+        conn_next = conn_tmp->next;
+        free(conn_tmp);
+        conn_tmp = conn_next;
+    }
+    *conn = NULL;
+}
+
+#ifdef WITH_IPV6
+static void free_connection6(
+    struct ip6_connections **conn)
+{
+    struct ip6_connections *conn_tmp, *conn_next;
+
+    conn_tmp = *conn;
+    while(conn_tmp != NULL)
+    {
+        conn_next = conn_tmp->next;
+        free(conn_tmp);
+        conn_tmp = conn_next;
+    }
+    *conn = NULL;
+}
+#endif
+
+/*
+ * Free up structures allocated in add_inode
+ */
+static void free_inodes(
+    struct inode_list **match_inodes)
+{
+    struct inode_list *inode_tmp, *inode_next;
+
+    inode_tmp = *match_inodes;
+    while(inode_tmp != NULL)
+    {
+        inode_next = inode_tmp->next;
+        free(inode_tmp);
+        inode_tmp = inode_next;
+    }
+    *match_inodes = NULL;
+}
+
+/*
+ * Free up structures allocated in add_device
+ */
+static void free_devices(
+    struct device_list **match_devices)
+{
+    struct device_list *device_tmp, *device_next;
+
+    device_tmp = *match_devices;
+    while(device_tmp != NULL)
+    {
+        device_next = device_tmp->next;
+        free(device_tmp);
+        device_tmp = device_next;
+    }
+    *match_devices = NULL;
+}
+
+static void atexit_free_lists()
+{
+    free_connection(&tcp_connection_list);
+    free_connection(&udp_connection_list);
+#ifdef WITH_IPV6
+    free_connection6(&tcp6_connection_list);
+    free_connection6(&udp6_connection_list);
+#endif
+
+    free_inodes(&match_inodes);
+    free_devices(&match_devices);
+
+    free_names();
+}
+
+
+static int is_mountpoint(
+    struct mount_list **mnt_list,
+    char *arg)
+{
+    char *p;
+    struct mount_list *mnt_tmp;
+
+    if (*arg == '\0')
+        return 0;
+    /* Remove trailing slashes. */
+    for (p = arg; *p != '\0'; p++)
+        /*do nothing*/;
+    while (*(--p) == '/' && p > arg)
+        *p = '\0';
+
+    for (mnt_tmp = *mnt_list; mnt_tmp != NULL; mnt_tmp = mnt_tmp->next)
+        if (!strcmp(mnt_tmp->mountpoint, arg))
+            return 1;
+    return 0;
+}
+
+static void check_mountpoints(
+    struct mount_list **mnt_list,
+    struct names **head,
+    struct names **tail)
+{
+    struct names *this, *last;
+
+    last = NULL;
+    for(this = *head; this != NULL; this = this->next)
+    {
+        if (this->name_space == NAMESPACE_FILE &&
+            !is_mountpoint(mnt_list, this->filename))
+        {
+            fprintf(stderr,
+                    _("Specified filename %s is not a mountpoint.\n"),
+                    this->filename);
+            /* Remove from list */
+            if (last)
+                last->next = this->next;
+            if (*head == this)
+                *head = this->next;
+            if (*tail == this)
+                *tail = last;
+        } else {
+            last = this;
+        }
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    opt_type opts;
+    int sig_number;
+#ifdef WITH_IPV6
+    int ipv4_only, ipv6_only;
+#endif
+    unsigned char default_namespace = NAMESPACE_FILE;
+
+    dev_t netdev;
+    struct names *this_name;
+    int argc_cnt;
+    char *current_argv, *option;
+    char option_buf[3];
+    struct option *optr;
+    char *nsptr;
+    int skip_argv;
+
+    struct option options[] = {
+        {"all", 0, NULL, 'a'},
+        {"kill", 0, NULL, 'k'},
+        {"interactive", 0, NULL, 'i'},
+        {"inode", 0, NULL, 'I'},
+        {"list-signals", 0, NULL, 'l'},
+        {"mount", 0, NULL, 'm'},
+        {"ismountpoint", 0, NULL, 'M'},
+        {"namespace", 1, NULL, 'n'},
+        {"silent", 0, NULL, 's'},
+        {"user", 0, NULL, 'u'},
+        {"verbose", 0, NULL, 'v'},
+        {"writeonly", 0, NULL, 'w'},
+        {"version", 0, NULL, 'V'},
+#ifdef WITH_IPV6
+        {"ipv4", 0, NULL, '4'},
+        {"ipv6", 0, NULL, '6'},
+#endif
+        {0, 0, 0, 0}
+    };
+
+#ifdef WITH_IPV6
+    ipv4_only = ipv6_only = 0;
+#endif
+    this_name = NULL;
+    opts = 0;
+    sig_number = SIGKILL;
+
+#ifdef ENABLE_NLS
+    /* Set up the i18n */
+    setlocale(LC_ALL, "");
+    bindtextdomain(PACKAGE, LOCALEDIR);
+    textdomain(PACKAGE);
+#endif
+
+    netdev = find_net_dev();
+#ifndef __CYGWIN__        /* Cygwin doesn't support /proc/net/unix */
+    fill_unix_cache(&unixsockets);
+    atexit(atexit_clear_unix_cache);
+#endif
+    atexit(atexit_free_lists);
+
+    for (argc_cnt = 1; argc_cnt < argc; argc_cnt++)
+    {
+        current_argv = argv[argc_cnt];
+        if (current_argv[0] == '-') /* its an option */
+        {
+            if (current_argv[1] == '-') /* its a long option */
+            {
+                if (current_argv[2] == '\0')    /* -- */
+                    break;
+                /* Parse the long options */
+                option = option_buf;
+                for (optr = options; optr->name != NULL; optr++)
+                {
+                    if (strcmp(current_argv + 2, optr->name) == 0)
+                    {
+                        sprintf(option_buf, "-%c", (char)optr->val);
+                        break;
+                    }
+                }
+                if (optr->name == NULL)
+                {
+                    fprintf(stderr, _("%s: Invalid option %s\n"),
+                            argv[0], current_argv);
+                    usage(NULL);
+                }
+            } else {
+                option = current_argv;
+            }
+            skip_argv = 0;
+            while (*(++option) != '\0' && !skip_argv)/* skips over the - */
+            {
+                switch (*option)
+                {
+#ifdef WITH_IPV6
+                case '4':
+                    ipv4_only = 1;
+                    break;
+                case '6':
+                    ipv6_only = 1;
+                    break;
+#endif                /* WITH_IPV6 */
+                case 'a':
+                    opts |= OPT_ALLFILES;
+                    break;
+                case 'c':
+                    opts |= OPT_MOUNTS;
+                    break;
+                case 'f':
+                    /* ignored */
+                    break;
+                case 'h':
+                    usage(NULL);
+                    break;
+                case 'i':
+                    opts |= OPT_INTERACTIVE;
+                    break;
+                case 'I':
+                    opts |= OPT_ALWAYSSTAT;
+                    break;
+                case 'k':
+                    opts |= OPT_KILL;
+                    break;
+                case 'l':
+                    list_signals();
+                    return 0;
+                case 'm':
+                    opts |= OPT_MOUNTS;
+                    break;
+                case 'M':
+                    opts |= OPT_ISMOUNTPOINT;
+                    break;
+                case 'n':
+                    argc_cnt++;
+                    if (argc_cnt >= argc)
+                    {
+                        usage(_
+                              ("Namespace option requires an argument."));
+                    }
+                    skip_argv = 1;
+                    //while(option != '\0') option++;
+                    if (strcmp(argv[argc_cnt], "tcp") == 0)
+                        default_namespace = NAMESPACE_TCP;
+                    else if (strcmp(argv[argc_cnt], "udp") == 0)
+                        default_namespace = NAMESPACE_UDP;
+                    else if (strcmp(argv[argc_cnt], "file") == 0)
+                        default_namespace = NAMESPACE_FILE;
+                    else
+                        usage(_
+                              ("Invalid namespace name"));
+                    break;
+                case 's':
+                    opts |= OPT_SILENT;
+                    break;
+                case 'u':
+                    opts |= OPT_USER;
+                    break;
+                case 'v':
+                    opts |= OPT_VERBOSE;
+                    break;
+                case 'w':
+                    opts |= OPT_WRITE;
+                    break;
+                case 'V':
+                    print_version();
+                    return 0;
+                default:
+                    if (isupper(*option) || isdigit(*option))
+                    {
+                        sig_number = get_signal(current_argv + 1, argv[0]);
+                        skip_argv = 1;
+                        break;
+                    }
+                    fprintf(stderr, "%s: Invalid option %c\n",
+                            argv[0], *option);
+                    usage(NULL);
+                    break;
+                }    /* switch */
+            }    /* while option */
+            continue;
+        }
+
+#if defined(HAVE_DECL_SYS_STATX) && HAVE_DECL_SYS_STATX == 1
+		if ((opts & OPT_ALWAYSSTAT))
+			stat_flags = 0;		/* Triggers sync with e.g. remote NFS server even on autofs */
+#endif
+        /* an option */
+        /* Not an option, must be a file specification */
+        if ((this_name = malloc(sizeof(struct names))) == NULL)
+            continue;
+        this_name->next = NULL;
+        /* try to find namespace spec */
+        this_name->name_space = default_namespace;
+        if (((nsptr = strchr(current_argv, '/')) != NULL)
+            && (nsptr != current_argv))
+        {
+            if (strcmp(nsptr + 1, "tcp") == 0)
+            {
+                this_name->name_space = NAMESPACE_TCP;
+                *nsptr = '\0';
+            } else if (strcmp(nsptr + 1, "udp") == 0)
+            {
+                this_name->name_space = NAMESPACE_UDP;
+                *nsptr = '\0';
+            } else if (strcmp(nsptr + 1, "file") == 0)
+            {
+                this_name->name_space = NAMESPACE_FILE;
+                *nsptr = '\0';
+            }
+        }
+        this_name->matched_procs = NULL;
+        if (opts & (OPT_MOUNTS | OPT_ISMOUNTPOINT)
+            && this_name->name_space != NAMESPACE_FILE)
+        {
+            free(this_name);
+            usage(_
+                  ("You can only use files with mountpoint options"));
+        }
+        switch (this_name->name_space)
+        {
+        case NAMESPACE_TCP:
+            if (asprintf
+                (&(this_name->filename), "%s/tcp",
+                 current_argv) > 0)
+            {
+#ifdef WITH_IPV6
+                parse_inet(this_name, ipv4_only, ipv6_only,
+                           &tcp_connection_list, &tcp6_connection_list);
+#else
+                parse_inet(this_name, &tcp_connection_list);
+#endif
+            }
+            break;
+        case NAMESPACE_UDP:
+            if (asprintf (&(this_name->filename), "%s/udp", current_argv) > 0)
+            {
+#ifdef WITH_IPV6
+                parse_inet(this_name, ipv4_only, ipv6_only,
+                       &udp_connection_list, &udp6_connection_list);
+#else
+                parse_inet(this_name, &udp_connection_list);
+#endif
+            }
+            break;
+        default:    /* FILE */
+            this_name->filename = strdup(current_argv);
+            if (parse_file(this_name, &match_inodes, opts) == 0)
+            {
+                if (opts & OPT_MOUNTS)
+                    parse_mounts(this_name, &match_devices, opts);
+                else
+                    parse_unixsockets(this_name, &match_inodes, unixsockets);
+            }
+            break;
+        }
+
+        if (names_head == NULL)
+            names_head = this_name;
+        if (names_tail != NULL)
+            names_tail->next = this_name;
+        names_tail = this_name;
+    }            /* for across the argvs */
+    if (names_head == NULL)
+        usage(_("No process specification given"));
+
+    /* Check if -M flag was used and if so check mounts */
+    if (opts & OPT_ISMOUNTPOINT)
+    {
+        struct mount_list *mounts = NULL;
+        read_proc_mounts(&mounts);
+        check_mountpoints(&mounts, &names_head, &names_tail);
+        free_proc_mounts(mounts);
+    }
+
+    if (opts & OPT_SILENT)
+    {
+        opts &= ~OPT_VERBOSE;
+        opts &= ~OPT_USER;
+        if (opts & OPT_ALLFILES)
+            usage(_
+                  ("all option cannot be used with silent option."));
+    }
+#ifdef WITH_IPV6
+    if (ipv4_only && ipv6_only)
+        usage(_
+              ("You cannot search for only IPv4 and only IPv6 sockets at the same time"));
+    if (!ipv6_only)
+    {
+#endif
+        if (tcp_connection_list != NULL)
+            find_net_sockets(&match_inodes, tcp_connection_list, "tcp", netdev);
+        if (udp_connection_list != NULL)
+            find_net_sockets(&match_inodes, udp_connection_list, "udp", netdev);
+#ifdef WITH_IPV6
+    }
+    if (!ipv4_only)
+    {
+        if (tcp6_connection_list != NULL)
+            find_net6_sockets(&match_inodes, tcp6_connection_list,
+                              "tcp", netdev);
+        if (udp6_connection_list != NULL)
+            find_net6_sockets(&match_inodes, udp6_connection_list,
+                              "udp", netdev);
+    }
+#endif
+    free_connection(&tcp_connection_list);
+    free_connection(&udp_connection_list);
+#ifdef WITH_IPV6
+    free_connection6(&tcp6_connection_list);
+    free_connection6(&udp6_connection_list);
+#endif
+#ifdef DEBUG
+    debug_match_lists(names_head, match_inodes, match_devices);
+#endif
+    scan_procs(names_head, match_inodes, match_devices, unixsockets, netdev);
+#ifndef __CYGWIN__        /* Cygwin doesn't support /proc/net/unix */
+    clear_unix_cache(&unixsockets);
+#endif
+    scan_knfsd(names_head, match_inodes, match_devices);
+    scan_mounts(names_head, match_inodes, match_devices);
+    scan_swaps(names_head, match_inodes, match_devices);
+    free_inodes(&match_inodes);
+    free_devices(&match_devices);
+    return print_matches(names_head, opts, sig_number);
+}
+
+/* 
+ * returns 0 if match, 1 if no match
+ */
+static int print_matches(
+    struct names *names_head,
+    const opt_type opts,
+    const int sig_number)
+{
+    struct names *nptr;
+    struct procs *pptr;
+    char head = 0;
+    char first = 1;
+    int len = 0;
+    struct passwd *pwent = NULL;
+    int have_match = 0;
+    int have_kill = 0;
+    int name_has_procs = 0;
+
+    for (nptr = names_head; nptr != NULL; nptr = nptr->next)
+    {
+        if (opts & OPT_SILENT)
+        {
+            for (pptr = nptr->matched_procs; pptr != NULL;
+                 pptr = pptr->next)
+            {
+                if (pptr->proc_type != PTYPE_NORMAL)
+                    continue;
+
+                have_match = 1;
+            }
+        } else {    /* We're not silent */
+            if ((opts & OPT_ALLFILES) == 0)
+            {
+                name_has_procs = 0;
+                if (opts & OPT_VERBOSE)
+                {
+                    if (nptr->matched_procs)
+                        name_has_procs = 1;
+                } else {
+                    for (pptr = nptr->matched_procs;
+                         pptr != NULL; pptr = pptr->next)
+                    {
+                        if (pptr->proc_type == PTYPE_NORMAL)
+                        {
+                            name_has_procs = 1;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (name_has_procs == 1 || opts & OPT_ALLFILES)
+            {
+                if (head == 0 && opts & OPT_VERBOSE)
+                {
+                    fprintf(stderr,
+                        _("%*s USER        PID ACCESS COMMAND\n"), NAME_FIELD, "");
+                    head = 1;
+                }
+
+                fprintf(stderr, "%s:", nptr->filename);
+                len = strlen(nptr->filename) + 1;
+            }
+
+            first = 1;
+            for (pptr = nptr->matched_procs; pptr != NULL; pptr = pptr->next)
+            {
+                /* Suppress any special "processes" */
+                if (!(opts & OPT_VERBOSE)
+                    && (pptr->proc_type != PTYPE_NORMAL))
+                    continue;
+
+                have_match = 1;
+                if (opts & (OPT_VERBOSE | OPT_USER))
+                {
+                    if (pwent == NULL || pwent->pw_uid != pptr->uid)
+                        pwent = getpwuid(pptr->uid);
+                }
+                if (len > NAME_FIELD && (opts & OPT_VERBOSE))
+                {
+                    putc('\n', stderr);
+                    len = 0;
+                }
+                if ((opts & OPT_VERBOSE) || first)
+                    while (len++ < NAME_FIELD)
+                        putc(' ', stderr);
+                if (opts & OPT_VERBOSE)
+                {
+                    if (pwent == NULL)
+                        fprintf(stderr, " %-8s ",
+                            _("(unknown)"));
+                    else
+                        fprintf(stderr, " %-8s ",
+                            pwent->pw_name);
+                }
+                if (pptr->proc_type == PTYPE_NORMAL)
+                    printf(" %5d", pptr->pid);
+                else
+                    printf("kernel");
+                fflush(stdout);
+                if (opts & OPT_VERBOSE)
+                {
+                    switch (pptr->proc_type)
+                    {
+                    case PTYPE_KNFSD:
+                        fprintf(stderr, " knfsd ");
+                        break;
+                    case PTYPE_MOUNT:
+                        fprintf(stderr, " mount ");
+                        break;
+                    case PTYPE_SWAP:
+                        fprintf(stderr, " swap  ");
+                        break;
+                    default:
+                        fprintf(stderr, " %c%c%c%c%c ",
+                            pptr->access & ACCESS_FILE ?
+                            (pptr->access & ACCESS_FILEWR ? 'F' : 'f') : '.',
+                            pptr->access & ACCESS_ROOT ?  'r' : '.',
+                            pptr->access & ACCESS_CWD ?  'c' : '.',
+                            pptr->access & ACCESS_EXE ?  'e' : '.',
+                            (pptr->access & ACCESS_MMAP)
+                            && !(pptr-> access & ACCESS_EXE) ? 'm' : '.');
+                    }    /* switch */
+                } else {
+                    if (pptr->access & ACCESS_ROOT)
+                        putc('r', stderr);
+                    if (pptr->access & ACCESS_CWD)
+                        putc('c', stderr);
+                    if (pptr->access & ACCESS_EXE)
+                        putc('e', stderr);
+                    else if (pptr->access & ACCESS_MMAP)
+                        putc('m', stderr);
+                }
+                if (opts & OPT_USER)
+                {
+                    if (pwent == NULL)
+                        fprintf(stderr, " %-8s ", _("(unknown)"));
+                    else
+                        fprintf(stderr, "(%s)", pwent->pw_name);
+                }
+                if (opts & OPT_VERBOSE)
+                {
+                    if (pptr->command == NULL)
+                        fprintf(stderr, "???\n");
+                    else
+                        fprintf(stderr, "%s\n", pptr->command);
+                }
+                len = 0;
+                first = 0;
+            }
+            if (opts & OPT_VERBOSE)
+            {
+                /* put a newline if showing all files and no procs */
+                if (nptr->matched_procs == NULL && (opts & OPT_ALLFILES))
+                    putc('\n', stderr);
+            } else {
+                if (name_has_procs || (opts & OPT_ALLFILES))
+                    putc('\n', stderr);
+            }
+        }        /* be silent */
+        if (opts & OPT_KILL)
+            have_kill |= kill_matched_proc(nptr->matched_procs,
+                                           opts, sig_number);
+
+    }            /* next name */
+    if (opts & OPT_KILL)
+        return (have_kill == 1 ? 0 : 1);
+    else
+        return (have_match == 1 ? 0 : 1);
+
+}
+
+static struct stat *get_pidstat(
+    const pid_t pid,
+    const char *filename)
+{
+    char pathname[PATH_MAX];
+    struct stat *st;
+
+    if ((st = (struct stat *)malloc(sizeof(struct stat))) == NULL)
+        return NULL;
+    snprintf(pathname, PATH_MAX-1, "/proc/%d/%s", pid, filename);
+    if (statn(pathname, STATX_UID|STATX_INO|STATX_TYPE, st) != 0)
+    {
+        free(st);
+        return NULL;
+    }
+    return st;
+}
+
+static void check_dir(
+    const pid_t pid,
+    const char *dirname,
+    struct device_list *dev_head,
+    struct inode_list *ino_head,
+    const uid_t uid,
+    const char access,
+    struct unixsocket_list *sockets,
+    dev_t netdev)
+{
+    DIR *dirp;
+    dev_t thedev;
+    struct dirent *direntry;
+    struct inode_list *ino_tmp;
+    struct device_list *dev_tmp;
+    struct unixsocket_list *sock_tmp;
+    struct stat st, lst;
+    char *dirpath;
+    char filepath[PATH_MAX];
+    char real_filepath[PATH_MAX];
+
+    if (asprintf(&dirpath, "/proc/%d/%s", pid, dirname) < 0)
+        return;
+    if ((dirp = opendir(dirpath)) == NULL)
+    {
+        free(dirpath);
+        return;
+    }
+    free(dirpath);
+
+    while ((direntry = readdir(dirp)) != NULL)
+    {
+        if (direntry->d_name[0] < '0' || direntry->d_name[0] > '9')
+            continue;
+
+        snprintf(filepath, sizeof filepath - 1, "/proc/%d/%s/%s",
+             pid, dirname, direntry->d_name);
+
+	if (statn(filepath, STATX_INO, &st) != 0)
+        {
+            if (errno != ENOENT && errno != ENOTDIR && errno != EACCES)
+            {
+                fprintf(stderr, _("Cannot stat file %s: %s\n"),
+                        filepath, strerror(errno));
+            }
+        } else {
+            thedev = st.st_dev;
+            if (thedev == netdev)
+            {
+                for (sock_tmp = sockets; sock_tmp != NULL;
+                     sock_tmp = sock_tmp->next)
+                {
+                    if (sock_tmp->net_inode == st.st_ino)
+                    {
+                        st.st_ino = sock_tmp->inode;
+                        st.st_dev = sock_tmp->dev;
+                        thedev = sock_tmp->dev;
+                        break;
+                    }
+                }
+            }
+            for (dev_tmp = dev_head; dev_tmp != NULL;
+                 dev_tmp = dev_tmp->next)
+            {
+                if (thedev != dev_tmp->device)
+                    continue;
+
+                /* check the paths match if it is not a block device or socket */
+                if (! S_ISBLK(dev_tmp->name->st.st_mode)
+                    && !S_ISSOCK(st.st_mode))
+                {
+                    if (readlink(filepath, real_filepath, PATH_MAX-1) < 0)
+                    {
+                        if (strncmp(dev_tmp->name->filename, filepath,
+                                    strlen(dev_tmp->name->filename)) != 0)
+                            continue;
+                    } else {
+                        if (strncmp(dev_tmp->name->filename, real_filepath,
+                                    strlen(dev_tmp->name->filename)) != 0)
+                            continue;
+                    }
+                }
+                if (access == ACCESS_FILE
+                    && (lstat(filepath, &lst) == 0)
+                    && (lst.st_mode & S_IWUSR))
+                {
+                    add_matched_proc(dev_tmp->name, pid, uid,
+                                     ACCESS_FILEWR | access);
+                } else {
+                    add_matched_proc(dev_tmp->name, pid, uid, access);
+                }
+            }
+            for (ino_tmp = ino_head; ino_tmp != NULL; ino_tmp = ino_tmp->next)
+            {
+                if (thedev != ino_tmp->device)
+                    continue;
+                if (!st.st_ino && statn(filepath, STATX_INO, &st) != 0)
+                {
+                    fprintf(stderr, _("Cannot stat file %s: %s\n"),
+                            filepath, strerror(errno));
+                    continue;
+                }
+                if (st.st_ino == ino_tmp->inode)
+                {
+                    if (access == ACCESS_FILE
+                        && (lstat(filepath, &lst) == 0)
+                        && (lst.st_mode & S_IWUSR))
+                    {
+                        add_matched_proc(ino_tmp->name, pid, uid,
+                                         ACCESS_FILEWR | access);
+                    } else {
+                        add_matched_proc(ino_tmp->name, pid, uid, access);
+                    }
+                }
+            }
+        }
+    }            /* while fd_dent */
+    closedir(dirp);
+}
+
+static void check_map(
+    const pid_t pid,
+    const char *filename,
+   struct device_list *dev_head,
+   struct inode_list *ino_head,
+   const uid_t uid,
+   const char access)
+{
+    char *pathname;
+    char line[BUFSIZ];
+    struct inode_list *ino_tmp;
+    struct device_list *dev_tmp;
+    FILE *fp;
+    unsigned long long tmp_inode;
+    unsigned int tmp_maj, tmp_min;
+    dev_t tmp_device;
+
+    if (asprintf(&pathname, "/proc/%d/%s", pid, filename) < 0)
+        return;
+    if ((fp = fopen(pathname, "r")) == NULL)
+    {
+        free(pathname);
+        return;
+    }
+    free(pathname);
+    while (fgets(line, BUFSIZ, fp))
+    {
+        if (sscanf(line, "%*s %*s %*s %x:%x %lld",
+                   &tmp_maj, &tmp_min, &tmp_inode) == 3)
+        {
+            tmp_device = tmp_maj * 256 + tmp_min;
+            for (dev_tmp = dev_head; dev_tmp != NULL; dev_tmp = dev_tmp->next)
+                if (dev_tmp->device == tmp_device)
+                    add_matched_proc(dev_tmp->name, pid, uid, access);
+            for (ino_tmp = ino_head; ino_tmp != NULL; ino_tmp = ino_tmp->next)
+                if (ino_tmp->device == tmp_device
+                    && ino_tmp->inode == tmp_inode)
+                    add_matched_proc(ino_tmp->name, pid, uid, access);
+        }
+    }
+    fclose(fp);
+}
+
+static uid_t getpiduid(
+    const pid_t pid)
+{
+    char *pathname;
+    struct stat st;
+
+    if (asprintf(&pathname, "/proc/%d", pid) < 0)
+        return 0;
+    if (statn(pathname, STATX_UID, &st) != 0)
+    {
+        free(pathname);
+        return 0;
+    }
+    free(pathname);
+    return st.st_uid;
+}
+
+/*
+ * fill_unix_cache : Create a list of Unix sockets
+ *   This list is used later for matching purposes
+ */
+void fill_unix_cache(
+    struct unixsocket_list **unixsocket_head)
+{
+    FILE *fp;
+    char line[BUFSIZ];
+    unsigned long long scanned_inode;
+    struct stat st;
+    struct unixsocket_list *newsocket;
+
+    if ((fp = fopen("/proc/net/unix", "r")) == NULL)
+    {
+        fprintf(stderr, _("Cannot open /proc/net/unix: %s\n"),
+                strerror(errno));
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        char *path;
+        char *scanned_path = NULL;
+        if (sscanf(line, "%*x: %*x %*x %*x %*x %*d %llu %ms",
+               &scanned_inode, &scanned_path) != 2)
+        {
+            if (scanned_path)
+                free(scanned_path);
+            continue;
+        }
+        if (scanned_path == NULL)
+            continue;
+        path = scanned_path;
+        if (*scanned_path == '@')
+            scanned_path++;
+	if (statn(scanned_path, STATX_INO, &st) < 0)
+        {
+            free(path);
+            continue;
+        }
+        if ((newsocket = (struct unixsocket_list *)
+             malloc(sizeof(struct unixsocket_list))) == NULL)
+        {
+            free(path);
+            continue;
+        }
+        newsocket->sun_name = strdup(scanned_path);
+        newsocket->inode = st.st_ino;
+        newsocket->dev = st.st_dev;
+        newsocket->net_inode = scanned_inode;
+        newsocket->next = *unixsocket_head;
+        *unixsocket_head = newsocket;
+        free(path);
+    } /* while */
+
+    fclose(fp);
+}
+
+/*
+ * Free up the list of Unix sockets
+ */
+void clear_unix_cache(
+    struct unixsocket_list **unixsocket_head)
+{
+    while(*unixsocket_head != NULL)
+    {
+        struct unixsocket_list *oldsocket = *unixsocket_head;
+        *unixsocket_head = oldsocket->next;
+        free(oldsocket->sun_name);
+        free(oldsocket);
+    }
+}
+
+static void atexit_clear_unix_cache()
+{
+    clear_unix_cache(&unixsockets);
+}
+
+#ifdef DEBUG
+/* often not used, doesn't need translation */
+static void debug_match_lists(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head)
+{
+    struct names *nptr;
+    struct inode_list *iptr;
+    struct device_list *dptr;
+
+    fprintf(stderr, "Specified Names:\n");
+    for (nptr = names_head; nptr != NULL; nptr = nptr->next)
+    {
+        fprintf(stderr, "\t%s %c\n", nptr->filename, nptr->name_space);
+    }
+    fprintf(stderr, "\nInodes:\n");
+    for (iptr = ino_head; iptr != NULL; iptr = iptr->next)
+    {
+        fprintf(stderr, "  Dev:%0lx Inode:(%0ld) 0x%0lx => %s\n",
+                (unsigned long)iptr->device, (unsigned long)iptr->inode,
+                (unsigned long)iptr->inode, iptr->name->filename);
+    }
+    fprintf(stderr, "\nDevices:\n");
+    for (dptr = dev_head; dptr != NULL; dptr = dptr->next)
+    {
+        fprintf(stderr, "\tDev:%0lx\n", (unsigned long)dptr->device);
+    }
+}
+
+#endif
+
+/* 0 = no, 1=yes */
+static int ask(
+    const pid_t pid)
+{
+    int res;
+    size_t len = 0;
+    char *line = NULL;
+
+    fflush(stdout);
+    while (1)
+    {
+        fprintf(stderr, _("Kill process %d ? (y/N) "), pid);
+        fflush(stderr);
+        if (getline(&line, &len, stdin) < 0)
+            return 0;
+        if (line[0] == '\n')
+        {
+            free(line);
+            return 0;
+        }
+        res = rpmatch(line);
+        if (res >= 0)
+        {
+            free(line);
+            return res;
+        }
+    }            /* while */
+}
+
+static int kill_matched_proc(
+    struct procs *proc_head,
+    const opt_type opts,
+    const int sig_number)
+{
+    struct procs *pptr;
+    pid_t mypid;
+    int ret = 0;
+
+    mypid = getpid();
+
+    for (pptr = proc_head; pptr != NULL; pptr = pptr->next)
+    {
+        if (pptr->pid == mypid)
+            continue;    /* dont kill myself */
+        if (pptr->proc_type != PTYPE_NORMAL)
+            continue;
+        if ((opts & OPT_WRITE) && ((pptr->access & ACCESS_FILEWR) == 0))
+            continue;
+        if ((opts & OPT_INTERACTIVE) && (ask(pptr->pid) == 0))
+            continue;
+        if (kill(pptr->pid, sig_number) < 0)
+        {
+            fprintf(stderr, _("Could not kill process %d: %s\n"),
+                    pptr->pid, strerror(errno));
+            continue;
+        }
+        ret = 1;
+    }
+    return ret;
+}
+
+static dev_t find_net_dev(void)
+{
+    int skt;
+    struct stat st;
+
+    if ((skt = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
+    {
+        fprintf(stderr, _("Cannot open a network socket.\n"));
+        return -1;
+    }
+    if (fstatn(skt, STATX_INO, &st) != 0)
+    {
+        fprintf(stderr, _("Cannot find socket's device number.\n"));
+        close(skt);
+        return -1;
+    }
+    close(skt);
+    return st.st_dev;
+}
+
+static void scan_knfsd(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head)
+{
+    struct device_list *dev_tmp;
+    struct inode_list *ino_tmp;
+    FILE *fp;
+    char line[BUFSIZ];
+    char *find_space;
+    struct stat st;
+
+    if ( (ino_head == NULL) && (dev_head == NULL) )
+        return;
+
+
+    if ((fp = fopen(KNFSD_EXPORTS, "r")) == NULL)
+    {
+#ifdef DEBUG
+        printf("Cannot open %s\n", KNFSD_EXPORTS);
+#endif
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if (line[0] == '#')
+            continue;
+        
+        if ((find_space = strpbrk(line, " \t")) == NULL)
+            continue;
+
+        *find_space = '\0';
+	if (statn(line, STATX_INO, &st) != 0)
+            continue;
+
+        /* Scan the devices */
+        for (dev_tmp = dev_head; dev_tmp != NULL;
+             dev_tmp = dev_tmp->next)
+        {
+            if (st.st_dev == dev_tmp->device)
+                add_special_proc(dev_tmp->name, PTYPE_KNFSD, 0, line);
+        }
+
+        for (ino_tmp = ino_head; ino_tmp != NULL;
+             ino_tmp = ino_tmp->next)
+        {
+            if (st.st_dev == ino_tmp->device
+                && st.st_ino == ino_tmp->inode)
+                add_special_proc(ino_tmp->name, PTYPE_KNFSD, 0, line);
+        }
+    }
+    fclose(fp);
+}
+
+static void scan_mounts(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head)
+{
+    struct device_list *dev_tmp;
+    struct inode_list *ino_tmp;
+    FILE *fp;
+    char line[BUFSIZ];
+    char *find_mountp;
+    char *find_space;
+    struct stat st;
+
+    if ( (ino_head == NULL) && (dev_head == NULL) )
+        return;
+
+
+    if ((fp = fopen(PROC_MOUNTS, "r")) == NULL)
+    {
+        fprintf(stderr, "Cannot open %s\n", PROC_MOUNTS);
+        return;
+    }
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if ((find_mountp = strchr(line, ' ')) == NULL)
+            continue;
+        find_mountp++;
+        if ((find_space = strchr(find_mountp, ' ')) == NULL)
+            continue;
+        *find_space = '\0';
+	if (statn(find_mountp, STATX_INO, &st) != 0)
+            continue;
+        /* Scan the devices */
+        for (dev_tmp = dev_head; dev_tmp != NULL;
+             dev_tmp = dev_tmp->next)
+        {
+            if (st.st_dev == dev_tmp->device)
+                add_special_proc(dev_tmp->name, PTYPE_MOUNT, 0, find_mountp);
+        }
+        for (ino_tmp = ino_head; ino_tmp != NULL;
+             ino_tmp = ino_tmp->next)
+        {
+            if (st.st_dev == ino_tmp->device
+                && st.st_ino == ino_tmp->inode)
+                add_special_proc(ino_tmp->name, PTYPE_MOUNT, 0, find_mountp);
+        }
+    }
+    fclose(fp);
+}
+
+static void scan_swaps(
+    struct names *names_head,
+    struct inode_list *ino_head,
+    struct device_list *dev_head)
+{
+    struct device_list *dev_tmp;
+    struct inode_list *ino_tmp;
+    FILE *fp;
+    char line[BUFSIZ];
+    char *find_space;
+    struct stat st;
+
+    if ( (ino_head == NULL) && (dev_head == NULL) )
+        return;
+
+    if ((fp = fopen(PROC_SWAPS, "r")) == NULL)
+    {
+        /*fprintf(stderr, "Cannot open %s\n", PROC_SWAPS); */
+        return;
+    }
+    /* lines are filename   type */
+    while (fgets(line, BUFSIZ, fp) != NULL)
+    {
+        if ((find_space = strchr(line, ' ')) == NULL)
+            continue;
+        *find_space = '\0';
+        find_space++;
+        while (*find_space == ' ')
+        {
+            find_space++;
+            if (*find_space == '\0')
+                continue;
+        }
+	if (statn(line, STATX_INO, &st) != 0)
+            continue;
+
+        /* Scan the devices */
+        for (dev_tmp = dev_head; dev_tmp != NULL;
+             dev_tmp = dev_tmp->next)
+        {
+            if (st.st_dev == dev_tmp->device)
+                add_special_proc(dev_tmp->name, PTYPE_SWAP, 0, line);
+        }
+        for (ino_tmp = ino_head; ino_tmp != NULL;
+             ino_tmp = ino_tmp->next)
+        {
+            if (st.st_dev == ino_tmp->device
+                && st.st_ino == ino_tmp->inode)
+                add_special_proc(ino_tmp->name, PTYPE_SWAP, 0, line);
+        }
+    }
+    fclose(fp);
+}
+
+/*
+ * Somehow the realpath(3) glibc function call, nevertheless
+ * it avoids lstat(2) system calls.
+ */
+static char real[PATH_MAX + 1];
+char *expandpath(
+    const char *path)
+{
+    char tmpbuf[PATH_MAX + 1];
+    const char *start, *end;
+    char *curr, *dest;
+    int deep = MAXSYMLINKS;
+
+    if (!path || *path == '\0')
+        return (char *)0;
+
+    curr = &real[0];
+
+    if (*path != '/')
+    {
+        if (!getcwd(curr, PATH_MAX))
+            return (char *)0;
+        dest = strchr(curr, '\0');
+    } else {
+        *curr = '/';
+        dest = curr + 1;
+    }
+
+    for (start = end = path; *start; start = end)
+    {
+        while (*start == '/')
+            ++start;
+
+        for (end = start; *end && *end != '/'; ++end) ;
+
+        if (end - start == 0)
+            break;
+        else if (end - start == 1 && start[0] == '.')
+        {
+            ;
+        } else if (end - start == 2 && start[0] == '.' && start[1] == '.')
+        {
+            if (dest > curr + 1)
+                while ((--dest)[-1] != '/') ;
+        } else {
+            char lnkbuf[PATH_MAX + 1];
+            size_t len;
+            ssize_t n;
+
+            if (dest[-1] != '/')
+                *dest++ = '/';
+
+            if (dest + (end - start) > curr + PATH_MAX)
+            {
+                errno = ENAMETOOLONG;
+                return (char *)0;
+            }
+
+            dest = mempcpy(dest, start, end - start);
+            *dest = '\0';
+
+            if (deep-- < 0)
+            {
+                errno = ELOOP;
+                return (char *)0;
+            }
+
+            errno = 0;
+            if ((n = readlink(curr, lnkbuf, PATH_MAX)) < 0)
+            {
+                deep = MAXSYMLINKS;
+                if (errno == EINVAL)
+                    continue;    /* Not a symlink */
+                return (char *)0;
+            }
+            lnkbuf[n] = '\0';    /* Don't be fooled by readlink(2) */
+
+            len = strlen(end);
+            if ((n + len) > PATH_MAX)
+            {
+                errno = ENAMETOOLONG;
+                return (char *)0;
+            }
+
+            memmove(&tmpbuf[n], end, len + 1);
+            path = end = memcpy(tmpbuf, lnkbuf, n);
+
+            if (lnkbuf[0] == '/')
+                dest = curr + 1;
+            else if (dest > curr + 1)
+                while ((--dest)[-1] != '/') ;
+
+        }
+    }
+
+    if (dest > curr + 1 && dest[-1] == '/')
+        --dest;
+    *dest = '\0';
+
+    return curr;
+}