![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sysline.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / sysline|
Return to sysline.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / sysline |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif not lint ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)sysline.c 5.6 (Berkeley) 1/9/86"; ! 15: #endif not lint ! 16: ! 17: /* ! 18: * sysline - system status display on 25th line of terminal ! 19: * j.k.foderaro ! 20: * ! 21: * Prints a variety of information on the special status line of terminals ! 22: * that have a status display capability. Cursor motions, status commands, ! 23: * etc. are gleamed from /etc/termcap. ! 24: * By default, all information is printed, and flags are given on the command ! 25: * line to disable the printing of information. The information and ! 26: * disabling flags are: ! 27: * ! 28: * flag what ! 29: * ----- ---- ! 30: * time of day ! 31: * load average and change in load average in the last 5 mins ! 32: * number of user logged on ! 33: * -p # of processes the users owns which are runnable and the ! 34: * number which are suspended. Processes whose parent is 1 ! 35: * are not counted. ! 36: * -l users who've logged on and off. ! 37: * -m summarize new mail which has arrived ! 38: * ! 39: * <other flags> ! 40: * -r use non reverse video ! 41: * -c turn off 25th line for 5 seconds before redisplaying. ! 42: * -b beep once one the half hour, twice on the hour ! 43: * +N refresh display every N seconds. ! 44: * -i print pid first thing ! 45: * -e do simple print designed for an emacs buffer line ! 46: * -w do the right things for a window ! 47: * -h print hostname between time and load average ! 48: * -D print day/date before time of day ! 49: * -d debug mode - print status line data in human readable format ! 50: * -q quiet mode - don't output diagnostic messages ! 51: * -s print Short (left-justified) line if escapes not allowed ! 52: * -j Print left Justified line regardless ! 53: */ ! 54: ! 55: #define BSD4_2 /* for 4.2 BSD */ ! 56: #define WHO /* turn this on always */ ! 57: #define HOSTNAME /* 4.1a or greater, with hostname() */ ! 58: #define RWHO /* 4.1a or greater, with rwho */ ! 59: #define VMUNIX /* turn this on if you are running on vmunix */ ! 60: #define NEW_BOOTTIME /* 4.1c or greater */ ! 61: ! 62: #define NETPREFIX "ucb" ! 63: #define DEFDELAY 60 /* update status once per minute */ ! 64: #define MAILDIR "/usr/spool/mail" ! 65: /* ! 66: * if MAXLOAD is defined, then if the load average exceeded MAXLOAD ! 67: * then the process table will not be scanned and the log in/out data ! 68: * will not be checked. The purpose of this is to reduced the load ! 69: * on the system when it is loaded. ! 70: */ ! 71: #define MAXLOAD 6.0 ! 72: ! 73: #include <stdio.h> ! 74: #include <sys/param.h> ! 75: #include <sys/signal.h> ! 76: #include <utmp.h> ! 77: #include <ctype.h> ! 78: #ifndef BSD4_2 ! 79: #include <unctrl.h> ! 80: #endif ! 81: #include <sys/time.h> ! 82: #include <sys/stat.h> ! 83: #ifdef VMUNIX ! 84: #include <nlist.h> ! 85: #include <sys/vtimes.h> ! 86: #include <sys/proc.h> ! 87: #endif ! 88: #ifdef pdp11 ! 89: #include <a.out.h> ! 90: #include <sys/proc.h> ! 91: #endif ! 92: #include <curses.h> ! 93: #undef nl ! 94: #ifdef TERMINFO ! 95: #include <term.h> ! 96: #endif TERMINFO ! 97: ! 98: #ifdef RWHO ! 99: #include <protocols/rwhod.h> ! 100: ! 101: #define DOWN_THRESHOLD (11 * 60) ! 102: #define RWHOLEADER "/usr/spool/rwho/whod." ! 103: ! 104: struct remotehost { ! 105: char *rh_host; ! 106: int rh_file; ! 107: } remotehost[10]; ! 108: int nremotes = 0; ! 109: #endif RWHO ! 110: ! 111: struct nlist nl[] = { ! 112: #ifdef NEW_BOOTTIME ! 113: { "_boottime" }, /* After 4.1a the label changed to "boottime" */ ! 114: #else ! 115: { "_bootime" }, /* Under 4.1a and earlier it is "bootime" */ ! 116: #endif ! 117: #define NL_BOOT 0 ! 118: { "_proc" }, ! 119: #define NL_PROC 1 ! 120: { "_avenrun" }, ! 121: #define NL_AVEN 2 ! 122: #ifdef VMUNIX ! 123: { "_nproc" }, ! 124: #define NL_NPROC 3 ! 125: #endif ! 126: 0 ! 127: }; ! 128: ! 129: /* stuff for the kernel */ ! 130: int kmem; /* file descriptor for /dev/kmem */ ! 131: struct proc *proc, *procNPROC; ! 132: int nproc; ! 133: int procadr; ! 134: double avenrun[3]; /* used for storing load averages */ ! 135: ! 136: /* ! 137: * In order to determine how many people are logged on and who has ! 138: * logged in or out, we read in the /etc/utmp file. We also keep track of ! 139: * the previous utmp file. ! 140: */ ! 141: int ut = -1; /* the file descriptor */ ! 142: struct utmp *new, *old; ! 143: char *status; /* per tty status bits, see below */ ! 144: int nentries; /* number of utmp entries */ ! 145: /* string lengths for printing */ ! 146: #define LINESIZE (sizeof old->ut_line) ! 147: #define NAMESIZE (sizeof old->ut_name) ! 148: /* ! 149: * Status codes to say what has happened to a particular entry in utmp. ! 150: * NOCH means no change, ON means new person logged on, ! 151: * OFF means person logged off. ! 152: */ ! 153: #define NOCH 0 ! 154: #define ON 0x1 ! 155: #define OFF 0x2 ! 156: ! 157: #ifdef WHO ! 158: char whofilename[100]; ! 159: char whofilename2[100]; ! 160: #endif ! 161: ! 162: #ifdef HOSTNAME ! 163: char hostname[MAXHOSTNAMELEN+1]; /* one more for null termination */ ! 164: #endif ! 165: ! 166: char lockfilename[100]; /* if exists, will prevent us from running */ ! 167: ! 168: /* flags which determine which info is printed */ ! 169: int mailcheck = 1; /* m - do biff like checking of mail */ ! 170: int proccheck = 1; /* p - give information on processes */ ! 171: int logcheck = 1; /* l - tell who logs in and out */ ! 172: int hostprint = 0; /* h - print out hostname */ ! 173: int dateprint = 0; /* h - print out day/date */ ! 174: int quiet = 0; /* q - hush diagnostic messages */ ! 175: ! 176: /* flags which determine how things are printed */ ! 177: int clr_bet_ref = 0; /* c - clear line between refeshes */ ! 178: int reverse = 1; /* r - use reverse video */ ! 179: int shortline = 0; /* s - short (left-justified) if escapes not allowed */ ! 180: int leftline = 0; /* j - left-justified even if escapes allowed */ ! 181: ! 182: /* flags which have terminal do random things */ ! 183: int beep = 0; /* b - beep every half hour and twice every hour */ ! 184: int printid = 0; /* i - print pid of this process at startup */ ! 185: int synch = 1; /* synchronize with clock */ ! 186: ! 187: /* select output device (status display or straight output) */ ! 188: int emacs = 0; /* e - assume status display */ ! 189: int window = 0; /* w - window mode */ ! 190: int dbug = 0; /* d - debug */ ! 191: ! 192: /* ! 193: * used to turn off reverse video every REVOFF times ! 194: * in an attempt to not wear out the phospher. ! 195: */ ! 196: #define REVOFF 5 ! 197: int revtime = 1; ! 198: ! 199: /* used by mail checker */ ! 200: off_t mailsize = 0; ! 201: off_t linebeg = 0; /* place where we last left off reading */ ! 202: ! 203: /* things used by the string routines */ ! 204: int chars; /* number of printable characters */ ! 205: char *sp; ! 206: char strarr[512]; /* big enough now? */ ! 207: /* flags to stringdump() */ ! 208: char sawmail; /* remember mail was seen to print bells */ ! 209: char mustclear; /* status line messed up */ ! 210: ! 211: /* strings which control status line display */ ! 212: #ifdef TERMINFO ! 213: char *rev_out, *rev_end, *arrows; ! 214: char *tparm(); ! 215: #else ! 216: char to_status_line[64]; ! 217: char from_status_line[64]; ! 218: char dis_status_line[64]; ! 219: char clr_eol[64]; ! 220: char rev_out[20], rev_end[20]; ! 221: char *arrows, *bell = "\007"; ! 222: int eslok; /* escapes on status line okay (reverse, cursor addressing) */ ! 223: int columns; ! 224: #define tparm(cap, parm) tgoto((cap), 0, (parm)) ! 225: char *tgoto(); ! 226: #endif ! 227: ! 228: /* to deal with window size changes */ ! 229: #ifdef SIGWINCH ! 230: int sigwinch(); ! 231: char winchanged; /* window size has changed since last update */ ! 232: #endif ! 233: ! 234: /* random globals */ ! 235: char *username; ! 236: char *ourtty; /* keep track of what tty we're on */ ! 237: struct stat stbuf, mstbuf; /* mstbuf for mail check only */ ! 238: unsigned delay = DEFDELAY; ! 239: short uid; ! 240: double loadavg = 0.0; /* current load average */ ! 241: int users = 0; ! 242: ! 243: char *getenv(); ! 244: char *ttyname(); ! 245: char *strcpy1(); ! 246: char *sysrup(); ! 247: char *calloc(); ! 248: char *malloc(); ! 249: int outc(); ! 250: int erroutc(); ! 251: ! 252: main(argc,argv) ! 253: register char **argv; ! 254: { ! 255: int clearbotl(); ! 256: register char *cp; ! 257: char *home; ! 258: extern char _sobuf[]; ! 259: extern char *index(); ! 260: ! 261: setbuf(stdout, _sobuf); ! 262: ! 263: #ifdef HOSTNAME ! 264: gethostname(hostname, sizeof hostname - 1); ! 265: if ((cp = index(hostname, '.')) != NULL) ! 266: *cp = '\0'; ! 267: #endif ! 268: ! 269: for (argv++; *argv != 0; argv++) ! 270: switch (**argv) { ! 271: case '-': ! 272: for (cp = *argv + 1; *cp; cp++) { ! 273: switch(*cp) { ! 274: case 'r' : /* turn off reverse video */ ! 275: reverse = 0; ! 276: break; ! 277: case 'c': ! 278: clr_bet_ref = 1; ! 279: break; ! 280: case 'h': ! 281: hostprint = 1; ! 282: break; ! 283: case 'D': ! 284: dateprint = 1; ! 285: break; ! 286: #ifdef RWHO ! 287: case 'H': ! 288: if (argv[1] == 0) ! 289: break; ! 290: argv++; ! 291: if (strcmp(hostname, *argv) && ! 292: strcmp(&hostname[sizeof NETPREFIX - 1], *argv)) ! 293: remotehost[nremotes++].rh_host = *argv; ! 294: break; ! 295: #endif RWHO ! 296: case 'm': ! 297: mailcheck = 0; ! 298: break; ! 299: case 'p': ! 300: proccheck = 0; ! 301: break; ! 302: case 'l': ! 303: logcheck = 0; ! 304: break; ! 305: case 'b': ! 306: beep = 1; ! 307: break; ! 308: case 'i': ! 309: printid = 1; ! 310: break; ! 311: case 'w': ! 312: window = 1; ! 313: break; ! 314: case 'e': ! 315: emacs = 1; ! 316: break; ! 317: case 'd': ! 318: dbug = 1; ! 319: break; ! 320: case 'q': ! 321: quiet = 1; ! 322: break; ! 323: case 's': ! 324: shortline = 1; ! 325: break; ! 326: case 'j': ! 327: leftline = 1; ! 328: break; ! 329: default: ! 330: fprintf(stderr, ! 331: "sysline: bad flag: %c\n", *cp); ! 332: } ! 333: } ! 334: break; ! 335: case '+': ! 336: delay = atoi(*argv + 1); ! 337: if (delay < 10) ! 338: delay = 10; ! 339: else if (delay > 500) ! 340: delay = 500; ! 341: synch = 0; /* no more sync */ ! 342: break; ! 343: default: ! 344: fprintf(stderr, "sysline: illegal argument %s\n", ! 345: argv[0]); ! 346: } ! 347: if (emacs) { ! 348: reverse = 0; ! 349: columns = 79; ! 350: } else /* if not to emacs window, initialize terminal dependent info */ ! 351: initterm(); ! 352: #ifdef SIGWINCH ! 353: /* ! 354: * When the window size changes and we are the foreground ! 355: * process (true if -w), we get this signal. ! 356: */ ! 357: signal(SIGWINCH, sigwinch); ! 358: #endif ! 359: getwinsize(); /* get window size from ioctl */ ! 360: ! 361: /* immediately fork and let the parent die if not emacs mode */ ! 362: if (!emacs && !window && !dbug) { ! 363: if (fork()) ! 364: exit(0); ! 365: /* pgrp should take care of things, but ignore them anyway */ ! 366: signal(SIGINT, SIG_IGN); ! 367: signal(SIGQUIT, SIG_IGN); ! 368: #ifdef VMUNIX ! 369: signal(SIGTTOU, SIG_IGN); ! 370: #endif ! 371: } ! 372: /* ! 373: * When we logoff, init will do a "vhangup()" on this ! 374: * tty which turns off I/O access and sends a SIGHUP ! 375: * signal. We catch this and thereby clear the status ! 376: * display. Note that a bug in 4.1bsd caused the SIGHUP ! 377: * signal to be sent to the wrong process, so you had to ! 378: * `kill -HUP' yourself in your .logout file. ! 379: * Do the same thing for SIGTERM, which is the default kill ! 380: * signal. ! 381: */ ! 382: signal(SIGHUP, clearbotl); ! 383: signal(SIGTERM, clearbotl); ! 384: /* ! 385: * This is so kill -ALRM to force update won't screw us up.. ! 386: */ ! 387: signal(SIGALRM, SIG_IGN); ! 388: ! 389: uid = getuid(); ! 390: ourtty = ttyname(2); /* remember what tty we are on */ ! 391: if (printid) { ! 392: printf("%d\n", getpid()); ! 393: fflush(stdout); ! 394: } ! 395: dup2(2, 1); ! 396: ! 397: if ((home = getenv("HOME")) == 0) ! 398: home = ""; ! 399: strcpy1(strcpy1(whofilename, home), "/.who"); ! 400: strcpy1(strcpy1(whofilename2, home), "/.sysline"); ! 401: strcpy1(strcpy1(lockfilename, home), "/.syslinelock"); ! 402: ! 403: if ((kmem = open("/dev/kmem",0)) < 0) { ! 404: fprintf(stderr, "Can't open kmem.\n"); ! 405: exit(1); ! 406: } ! 407: readnamelist(); ! 408: if (proccheck) ! 409: initprocread(); ! 410: if (mailcheck) ! 411: if ((username = getenv("USER")) == 0) ! 412: mailcheck = 0; ! 413: else { ! 414: chdir(MAILDIR); ! 415: if (stat(username, &mstbuf) >= 0) ! 416: mailsize = mstbuf.st_size; ! 417: else ! 418: mailsize = 0; ! 419: } ! 420: ! 421: while (emacs || window || isloggedin()) ! 422: if (access(lockfilename, 0) >= 0) ! 423: sleep(60); ! 424: else { ! 425: prtinfo(); ! 426: sleep(delay); ! 427: if (clr_bet_ref) { ! 428: tputs(dis_status_line, 1, outc); ! 429: fflush(stdout); ! 430: sleep(5); ! 431: } ! 432: revtime = (1 + revtime) % REVOFF; ! 433: } ! 434: clearbotl(); ! 435: /*NOTREACHED*/ ! 436: } ! 437: ! 438: isloggedin() ! 439: { ! 440: /* ! 441: * you can tell if a person has logged out if the owner of ! 442: * the tty has changed ! 443: */ ! 444: struct stat statbuf; ! 445: ! 446: return fstat(2, &statbuf) == 0 && statbuf.st_uid == uid; ! 447: } ! 448: ! 449: readnamelist() ! 450: { ! 451: time_t bootime, clock, nintv, time(); ! 452: ! 453: #ifdef pdp11 ! 454: nlist("/unix", nl); ! 455: #else ! 456: nlist("/vmunix", nl); ! 457: #endif ! 458: if (nl[0].n_value == 0) { ! 459: if (!quiet) ! 460: fprintf(stderr, "No namelist\n"); ! 461: return; ! 462: } ! 463: lseek(kmem, (long)nl[NL_BOOT].n_value, 0); ! 464: read(kmem, &bootime, sizeof(bootime)); ! 465: (void) time(&clock); ! 466: nintv = clock - bootime; ! 467: if (nintv <= 0L || nintv > 60L*60L*24L*365L) { ! 468: if (!quiet) ! 469: fprintf(stderr, ! 470: "Time makes no sense... namelist must be wrong\n"); ! 471: nl[NL_PROC].n_value = nl[NL_AVEN].n_value = 0; ! 472: } ! 473: } ! 474: ! 475: readutmp(nflag) ! 476: char nflag; ! 477: { ! 478: static time_t lastmod; /* initially zero */ ! 479: static off_t utmpsize; /* ditto */ ! 480: struct stat st; ! 481: ! 482: if (ut < 0 && (ut = open("/etc/utmp", 0)) < 0) { ! 483: fprintf(stderr, "sysline: Can't open utmp.\n"); ! 484: exit(1); ! 485: } ! 486: if (fstat(ut, &st) < 0 || st.st_mtime == lastmod) ! 487: return 0; ! 488: lastmod = st.st_mtime; ! 489: if (utmpsize != st.st_size) { ! 490: utmpsize = st.st_size; ! 491: nentries = utmpsize / sizeof (struct utmp); ! 492: if (old == 0) { ! 493: old = (struct utmp *)calloc(utmpsize, 1); ! 494: new = (struct utmp *)calloc(utmpsize, 1); ! 495: } else { ! 496: old = (struct utmp *)realloc((char *)old, utmpsize); ! 497: new = (struct utmp *)realloc((char *)new, utmpsize); ! 498: free(status); ! 499: } ! 500: status = malloc(nentries * sizeof *status); ! 501: if (old == 0 || new == 0 || status == 0) { ! 502: fprintf(stderr, "sysline: Out of memory.\n"); ! 503: exit(1); ! 504: } ! 505: } ! 506: lseek(ut, 0L, 0); ! 507: (void) read(ut, (char *) (nflag ? new : old), utmpsize); ! 508: return 1; ! 509: } ! 510: ! 511: /* ! 512: * read in the process table locations and sizes, and allocate space ! 513: * for storing the process table. This is done only once. ! 514: */ ! 515: initprocread() ! 516: { ! 517: ! 518: if (nl[NL_PROC].n_value == 0) ! 519: return; ! 520: #ifdef VMUNIX ! 521: lseek(kmem, (long)nl[NL_PROC].n_value, 0); ! 522: read(kmem, &procadr, sizeof procadr); ! 523: lseek(kmem, (long)nl[NL_NPROC].n_value, 0); ! 524: read(kmem, &nproc, sizeof nproc); ! 525: #endif ! 526: #ifdef pdp11 ! 527: procadr = nl[NL_PROC].n_value; ! 528: nproc = NPROC; /* from param.h */ ! 529: #endif ! 530: if ((proc = (struct proc *) calloc(nproc, sizeof (struct proc))) == 0) { ! 531: fprintf(stderr, "Out of memory.\n"); ! 532: exit(1); ! 533: } ! 534: procNPROC = proc + nproc; ! 535: } ! 536: ! 537: /* ! 538: * read in the process table. This assumes that initprocread has alread been ! 539: * called to set up storage. ! 540: */ ! 541: readproctab() ! 542: { ! 543: ! 544: if (nl[NL_PROC].n_value == 0) ! 545: return (0); ! 546: lseek(kmem, (long)procadr, 0); ! 547: read(kmem, (char *)proc, nproc * sizeof (struct proc)); ! 548: return (1); ! 549: } ! 550: ! 551: prtinfo() ! 552: { ! 553: int on, off; ! 554: register i; ! 555: char fullprocess; ! 556: ! 557: stringinit(); ! 558: #ifdef SIGWINCH ! 559: if (winchanged) { ! 560: winchanged = 0; ! 561: getwinsize(); ! 562: mustclear = 1; ! 563: } ! 564: #endif ! 565: #ifdef WHO ! 566: /* check for file named .who in the home directory */ ! 567: whocheck(); ! 568: #endif ! 569: timeprint(); ! 570: /* ! 571: * if mail is seen, don't print rest of info, just the mail ! 572: * reverse new and old so that next time we run, we won't lose log ! 573: * in and out information ! 574: */ ! 575: if (mailcheck && (sawmail = mailseen())) ! 576: goto bottom; ! 577: #ifdef HOSTNAME ! 578: #ifdef RWHO ! 579: for (i = 0; i < nremotes; i++) { ! 580: char *tmp; ! 581: ! 582: stringspace(); ! 583: tmp = sysrup(remotehost + i); ! 584: stringcat(tmp, strlen(tmp)); ! 585: } ! 586: #endif ! 587: /* ! 588: * print hostname info if requested ! 589: */ ! 590: if (hostprint) { ! 591: stringspace(); ! 592: stringcat(hostname, -1); ! 593: } ! 594: #endif ! 595: /* ! 596: * print load average and difference between current load average ! 597: * and the load average 5 minutes ago ! 598: */ ! 599: if (nl[NL_AVEN].n_value != 0) { ! 600: double diff; ! 601: ! 602: stringspace(); ! 603: #ifdef VMUNIX ! 604: lseek(kmem, (long)nl[NL_AVEN].n_value, 0); ! 605: read(kmem, avenrun, sizeof avenrun); ! 606: #endif ! 607: #ifdef pdp11 ! 608: loadav(avenrun); ! 609: #endif ! 610: if ((diff = avenrun[0] - avenrun[1]) < 0.0) ! 611: stringprt("%.1f %.1f", avenrun[0], diff); ! 612: else ! 613: stringprt("%.1f +%.1f", avenrun[0], diff); ! 614: loadavg = avenrun[0]; /* remember load average */ ! 615: } ! 616: /* ! 617: * print log on and off information ! 618: */ ! 619: stringspace(); ! 620: fullprocess = 1; ! 621: #ifdef MAXLOAD ! 622: if (loadavg > MAXLOAD) ! 623: fullprocess = 0; /* too loaded to run */ ! 624: #endif ! 625: /* ! 626: * Read utmp file (logged in data) only if we are doing a full ! 627: * process, or if this is the first time and we are calculating ! 628: * the number of users. ! 629: */ ! 630: on = off = 0; ! 631: if (users == 0) { /* first time */ ! 632: if (readutmp(0)) ! 633: for (i = 0; i < nentries; i++) ! 634: if (old[i].ut_name[0]) ! 635: users++; ! 636: } else if (fullprocess && readutmp(1)) { ! 637: struct utmp *tmp; ! 638: ! 639: users = 0; ! 640: for (i = 0; i < nentries; i++) { ! 641: if (strncmp(old[i].ut_name, ! 642: new[i].ut_name, NAMESIZE) == 0) ! 643: status[i] = NOCH; ! 644: else if (old[i].ut_name[0] == '\0') { ! 645: status[i] = ON; ! 646: on++; ! 647: } else if (new[i].ut_name[0] == '\0') { ! 648: status[i] = OFF; ! 649: off++; ! 650: } else { ! 651: status[i] = ON | OFF; ! 652: on++; ! 653: off++; ! 654: } ! 655: if (new[i].ut_name[0]) ! 656: users++; ! 657: } ! 658: tmp = new; ! 659: new = old; ! 660: old = tmp; ! 661: } ! 662: /* ! 663: * Print: ! 664: * 1. number of users ! 665: * 2. a * for unread mail ! 666: * 3. a - if load is too high ! 667: * 4. number of processes running and stopped ! 668: */ ! 669: stringprt("%du", users); ! 670: if (mailsize > 0 && mstbuf.st_mtime >= mstbuf.st_atime) ! 671: stringcat("*", -1); ! 672: if (!fullprocess && (proccheck || logcheck)) ! 673: stringcat("-", -1); ! 674: if (fullprocess && proccheck && readproctab()) { ! 675: register struct proc *p; ! 676: int procrun, procstop; ! 677: ! 678: /* ! 679: * We are only interested in processes which have the same ! 680: * uid as us, and whose parent process id is not 1. ! 681: */ ! 682: procrun = procstop = 0; ! 683: for (p = proc; p < procNPROC; p++) { ! 684: if (p->p_stat == 0 || p->p_pgrp == 0 || ! 685: p->p_uid != uid || p->p_ppid == 1) ! 686: continue; ! 687: switch (p->p_stat) { ! 688: case SSTOP: ! 689: procstop++; ! 690: break; ! 691: case SSLEEP: ! 692: /* ! 693: * Sleep can mean waiting for a signal or just ! 694: * in a disk or page wait queue ready to run. ! 695: * We can tell if it is the later by the pri ! 696: * being negative. ! 697: */ ! 698: if (p->p_pri < PZERO) ! 699: procrun++; ! 700: break; ! 701: case SWAIT: ! 702: case SRUN: ! 703: case SIDL: ! 704: procrun++; ! 705: } ! 706: } ! 707: if (procrun > 0 || procstop > 0) { ! 708: stringspace(); ! 709: if (procrun > 0 && procstop > 0) ! 710: stringprt("%dr %ds", procrun, procstop); ! 711: else if (procrun > 0) ! 712: stringprt("%dr", procrun); ! 713: else ! 714: stringprt("%ds", procstop); ! 715: } ! 716: } ! 717: /* ! 718: * If anyone has logged on or off, and we are interested in it, ! 719: * print it out. ! 720: */ ! 721: if (logcheck) { ! 722: /* old and new have already been swapped */ ! 723: if (on) { ! 724: stringspace(); ! 725: stringcat("on:", -1); ! 726: for (i = 0; i < nentries; i++) ! 727: if (status[i] & ON) { ! 728: stringprt(" %.8s", old[i].ut_name); ! 729: ttyprint(old[i].ut_line); ! 730: } ! 731: } ! 732: if (off) { ! 733: stringspace(); ! 734: stringcat("off:", -1); ! 735: for (i = 0; i < nentries; i++) ! 736: if (status[i] & OFF) { ! 737: stringprt(" %.8s", new[i].ut_name); ! 738: ttyprint(new[i].ut_line); ! 739: } ! 740: } ! 741: } ! 742: bottom: ! 743: /* dump out what we know */ ! 744: stringdump(); ! 745: } ! 746: ! 747: timeprint() ! 748: { ! 749: long curtime; ! 750: struct tm *tp, *localtime(); ! 751: static int beepable = 1; ! 752: ! 753: /* always print time */ ! 754: time(&curtime); ! 755: tp = localtime(&curtime); ! 756: if (dateprint) ! 757: stringprt("%.11s", ctime(&curtime)); ! 758: stringprt("%d:%02d", tp->tm_hour > 12 ? tp->tm_hour - 12 : ! 759: (tp->tm_hour == 0 ? 12 : tp->tm_hour), tp->tm_min); ! 760: if (synch) /* sync with clock */ ! 761: delay = 60 - tp->tm_sec; ! 762: /* ! 763: * Beepable is used to insure that we get at most one set of beeps ! 764: * every half hour. ! 765: */ ! 766: if (beep) ! 767: if (beepable) { ! 768: if (tp->tm_min == 30) { ! 769: tputs(bell, 1, outc); ! 770: fflush(stdout); ! 771: beepable = 0; ! 772: } else if (tp->tm_min == 0) { ! 773: tputs(bell, 1, outc); ! 774: fflush(stdout); ! 775: sleep(2); ! 776: tputs(bell, 1, outc); ! 777: fflush(stdout); ! 778: beepable = 0; ! 779: } ! 780: } else ! 781: if (tp->tm_min != 0 && tp->tm_min != 30) ! 782: beepable = 1; ! 783: } ! 784: ! 785: /* ! 786: * whocheck -- check for file named .who and print it on the who line first ! 787: */ ! 788: whocheck() ! 789: { ! 790: int chss; ! 791: register char *p; ! 792: char buff[81]; ! 793: int whofile; ! 794: ! 795: if ((whofile = open(whofilename, 0)) < 0 && ! 796: (whofile = open(whofilename2, 0)) < 0) ! 797: return; ! 798: chss = read(whofile, buff, sizeof buff - 1); ! 799: close(whofile); ! 800: if (chss <= 0) ! 801: return; ! 802: buff[chss] = '\0'; ! 803: /* ! 804: * Remove all line feeds, and replace by spaces if they are within ! 805: * the message, else replace them by nulls. ! 806: */ ! 807: for (p = buff; *p;) ! 808: if (*p == '\n') ! 809: if (p[1]) ! 810: *p++ = ' '; ! 811: else ! 812: *p = '\0'; ! 813: else ! 814: p++; ! 815: stringcat(buff, p - buff); ! 816: stringspace(); ! 817: } ! 818: ! 819: /* ! 820: * ttyprint -- given the name of a tty, print in the string buffer its ! 821: * short name surrounded by parenthesis. ! 822: * ttyxx is printed as (xx) ! 823: * console is printed as (cty) ! 824: */ ! 825: ttyprint(name) ! 826: char *name; ! 827: { ! 828: char buff[11]; ! 829: ! 830: if (strncmp(name, "tty", 3) == 0) ! 831: stringprt("(%.*s)", LINESIZE - 3, name + 3); ! 832: else if (strcmp(name, "console") == 0) ! 833: stringcat("(cty)", -1); ! 834: else ! 835: stringprt("(%.*s)", LINESIZE, name); ! 836: } ! 837: ! 838: /* ! 839: * mail checking function ! 840: * returns 0 if no mail seen ! 841: */ ! 842: mailseen() ! 843: { ! 844: FILE *mfd; ! 845: register n; ! 846: register char *cp; ! 847: char lbuf[100], sendbuf[100], *bufend; ! 848: char seenspace; ! 849: int retval = 0; ! 850: ! 851: if (stat(username, &mstbuf) < 0) { ! 852: mailsize = 0; ! 853: return 0; ! 854: } ! 855: if (mstbuf.st_size <= mailsize || (mfd = fopen(username,"r")) == NULL) { ! 856: mailsize = mstbuf.st_size; ! 857: return 0; ! 858: } ! 859: fseek(mfd, mailsize, 0); ! 860: while ((n = readline(mfd, lbuf, sizeof lbuf)) >= 0 && ! 861: strncmp(lbuf, "From ", 5) != 0) ! 862: ; ! 863: if (n < 0) { ! 864: stringcat("Mail has just arrived", 0); ! 865: goto out; ! 866: } ! 867: retval = 1; ! 868: /* ! 869: * Found a From line, get second word, which is the sender, ! 870: * and print it. ! 871: */ ! 872: for (cp = lbuf + 5; *cp && *cp != ' '; cp++) /* skip to blank */ ! 873: ; ! 874: *cp = '\0'; /* terminate name */ ! 875: stringspace(); ! 876: stringprt("Mail from %s ", lbuf + 5); ! 877: /* ! 878: * Print subject, and skip over header. ! 879: */ ! 880: while ((n = readline(mfd, lbuf, sizeof lbuf)) > 0) ! 881: if (strncmp(lbuf, "Subject:", 8) == 0) ! 882: stringprt("on %s ", lbuf + 9); ! 883: if (!emacs) ! 884: stringcat(arrows, 2); ! 885: else ! 886: stringcat(": ", 2); ! 887: if (n < 0) /* already at eof */ ! 888: goto out; ! 889: /* ! 890: * Print as much of the letter as we can. ! 891: */ ! 892: cp = sendbuf; ! 893: if ((n = columns - chars) > sizeof sendbuf - 1) ! 894: n = sizeof sendbuf - 1; ! 895: bufend = cp + n; ! 896: seenspace = 0; ! 897: while ((n = readline(mfd, lbuf, sizeof lbuf)) >= 0) { ! 898: register char *rp; ! 899: ! 900: if (strncmp(lbuf, "From ", 5) == 0) ! 901: break; ! 902: if (cp >= bufend) ! 903: continue; ! 904: if (!seenspace) { ! 905: *cp++ = ' '; /* space before lines */ ! 906: seenspace = 1; ! 907: } ! 908: rp = lbuf; ! 909: while (*rp && cp < bufend) ! 910: if (isspace(*rp)) { ! 911: if (!seenspace) { ! 912: *cp++ = ' '; ! 913: seenspace = 1; ! 914: } ! 915: rp++; ! 916: } else { ! 917: *cp++ = *rp++; ! 918: seenspace = 0; ! 919: } ! 920: } ! 921: *cp = 0; ! 922: stringcat(sendbuf, -1); ! 923: /* ! 924: * Want to update write time so a star will ! 925: * appear after the number of users until the ! 926: * user reads his mail. ! 927: */ ! 928: out: ! 929: mailsize = linebeg; ! 930: fclose(mfd); ! 931: touch(username); ! 932: return retval; ! 933: } ! 934: ! 935: /* ! 936: * readline -- read a line from fp and store it in buf. ! 937: * return the number of characters read. ! 938: */ ! 939: readline(fp, buf, n) ! 940: register FILE *fp; ! 941: char *buf; ! 942: register n; ! 943: { ! 944: register c; ! 945: register char *cp = buf; ! 946: ! 947: linebeg = ftell(fp); /* remember loc where line begins */ ! 948: cp = buf; ! 949: while (--n > 0 && (c = getc(fp)) != EOF && c != '\n') ! 950: *cp++ = c; ! 951: *cp = 0; ! 952: if (c == EOF && cp - buf == 0) ! 953: return -1; ! 954: return cp - buf; ! 955: } ! 956: ! 957: ! 958: /* ! 959: * string hacking functions ! 960: */ ! 961: ! 962: stringinit() ! 963: { ! 964: sp = strarr; ! 965: chars = 0; ! 966: } ! 967: ! 968: /*VARARGS1*/ ! 969: stringprt(format, a, b, c) ! 970: char *format; ! 971: { ! 972: char tempbuf[150]; ! 973: ! 974: stringcat(sprintf(tempbuf, format, a, b, c), -1); ! 975: } ! 976: ! 977: stringdump() ! 978: { ! 979: char bigbuf[sizeof strarr + 200]; ! 980: register char *bp = bigbuf; ! 981: register int i; ! 982: ! 983: if (!emacs) { ! 984: if (sawmail) ! 985: bp = strcpy1(bp, bell); ! 986: if (eslok) ! 987: bp = strcpy1(bp, tparm(to_status_line, ! 988: leftline ? 0 : columns - chars)); ! 989: else { ! 990: bp = strcpy1(bp, to_status_line); ! 991: if (!shortline && !leftline) ! 992: for (i = columns - chars; --i >= 0;) ! 993: *bp++ = ' '; ! 994: } ! 995: if (reverse && revtime != 0) ! 996: bp = strcpy1(bp, rev_out); ! 997: } ! 998: *sp = 0; ! 999: bp = strcpy1(bp, strarr); ! 1000: if (!emacs) { ! 1001: if (reverse) ! 1002: bp = strcpy1(bp, rev_end); ! 1003: bp = strcpy1(bp, from_status_line); ! 1004: if (sawmail) ! 1005: bp = strcpy1(strcpy1(bp, bell), bell); ! 1006: *bp = 0; ! 1007: tputs(bigbuf, 1, outc); ! 1008: if (mustclear) { ! 1009: mustclear = 0; ! 1010: tputs(clr_eol, 1, outc); ! 1011: } ! 1012: if (dbug) ! 1013: putchar('\n'); ! 1014: fflush(stdout); ! 1015: } else ! 1016: write(2, bigbuf, bp - bigbuf); ! 1017: } ! 1018: ! 1019: stringspace() ! 1020: { ! 1021: if (reverse && revtime != 0) { ! 1022: #ifdef TERMINFO ! 1023: stringcat(rev_end, ! 1024: magic_cookie_glitch <= 0 ? 0 : magic_cookie_glitch); ! 1025: stringcat(" ", 1); ! 1026: stringcat(rev_out, ! 1027: magic_cookie_glitch <= 0 ? 0 : magic_cookie_glitch); ! 1028: #else ! 1029: stringcat(rev_end, 0); ! 1030: stringcat(" ", 1); ! 1031: stringcat(rev_out, 0); ! 1032: #endif TERMINFO ! 1033: } else ! 1034: stringcat(" ", 1); ! 1035: } ! 1036: ! 1037: /* ! 1038: * stringcat :: concatenate the characters in string str to the list we are ! 1039: * building to send out. ! 1040: * str - the string to print. may contain funny (terminal control) chars. ! 1041: * n - the number of printable characters in the string ! 1042: * or if -1 then str is all printable so we can truncate it, ! 1043: * otherwise don't print only half a string. ! 1044: */ ! 1045: stringcat(str, n) ! 1046: register char *str; ! 1047: register n; ! 1048: { ! 1049: register char *p = sp; ! 1050: ! 1051: if (n < 0) { /* truncate */ ! 1052: n = columns - chars; ! 1053: while ((*p++ = *str++) && --n >= 0) ! 1054: ; ! 1055: p--; ! 1056: chars += p - sp; ! 1057: sp = p; ! 1058: } else if (chars + n <= columns) { /* don't truncate */ ! 1059: while (*p++ = *str++) ! 1060: ; ! 1061: chars += n; ! 1062: sp = p - 1; ! 1063: } ! 1064: } ! 1065: ! 1066: /* ! 1067: * touch :: update the modify time of a file. ! 1068: */ ! 1069: touch(name) ! 1070: char *name; /* name of file */ ! 1071: { ! 1072: register fd; ! 1073: char buf; ! 1074: ! 1075: if ((fd = open(name, 2)) >= 0) { ! 1076: read(fd, &buf, 1); /* get first byte */ ! 1077: lseek(fd, 0L, 0); /* go to beginning */ ! 1078: write(fd, &buf, 1); /* and rewrite first byte */ ! 1079: close(fd); ! 1080: } ! 1081: } ! 1082: ! 1083: ! 1084: /* ! 1085: * clearbotl :: clear bottom line. ! 1086: * called when process quits or is killed. ! 1087: * it clears the bottom line of the terminal. ! 1088: */ ! 1089: clearbotl() ! 1090: { ! 1091: register int fd; ! 1092: int exit(); ! 1093: ! 1094: signal(SIGALRM, exit); ! 1095: alarm(30); /* if can't open in 30 secs, just die */ ! 1096: if (!emacs && (fd = open(ourtty, 1)) >= 0) { ! 1097: write(fd, dis_status_line, strlen(dis_status_line)); ! 1098: close(fd); ! 1099: } ! 1100: #ifdef PROF ! 1101: if (chdir("/usr/src/ucb/sysline") < 0) ! 1102: (void) chdir("/tmp"); ! 1103: #endif ! 1104: exit(0); ! 1105: } ! 1106: ! 1107: #ifdef TERMINFO ! 1108: initterm() ! 1109: { ! 1110: static char standbuf[40]; ! 1111: ! 1112: setupterm(0, 1, 0); ! 1113: if (!window && !has_status_line) { ! 1114: /* not an appropriate terminal */ ! 1115: if (!quiet) ! 1116: fprintf(stderr, "sysline: no status capability for %s\n", ! 1117: getenv("TERM")); ! 1118: exit(1); ! 1119: } ! 1120: if (window || status_line_esc_ok) { ! 1121: if (set_attributes) { ! 1122: /* reverse video mode */ ! 1123: strcpy(standbuf, ! 1124: tparm(set_attributes,0,0,1,0,0,0,0,0,0)); ! 1125: rev_out = standbuf; ! 1126: rev_end = exit_attribute_mode; ! 1127: } else if (enter_standout_mode && exit_standout_mode) { ! 1128: rev_out = enter_standout_mode; ! 1129: rev_end = exit_standout_mode; ! 1130: } else ! 1131: rev_out = rev_end = ""; ! 1132: } else ! 1133: rev_out = rev_end = ""; ! 1134: columns--; /* avoid cursor wraparound */ ! 1135: } ! 1136: ! 1137: #else /* TERMCAP */ ! 1138: ! 1139: initterm() ! 1140: { ! 1141: char *term, *cp; ! 1142: static char tbuf[1024]; ! 1143: char is2[40]; ! 1144: extern char *UP; ! 1145: ! 1146: if ((term = getenv("TERM")) == NULL) { ! 1147: if (!quiet) ! 1148: fprintf(stderr, ! 1149: "sysline: No TERM variable in enviroment\n"); ! 1150: exit(1); ! 1151: } ! 1152: if (tgetent(tbuf, term) <= 0) { ! 1153: if (!quiet) ! 1154: fprintf(stderr, ! 1155: "sysline: Unknown terminal type: %s\n", term); ! 1156: exit(1); ! 1157: } ! 1158: if (!window && tgetflag("hs") <= 0) { ! 1159: if (!strncmp(term, "h19", 3)) { ! 1160: /* for upward compatability with h19sys */ ! 1161: strcpy(to_status_line, ! 1162: "\033j\033x5\033x1\033Y8%+ \033o"); ! 1163: strcpy(from_status_line, "\033k\033y5"); ! 1164: strcpy(dis_status_line, "\033y1"); ! 1165: strcpy(rev_out, "\033p"); ! 1166: strcpy(rev_end, "\033q"); ! 1167: arrows = "\033Fhh\033G"; ! 1168: columns = 80; ! 1169: UP = "\b"; ! 1170: return; ! 1171: } ! 1172: if (!quiet) ! 1173: fprintf(stderr, ! 1174: "sysline: No status capability for %s\n", term); ! 1175: exit(1); ! 1176: } ! 1177: cp = is2; ! 1178: if (tgetstr("i2", &cp) != NULL) { ! 1179: /* someday tset will do this */ ! 1180: tputs(is2, 1, erroutc); ! 1181: fflush(stdout); ! 1182: } ! 1183: ! 1184: /* the "-1" below is to avoid cursor wraparound problems */ ! 1185: columns = tgetnum("co") - 1; ! 1186: if (window) { ! 1187: strcpy(to_status_line, "\r"); ! 1188: cp = dis_status_line; /* use the clear line sequence */ ! 1189: *cp++ = '\r'; ! 1190: tgetstr("ce", &cp); ! 1191: if (leftline) ! 1192: strcpy(from_status_line, dis_status_line + 1); ! 1193: else ! 1194: strcpy(from_status_line, ""); ! 1195: } else { ! 1196: cp = to_status_line; ! 1197: tgetstr("ts", &cp); ! 1198: cp = from_status_line; ! 1199: tgetstr("fs", &cp); ! 1200: cp = dis_status_line; ! 1201: tgetstr("ds", &cp); ! 1202: eslok = tgetflag("es"); ! 1203: } ! 1204: if (eslok || window) { ! 1205: cp = rev_out; ! 1206: tgetstr("so", &cp); ! 1207: cp = rev_end; ! 1208: tgetstr("se", &cp); ! 1209: cp = clr_eol; ! 1210: tgetstr("ce", &cp); ! 1211: } else ! 1212: reverse = 0; /* turn off reverse video */ ! 1213: UP = "\b"; ! 1214: if (!strncmp(term, "h19", 3)) ! 1215: arrows = "\033Fhh\033G"; /* "two tiny graphic arrows" */ ! 1216: else ! 1217: arrows = "->"; ! 1218: } ! 1219: #endif TERMINFO ! 1220: ! 1221: #ifdef pdp11 ! 1222: loadav(ap) ! 1223: double ap[]; ! 1224: { ! 1225: register int i; ! 1226: short s_avenrun[3]; ! 1227: ! 1228: lseek(kmem, (long)nl[NL_AVEN].n_value, 0); ! 1229: read(kmem, s_avenrun, sizeof(s_avenrun)); ! 1230: for (i=0; i < (sizeof(s_avenrun)/sizeof(s_avenrun[0])); i++) ! 1231: ap[i] = s_avenrun[i] / 256.0; ! 1232: } ! 1233: #endif ! 1234: ! 1235: #ifdef RWHO ! 1236: char * ! 1237: sysrup(hp) ! 1238: register struct remotehost *hp; ! 1239: { ! 1240: char filename[100]; ! 1241: struct whod wd; ! 1242: #define WHOD_HDR_SIZE (sizeof (wd) - sizeof (wd.wd_we)) ! 1243: static char buffer[50]; ! 1244: time_t now; ! 1245: ! 1246: /* ! 1247: * rh_file is initially 0. ! 1248: * This is ok since standard input is assumed to exist. ! 1249: */ ! 1250: if (hp->rh_file == 0) { ! 1251: /* ! 1252: * Try rwho hostname file, and if that fails try ucbhostname. ! 1253: */ ! 1254: (void) strcpy1(strcpy1(filename, RWHOLEADER), hp->rh_host); ! 1255: if ((hp->rh_file = open(filename, 0)) < 0) { ! 1256: (void) strcpy1(strcpy1(strcpy1(filename, RWHOLEADER), ! 1257: NETPREFIX), hp->rh_host); ! 1258: hp->rh_file = open(filename, 0); ! 1259: } ! 1260: } ! 1261: if (hp->rh_file < 0) ! 1262: return sprintf(buffer, "%s?", hp->rh_host); ! 1263: (void) lseek(hp->rh_file, (off_t)0, 0); ! 1264: if (read(hp->rh_file, (char *)&wd, WHOD_HDR_SIZE) != WHOD_HDR_SIZE) ! 1265: return sprintf(buffer, "%s ?", hp->rh_host); ! 1266: (void) time(&now); ! 1267: if (now - wd.wd_recvtime > DOWN_THRESHOLD) { ! 1268: long interval; ! 1269: long days, hours, minutes; ! 1270: ! 1271: interval = now - wd.wd_recvtime; ! 1272: minutes = (interval + 59) / 60; /* round to minutes */ ! 1273: hours = minutes / 60; /* extract hours from minutes */ ! 1274: minutes %= 60; /* remove hours from minutes */ ! 1275: days = hours / 24; /* extract days from hours */ ! 1276: hours %= 24; /* remove days from hours */ ! 1277: if (days > 7 || days < 0) ! 1278: (void) sprintf(buffer, "%s down", hp->rh_host); ! 1279: else if (days > 0) ! 1280: (void) sprintf(buffer, "%s %d+%d:%02d", ! 1281: hp->rh_host, days, hours, minutes); ! 1282: else ! 1283: (void) sprintf(buffer, "%s %d:%02d", ! 1284: hp->rh_host, hours, minutes); ! 1285: } else ! 1286: (void) sprintf(buffer, "%s %.1f", ! 1287: hp->rh_host, wd.wd_loadav[0]/100.0); ! 1288: return buffer; ! 1289: } ! 1290: #endif RWHO ! 1291: ! 1292: getwinsize() ! 1293: { ! 1294: #ifdef TIOCGWINSZ ! 1295: struct winsize winsize; ! 1296: ! 1297: /* the "-1" below is to avoid cursor wraparound problems */ ! 1298: if (ioctl(2, TIOCGWINSZ, (char *)&winsize) >= 0 && winsize.ws_col != 0) ! 1299: columns = winsize.ws_col - 1; ! 1300: #endif ! 1301: } ! 1302: ! 1303: #ifdef SIGWINCH ! 1304: sigwinch() ! 1305: { ! 1306: winchanged++; ! 1307: } ! 1308: #endif ! 1309: ! 1310: char * ! 1311: strcpy1(p, q) ! 1312: register char *p, *q; ! 1313: { ! 1314: ! 1315: while (*p++ = *q++) ! 1316: ; ! 1317: return p - 1; ! 1318: } ! 1319: ! 1320: outc(c) ! 1321: char c; ! 1322: { ! 1323: if (dbug) ! 1324: printf("%s", unctrl(c)); ! 1325: else ! 1326: putchar(c); ! 1327: } ! 1328: ! 1329: erroutc(c) ! 1330: char c; ! 1331: { ! 1332: if (dbug) ! 1333: fprintf(stderr, "%s", unctrl(c)); ! 1334: else ! 1335: putc(c, stderr); ! 1336: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.