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