/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2017 Gary Mills * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include #include "uucp.h" #ifdef V7 #define O_RDONLY 0 #endif #define KILLMSG "the system administrator has killed job" #define USAGE1 "[-q] | [-m] | [-k JOB [-n]] | [-r JOB [-n]] | [-p]" #define USAGE2 "[-a] [-s SYSTEM [-j]] [-u USER] [-S STATE]" #define USAGE3 "-t SYSTEM [-d number] [-c]" #define LOCK "LCK.." #define STST_MAX 132 #define MAXDATE 12 #define MINTIME 60 #define MINUTES 60 #define CHAR "a" #define MAXSTATE 4 /* #include "logs.h" */ struct m { char mach[15]; /* machine name */ char locked; int ccount, xcount; int count, type; long retrytime; time_t lasttime; short c_age; /* age of oldest C. file */ short x_age; /* age of oldest X. file */ char stst[STST_MAX]; } M[UUSTAT_TBL+2]; struct userdate { char uhour[3]; char umin[3]; char lhour[3]; char lmin[3]; }; struct userdate userformat; struct userdate *friendlyptr = &userformat; extern long atol(); static int whattodo(); static int readperf(); static void queuetime(); static void xfertime(); static char * gmt(); static char * gmts(); static void errortn(); static void friendlytime(); static void complete(); static int state(); static int gnameflck(); static void kprocessC(); static int convert(); void uprocessC(), printit(), docalc(), procState(); static short State, Queued, Running, Complete, Interrupted; static char mailmsg[BUFSIZ]; static char outbuf[BUFSIZ+1]; static int count; static short jobcount; static short execute; static char lowerlimit[MAXDATE+1], upperlimit[MAXDATE+1]; static float totalque, totalxfer; static long totaljob, totalbytes; static long inputsecs; #ifdef ATTSV extern void qsort(); /* qsort(3) and comparison test */ #endif /* ATTSV */ int sortcnt = -1; extern int machcmp(); extern int _age(); /* find the age of a file */ static long calcnum; extern char Jobid[]; /* jobid for status or kill option */ short Kill; /* == 1 if -k specified */ short Rejuvenate; /* == 1 for -r specified */ short Uopt; /* == 1 if -u option specified */ short Sysopt; /* == 1 if -s option specified */ static short Calctime; /* == 1 if -t parameter set */ short Summary; /* == 1 if -q or -m is specified */ short Queue; /* == 1 if -q option set - queue summary */ short Machines; /* == 1 if -m option set - machines summary */ short Psopt; /* == 1 if -p option set - output "ps" of LCK pids */ static short Window; /* == 1 if -d parameter set with -t option */ static short nonotf; /* == 1 if -n parameter set with -k option */ short avgqueue; /* == 1 if -c parameter set with -t option */ short avgxfer; /* will be set to 1 if -c not specified */ short Jobcount; /* == 1 if -j parameter set with -s option */ char f[NAMESIZE]; int main(argc, argv, envp) char *argv[]; char **envp; { struct m *m, *machine(); DIR *spooldir, *subdir, *machdir, *gradedir; char *str, *rindex(); char subf[256], gradef[256]; char *c, lckdir[BUFSIZ]; char buf[BUFSIZ]; char chkname[MAXFULLNAME]; char *vec[7]; int i, chkid; char fullpath[MAXFULLNAME]; long temp; char arglist[MAXSTATE+1]; /* Set locale environment variables local definitions */ (void) setlocale(LC_ALL, ""); #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ #endif (void) textdomain(TEXT_DOMAIN); User[0] = '\0'; Rmtname[0] = '\0'; Jobid[0] = '\0'; Psopt=Machines=Summary=Queue=Kill=Rejuvenate=Uopt=Sysopt=Jobcount=0; execute=avgqueue=avgxfer=Calctime=Window=0; jobcount=nonotf=0; /* set calcnum to default time in minutes */ calcnum=MINTIME; (void) strcpy(Progname, "uustat"); Uid = getuid(); Euid = geteuid(); guinfo(Uid, Loginuser); uucpname(Myname); while ((i = getopt(argc, argv, "acjk:mnpr:qs:u:x:t:d:S:")) != EOF) { switch(i){ case 'a': Sysopt = 1; break; case 'c': avgqueue = 1; break; case 'd': Window = 1; calcnum = atoi(optarg); if (calcnum <= 0) calcnum = MINTIME; break; case 'k': (void) strncpy(Jobid, optarg, NAMESIZE); Jobid[NAMESIZE-1] = '\0'; Kill = 1; break; case 'j': Jobcount = 1; break; case 'm': Machines = Summary = 1; break; case 'n': nonotf = 1; break; case 'p': Psopt = 1; break; case 'r': (void) strncpy(Jobid, optarg, NAMESIZE); Jobid[NAMESIZE-1] = '\0'; Rejuvenate = 1; break; case 'q': Queue = Summary = 1; break; case 's': (void) strncpy(Rmtname, optarg, MAXBASENAME); Rmtname[MAXBASENAME] = '\0'; if (versys(Rmtname)) { fprintf(stderr, gettext("Invalid system\n")); exit(1); } Sysopt = 1; break; case 't': Calctime = 1; (void) strncpy(Rmtname, optarg, MAXBASENAME); Rmtname[MAXBASENAME] = '\0'; if (versys(Rmtname)) { fprintf(stderr, gettext("Invalid system\n")); exit(1); } break; case 'u': (void) strncpy(User, optarg, 8); User[8] = '\0'; if(gninfo(User, &chkid, chkname)) { fprintf(stderr, gettext("Invalid user\n")); exit(1); } Uopt = 1; execute = 1; break; case 'x': Debug = atoi(optarg); if (Debug <= 0) Debug = 1; break; case 'S': if (strlen(optarg) > sizeof (arglist)) { errortn(); exit(1); } State = 1; (void) strlcpy(arglist, optarg, sizeof (arglist)); procState(arglist); break; default: errortn(); exit(1); } } if (argc != optind) { errortn(); exit(1); } DEBUG(9, "Progname (%s): STARTED\n", Progname); DEBUG(9, "User=%s, ", User); DEBUG(9, "Loginuser=%s, ", Loginuser); DEBUG(9, "Jobid=%s, ", Jobid); DEBUG(9, "Rmtname=%s\n", Rmtname); /* -j only allowed with -s */ if (Jobcount && !Sysopt) { errortn(); exit(1); } if ((Calctime + Psopt + Machines + Queue + Kill + Rejuvenate + (Uopt|Sysopt |State)) >1) { /* only -u, -S and -s can be used together */ errortn(); exit(1); } if ((avgqueue | Window) & (!Calctime)) { errortn(); exit(1); } if ( !(Calctime | Kill | Rejuvenate | Uopt | Sysopt | Queue| Machines | State) ) { (void) strcpy(User, Loginuser); Uopt = 1; } if ( nonotf && !(Kill | Rejuvenate) ) { errortn(); exit(1); } /*****************************************/ /* PROCESS THE OPTIONS */ /*****************************************/ if (State && Complete) { DEBUG(9, "calling complete %d\n",Complete); complete(); } if (Calctime) { count = readperf(calcnum); if (count != 0) docalc(); } if (Psopt) { /* do "ps -flp" or pids in LCK files */ lckpid(); /* lckpid will not return */ } if (Summary) { /* Gather data for Summary option report */ if (chdir(STATDIR) || (spooldir = opendir(STATDIR)) == NULL) exit(101); /* good old code 101 */ while (gnamef(spooldir, f) == TRUE) { if (freopen(f, "r", stdin) == NULL) continue; m = machine(f); if (fgets(buf, sizeof(buf), stdin) == NULL) continue; if (getargs(buf, vec, 5) < 5) continue; m->type = atoi(vec[0]); m->count = atoi(vec[1]); m->lasttime = atol(vec[2]); m->retrytime = atol(vec[3]); (void) strncpy(m->stst, vec[4], STST_MAX); str = rindex(m->stst, ' '); (void) machine(++str); /* longer name? */ *str = '\0'; } closedir(spooldir); } if (Summary) { /* search for LCK machines */ char flck[MAXNAMESIZE]; (void) strcpy(lckdir, LOCKPRE); *strrchr(lckdir, '/') = '\0'; /* open lock directory */ if (chdir(lckdir) != 0 || (subdir = opendir(lckdir)) == NULL) exit(101); /* good old code 101 */ while (gnameflck(subdir, flck) == TRUE) { /* XXX - this is disgusting... */ if (EQUALSN("LCK..", flck, 5)) { if (!EQUALSN(flck + 5, "cul", 3) && !EQUALSN(flck + 5, "cua", 3) && !EQUALSN(flck + 5, "tty", 3) && !EQUALSN(flck + 5, "dtsw", 4) && !EQUALSN(flck + 5, "vadic", 5) && !EQUALSN(flck + 5, "micom", 5)) machine(flck + 5)->locked++; } } } if (chdir(SPOOL) != 0 || (spooldir = opendir(SPOOL)) == NULL) exit(101); /* good old code 101 */ while (gnamef(spooldir, f) == TRUE) { /* at /var/spool/uucp directory */ /* f will contain remote machine names */ if (EQUALSN("LCK..", f, 5)) continue; if (*Rmtname && !EQUALSN(Rmtname, f, MAXBASENAME)) continue; if ( (Kill || Rejuvenate) && (!EQUALSN(f, Jobid, strlen(Jobid)-5)) ) continue; if (DIRECTORY(f)) { if (chdir(f) != 0) exit(101); (void) sprintf(fullpath, "%s/%s", SPOOL, f); machdir = opendir(fullpath); if (machdir == NULL) exit(101); m = machine(f); while (gnamef(machdir, gradef) == TRUE) { /* at /var/spool/uucp/remote_name */ /* gradef will contain job_grade directory names */ if (DIRECTORY(gradef) && (gradedir = opendir(gradef))) { /* at /var/spool/uucp/remote_name/job_grade */ while (gnamef(gradedir, subf) == TRUE) { /* subf will contain file names */ /* files can be C. or D. or A., etc.. */ if (subf[1] == '.') { if (subf[0] == CMDPRE) { /* if file name is C. */ m->ccount++; if (Kill || Rejuvenate) kprocessC(gradef, subf); else if (Uopt | Sysopt | Queued | Running | Interrupted) /* go print out C. file info */ uprocessC(f ,gradef, subf); else /* get the age of the C. file */ if ( (i = _age(gradef, subf))>m->c_age) m->c_age = i; } } } closedir(gradedir); } else if (gradef[0] == XQTPRE && gradef[1] == '.') { m->xcount++; if ( (i = _age(machdir, gradef)) > m->x_age) m->x_age = i; } } closedir(machdir); } /* cd back to /var/spoool/uucp dir */ if (chdir(SPOOL) != 0) exit(101); } /* while more files in spooldir */ closedir(spooldir); if (Jobcount && (jobcount != 0)) printf("job count = %d\n",jobcount); /* for Kill or Rejuvenate - will not get here unless it failed */ if (Kill) { printf(gettext("Can't find Job %s; Not killed\n"), Jobid); exit(1); } else if (Rejuvenate) { printf(gettext("Can't find Job %s; Not rejuvenated\n"), Jobid); exit(1); } /* Make sure the overflow entry is null since it may be incorrect */ M[UUSTAT_TBL].mach[0] = NULLCHAR; if (Summary) { for((sortcnt = 0, m = &M[0]);*(m->mach) != '\0';(sortcnt++,m++)) ; qsort((char *)M, (unsigned int)sortcnt, sizeof(struct m), machcmp); for (m = M; m->mach[0] != NULLCHAR; m++) printit(m); } return (0); } /* * uprocessC - get information about C. file * */ void uprocessC(machine, dir, file) char *machine, *dir, *file; { struct stat s; struct tm *tp; char fullname[MAXFULLNAME], buf[BUFSIZ], user[9]; char xfullname[MAXFULLNAME]; char file1[BUFSIZ], file2[BUFSIZ], file3[BUFSIZ], type[2], opt[256]; short goodRecord = 0; FILE *fp, *xfp; short first = 1; int statefound = 0; extern long fsize(); char format_tmp[BUFSIZ+1]; fp=xfp=NULL; /*********************************************/ /* initialize output buffer to blanks */ /*********************************************/ if (Complete && !Queued && !Running && !Interrupted) return; outbuf[0] = NULLCHAR; DEBUG(9, "uprocessC(%s, ", dir); DEBUG(9, "%s);\n", file); if (Jobid[0] != '\0' && (!EQUALS(Jobid, &file[2])) ) { /* kill job - not this one */ return; } (void) sprintf(fullname, "%s/%s", dir, file); if (stat(fullname, &s) != 0) { /* error - can't stat */ DEBUG(4, "Can't stat file (%s),", fullname); DEBUG(4, " errno (%d) -- skip it!\n", errno); } fp = fopen(fullname, "r"); if (fp == NULL) { DEBUG(4, "Can't open file (%s), ", fullname); DEBUG(4, "errno=%d -- skip it!\n", errno); return; } tp = localtime(&s.st_mtime); if (s.st_size == 0 && User[0] == '\0') { /* dummy D. for polling */ sprintf(format_tmp,"%-12s %2.2d/%2.2d-%2.2d:%2.2d:%2.2d (POLL)\n", &file[2], tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec); (void) strcat(outbuf, format_tmp); } else while (fgets(buf, BUFSIZ, fp) != NULL) { if (sscanf(buf,"%s%s%s%s%s%s", type, file1, file2, user, opt, file3) <5) { DEBUG(4, "short line (%s)\n", buf); continue; } DEBUG(9, "type (%s), ", type); DEBUG(9, "file1 (%s)", file1); DEBUG(9, "file2 (%s)", file2); DEBUG(9, "file3 (%s)", file3); DEBUG(9, "user (%s)", user); goodRecord = 0; if (User[0] != '\0' && (!EQUALS(User, user)) ) continue; if (first) { sprintf(format_tmp,"%-12s", &file[2]); (void) strcat(outbuf, format_tmp); /* if the job state is requested call the state function to determine this job's state */ if (State) { statefound = state(dir, file); DEBUG(9, "uprocessC: statefound value = %d\n", statefound); if ((whattodo(statefound) != TRUE)) { outbuf[0] = NULLCHAR; return; } else { if (statefound == 1) (void) strcat(outbuf, "queued"); else if (statefound == 2) (void) strcat(outbuf, "running"); else if (statefound == 3) (void) strcat(outbuf, "interrupted"); } } sprintf(format_tmp, " %2.2d/%2.2d-%2.2d:%2.2d ", tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min); (void) strcat(outbuf, format_tmp); } else { sprintf(format_tmp,"%-12s %2.2d/%2.2d-%2.2d:%2.2d ", "", tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min); (void) strcat(outbuf, format_tmp); } first = 0; sprintf(format_tmp,"%s %s ", type, machine); (void) strcat(outbuf, format_tmp); if (*type == 'R') { sprintf(format_tmp,"%s %s ", user, file1); (void) strcat(outbuf, format_tmp); } else if (file2[0] != 'X') { sprintf(format_tmp,"%s %ld %s ", user, fsize(dir, file3, file1), file1); (void) strcat(outbuf, format_tmp); } else if (*type == 'S' && file2[0] == 'X') { (void) sprintf(xfullname, "%s/%s", dir, file1); xfp = fopen(xfullname, "r"); if (xfp == NULL) { /* program error */ DEBUG(4, "Can't read %s, ", xfullname); DEBUG(4, "errno=%d -- skip it!\n", errno); sprintf(format_tmp,"%s ", user); (void) strcat(outbuf, format_tmp); (void) strcat(outbuf,"????\n"); } else { char command[BUFSIZ], uline_u[BUFSIZ], uline_m[BUFSIZ]; char retaddr[BUFSIZ], *username; *retaddr = *uline_u = *uline_m = '\0'; while (fgets(buf, BUFSIZ, xfp) != NULL) { switch(buf[0]) { case 'C': strcpy(command, buf + 2); break; case 'U': sscanf(buf + 2, "%s%s", uline_u, uline_m); break; case 'R': sscanf(buf+2, "%s", retaddr); break; } } username = user; if (*uline_u != '\0') username = uline_u; if (*retaddr != '\0') username = retaddr; if (!EQUALS(uline_m, Myname)) printf("%s!", uline_m); sprintf(format_tmp,"%s %s", username, command); (void) strcat(outbuf, format_tmp); } } strcat(outbuf, "\n"); fputs(outbuf, stdout); outbuf[0] = NULLCHAR; goodRecord = 1; } /* end of while more data in buffer */ /* successful processing of a job, increment job count counter */ if (goodRecord) jobcount++; if (xfp != NULL) fclose(xfp); fclose(fp); return; } /* * whattodo - determine what to do with current C dot file * depending on any combination (2**3 - 1) of input * job states */ static int whattodo(inputint) int inputint; { /* Maybe some commentary here will help explain this truth table. Queued |Running |Interrupted ------------------------------------------------- X | | ------------------------------------------------- | X | ------------------------------------------------- | | X ------------------------------------------------- X | X | ------------------------------------------------- | X | X ------------------------------------------------- X | | X ------------------------------------------------- X | X | X ------------------------------------------------- Now do you understand. All possible combinations have to be evaluated to determine whether or not to print the C dot information out or not! Well, all but 000, because if neither of these states are input by the user we would not be examing the C dot file anyway! */ if (Queued && Running && Interrupted) return(TRUE); else if ((Queued && !Running && !Interrupted) && (inputint == 1)) return(TRUE); else if ((Running && !Queued && !Interrupted) && (inputint == 2)) return(TRUE); else if ((Interrupted && !Queued && !Running) && (inputint == 3)) return(TRUE); else if ((Queued && Running && !Interrupted) && (inputint == 1 || inputint == 2)) return(TRUE); else if ((!Queued && Running && Interrupted) && (inputint == 2 || inputint == 3)) return(TRUE); else if ((Queued && !Running && Interrupted) && (inputint ==1 || inputint == 3)) return(TRUE); else return(FALSE); } /* * kprocessC - process kill or rejuvenate job */ static void kprocessC(dir, file) char *file, *dir; { struct stat s; struct tm *tp; extern struct tm *localtime(); char fullname[MAXFULLNAME], buf[BUFSIZ], user[9]; char rfullname[MAXFULLNAME]; char file1[BUFSIZ], file2[BUFSIZ], file3[BUFSIZ], type[2], opt[256]; FILE *fp, *xfp; struct utimbuf times; short ret; short first = 1; DEBUG(9, "kprocessC(%s, ", dir); DEBUG(9, "%s);\n", file); if ((!EQUALS(Jobid, &file[2])) ) { /* kill job - not this one */ return; } (void) sprintf(fullname, "%s/%s", dir, file); if (stat(fullname, &s) != 0) { /* error - can't stat */ if(Kill) { fprintf(stderr, gettext("Can't stat:%s, errno (%d)--can't kill it!\n"), fullname, errno); } else { fprintf(stderr, gettext("Can't stat:%s, errno (%d)--can't rejuvenate it!\n"), fullname, errno); } exit(1); } fp = fopen(fullname, "r"); if (fp == NULL) { if(Kill) { fprintf(stderr, gettext("Can't read:%s, errno (%d)--can't kill it!\n"), fullname, errno); } else { fprintf(stderr, gettext("Can't read:%s, errno (%d)--can't rejuvenate it!\n"), fullname, errno); } exit(1); } times.actime = times.modtime = time((time_t *)NULL); while (fgets(buf, BUFSIZ, fp) != NULL) { if (sscanf(buf,"%s%s%s%s%s%s", type, file1, file2, user, opt, file3) <6) { if(Kill) { fprintf(stderr, gettext("Bad format:%s, errno (%d)--can't kill it!\n"), fullname, errno); } else { fprintf(stderr, gettext("Bad format:%s, errno (%d)--can't rejuvenate it!\n"), fullname, errno); } exit(1); } DEBUG(9, "buf in uprocessK = %s\n ", buf); DEBUG(9, "fullname is %s\n",fullname); DEBUG(9, "type (%s), ", type); DEBUG(9, "file1 (%s)", file1); DEBUG(9, "file2 (%s)", file2); DEBUG(9, "file3 (%s)", file3); DEBUG(9, "user (%s)", user); if (first) { if ((access(fullname, 02) != 0) && !PREFIX(Loginuser, user) && !PREFIX(user, Loginuser) ) { /* not allowed - not owner or root */ if(Kill) fprintf(stderr, gettext("Not owner," " uucp or root - can't kill job %s\n"), Jobid); else fprintf(stderr, gettext("Not owner, uucp or root -" " can't rejuvenate job %s\n"), Jobid); exit(1); } first = 0; } /* remove D. file */ (void) sprintf(rfullname, "%s/%s", dir, file3); DEBUG(4, "Remove %s\n", rfullname); if (Kill) ret = unlink(rfullname); else /* Rejuvenate */ ret = utime(rfullname, ×); if (ret != 0 && errno != ENOENT) { /* program error?? */ if(Kill) fprintf(stderr, gettext("Error: Can't kill," " File (%s), errno (%d)\n"), rfullname, errno); else fprintf(stderr, gettext("Error: Can't rejuvenated," " File (%s), errno (%d)\n"), rfullname, errno); exit(1); } } DEBUG(4, "Remove %s\n", fullname); if (Kill) ret = unlink(fullname); else /* Rejuvenate */ ret = utime(fullname, ×); if (ret != 0) { /* program error?? */ if(Kill) fprintf(stderr, gettext("Error1: Can't kill," " File (%s), errno (%d)\n"), fullname, errno); else fprintf(stderr, gettext("Error1: Can't rejuvenate," " File (%s), errno (%d)\n"), fullname, errno); exit(1); } /* if kill done by SA then send user mail */ else if (!EQUALS(Loginuser, user)) { sprintf(mailmsg, "%s %s", KILLMSG, Jobid); mailst(user, "job killed", mailmsg, "", ""); } fclose(fp); if (!nonotf) { if(Kill) printf(gettext("Job: %s successfully killed\n"), Jobid); else printf(gettext("Job: %s successfully rejuvenated\n"), Jobid); } exit(0); } /* * fsize - return the size of f1 or f2 (if f1 does not exist) * f1 is the local name * */ long fsize(dir, f1, f2) char *dir, *f1, *f2; { struct stat s; char fullname[BUFSIZ]; (void) sprintf(fullname, "%s/%s", dir, f1); if (stat(fullname, &s) == 0) { return(s.st_size); } if (stat(f2, &s) == 0) { return(s.st_size); } return(-99999); } void cleanup(){} void logent(){} /* to load ulockf.c */ void systat(){} /* to load utility.c */ struct m * machine(name) char *name; { struct m *m; size_t namelen; DEBUG(9, "machine(%s), ", name); namelen = strlen(name); for (m = M; m->mach[0] != NULLCHAR; m++) /* match on overlap? */ if (EQUALSN(name, m->mach, MAXBASENAME)) { /* use longest name */ if (namelen > strlen(m->mach)) (void) strcpy(m->mach, name); return(m); } /* * The table is set up with 2 extra entries * When we go over by one, output error to errors log * When more than one over, just reuse the previous entry */ DEBUG(9, "m-M=%d\n", m-M); if (m-M >= UUSTAT_TBL) { if (m-M == UUSTAT_TBL) { errent("MACHINE TABLE FULL", "", UUSTAT_TBL, __FILE__, __LINE__); (void) fprintf(stderr, gettext("WARNING: Table Overflow--output not complete\n")); } else /* use the last entry - overwrite it */ m = &M[UUSTAT_TBL]; } (void) strcpy(m->mach, name); m->c_age= m->x_age= m->lasttime= m->locked= m->ccount= m->xcount= 0; m->stst[0] = '\0'; return(m); } void printit(m) struct m *m; { struct tm *tp; time_t t; int minimum; extern struct tm *localtime(); if (m->ccount == 0 && m->xcount == 0 /*&& m->stst[0] == '\0'*/ && m->locked == 0 && Queue && m->type == 0) return; printf("%-10s", m->mach); if (Queue) { if (m->ccount) printf("%3dC", m->ccount); else printf(" "); if (m->c_age) printf("(%d)", m->c_age); else printf(" "); if (m->xcount) printf("%3dX", m->xcount); else printf(" "); if (m->x_age) printf("(%d) ", m->x_age); else printf(" "); } else printf(" "); if (m->lasttime) { tp = localtime(&m->lasttime); printf("%2.2d/%2.2d-%2.2d:%2.2d ", tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min); } /* if (m->locked && m->type != SS_INPROGRESS) */ if (m->locked) printf("Locked "); if (m->stst[0] != '\0') { printf("%s", m->stst); switch (m->type) { case SS_SEQBAD: case SS_LOGIN_FAILED: case SS_DIAL_FAILED: case SS_BAD_LOG_MCH: case SS_BADSYSTEM: case SS_CANT_ACCESS_DEVICE: case SS_DEVICE_FAILED: case SS_WRONG_MCH: case SS_RLOCKED: case SS_RUNKNOWN: case SS_RLOGIN: case SS_UNKNOWN_RESPONSE: case SS_STARTUP: case SS_CHAT_FAILED: (void) time(&t); t = m->retrytime - (t - m->lasttime); if (t > 0) { minimum = (t + 59) / 60; printf("Retry: %d:%2.2d", minimum/60, minimum%60); } if (m->count > 1) printf(" Count: %d", m->count); } } putchar('\n'); return; } #define MAXLOCKS 100 /* Maximum number of lock files this will handle */ int lckpid() { int i; int fd, ret; pid_t pid, list[MAXLOCKS]; char alpid[SIZEOFPID+2]; /* +2 for '\n' and null */ char buf[BUFSIZ], f[MAXNAMESIZE]; char *c, lckdir[BUFSIZ]; DIR *dir; DEBUG(9, "lckpid() - entered\n%s", ""); for (i=0; i 0) #ifdef V7 execl("/bin/ps", "uustat-ps", buf, (char *) 0); #else execl("/usr/bin/ps", "ps", "-flp", buf, (char *) 0); #endif exit(0); } /* * get next file name from lock directory * p -> file description of directory file to read * filename -> address of buffer to return filename in * must be of size NAMESIZE * returns: * FALSE -> end of directory read * TRUE -> returned name */ static int gnameflck(p, filename) char *filename; DIR *p; { struct dirent dentry; struct dirent *dp = &dentry; for (;;) { if ((dp = readdir(p)) == NULL) return(FALSE); if (dp->d_ino != 0 && dp->d_name[0] != '.') break; } (void) strncpy(filename, dp->d_name, MAXNAMESIZE-1); filename[MAXNAMESIZE-1] = '\0'; return(TRUE); } int machcmp(a,b) char *a,*b; { return(strcmp(((struct m *) a)->mach,((struct m *) b)->mach)); } static long _sec_per_day = 86400L; /* * _age - find the age of "file" in days * return: * age of file * 0 - if stat fails */ int _age(dir, file) char * file; /* the file name */ char * dir; /* system spool directory */ { char fullname[MAXFULLNAME]; static time_t ptime = 0; time_t time(); struct stat stbuf; if (!ptime) (void) time(&ptime); (void) sprintf(fullname, "%s/%s", dir, file); if (stat(fullname, &stbuf) != -1) { return ((int)((ptime - stbuf.st_mtime)/_sec_per_day)); } else return(0); } /* Function: complete - find and print jobids of completed jobs for * user. * * Look thru the /var/uucp/.Admin/account file (if present) * for all jobs initiated by user and print. * * Parameters: * * Username - user that initiated uustat request * * Returns: * */ static void complete() { /* Function name: complete Author: Roland T. Conwell Date: July 31, 1986 Naration: This function will search through /var/uucp/.Admin/account file for all jobs submitted by User. If User jobs are found the state of 'completed' will be printed on stdout. Module called by uustat main */ char abuf[BUFSIZ]; FILE *fp; char accno[15], jobid[15], system[15], loginame[15], time[20], dest[15]; char size[15]; char grade[2], jgrade[2]; char status[2]; int x; fp = fopen(ACCOUNT, "r"); if (fp == NULL) { fprintf(stderr, gettext("Can't open account log\n")); return; } while (fgets(abuf, BUFSIZ, fp) != NULL) { x = sscanf(abuf, "%s%s%s%s%s%s%s%s%s%s", accno,jobid, size, status, grade, jgrade, system, loginame, time, dest); if (x < 6) continue; if (!EQUALS(status, "C")) continue; DEBUG(9, "COMPLETE: accno = %s\n", accno); DEBUG(9, "COMPLETE: jobid = %s\n", jobid); DEBUG(9, "COMPLETE: size = %s\n", size); DEBUG(9, "COMPLETE: status = %s\n", status); DEBUG(9, "COMPLETE: grade = %s\n", grade); DEBUG(9, "COMPLETE: jgrade = %s\n", jgrade); DEBUG(9, "COMPLETE: system = %s\n", system); DEBUG(9, "COMPLETE: loginame = %s\n", loginame); DEBUG(9, "COMPLETE: time = %s\n", time); DEBUG(9, "COMPLETE: dest = %s\n", dest); if (*Rmtname && !EQUALS(Rmtname, dest)) continue; if (*User && !EQUALS(User, loginame)) continue; if (State && !Uopt) { if (EQUALS(Loginuser, loginame)) { printf("%s completed\n",jobid); jobcount++; } } else { printf("%s completed\n", jobid); jobcount++; } } fclose(fp); return; } /* Function: state - determine if Cdotfile is queued or running * * This function searches thru the directory jcdir for a Adotfile * that matches the Cdotfile. If found then look for a matching * lock file. If a Adotfile and a lock file is found then the * job is in the running state. If no Adotfile is found then the * job is in the queued state. If a Adotfile is found and no * lock file is found then the job is queued. * * Parameters: * * jcdir - the job grade directory to search * cdotfile - the Cdotfile whose state is to be determined * * Returns: * */ static int state(jcdir, cdotfile) char *jcdir, *cdotfile; { short found, foundlck, CequalA; char comparef[MAXBASENAME+1], afile[MAXBASENAME+1], cfile[MAXBASENAME+1]; char lckfile[MAXBASENAME+1], lockname[MAXBASENAME+1]; char lckdir[BUFSIZ+1]; DIR *subjcdir, *sjcdir; int rtnstate = 0; foundlck = 0; CequalA = 0; sjcdir = opendir(jcdir); if (sjcdir == NULL) return (0); while (gnamef(sjcdir, comparef) == TRUE) { if (comparef[0] == 'A') { (void) strcpy(afile, comparef); *strchr(afile, 'A') = ' '; (void) strcpy(cfile, cdotfile); *strchr(cfile, 'C') = ' '; if (EQUALS(cfile, afile)) { /* now we have a C. and A. for same job */ /* check for LCK..machine.job_grade */ /* if no LCK file at this point we will */ /* print the RUNNING state */ CequalA = 1; (void) strcpy(lckdir, LOCKPRE); *strrchr(lckdir, '/') = '\0'; /* open lock directory */ subjcdir = opendir(lckdir); if (subjcdir == NULL) exit(101); /* I know, I know! */ (void) sprintf(lockname,"%s%s.%s",LOCK, f, jcdir); while (gnamef(subjcdir, lckfile) == TRUE) { DEBUG(9, "STATE: lockfile = %s\n",lckfile); if (EQUALS(lockname, lckfile)) foundlck = 1; } closedir(subjcdir); } } } closedir(sjcdir); /* got adot, cdot and lock file */ if (Running && foundlck) rtnstate = 2; else if (Interrupted && CequalA && !foundlck) rtnstate = 3; else if (Queued && !CequalA && !foundlck) rtnstate = 1; DEBUG(9, "STATE: returning with value %d\n",rtnstate); return(rtnstate); } /* end of state.c */ static int readperf(timerange) long timerange; { char proto[2], jc[2], role[2]; char rectype[5], time[MAXDATE+1], pid[10],wmachine[10]; char remote[10],device[10], netid[20], jobid[20]; static float queuetime, tat; static long size; struct tm tm_tmp; time_t t_time, t_starttime, t_upperlimit; char options[10]; static float rst, ust, kst, xferrate, utt, ktt; static float rtt, wfield, xfield, yfield; struct perfrec *recptr; static float tqt; static int jobs; char abuf[BUFSIZ]; FILE *fp; static int x; char *strptr, *startime; int recordcnt; totalxfer=totalbytes=recordcnt=totaljob=totalque=0; lowerlimit[0] = '\0'; upperlimit[0] = '\0'; inputsecs = convert(timerange); startime = gmts(); strncpy(lowerlimit, startime, MAXDATE); strncpy(upperlimit, gmt(), MAXDATE); /* convert lowerlimit and upperlimit to HH:MM format */ friendlytime(lowerlimit, upperlimit); fp = fopen(PERFLOG, "r"); if (fp == NULL) { (void) fprintf(stderr, gettext("Can't open performance log\n")); return(0); } while (fgets(abuf, BUFSIZ, fp) != NULL) { DEBUG(9, "READPERF: abuf before = %s\n",abuf); if (!EQUALSN(abuf, "xfer", 4)) continue; /* convert all '|'s to blanks for sscanf */ for (strptr = abuf; *strptr != '\0'; strptr++) if (*strptr == '|') *strptr = ' '; DEBUG(9, "READPERF: abuf = %s\n",abuf); x = sscanf(abuf, "%s%*s%s%s%s%s%s%s%*s%s%s%f%f%ld%s%f%f%f%f%f%f%f%f%f%*s", rectype, time, pid, wmachine, role, remote, device, netid, jobid, &queuetime, &tat, &size, options, &rst, &ust, &kst, &xferrate, &utt, &ktt, &rtt, &wfield, &xfield); DEBUG(9, "READPERF: rectype = %s\n",rectype); DEBUG(9, "READPERF: time = %s\n",time); DEBUG(9, "READPERF: pid = %s\n",pid); DEBUG(9, "READPERF: remote = %s\n",remote); DEBUG(9, "READPERF: jobid = %s\n",jobid); DEBUG(9, "READPERF: queuetime = %f\n",queuetime); DEBUG(9, "READPERF: tat = %f\n",tat); DEBUG(9, "READPERF: xferrate = %f\n",xferrate); abuf[0] = '\0'; if (!EQUALS(Rmtname, remote)) continue; if (!EQUALS(role, "M")) continue; if (x < 18) continue; DEBUG(9, "READPERF: startime = %s\n", startime); DEBUG(9, "READPERF: lowerlimit = %s\n", lowerlimit); DEBUG(9, "READPERF: time = %s\n", time); DEBUG(9, "READPERF: upperlimit = %s\n", upperlimit); strptime(time, "%y %m %d %H %M %S", &tm_tmp); t_time = mktime(&tm_tmp); strptime(startime, "%y %m %d %H %M %S", &tm_tmp); t_starttime = mktime(&tm_tmp); strptime(upperlimit, "%y %m %d %H %M %S", &tm_tmp); t_upperlimit = mktime(&tm_tmp); DEBUG(9, "READPERF: t_time = %d\n", t_time); DEBUG(9, "READPERF: t_starttime = %d\n", t_starttime); DEBUG(9, "READPERF: t_upperlimit = %d\n", t_upperlimit); if (t_starttime <= t_time && t_upperlimit >= t_time) { totaljob++; totalque = totalque + queuetime; totalxfer = totalxfer + xferrate; totalbytes = totalbytes + size; recordcnt = recordcnt + 1; DEBUG(9, " processing recordcnt %d\n", recordcnt); } DEBUG(9, "END step 1 %d\n", recordcnt); } /* while */ DEBUG(9, "END step 2 recordcnt %d\n", recordcnt); fclose(fp); return(recordcnt); } /* end of readperf */ void docalc() { if (avgqueue) queuetime(); else xfertime(); return; } static int convert(intime) long intime; { long outtime; outtime = intime * 60; return(outtime); } static void queuetime() { static double avgqtime; avgqtime = totalque / totaljob; printf("average queue time to [%s] for last [%ld] minutes: %6.2f seconds\n",Rmtname, calcnum, avgqtime); printf("data gathered from %s:%s to %s:%s GMT\n", friendlyptr->uhour, friendlyptr->umin, friendlyptr->lhour, friendlyptr->lmin); return; } static void xfertime() { static double avgxrate; avgxrate = totalbytes / totalxfer; printf("average transfer rate with [ %s ] for last [%ld] minutes: %6.2f bytes/sec\n", Rmtname, calcnum, avgxrate); printf("data gathered from %s:%s to %s:%s GMT\n", friendlyptr->uhour, friendlyptr->umin, friendlyptr->lhour, friendlyptr->lmin); return; } /* * Local Function: gmts - Generate Start Time String * * This function returns the address to a string containing the start * time, or upperlimit, for searching the PERFLOG. * The start time is in GMT in the form YYMMDDhhmmss. * * Parameters: * * none * * Return: * * An address of a static character array containing the date. */ static char * gmts() { static char date[] = "YYMMDDhhmmss"; struct tm *td; time_t now; /* Current time. */ time_t temp; now = time((time_t *) 0); /* inputsecs is declared global to this file */ DEBUG(9, "GMTS: now = %ld\n", now); DEBUG(9, "GMTS: inputsecs = %ld\n", inputsecs); temp = (now - inputsecs); td = gmtime(&temp); (void) sprintf(date, "%02d%02d%02d%02d%02d%02d", (td->tm_year % 100), td->tm_mon + 1, td->tm_mday, td->tm_hour, td->tm_min, td->tm_sec ); return date; } /* * Local Function: gmt - Generate Current Time String * * This function returns the address to a string containing the current * GMT in the form YYMMDDhhmmss. * * Parameters: * * none * * Return: * * An address of a static character array containing the date. */ static char * gmt() { static char date[] = "YYMMDDhhmmss"; struct tm *td; time_t now; /* Current time. */ now = time((time_t *) 0); td = gmtime(&now); (void) sprintf(date, "%02d%02d%02d%02d%02d%02d", (td->tm_year % 100), td->tm_mon + 1, td->tm_mday, td->tm_hour, td->tm_min, td->tm_sec ); return date; } static void friendlytime(uplimit, lolimit) char *uplimit, *lolimit; { friendlyptr->uhour[0] = *(uplimit+6); friendlyptr->uhour[1] = *(uplimit+7); friendlyptr->lhour[0] = *(lolimit+6); friendlyptr->lhour[1] = *(lolimit+7); friendlyptr->umin[0] = *(uplimit+8); friendlyptr->umin[1] = *(uplimit+9); friendlyptr->lmin[0] = *(lolimit+8); friendlyptr->lmin[1] = *(lolimit+9); friendlyptr->uhour[2] = '\0'; friendlyptr->lhour[2] = '\0'; friendlyptr->umin[2] = '\0'; friendlyptr->lmin[2] = '\0'; return; } void procState(inputargs) char * inputargs; { if (strchr(inputargs, 'q') != NULL) Queued = 1; if (strchr(inputargs, 'r') != NULL) Running = 1; if (strchr(inputargs, 'i') != NULL) Interrupted = 1; if (strchr(inputargs, 'c') != NULL) Complete = 1; if ((size_t)(Queued + Running + Interrupted + Complete) < strlen(inputargs)) { errortn(); exit(1); } return; } static void errortn() { (void) fprintf(stderr, gettext("\tUsage: %s " USAGE1 "\n"), Progname); (void) fprintf(stderr, gettext("or\n\tUsage: %s " USAGE2 "\n"), Progname); (void) fprintf(stderr, gettext("or\n\tUsage: %s " USAGE3 "\n"), Progname); return; }