#pragma ident "%Z%%M% %I% %E% SMI"

#include <time.h>

#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

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];

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) != NULL;(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(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

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

if (goodRecord)

jobcount++;

if (xfp != NULL)

fclose(xfp);

fclose(fp);

return;

}

static int

whattodo(inputint)

int inputint;

{

/* Maybe some commentary here will help explain this truth

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);

}

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, &times);

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, &times);

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(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);

}

/*

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);

}

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)

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

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<MAXLOCKS; i++)

list[i] = -1;

(void) strcpy(lckdir, LOCKPRE);

*strrchr(lckdir, '/') = '\0';

DEBUG(9, "lockdir (%s)\n", lckdir);

/* open lock directory */

if (chdir(lckdir) != 0 || (dir = opendir(lckdir)) == NULL)

exit(101); /* good old code 101 */

while (gnameflck(dir, f) == TRUE) {

/* find all lock files */

DEBUG(9, "f (%s)\n", f);

if (EQUALSN("LCK.", f, 4) || EQUALSN("LK.", f, 3)) {

/* read LCK file */

fd = open(f, O_RDONLY);

printf("%s: ", f);

ret = read(fd, alpid, SIZEOFPID+2); /* +2 for '\n' and null */

pid = strtol(alpid, (char **) NULL, 10);

(void) close(fd);

if (ret != -1) {

printf("%ld\n", (long) pid);

for(i=0; i<MAXLOCKS; i++) {

if (list[i] == pid)

break;

if (list[i] == -1) {

list[i] = pid;

break;

}

}

}

else

printf("????\n");

}

}

fflush(stdout);

*buf = NULLCHAR;

for (i=0; i<MAXLOCKS; i++) {

if( list[i] == -1)

break;

(void) sprintf(&buf[strlen(buf)], "%d ", list[i]);

}

if (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);

}

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);

}

machcmp(a,b)

char *a,*b;

{

return(strcmp(((struct m *) a)->mach,((struct m *) b)->mach));

}

static long _sec_per_day = 86400L;

_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);

}

static void

complete()

{

/* Function name: complete

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;

}

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

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;

}

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;

}

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;

{

char c;

c = *(uplimit+6);

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;

}

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;

}