| /* |
| * 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); |
| } |
