githubmirror/lsof

tests/LTunix.c
345 строк10 KB
Chen
Expose functionality as a re-usable library - Part 2 (#284)
12 апр 2023, 09:01
12 апр 2023, 09:016dca348
/*
 * LTunix.c -- Lsof Test UNIX domain socket test
 *
 * V. Abell
 * Purdue University
 */

/*
 * Copyright 2002 Purdue Research Foundation, West Lafayette, Indiana
 * 47907.  All rights reserved.
 *
 * Written by V. Abell.
 *
 * This software is not subject to any license of the American Telephone
 * and Telegraph Company or the Regents of the University of California.
 *
 * Permission is granted to anyone to use this software for any purpose on
 * any computer system, and to alter it and redistribute it freely, subject
 * to the following restrictions:
 *
 * 1. Neither the authors nor Purdue University are responsible for any
 *    consequences of the use of this software.
 *
 * 2. The origin of this software must not be misrepresented, either by
 *    explicit claim or by omission.  Credit to the authors and Purdue
 *    University must appear in documentation and sources.
 *
 * 3. Altered versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 * 4. This notice may not be removed or altered.
 */

#include "LsofTest.h"
#include "lsof_fields.h"

#include <sys/socket.h>
#include <sys/un.h>

/*
 * Local definitions
 */

#if !defined(MAXPATHLEN)
#    define MAXPATHLEN 1024 /* maximum path length */
#endif                      /* !defined(MAXPATHLEN) */

/*
 * Globals
 */

pid_t MyPid = (pid_t)0;  /* PID of this process */
char *Pn = (char *)NULL; /* program name */
int SpFd[2] = {-1, -1};  /* socket pair FDs */
char *Path[2] = {(char *)NULL, (char *)NULL};
/* socket pair paths */

/*
 * Local function prototypes
 */

static void cleanup(void);
static char *FindUsocks(void);

/*
 * Main program
 */

int main(int argc,     /* argument count */
         char *argv[]) /* arguments */
{
    char buf[2048];           /* temporary buffer */
    char cwd[MAXPATHLEN + 1]; /* CWD buffer */
    char *em;                 /* error message pointer */
    int ti, tj;               /* temporary indexes */
    struct sockaddr_un ua;    /* UNIX socket address */
    int xv = 0;               /* exit value */
                              /*
                               * Get program name and PID, issue start message, and build space prefix.
                               */
    if ((Pn = strrchr(argv[0], '/')))
        Pn++;
    else
        Pn = argv[0];
    MyPid = getpid();
    (void)printf("%s ... ", Pn);
    (void)fflush(stdout);
    PrtMsg((char *)NULL, Pn);
    /*
     * Process arguments.
     */
    if (ScanArg(argc, argv, "h", Pn))
        xv = 1;
    if (xv || LTopt_h) {
        (void)PrtMsg("usage: [-h]", Pn);
        PrtMsgX("       -h       print help (this panel)", Pn, cleanup, xv);
    }
    /*
     * See if lsof can be executed and can access kernel memory.
     */
    if ((em = IsLsofExec()))
        (void)PrtMsgX(em, Pn, cleanup, 1);
    if ((em = CanRdKmem()))
        (void)PrtMsgX(em, Pn, cleanup, 1);
        /*
         * Construct the socket paths.
         */

#if defined(USE_GETCWD)
    if (!getcwd(cwd, sizeof(cwd)))
#else  /* ! defined(USE_GETCWD) */
    if (!getwd(cwd))
#endif /* defined(USE_GETCWD) */

    {
        em = "ERROR!!!  can't get CWD";
        goto print_errno;
    }
    cwd[sizeof(cwd) - 1] = '\0';
    if ((strlen(cwd) + strlen("/config.LT#U9223372036854775807") + 1) >
        sizeof(ua.sun_path)) {
        strncpy(cwd, "/tmp", sizeof(cwd) - 1);
    }
    for (ti = 0; ti < 2; ti++) {
        (void)snprintf(buf, sizeof(buf) - 1, "%s/config.LT%dU%ld", cwd, ti,
                       (long)MyPid);
        buf[sizeof(buf) - 1] = '\0';
        Path[ti] = MkStrCpy(buf, &tj);
        (void)unlink(Path[ti]);
    }
    /*
     * Get two UNIX domain socket FDs.
     */
    for (ti = 0; ti < 2; ti++) {
        if ((SpFd[ti] = socket(AF_UNIX, SOCK_STREAM, PF_UNSPEC)) < 0) {
            em = "socket";

        print_errno_by_ti:

            (void)snprintf(buf, sizeof(buf) - 1, "ERROR!!!  %s(%s) failure", em,
                           Path[ti]);
            buf[sizeof(buf) - 1] = '\0';
            em = buf;

        print_errno:

            PrtMsg(em, Pn);
            (void)snprintf(buf, sizeof(buf) - 1, "    Errno %d: %s", errno,
                           strerror(errno));
            buf[sizeof(buf) - 1] = '\0';
            PrtMsgX(buf, Pn, cleanup, 1);
        }
    }
    /*
     * Bind file system names to the sockets.
     */
    for (ti = 0; ti < 2; ti++) {
        (void)memset((void *)&ua, 0, sizeof(ua));
        ua.sun_family = AF_UNIX;
        (void)strncpy(ua.sun_path, Path[ti], sizeof(ua.sun_path));
        ua.sun_path[sizeof(ua.sun_path) - 1] = '\0';
        if (bind(SpFd[ti], (struct sockaddr *)&ua, sizeof(ua)) < 0) {
            em = "bind";
            goto print_errno_by_ti;
        }
    }
    /*
     * Look for the open UNIX domain socket files with lsof.
     */
    if ((em = FindUsocks()))
        (void)PrtMsgX(em, Pn, cleanup, 1);
    /*
     * Exit successfully.
     */
    (void)PrtMsgX("OK", Pn, cleanup, 0);
    return (0);
}

/*
 * cleanup() -- release resources
 */

static void cleanup() {
    int ti;

    for (ti = 0; ti < 2; ti++) {
        if (SpFd[ti] >= 0) {
            (void)close(SpFd[ti]);
            SpFd[ti] = -1;
        }
        if (Path[ti]) {
            (void)unlink(Path[ti]);
            (void)free((void *)Path[ti]);
            Path[ti] = (char *)NULL;
        }
    }
}

/*
 * FindUsocks() -- find UNIX sockets with lsof
 */

static char *FindUsocks() {
    char buf[2048];           /* temporary buffer */
    char *cem;                /* current error message pointer */
    LTfldo_t *cmdp;           /* command pointer */
    int ff[2];                /* file-found flags */
    LTfldo_t *fop;            /* field output pointer */
    int nf;                   /* number of fields */
    int nl;                   /* name length */
    LTfldo_t *nmp;            /* name pointer */
    char *opv[5];             /* option vector for ExecLsof() */
    char *pem = (char *)NULL; /* previous error message pointer */
    pid_t pid;                /* PID */
    int pids = 0;             /* PID found status */
    char *tcp;                /* temporary character pointer */
    int ti, tj;               /* temporary integers */
    LTfldo_t *typ;            /* file type pointer */
                              /*
                               * Build the option vector and start lsof execution.
                               */
    ff[0] = ff[1] = ti = 0;
    opv[ti++] = "-aU";
    opv[ti++] = "-p";
    (void)snprintf(buf, sizeof(buf) - 1, "%ld", (long)MyPid);
    buf[sizeof(buf) - 1] = '\0';
    opv[ti++] = MkStrCpy(buf, &tj);

#if defined(USE_LSOF_C_OPT)
    opv[ti++] = "-C";
#endif /* defined(USE_LSOF_C_OPT) */

    opv[ti] = (char *)NULL;
    if ((cem = ExecLsof(opv)))
        return (cem);
    /*
     * Read lsof output.
     */
    while (((ff[0] + ff[1]) < 2) && (fop = RdFrLsof(&nf, &cem))) {
        if (cem) {
            if (pem)
                (void)PrtMsg(pem, Pn);
            return (cem);
        }
        switch (fop->ft) {
        case LSOF_FID_PID:

            /*
             * This is a process information line.
             */
            pid = (pid_t)atoi(fop->v);
            pids = 1;
            cmdp = (LTfldo_t *)NULL;
            for (fop++, ti = 1; ti < nf; fop++, ti++) {
                switch (fop->ft) {
                case LSOF_FID_CMD:
                    cmdp = fop;
                    break;
                }
            }
            if (!cmdp || (pid != MyPid))
                pids = 0;
            break;
        case LSOF_FID_FD:

            /*
             * This is a file descriptor line.  Make sure its number matches a
             * test file descriptor number.
             */
            if (!pids)
                break;
            for (ti = 0, tcp = fop->v; *tcp; tcp++) {

                /*
                 * Convert file descriptor to a number.
                 */
                if (*tcp == ' ')
                    continue;
                if (((int)*tcp < (int)'0') || ((int)*tcp > (int)'9')) {
                    ti = -1;
                    break;
                }
                ti = (ti * 10) + (int)*tcp - (int)'0';
            }
            for (tj = 0; tj < 2; tj++) {
                if (ff[tj])
                    continue;
                if (SpFd[tj] == ti)
                    break;
            }
            if (tj >= 2)
                break;
            /*
             * Scan for name and type.
             */
            nmp = typ = (LTfldo_t *)NULL;
            for (fop++, ti = 1; ti < nf; fop++, ti++) {
                switch (fop->ft) {
                case LSOF_FID_NAME:
                    nmp = fop;
                    break;
                case LSOF_FID_TYPE:
                    typ = fop;
                    break;
                }
            }
            /*
             * Check the type of the file.
             */
            if (!typ || strcasecmp(typ->v, "unix"))
                break;
            /*
             * Look for the name.
             */
            if (!nmp)
                break;
            nl = strlen(Path[tj]);
            for (tcp = nmp->v; tcp; tcp = strchr(tcp + 1, '/')) {
                if (!strncmp(tcp, Path[tj], nl)) {

                    /*
                     * Mark a file as found.
                     */
                    ff[tj] = 1;
                    break;
                }
            }
        }
    }
    /*
     * Clean up and return.
     */
    (void)StopLsof();
    for (ti = 0; ti < 2; ti++) {
        if (ff[tj])
            continue;
        (void)snprintf(buf, sizeof(buf) - 1, "ERROR!!!  not found: %s",
                       Path[ti]);
        buf[sizeof(buf) - 1] = '\0';
        if (pem)
            (void)PrtMsg(pem, Pn);
        pem = MkStrCpy(buf, &tj);
    }
    return (pem);
}