1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31 #include <time.h>
32 #include "uucp.h"
33
34 #ifdef V7
35 #define O_RDONLY 0
36 #endif
37 #define KILLMSG "the system administrator has killed job"
38 #define USAGE1 "[-q] | [-m] | [-k JOB [-n]] | [-r JOB [-n]] | [-p]"
39 #define USAGE2 "[-a] [-s SYSTEM [-j]] [-u USER] [-S STATE]"
40 #define USAGE3 "-t SYSTEM [-d number] [-c]"
41 #define LOCK "LCK.."
42 #define STST_MAX 132
43 #define MAXDATE 12
44 #define MINTIME 60
45 #define MINUTES 60
46 #define CHAR "a"
47 #define MAXSTATE 4
48 /* #include "logs.h" */
49 struct m {
50 char mach[15]; /* machine name */
51 char locked;
52 int ccount, xcount;
53 int count, type;
54 long retrytime;
55 time_t lasttime;
56 short c_age; /* age of oldest C. file */
57 short x_age; /* age of oldest X. file */
58 char stst[STST_MAX];
59 } M[UUSTAT_TBL+2];
60
61
62 struct userdate {
63 char uhour[3];
64 char umin[3];
65 char lhour[3];
66 char lmin[3];
67 };
68
69 struct userdate userformat;
70 struct userdate *friendlyptr = &userformat;
71
72 extern long atol();
73 static int whattodo();
74 static int readperf();
75 static void queuetime();
76 static void xfertime();
77 static char * gmt();
78 static char * gmts();
79 static void errortn();
80 static void friendlytime();
81 static void complete();
82 static int state();
83 static int gnameflck();
84 static void kprocessC();
85 static int convert();
86 void uprocessC(), printit(), docalc(), procState();
87
88 static short State, Queued, Running, Complete, Interrupted;
89
90 static char mailmsg[BUFSIZ];
91 static char outbuf[BUFSIZ+1];
92 static int count;
93 static short jobcount;
94 static short execute;
95 static char lowerlimit[MAXDATE+1], upperlimit[MAXDATE+1];
96 static float totalque, totalxfer;
97 static long totaljob, totalbytes;
98 static long inputsecs;
99 #ifdef ATTSV
100 extern void qsort(); /* qsort(3) and comparison test */
101 #endif /* ATTSV */
102 int sortcnt = -1;
103 extern int machcmp();
104 extern int _age(); /* find the age of a file */
105 static long calcnum;
106 extern char Jobid[]; /* jobid for status or kill option */
107 short Kill; /* == 1 if -k specified */
108 short Rejuvenate; /* == 1 for -r specified */
109 short Uopt; /* == 1 if -u option specified */
110 short Sysopt; /* == 1 if -s option specified */
111 static short Calctime; /* == 1 if -t parameter set */
112 short Summary; /* == 1 if -q or -m is specified */
113 short Queue; /* == 1 if -q option set - queue summary */
114 short Machines; /* == 1 if -m option set - machines summary */
115 short Psopt; /* == 1 if -p option set - output "ps" of LCK pids */
116 static short Window; /* == 1 if -d parameter set with -t option */
117 static short nonotf; /* == 1 if -n parameter set with -k option */
118 short avgqueue; /* == 1 if -c parameter set with -t option */
119 short avgxfer; /* will be set to 1 if -c not specified */
120 short Jobcount; /* == 1 if -j parameter set with -s option */
121 char f[NAMESIZE];
122
123 int
124 main(argc, argv, envp)
125 char *argv[];
126 char **envp;
127 {
128 struct m *m, *machine();
129 DIR *spooldir, *subdir, *machdir, *gradedir;
130 char *str, *rindex();
131 char subf[256], gradef[256];
132 char *c, lckdir[BUFSIZ];
133 char buf[BUFSIZ];
134 char chkname[MAXFULLNAME];
135 char *vec[7];
136 int i, chkid;
137 char fullpath[MAXFULLNAME];
138 long temp;
139
140 char arglist[MAXSTATE+1];
141
142 /* Set locale environment variables local definitions */
143 (void) setlocale(LC_ALL, "");
144 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
145 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */
146 #endif
147 (void) textdomain(TEXT_DOMAIN);
148
149 User[0] = '\0';
150 Rmtname[0] = '\0';
151 Jobid[0] = '\0';
152 Psopt=Machines=Summary=Queue=Kill=Rejuvenate=Uopt=Sysopt=Jobcount=0;
153 execute=avgqueue=avgxfer=Calctime=Window=0;
154 jobcount=nonotf=0;
155
156 /* set calcnum to default time in minutes */
157 calcnum=MINTIME;
158
159 (void) strcpy(Progname, "uustat");
160 Uid = getuid();
161 Euid = geteuid();
162 guinfo(Uid, Loginuser);
163 uucpname(Myname);
164 while ((i = getopt(argc, argv, "acjk:mnpr:qs:u:x:t:d:S:")) != EOF) {
165 switch(i){
166 case 'a':
167 Sysopt = 1;
168 break;
169 case 'c':
170 avgqueue = 1;
171 break;
172 case 'd':
173 Window = 1;
174 calcnum = atoi(optarg);
175 if (calcnum <= 0)
176 calcnum = MINTIME;
177 break;
178 case 'k':
179 (void) strncpy(Jobid, optarg, NAMESIZE);
180 Jobid[NAMESIZE-1] = '\0';
181 Kill = 1;
182 break;
183 case 'j':
184 Jobcount = 1;
185 break;
186 case 'm':
187 Machines = Summary = 1;
188 break;
189 case 'n':
190 nonotf = 1;
191 break;
192 case 'p':
193 Psopt = 1;
194 break;
195 case 'r':
196 (void) strncpy(Jobid, optarg, NAMESIZE);
197 Jobid[NAMESIZE-1] = '\0';
198 Rejuvenate = 1;
199 break;
200 case 'q':
201 Queue = Summary = 1;
202 break;
203 case 's':
204 (void) strncpy(Rmtname, optarg, MAXBASENAME);
205
206 Rmtname[MAXBASENAME] = '\0';
207 if (versys(Rmtname)) {
208 fprintf(stderr, gettext("Invalid system\n"));
209 exit(1);
210 }
211 Sysopt = 1;
212 break;
213 case 't':
214 Calctime = 1;
215 (void) strncpy(Rmtname, optarg, MAXBASENAME);
216 Rmtname[MAXBASENAME] = '\0';
217 if (versys(Rmtname)) {
218 fprintf(stderr, gettext("Invalid system\n"));
219 exit(1);
220 }
221 break;
222 case 'u':
223 (void) strncpy(User, optarg, 8);
224 User[8] = '\0';
225 if(gninfo(User, &chkid, chkname)) {
226 fprintf(stderr, gettext("Invalid user\n"));
227 exit(1);
228 }
229 Uopt = 1;
230 execute = 1;
231 break;
232 case 'x':
233 Debug = atoi(optarg);
234 if (Debug <= 0)
235 Debug = 1;
236 break;
237 case 'S':
238 if (strlen(optarg) > sizeof (arglist)) {
239 errortn();
240 exit(1);
241 }
242 State = 1;
243 (void) strlcpy(arglist, optarg, sizeof (arglist));
244 procState(arglist);
245 break;
246 default:
247 errortn();
248 exit(1);
249 }
250 }
251
252 if (argc != optind) {
253 errortn();
254 exit(1);
255 }
256
257 DEBUG(9, "Progname (%s): STARTED\n", Progname);
258 DEBUG(9, "User=%s, ", User);
259 DEBUG(9, "Loginuser=%s, ", Loginuser);
260 DEBUG(9, "Jobid=%s, ", Jobid);
261 DEBUG(9, "Rmtname=%s\n", Rmtname);
262
263 /* -j only allowed with -s */
264 if (Jobcount && !Sysopt)
265 {
266 errortn();
267 exit(1);
268 }
269 if ((Calctime + Psopt + Machines + Queue + Kill + Rejuvenate + (Uopt|Sysopt |State)) >1) {
270 /* only -u, -S and -s can be used together */
271 errortn();
272 exit(1);
273 }
274 if ((avgqueue | Window) & (!Calctime))
275 {
276 errortn();
277 exit(1);
278 }
279
280 if ( !(Calctime | Kill | Rejuvenate | Uopt | Sysopt | Queue| Machines | State) ) {
281 (void) strcpy(User, Loginuser);
282 Uopt = 1;
283 }
284
285 if ( nonotf && !(Kill | Rejuvenate) ) {
286 errortn();
287 exit(1);
288 }
289
290 /*****************************************/
291 /* PROCESS THE OPTIONS */
292 /*****************************************/
293
294 if (State && Complete)
295 {
296 DEBUG(9, "calling complete %d\n",Complete);
297 complete();
298 }
299
300 if (Calctime) {
301 count = readperf(calcnum);
302
303 if (count != 0)
304 docalc();
305
306 }
307
308 if (Psopt) {
309 /* do "ps -flp" or pids in LCK files */
310 lckpid();
311 /* lckpid will not return */
312 }
313
314 if (Summary) {
315 /* Gather data for Summary option report */
316 if (chdir(STATDIR) || (spooldir = opendir(STATDIR)) == NULL)
317 exit(101); /* good old code 101 */
318 while (gnamef(spooldir, f) == TRUE) {
319 if (freopen(f, "r", stdin) == NULL)
320 continue;
321 m = machine(f);
322 if (fgets(buf, sizeof(buf), stdin) == NULL)
323 continue;
324 if (getargs(buf, vec, 5) < 5)
325 continue;
326 m->type = atoi(vec[0]);
327 m->count = atoi(vec[1]);
328 m->lasttime = atol(vec[2]);
329 m->retrytime = atol(vec[3]);
330 (void) strncpy(m->stst, vec[4], STST_MAX);
331 str = rindex(m->stst, ' ');
332 (void) machine(++str); /* longer name? */
333 *str = '\0';
334
335 }
336 closedir(spooldir);
337 }
338
339
340 if (Summary) {
341 /* search for LCK machines */
342 char flck[MAXNAMESIZE];
343
344 (void) strcpy(lckdir, LOCKPRE);
345 *strrchr(lckdir, '/') = '\0';
346 /* open lock directory */
347 if (chdir(lckdir) != 0 || (subdir = opendir(lckdir)) == NULL)
348 exit(101); /* good old code 101 */
349
350 while (gnameflck(subdir, flck) == TRUE) {
351 /* XXX - this is disgusting... */
352 if (EQUALSN("LCK..", flck, 5)) {
353 if (!EQUALSN(flck + 5, "cul", 3)
354 && !EQUALSN(flck + 5, "cua", 3)
355 && !EQUALSN(flck + 5, "tty", 3)
356 && !EQUALSN(flck + 5, "dtsw", 4)
357 && !EQUALSN(flck + 5, "vadic", 5)
358 && !EQUALSN(flck + 5, "micom", 5))
359 machine(flck + 5)->locked++;
360 }
361 }
362 }
363
364 if (chdir(SPOOL) != 0 || (spooldir = opendir(SPOOL)) == NULL)
365 exit(101); /* good old code 101 */
366
367 while (gnamef(spooldir, f) == TRUE) {
368 /* at /var/spool/uucp directory */
369 /* f will contain remote machine names */
370
371 if (EQUALSN("LCK..", f, 5))
372 continue;
373
374 if (*Rmtname && !EQUALSN(Rmtname, f, MAXBASENAME))
375 continue;
376
377 if ( (Kill || Rejuvenate)
378 && (!EQUALSN(f, Jobid, strlen(Jobid)-5)) )
379 continue;
380
381 if (DIRECTORY(f)) {
382 if (chdir(f) != 0)
383 exit(101);
384 (void) sprintf(fullpath, "%s/%s", SPOOL, f);
385 machdir = opendir(fullpath);
386 if (machdir == NULL)
387 exit(101);
388
389 m = machine(f);
390 while (gnamef(machdir, gradef) == TRUE) {
391 /* at /var/spool/uucp/remote_name */
392 /* gradef will contain job_grade directory names */
393
394 if (DIRECTORY(gradef) && (gradedir = opendir(gradef))) {
395 /* at /var/spool/uucp/remote_name/job_grade */
396
397 while (gnamef(gradedir, subf) == TRUE) {
398 /* subf will contain file names */
399 /* files can be C. or D. or A., etc.. */
400
401 if (subf[1] == '.') {
402 if (subf[0] == CMDPRE) {
403 /* if file name is C. */
404 m->ccount++;
405
406 if (Kill || Rejuvenate)
407 kprocessC(gradef, subf);
408 else if (Uopt | Sysopt | Queued | Running | Interrupted)
409 /* go print out C. file info */
410 uprocessC(f ,gradef, subf);
411
412 else /* get the age of the C. file */
413 if ( (i = _age(gradef, subf))>m->c_age)
414 m->c_age = i;
415 }
416 }
417 }
418 closedir(gradedir);
419 }
420
421 else if (gradef[0] == XQTPRE && gradef[1] == '.') {
422 m->xcount++;
423 if ( (i = _age(machdir, gradef)) > m->x_age)
424 m->x_age = i;
425 }
426 }
427 closedir(machdir);
428 }
429 /* cd back to /var/spoool/uucp dir */
430 if (chdir(SPOOL) != 0)
431 exit(101);
432 } /* while more files in spooldir */
433 closedir(spooldir);
434
435 if (Jobcount && (jobcount != 0))
436 printf("job count = %d\n",jobcount);
437
438 /* for Kill or Rejuvenate - will not get here unless it failed */
439 if (Kill) {
440 printf(gettext("Can't find Job %s; Not killed\n"), Jobid);
441 exit(1);
442 } else if (Rejuvenate) {
443 printf(gettext("Can't find Job %s; Not rejuvenated\n"), Jobid);
444 exit(1);
445 }
446
447 /* Make sure the overflow entry is null since it may be incorrect */
448 M[UUSTAT_TBL].mach[0] = NULLCHAR;
449 if (Summary) {
450 for((sortcnt = 0, m = &M[0]);*(m->mach) != NULL;(sortcnt++,m++))
451 ;
452 qsort((char *)M, (unsigned int)sortcnt, sizeof(struct m), machcmp);
453 for (m = M; m->mach[0] != NULLCHAR; m++)
454 printit(m);
455 }
456 return (0);
457 }
458
459
460 /*
461 * uprocessC - get information about C. file
462 *
463 */
464
465 void
466 uprocessC(machine, dir, file)
467 char *machine, *dir, *file;
468 {
469 struct stat s;
470 struct tm *tp;
471 char fullname[MAXFULLNAME], buf[BUFSIZ], user[9];
472 char xfullname[MAXFULLNAME];
473 char file1[BUFSIZ], file2[BUFSIZ], file3[BUFSIZ], type[2], opt[256];
474 short goodRecord = 0;
475 FILE *fp, *xfp;
476 short first = 1;
477 int statefound = 0;
478 extern long fsize();
479 char format_tmp[BUFSIZ+1];
480 fp=xfp=NULL;
481
482 /*********************************************/
483 /* initialize output buffer to blanks */
484 /*********************************************/
485
486 if (Complete && !Queued && !Running && !Interrupted)
487 return;
488 outbuf[0] = NULLCHAR;
489
490 DEBUG(9, "uprocessC(%s, ", dir);
491 DEBUG(9, "%s);\n", file);
492
493 if (Jobid[0] != '\0' && (!EQUALS(Jobid, &file[2])) ) {
494 /* kill job - not this one */
495 return;
496 }
497
498 (void) sprintf(fullname, "%s/%s", dir, file);
499 if (stat(fullname, &s) != 0) {
500 /* error - can't stat */
501 DEBUG(4, "Can't stat file (%s),", fullname);
502 DEBUG(4, " errno (%d) -- skip it!\n", errno);
503 }
504
505 fp = fopen(fullname, "r");
506 if (fp == NULL) {
507 DEBUG(4, "Can't open file (%s), ", fullname);
508 DEBUG(4, "errno=%d -- skip it!\n", errno);
509 return;
510 }
511 tp = localtime(&s.st_mtime);
512
513 if (s.st_size == 0 && User[0] == '\0') { /* dummy D. for polling */
514 sprintf(format_tmp,"%-12s %2.2d/%2.2d-%2.2d:%2.2d:%2.2d (POLL)\n",
515 &file[2], tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
516 tp->tm_min, tp->tm_sec);
517 (void) strcat(outbuf, format_tmp);
518 }
519 else while (fgets(buf, BUFSIZ, fp) != NULL) {
520 if (sscanf(buf,"%s%s%s%s%s%s", type, file1, file2,
521 user, opt, file3) <5) {
522 DEBUG(4, "short line (%s)\n", buf);
523 continue;
524 }
525 DEBUG(9, "type (%s), ", type);
526 DEBUG(9, "file1 (%s)", file1);
527 DEBUG(9, "file2 (%s)", file2);
528 DEBUG(9, "file3 (%s)", file3);
529 DEBUG(9, "user (%s)", user);
530
531 goodRecord = 0;
532
533 if (User[0] != '\0' && (!EQUALS(User, user)) )
534 continue;
535
536
537 if (first)
538 {
539 sprintf(format_tmp,"%-12s", &file[2]);
540 (void) strcat(outbuf, format_tmp);
541
542 /* if the job state is requested call the
543 state function to determine this job's state */
544
545 if (State)
546 {
547 statefound = state(dir, file);
548 DEBUG(9, "uprocessC: statefound value = %d\n", statefound);
549 if ((whattodo(statefound) != TRUE))
550 {
551 outbuf[0] = NULLCHAR;
552 return;
553 }
554 else
555 {
556 if (statefound == 1)
557 (void) strcat(outbuf, "queued");
558 else if (statefound == 2)
559 (void) strcat(outbuf, "running");
560 else if (statefound == 3)
561 (void) strcat(outbuf, "interrupted");
562 }
563 }
564 sprintf(format_tmp, " %2.2d/%2.2d-%2.2d:%2.2d ",
565 tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
566 tp->tm_min);
567 (void) strcat(outbuf, format_tmp);
568 }
569 else
570 {
571 sprintf(format_tmp,"%-12s %2.2d/%2.2d-%2.2d:%2.2d ",
572 "", tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
573 tp->tm_min);
574 (void) strcat(outbuf, format_tmp);
575 }
576 first = 0;
577
578 sprintf(format_tmp,"%s %s ", type, machine);
579 (void) strcat(outbuf, format_tmp);
580 if (*type == 'R')
581 {
582 sprintf(format_tmp,"%s %s ", user, file1);
583 (void) strcat(outbuf, format_tmp);
584 }
585 else if (file2[0] != 'X')
586 {
587 sprintf(format_tmp,"%s %ld %s ", user, fsize(dir, file3, file1), file1);
588 (void) strcat(outbuf, format_tmp);
589 }
590 else if (*type == 'S' && file2[0] == 'X') {
591 (void) sprintf(xfullname, "%s/%s", dir, file1);
592 xfp = fopen(xfullname, "r");
593 if (xfp == NULL) { /* program error */
594 DEBUG(4, "Can't read %s, ", xfullname);
595 DEBUG(4, "errno=%d -- skip it!\n", errno);
596 sprintf(format_tmp,"%s ", user);
597 (void) strcat(outbuf, format_tmp);
598 (void) strcat(outbuf,"????\n");
599 }
600 else {
601 char command[BUFSIZ], uline_u[BUFSIZ], uline_m[BUFSIZ];
602 char retaddr[BUFSIZ], *username;
603
604 *retaddr = *uline_u = *uline_m = '\0';
605 while (fgets(buf, BUFSIZ, xfp) != NULL) {
606 switch(buf[0]) {
607 case 'C':
608 strcpy(command, buf + 2);
609 break;
610 case 'U':
611 sscanf(buf + 2, "%s%s", uline_u, uline_m);
612 break;
613 case 'R':
614 sscanf(buf+2, "%s", retaddr);
615 break;
616 }
617 }
618 username = user;
619 if (*uline_u != '\0')
620 username = uline_u;
621 if (*retaddr != '\0')
622 username = retaddr;
623 if (!EQUALS(uline_m, Myname))
624 printf("%s!", uline_m);
625 sprintf(format_tmp,"%s %s", username, command);
626 (void) strcat(outbuf, format_tmp);
627 }
628 }
629 strcat(outbuf, "\n");
630 fputs(outbuf, stdout);
631 outbuf[0] = NULLCHAR;
632 goodRecord = 1;
633 } /* end of while more data in buffer */
634
635 /* successful processing of a job, increment job count
636 counter */
637 if (goodRecord)
638 jobcount++;
639
640 if (xfp != NULL)
641 fclose(xfp);
642
643 fclose(fp);
644 return;
645 }
646 /*
647 * whattodo - determine what to do with current C dot file
648 * depending on any combination (2**3 - 1) of input
649 * job states
650 */
651 static int
652 whattodo(inputint)
653 int inputint;
654 {
655 /* Maybe some commentary here will help explain this truth
656 table.
657
658 Queued |Running |Interrupted
659 -------------------------------------------------
660 X | |
661 -------------------------------------------------
662 | X |
663 -------------------------------------------------
664 | | X
665 -------------------------------------------------
666 X | X |
667 -------------------------------------------------
668 | X | X
669 -------------------------------------------------
670 X | | X
671 -------------------------------------------------
672 X | X | X
673 -------------------------------------------------
674
675 Now do you understand. All possible combinations have to
676 be evaluated to determine whether or not to print the C dot
677 information out or not! Well, all but 000, because if neither
678 of these states are input by the user we would not be
679 examing the C dot file anyway!
680 */
681
682 if (Queued && Running && Interrupted)
683 return(TRUE);
684 else if ((Queued && !Running && !Interrupted) && (inputint == 1))
685 return(TRUE);
686 else if ((Running && !Queued && !Interrupted) && (inputint == 2)) return(TRUE);
687 else if ((Interrupted && !Queued && !Running) && (inputint == 3)) return(TRUE);
688 else if ((Queued && Running && !Interrupted) &&
689 (inputint == 1 || inputint == 2))
690 return(TRUE);
691 else if ((!Queued && Running && Interrupted) &&
692 (inputint == 2 || inputint == 3))
693 return(TRUE);
694 else if ((Queued && !Running && Interrupted) &&
695 (inputint ==1 || inputint == 3))
696 return(TRUE);
697 else return(FALSE);
698 }
699 /*
700 * kprocessC - process kill or rejuvenate job
701 */
702
703 static void
704 kprocessC(dir, file)
705 char *file, *dir;
706 {
707 struct stat s;
708 struct tm *tp;
709 extern struct tm *localtime();
710 char fullname[MAXFULLNAME], buf[BUFSIZ], user[9];
711 char rfullname[MAXFULLNAME];
712 char file1[BUFSIZ], file2[BUFSIZ], file3[BUFSIZ], type[2], opt[256];
713 FILE *fp, *xfp;
714 struct utimbuf times;
715 short ret;
716 short first = 1;
717
718 DEBUG(9, "kprocessC(%s, ", dir);
719 DEBUG(9, "%s);\n", file);
720
721 if ((!EQUALS(Jobid, &file[2])) ) {
722 /* kill job - not this one */
723 return;
724 }
725
726 (void) sprintf(fullname, "%s/%s", dir, file);
727 if (stat(fullname, &s) != 0) {
728 /* error - can't stat */
729 if(Kill) {
730 fprintf(stderr,
731 gettext("Can't stat:%s, errno (%d)--can't kill it!\n"),
732 fullname, errno);
733 } else {
734 fprintf(stderr,
735 gettext("Can't stat:%s, errno (%d)--can't rejuvenate it!\n"),
736 fullname, errno);
737 }
738 exit(1);
739 }
740
741 fp = fopen(fullname, "r");
742 if (fp == NULL) {
743 if(Kill) {
744 fprintf(stderr,
745 gettext("Can't read:%s, errno (%d)--can't kill it!\n"),
746 fullname, errno);
747 } else {
748 fprintf(stderr,
749 gettext("Can't read:%s, errno (%d)--can't rejuvenate it!\n"),
750 fullname, errno);
751 }
752 exit(1);
753 }
754
755 times.actime = times.modtime = time((time_t *)NULL);
756
757 while (fgets(buf, BUFSIZ, fp) != NULL) {
758 if (sscanf(buf,"%s%s%s%s%s%s", type, file1, file2,
759 user, opt, file3) <6) {
760 if(Kill) {
761 fprintf(stderr,
762 gettext("Bad format:%s, errno (%d)--can't kill it!\n"),
763 fullname, errno);
764 } else {
765 fprintf(stderr,
766 gettext("Bad format:%s, errno (%d)--can't rejuvenate it!\n"),
767 fullname, errno);
768 }
769 exit(1);
770 }
771
772 DEBUG(9, "buf in uprocessK = %s\n ", buf);
773 DEBUG(9, "fullname is %s\n",fullname);
774 DEBUG(9, "type (%s), ", type);
775 DEBUG(9, "file1 (%s)", file1);
776 DEBUG(9, "file2 (%s)", file2);
777 DEBUG(9, "file3 (%s)", file3);
778 DEBUG(9, "user (%s)", user);
779
780
781 if (first) {
782 if ((access(fullname, 02) != 0)
783 && !PREFIX(Loginuser, user)
784 && !PREFIX(user, Loginuser) ) {
785 /* not allowed - not owner or root */
786 if(Kill)
787 fprintf(stderr, gettext("Not owner,"
788 " uucp or root - can't kill job %s\n"), Jobid);
789 else
790 fprintf(stderr, gettext("Not owner, uucp or root -"
791 " can't rejuvenate job %s\n"), Jobid);
792 exit(1);
793 }
794 first = 0;
795 }
796
797 /* remove D. file */
798 (void) sprintf(rfullname, "%s/%s", dir, file3);
799 DEBUG(4, "Remove %s\n", rfullname);
800 if (Kill)
801 ret = unlink(rfullname);
802 else /* Rejuvenate */
803 ret = utime(rfullname, ×);
804 if (ret != 0 && errno != ENOENT) {
805 /* program error?? */
806 if(Kill)
807 fprintf(stderr, gettext("Error: Can't kill,"
808 " File (%s), errno (%d)\n"), rfullname, errno);
809 else
810 fprintf(stderr, gettext("Error: Can't rejuvenated,"
811 " File (%s), errno (%d)\n"), rfullname, errno);
812 exit(1);
813 }
814 }
815
816 DEBUG(4, "Remove %s\n", fullname);
817 if (Kill)
818 ret = unlink(fullname);
819 else /* Rejuvenate */
820 ret = utime(fullname, ×);
821
822 if (ret != 0) {
823 /* program error?? */
824 if(Kill)
825 fprintf(stderr, gettext("Error1: Can't kill,"
826 " File (%s), errno (%d)\n"), fullname, errno);
827 else
828 fprintf(stderr, gettext("Error1: Can't rejuvenate,"
829 " File (%s), errno (%d)\n"), fullname, errno);
830 exit(1);
831 }
832 /* if kill done by SA then send user mail */
833 else if (!EQUALS(Loginuser, user))
834 {
835 sprintf(mailmsg, "%s %s", KILLMSG, Jobid);
836 mailst(user, "job killed", mailmsg, "", "");
837 }
838 fclose(fp);
839 if (!nonotf) {
840 if(Kill)
841 printf(gettext("Job: %s successfully killed\n"), Jobid);
842 else
843 printf(gettext("Job: %s successfully rejuvenated\n"),
844 Jobid);
845 }
846 exit(0);
847 }
848
849 /*
850 * fsize - return the size of f1 or f2 (if f1 does not exist)
851 * f1 is the local name
852 *
853 */
854
855 long
856 fsize(dir, f1, f2)
857 char *dir, *f1, *f2;
858 {
859 struct stat s;
860 char fullname[BUFSIZ];
861
862 (void) sprintf(fullname, "%s/%s", dir, f1);
863 if (stat(fullname, &s) == 0) {
864 return(s.st_size);
865 }
866 if (stat(f2, &s) == 0) {
867 return(s.st_size);
868 }
869
870 return(-99999);
871 }
872
873 void cleanup(){}
874 void logent(){} /* to load ulockf.c */
875 void systat(){} /* to load utility.c */
876
877 struct m *
878 machine(name)
879 char *name;
880 {
881 struct m *m;
882 size_t namelen;
883
884 DEBUG(9, "machine(%s), ", name);
885 namelen = strlen(name);
886 for (m = M; m->mach[0] != NULLCHAR; m++)
887 /* match on overlap? */
888 if (EQUALSN(name, m->mach, MAXBASENAME)) {
889 /* use longest name */
890 if (namelen > strlen(m->mach))
891 (void) strcpy(m->mach, name);
892 return(m);
893 }
894
895 /*
896 * The table is set up with 2 extra entries
897 * When we go over by one, output error to errors log
898 * When more than one over, just reuse the previous entry
899 */
900 DEBUG(9, "m-M=%d\n", m-M);
901 if (m-M >= UUSTAT_TBL) {
902 if (m-M == UUSTAT_TBL) {
903 errent("MACHINE TABLE FULL", "", UUSTAT_TBL,
904 __FILE__, __LINE__);
905 (void) fprintf(stderr,
906 gettext("WARNING: Table Overflow--output not complete\n"));
907 }
908 else
909 /* use the last entry - overwrite it */
910 m = &M[UUSTAT_TBL];
911 }
912
913 (void) strcpy(m->mach, name);
914 m->c_age= m->x_age= m->lasttime= m->locked= m->ccount= m->xcount= 0;
915 m->stst[0] = '\0';
916 return(m);
917 }
918
919 void
920 printit(m)
921 struct m *m;
922 {
923 struct tm *tp;
924 time_t t;
925 int minimum;
926 extern struct tm *localtime();
927
928 if (m->ccount == 0
929 && m->xcount == 0
930 /*&& m->stst[0] == '\0'*/
931 && m->locked == 0
932 && Queue
933 && m->type == 0)
934 return;
935 printf("%-10s", m->mach);
936 if (Queue) {
937 if (m->ccount)
938 printf("%3dC", m->ccount);
939 else
940 printf(" ");
941 if (m->c_age)
942 printf("(%d)", m->c_age);
943 else
944 printf(" ");
945 if (m->xcount)
946 printf("%3dX", m->xcount);
947 else
948 printf(" ");
949 if (m->x_age)
950 printf("(%d) ", m->x_age);
951 else
952 printf(" ");
953 } else
954 printf(" ");
955
956 if (m->lasttime) {
957 tp = localtime(&m->lasttime);
958 printf("%2.2d/%2.2d-%2.2d:%2.2d ",
959 tp->tm_mon + 1, tp->tm_mday, tp->tm_hour,
960 tp->tm_min);
961 }
962 /* if (m->locked && m->type != SS_INPROGRESS) */
963 if (m->locked)
964 printf("Locked ");
965 if (m->stst[0] != '\0') {
966 printf("%s", m->stst);
967 switch (m->type) {
968 case SS_SEQBAD:
969 case SS_LOGIN_FAILED:
970 case SS_DIAL_FAILED:
971 case SS_BAD_LOG_MCH:
972 case SS_BADSYSTEM:
973 case SS_CANT_ACCESS_DEVICE:
974 case SS_DEVICE_FAILED:
975 case SS_WRONG_MCH:
976 case SS_RLOCKED:
977 case SS_RUNKNOWN:
978 case SS_RLOGIN:
979 case SS_UNKNOWN_RESPONSE:
980 case SS_STARTUP:
981 case SS_CHAT_FAILED:
982 (void) time(&t);
983 t = m->retrytime - (t - m->lasttime);
984 if (t > 0) {
985 minimum = (t + 59) / 60;
986 printf("Retry: %d:%2.2d", minimum/60, minimum%60);
987 }
988 if (m->count > 1)
989 printf(" Count: %d", m->count);
990 }
991 }
992 putchar('\n');
993 return;
994 }
995
996 #define MAXLOCKS 100 /* Maximum number of lock files this will handle */
997
998 int
999 lckpid()
1000 {
1001 int i;
1002 int fd, ret;
1003 pid_t pid, list[MAXLOCKS];
1004 char alpid[SIZEOFPID+2]; /* +2 for '\n' and null */
1005 char buf[BUFSIZ], f[MAXNAMESIZE];
1006 char *c, lckdir[BUFSIZ];
1007 DIR *dir;
1008
1009 DEBUG(9, "lckpid() - entered\n%s", "");
1010 for (i=0; i<MAXLOCKS; i++)
1011 list[i] = -1;
1012 (void) strcpy(lckdir, LOCKPRE);
1013 *strrchr(lckdir, '/') = '\0';
1014 DEBUG(9, "lockdir (%s)\n", lckdir);
1015
1016 /* open lock directory */
1017 if (chdir(lckdir) != 0 || (dir = opendir(lckdir)) == NULL)
1018 exit(101); /* good old code 101 */
1019 while (gnameflck(dir, f) == TRUE) {
1020 /* find all lock files */
1021 DEBUG(9, "f (%s)\n", f);
1022 if (EQUALSN("LCK.", f, 4) || EQUALSN("LK.", f, 3)) {
1023 /* read LCK file */
1024 fd = open(f, O_RDONLY);
1025 printf("%s: ", f);
1026 ret = read(fd, alpid, SIZEOFPID+2); /* +2 for '\n' and null */
1027 pid = strtol(alpid, (char **) NULL, 10);
1028 (void) close(fd);
1029 if (ret != -1) {
1030 printf("%ld\n", (long) pid);
1031 for(i=0; i<MAXLOCKS; i++) {
1032 if (list[i] == pid)
1033 break;
1034 if (list[i] == -1) {
1035 list[i] = pid;
1036 break;
1037 }
1038 }
1039 }
1040 else
1041 printf("????\n");
1042 }
1043 }
1044 fflush(stdout);
1045 *buf = NULLCHAR;
1046 for (i=0; i<MAXLOCKS; i++) {
1047 if( list[i] == -1)
1048 break;
1049 (void) sprintf(&buf[strlen(buf)], "%d ", list[i]);
1050 }
1051
1052 if (i > 0)
1053 #ifdef V7
1054 execl("/bin/ps", "uustat-ps", buf, (char *) 0);
1055 #else
1056 execl("/usr/bin/ps", "ps", "-flp", buf, (char *) 0);
1057 #endif
1058 exit(0);
1059 }
1060
1061 /*
1062 * get next file name from lock directory
1063 * p -> file description of directory file to read
1064 * filename -> address of buffer to return filename in
1065 * must be of size NAMESIZE
1066 * returns:
1067 * FALSE -> end of directory read
1068 * TRUE -> returned name
1069 */
1070 static int
1071 gnameflck(p, filename)
1072 char *filename;
1073 DIR *p;
1074 {
1075 struct dirent dentry;
1076 struct dirent *dp = &dentry;
1077
1078 for (;;) {
1079 if ((dp = readdir(p)) == NULL)
1080 return(FALSE);
1081 if (dp->d_ino != 0 && dp->d_name[0] != '.')
1082 break;
1083 }
1084
1085 (void) strncpy(filename, dp->d_name, MAXNAMESIZE-1);
1086 filename[MAXNAMESIZE-1] = '\0';
1087 return(TRUE);
1088 }
1089
1090 int
1091 machcmp(a,b)
1092 char *a,*b;
1093 {
1094 return(strcmp(((struct m *) a)->mach,((struct m *) b)->mach));
1095 }
1096
1097 static long _sec_per_day = 86400L;
1098
1099 /*
1100 * _age - find the age of "file" in days
1101 * return:
1102 * age of file
1103 * 0 - if stat fails
1104 */
1105
1106 int
1107 _age(dir, file)
1108 char * file; /* the file name */
1109 char * dir; /* system spool directory */
1110 {
1111 char fullname[MAXFULLNAME];
1112 static time_t ptime = 0;
1113 time_t time();
1114 struct stat stbuf;
1115
1116 if (!ptime)
1117 (void) time(&ptime);
1118 (void) sprintf(fullname, "%s/%s", dir, file);
1119 if (stat(fullname, &stbuf) != -1) {
1120 return ((int)((ptime - stbuf.st_mtime)/_sec_per_day));
1121 }
1122 else
1123 return(0);
1124 }
1125 /* Function: complete - find and print jobids of completed jobs for
1126 * user.
1127 *
1128 * Look thru the /var/uucp/.Admin/account file (if present)
1129 * for all jobs initiated by user and print.
1130 *
1131 * Parameters:
1132 *
1133 * Username - user that initiated uustat request
1134 *
1135 * Returns:
1136 *
1137 */
1138 static void
1139 complete()
1140 {
1141
1142 /* Function name: complete
1143 Author: Roland T. Conwell
1144 Date: July 31, 1986
1145 Naration: This function will search through
1146 /var/uucp/.Admin/account file
1147 for all jobs submitted by User. If User jobs are
1148 found the state of 'completed' will be
1149 printed on stdout. Module called by uustat main
1150
1151 */
1152 char abuf[BUFSIZ];
1153 FILE *fp;
1154 char accno[15], jobid[15], system[15], loginame[15], time[20], dest[15];
1155 char size[15];
1156 char grade[2], jgrade[2];
1157 char status[2];
1158 int x;
1159
1160 fp = fopen(ACCOUNT, "r");
1161 if (fp == NULL)
1162 {
1163 fprintf(stderr, gettext("Can't open account log\n"));
1164 return;
1165 }
1166 while (fgets(abuf, BUFSIZ, fp) != NULL)
1167 {
1168
1169 x = sscanf(abuf, "%s%s%s%s%s%s%s%s%s%s",
1170 accno,jobid, size, status, grade, jgrade, system, loginame,
1171 time, dest);
1172 if (x < 6)
1173 continue;
1174
1175 if (!EQUALS(status, "C"))
1176 continue;
1177
1178 DEBUG(9, "COMPLETE: accno = %s\n", accno);
1179 DEBUG(9, "COMPLETE: jobid = %s\n", jobid);
1180 DEBUG(9, "COMPLETE: size = %s\n", size);
1181 DEBUG(9, "COMPLETE: status = %s\n", status);
1182 DEBUG(9, "COMPLETE: grade = %s\n", grade);
1183 DEBUG(9, "COMPLETE: jgrade = %s\n", jgrade);
1184 DEBUG(9, "COMPLETE: system = %s\n", system);
1185 DEBUG(9, "COMPLETE: loginame = %s\n", loginame);
1186 DEBUG(9, "COMPLETE: time = %s\n", time);
1187 DEBUG(9, "COMPLETE: dest = %s\n", dest);
1188
1189 if (*Rmtname && !EQUALS(Rmtname, dest))
1190 continue;
1191 if (*User && !EQUALS(User, loginame))
1192 continue;
1193 if (State && !Uopt)
1194 {
1195 if (EQUALS(Loginuser, loginame))
1196 {
1197 printf("%s completed\n",jobid);
1198 jobcount++;
1199 }
1200 }
1201 else
1202 {
1203 printf("%s completed\n", jobid);
1204 jobcount++;
1205 }
1206 }
1207 fclose(fp);
1208 return;
1209 }
1210
1211 /* Function: state - determine if Cdotfile is queued or running
1212 *
1213 * This function searches thru the directory jcdir for a Adotfile
1214 * that matches the Cdotfile. If found then look for a matching
1215 * lock file. If a Adotfile and a lock file is found then the
1216 * job is in the running state. If no Adotfile is found then the
1217 * job is in the queued state. If a Adotfile is found and no
1218 * lock file is found then the job is queued.
1219 *
1220 * Parameters:
1221 *
1222 * jcdir - the job grade directory to search
1223 * cdotfile - the Cdotfile whose state is to be determined
1224 *
1225 * Returns:
1226 *
1227 */
1228 static int
1229 state(jcdir, cdotfile)
1230 char *jcdir, *cdotfile;
1231 {
1232 short found, foundlck, CequalA;
1233 char comparef[MAXBASENAME+1], afile[MAXBASENAME+1], cfile[MAXBASENAME+1];
1234 char lckfile[MAXBASENAME+1], lockname[MAXBASENAME+1];
1235 char lckdir[BUFSIZ+1];
1236 DIR *subjcdir, *sjcdir;
1237 int rtnstate = 0;
1238 foundlck = 0;
1239 CequalA = 0;
1240 sjcdir = opendir(jcdir);
1241 if (sjcdir == NULL)
1242 return (0);
1243
1244 while (gnamef(sjcdir, comparef) == TRUE) {
1245 if (comparef[0] == 'A') {
1246
1247 (void) strcpy(afile, comparef);
1248 *strchr(afile, 'A') = ' ';
1249 (void) strcpy(cfile, cdotfile);
1250 *strchr(cfile, 'C') = ' ';
1251
1252 if (EQUALS(cfile, afile)) {
1253 /* now we have a C. and A. for same job */
1254 /* check for LCK..machine.job_grade */
1255 /* if no LCK file at this point we will */
1256 /* print the RUNNING state */
1257 CequalA = 1;
1258
1259 (void) strcpy(lckdir, LOCKPRE);
1260 *strrchr(lckdir, '/') = '\0';
1261 /* open lock directory */
1262
1263 subjcdir = opendir(lckdir);
1264 if (subjcdir == NULL)
1265 exit(101); /* I know, I know! */
1266 (void) sprintf(lockname,"%s%s.%s",LOCK, f, jcdir);
1267 while (gnamef(subjcdir, lckfile) == TRUE)
1268 {
1269 DEBUG(9, "STATE: lockfile = %s\n",lckfile);
1270 if (EQUALS(lockname, lckfile))
1271 foundlck = 1;
1272 }
1273 closedir(subjcdir);
1274
1275 }
1276 }
1277
1278 }
1279
1280 closedir(sjcdir);
1281 /* got adot, cdot and lock file */
1282
1283 if (Running && foundlck)
1284 rtnstate = 2;
1285 else if (Interrupted && CequalA && !foundlck)
1286 rtnstate = 3;
1287 else if (Queued && !CequalA && !foundlck)
1288 rtnstate = 1;
1289 DEBUG(9, "STATE: returning with value %d\n",rtnstate);
1290 return(rtnstate);
1291
1292 } /* end of state.c */
1293
1294
1295
1296 static int
1297 readperf(timerange)
1298 long timerange;
1299 {
1300
1301 char proto[2], jc[2], role[2];
1302 char rectype[5], time[MAXDATE+1], pid[10],wmachine[10];
1303 char remote[10],device[10], netid[20], jobid[20];
1304 static float queuetime, tat;
1305 static long size;
1306 struct tm tm_tmp;
1307 time_t t_time, t_starttime, t_upperlimit;
1308
1309 char options[10];
1310 static float rst, ust, kst, xferrate, utt, ktt;
1311 static float rtt, wfield, xfield, yfield;
1312
1313 struct perfrec *recptr;
1314 static float tqt;
1315 static int jobs;
1316 char abuf[BUFSIZ];
1317 FILE *fp;
1318 static int x;
1319 char *strptr, *startime;
1320 int recordcnt;
1321
1322 totalxfer=totalbytes=recordcnt=totaljob=totalque=0;
1323 lowerlimit[0] = '\0';
1324 upperlimit[0] = '\0';
1325
1326
1327 inputsecs = convert(timerange);
1328 startime = gmts();
1329 strncpy(lowerlimit, startime, MAXDATE);
1330 strncpy(upperlimit, gmt(), MAXDATE);
1331
1332 /* convert lowerlimit and upperlimit to HH:MM format */
1333 friendlytime(lowerlimit, upperlimit);
1334
1335 fp = fopen(PERFLOG, "r");
1336 if (fp == NULL)
1337 {
1338 (void) fprintf(stderr, gettext("Can't open performance log\n"));
1339 return(0);
1340 }
1341
1342
1343 while (fgets(abuf, BUFSIZ, fp) != NULL)
1344 {
1345 DEBUG(9, "READPERF: abuf before = %s\n",abuf);
1346
1347 if (!EQUALSN(abuf, "xfer", 4))
1348 continue;
1349
1350 /* convert all '|'s to blanks for sscanf */
1351 for (strptr = abuf; *strptr != '\0'; strptr++)
1352 if (*strptr == '|')
1353 *strptr = ' ';
1354 DEBUG(9, "READPERF: abuf = %s\n",abuf);
1355
1356 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",
1357 rectype, time, pid, wmachine, role, remote, device, netid,
1358 jobid, &queuetime, &tat, &size, options, &rst,
1359 &ust, &kst, &xferrate, &utt, &ktt, &rtt, &wfield,
1360 &xfield);
1361
1362 DEBUG(9, "READPERF: rectype = %s\n",rectype);
1363 DEBUG(9, "READPERF: time = %s\n",time);
1364 DEBUG(9, "READPERF: pid = %s\n",pid);
1365 DEBUG(9, "READPERF: remote = %s\n",remote);
1366 DEBUG(9, "READPERF: jobid = %s\n",jobid);
1367 DEBUG(9, "READPERF: queuetime = %f\n",queuetime);
1368 DEBUG(9, "READPERF: tat = %f\n",tat);
1369 DEBUG(9, "READPERF: xferrate = %f\n",xferrate);
1370
1371 abuf[0] = '\0';
1372
1373 if (!EQUALS(Rmtname, remote))
1374 continue;
1375
1376 if (!EQUALS(role, "M"))
1377 continue;
1378
1379 if (x < 18)
1380 continue;
1381
1382 DEBUG(9, "READPERF: startime = %s\n", startime);
1383 DEBUG(9, "READPERF: lowerlimit = %s\n", lowerlimit);
1384 DEBUG(9, "READPERF: time = %s\n", time);
1385 DEBUG(9, "READPERF: upperlimit = %s\n", upperlimit);
1386
1387 strptime(time, "%y %m %d %H %M %S", &tm_tmp);
1388 t_time = mktime(&tm_tmp);
1389 strptime(startime, "%y %m %d %H %M %S", &tm_tmp);
1390 t_starttime = mktime(&tm_tmp);
1391 strptime(upperlimit, "%y %m %d %H %M %S", &tm_tmp);
1392 t_upperlimit = mktime(&tm_tmp);
1393
1394 DEBUG(9, "READPERF: t_time = %d\n", t_time);
1395 DEBUG(9, "READPERF: t_starttime = %d\n", t_starttime);
1396 DEBUG(9, "READPERF: t_upperlimit = %d\n", t_upperlimit);
1397 if (t_starttime <= t_time && t_upperlimit >= t_time)
1398 {
1399 totaljob++;
1400 totalque = totalque + queuetime;
1401 totalxfer = totalxfer + xferrate;
1402 totalbytes = totalbytes + size;
1403 recordcnt = recordcnt + 1;
1404 DEBUG(9, " processing recordcnt %d\n", recordcnt);
1405 }
1406 DEBUG(9, "END step 1 %d\n", recordcnt);
1407 } /* while */
1408 DEBUG(9, "END step 2 recordcnt %d\n", recordcnt);
1409
1410 fclose(fp);
1411 return(recordcnt);
1412
1413
1414 } /* end of readperf */
1415
1416 void
1417 docalc()
1418 {
1419 if (avgqueue)
1420 queuetime();
1421 else
1422 xfertime();
1423 return;
1424 }
1425
1426 static int
1427 convert(intime)
1428 long intime;
1429 {
1430 long outtime;
1431
1432 outtime = intime * 60;
1433 return(outtime);
1434
1435 }
1436 static void
1437 queuetime()
1438 {
1439 static double avgqtime;
1440
1441 avgqtime = totalque / totaljob;
1442
1443 printf("average queue time to [%s] for last [%ld] minutes: %6.2f seconds\n",Rmtname, calcnum, avgqtime);
1444 printf("data gathered from %s:%s to %s:%s GMT\n", friendlyptr->uhour, friendlyptr->umin, friendlyptr->lhour, friendlyptr->lmin);
1445 return;
1446 }
1447
1448
1449 static void
1450 xfertime()
1451 {
1452 static double avgxrate;
1453
1454 avgxrate = totalbytes / totalxfer;
1455
1456 printf("average transfer rate with [ %s ] for last [%ld] minutes: %6.2f bytes/sec\n", Rmtname, calcnum, avgxrate);
1457 printf("data gathered from %s:%s to %s:%s GMT\n", friendlyptr->uhour, friendlyptr->umin, friendlyptr->lhour, friendlyptr->lmin);
1458 return;
1459 }
1460
1461 /*
1462 * Local Function: gmts - Generate Start Time String
1463 *
1464 * This function returns the address to a string containing the start
1465 * time, or upperlimit, for searching the PERFLOG.
1466 * The start time is in GMT in the form YYMMDDhhmmss.
1467 *
1468 * Parameters:
1469 *
1470 * none
1471 *
1472 * Return:
1473 *
1474 * An address of a static character array containing the date.
1475 */
1476
1477 static char *
1478 gmts()
1479 {
1480 static char date[] = "YYMMDDhhmmss";
1481
1482 struct tm *td;
1483 time_t now; /* Current time. */
1484 time_t temp;
1485 now = time((time_t *) 0);
1486
1487 /* inputsecs is declared global to this file */
1488 DEBUG(9, "GMTS: now = %ld\n", now);
1489 DEBUG(9, "GMTS: inputsecs = %ld\n", inputsecs);
1490
1491 temp = (now - inputsecs);
1492 td = gmtime(&temp);
1493 (void) sprintf(date, "%02d%02d%02d%02d%02d%02d",
1494 (td->tm_year % 100),
1495 td->tm_mon + 1,
1496 td->tm_mday,
1497 td->tm_hour,
1498 td->tm_min,
1499 td->tm_sec
1500 );
1501 return date;
1502 }
1503
1504 /*
1505 * Local Function: gmt - Generate Current Time String
1506 *
1507 * This function returns the address to a string containing the current
1508 * GMT in the form YYMMDDhhmmss.
1509 *
1510 * Parameters:
1511 *
1512 * none
1513 *
1514 * Return:
1515 *
1516 * An address of a static character array containing the date.
1517 */
1518
1519 static char *
1520 gmt()
1521 {
1522 static char date[] = "YYMMDDhhmmss";
1523
1524 struct tm *td;
1525 time_t now; /* Current time. */
1526
1527 now = time((time_t *) 0);
1528 td = gmtime(&now);
1529 (void) sprintf(date, "%02d%02d%02d%02d%02d%02d",
1530 (td->tm_year % 100),
1531 td->tm_mon + 1,
1532 td->tm_mday,
1533 td->tm_hour,
1534 td->tm_min,
1535 td->tm_sec
1536 );
1537 return date;
1538 }
1539
1540 static void
1541 friendlytime(uplimit, lolimit)
1542 char *uplimit, *lolimit;
1543 {
1544
1545 char c;
1546
1547 c = *(uplimit+6);
1548 friendlyptr->uhour[0] = *(uplimit+6);
1549 friendlyptr->uhour[1] = *(uplimit+7);
1550 friendlyptr->lhour[0] = *(lolimit+6);
1551 friendlyptr->lhour[1] = *(lolimit+7);
1552 friendlyptr->umin[0] = *(uplimit+8);
1553 friendlyptr->umin[1] = *(uplimit+9);
1554 friendlyptr->lmin[0] = *(lolimit+8);
1555 friendlyptr->lmin[1] = *(lolimit+9);
1556
1557 friendlyptr->uhour[2] = '\0';
1558 friendlyptr->lhour[2] = '\0';
1559 friendlyptr->umin[2] = '\0';
1560 friendlyptr->lmin[2] = '\0';
1561 return;
1562 }
1563
1564 void
1565 procState(inputargs)
1566 char * inputargs;
1567 {
1568 if (strchr(inputargs, 'q') != NULL)
1569 Queued = 1;
1570 if (strchr(inputargs, 'r') != NULL)
1571 Running = 1;
1572 if (strchr(inputargs, 'i') != NULL)
1573 Interrupted = 1;
1574 if (strchr(inputargs, 'c') != NULL)
1575 Complete = 1;
1576
1577 if ((size_t)(Queued + Running + Interrupted + Complete) < strlen(inputargs))
1578 {
1579 errortn();
1580 exit(1);
1581 }
1582 return;
1583 }
1584
1585 static void
1586 errortn()
1587 {
1588
1589
1590 (void) fprintf(stderr, gettext("\tUsage: %s " USAGE1 "\n"),
1591 Progname);
1592 (void) fprintf(stderr, gettext("or\n\tUsage: %s " USAGE2 "\n"),
1593 Progname);
1594 (void) fprintf(stderr, gettext("or\n\tUsage: %s " USAGE3 "\n"),
1595 Progname);
1596 return;
1597 }