/*
 * 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.
 */

#ifndef lint
static char copyright[] =
"@(#) Copyright 2002 Purdue Research Foundation.\nAll rights reserved.\n";
#endif

#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
 */

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


/*
 * Main program
 */

int
main(argc, argv)
    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);
}