usr.bin/top/display.c

   1 /*
   2  *  Top users/processes display for Unix
   3  *  Version 3
   4  *
   5  *  This program may be freely redistributed,
   6  *  but this entire comment MUST remain intact.
   7  *
   8  *  Copyright (c) 1984, 1989, William LeFebvre, Rice University
   9  *  Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University
  10  *
  11  * $FreeBSD$
  12  */
  13
  14 /*
  15  *  This file contains the routines that display information on the screen.
  16  *  Each section of the screen has two routines:  one for initially writing
  17  *  all constant and dynamic text, and one for only updating the text that
  18  *  changes.  The prefix "i_" is used on all the "initial" routines and the
  19  *  prefix "u_" is used for all the "updating" routines.
  20  *
  21  *  ASSUMPTIONS:
  22  *        None of the "i_" routines use any of the termcap capabilities.
  23  *        In this way, those routines can be safely used on terminals that
  24  *        have minimal (or nonexistant) terminal capabilities.
  25  *
  26  *        The routines are called in this order:  *_loadave, i_timeofday,
  27  *        *_procstates, *_cpustates, *_memory, *_message, *_header,
  28  *        *_process, u_endscreen.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #include <sys/resource.h>
  33 #include <sys/time.h>
  34
  35 #include <assert.h>
  36 #include <ctype.h>
  37 #include <stdarg.h>
  38 #include <stdbool.h>
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <termcap.h>
  43 #include <time.h>
  44 #include <unistd.h>
  45
  46 #include "screen.h"             /* interface to screen package */
  47 #include "layout.h"             /* defines for screen position layout */
  48 #include "display.h"
  49 #include "top.h"
  50 #include "machine.h"            /* we should eliminate this!!! */
  51 #include "utils.h"
  52
  53 #ifdef DEBUG
  54 FILE *debug;
  55 #endif
  56
  57 static int lmpid = 0;
  58 static int last_hi = 0;         /* used in u_process and u_endscreen */
  59 static int lastline = 0;
  60
  61 #define lineindex(l) ((l)*screen_width)
  62
  63
  64 /* things initialized by display_init and used thruout */
  65
  66 /* buffer of proc information lines for display updating */
  67 static char *screenbuf = NULL;
  68
  69 static const char * const *procstate_names;
  70 static const char * const *cpustate_names;
  71 static const char * const *memory_names;
  72 static const char * const *arc_names;
  73 static const char * const *carc_names;
  74 static const char * const *swap_names;
  75
  76 static int num_procstates;
  77 static int num_cpustates;
  78 static int num_memory;
  79 static int num_swap;
  80
  81 static int *lprocstates;
  82 static int *lcpustates;
  83 static int *lmemory;
  84 static int *lswap;
  85
  86 static int num_cpus;
  87 static int *cpustate_columns;
  88 static int cpustate_total_length;
  89 static int cpustates_column;
  90
  91 static enum { OFF, ON, ERASE } header_status = ON;
  92
  93 static void summary_format(char *, int *, const char * const *);
  94 static void line_update(char *, char *, int, int);
  95
  96 static int setup_buffer_bufsiz = 0;
  97 static char * setup_buffer(char *, int);
  98
  99 int  x_lastpid =        10;
 100 int  y_lastpid =        0;
 101 int  x_loadave =        33;
 102 int  x_loadave_nompid = 15;
 103 int  y_loadave =        0;
 104 int  x_procstate =      0;
 105 int  y_procstate =      1;
 106 int  x_brkdn =          15;
 107 int  y_brkdn =          1;
 108 int  x_mem =            5;
 109 int  y_mem =            3;
 110 int  x_arc =            5;
 111 int  y_arc =            4;
 112 int  x_carc =           5;
 113 int  y_carc =           5;
 114 int  x_swap =           6;
 115 int  y_swap =           4;
 116 int  y_message =        5;
 117 int  x_header =         0;
 118 int  y_header =         6;
 119 int  x_idlecursor =     0;
 120 int  y_idlecursor =     5;
 121 int  y_procs =          7;
 122
 123 int  y_cpustates =      2;
 124 int  Header_lines =     7;
 125
 126 int
 127 display_resize(void)
 128 {
 129     int lines;
 130
 131     /* first, deallocate any previous buffer that may have been there */
 132     if (screenbuf != NULL)
 133     {
 134         free(screenbuf);
 135     }
 136
 137     /* calculate the current dimensions */
 138     /* if operating in "dumb" mode, we only need one line */
 139     lines = smart_terminal ? screen_length - Header_lines : 1;
 140
 141     if (lines < 0)
 142         lines = 0;
 143
 144     /* now, allocate space for the screen buffer */
 145     screenbuf = calloc(lines, screen_width);
 146     if (screenbuf == NULL)
 147     {
 148         /* oops! */
 149         return(-1);
 150     }
 151
 152     /* return number of lines available */
 153     /* for dumb terminals, pretend like we can show any amount */
 154     return(smart_terminal ? lines : Largest);
 155 }
 156
 157 int
 158 display_updatecpus(struct statics *statics)
 159 {
 160     int lines;
 161     int i;
 162
 163     /* call resize to do the dirty work */
 164     lines = display_resize();
 165     if (pcpu_stats)
 166                 num_cpus = statics->ncpus;
 167     else
 168                 num_cpus = 1;
 169     cpustates_column = 5;       /* CPU: */
 170     if (num_cpus > 1) {
 171                 cpustates_column += 1 + digits(num_cpus); /* CPU #: */
 172         }
 173
 174     /* fill the "last" array with all -1s, to insure correct updating */
 175         for (i = 0; i < num_cpustates * num_cpus; ++i) {
 176                 lcpustates[i] = -1;
 177     }
 178
 179     return(lines);
 180 }
 181
 182 int
 183 display_init(struct statics * statics)
 184 {
 185     int lines;
 186     char **pp;
 187     int *ip;
 188     int i;
 189
 190     lines = display_updatecpus(statics);
 191
 192     /* only do the rest if we need to */
 193     if (lines > -1)
 194     {
 195         /* save pointers and allocate space for names */
 196         procstate_names = statics->procstate_names;
 197         num_procstates = 8;
 198         assert(num_procstates > 0);
 199         lprocstates = calloc(num_procstates, sizeof(int));
 200
 201         cpustate_names = statics->cpustate_names;
 202
 203         swap_names = statics->swap_names;
 204         num_swap = 7;
 205         assert(num_swap > 0);
 206         lswap = calloc(num_swap, sizeof(int));
 207         num_cpustates = CPUSTATES;
 208         assert(num_cpustates > 0);
 209         lcpustates = calloc(num_cpustates * sizeof(int), statics->ncpus);
 210         cpustate_columns = calloc(num_cpustates, sizeof(int));
 211
 212         memory_names = statics->memory_names;
 213         num_memory = 7;
 214         assert(num_memory > 0);
 215         lmemory = calloc(num_memory, sizeof(int));
 216
 217         arc_names = statics->arc_names;
 218         carc_names = statics->carc_names;
 219
 220         /* calculate starting columns where needed */
 221         cpustate_total_length = 0;
 222         pp = cpustate_names;
 223         ip = cpustate_columns;
 224         while (*pp != NULL)
 225         {
 226             *ip++ = cpustate_total_length;
 227             if ((i = strlen(*pp++)) > 0)
 228             {
 229                 cpustate_total_length += i + 8;
 230             }
 231         }
 232     }
 233
 234     /* return number of lines available */
 235     return(lines);
 236 }
 237
 238 void
 239 i_loadave(int mpid, double avenrun[])
 240 {
 241     int i;
 242
 243     /* i_loadave also clears the screen, since it is first */
 244     top_clear();
 245
 246     /* mpid == -1 implies this system doesn't have an _mpid */
 247     if (mpid != -1)
 248     {
 249         printf("last pid: %5d;  ", mpid);
 250     }
 251
 252     printf("load averages");
 253
 254     for (i = 0; i < 3; i++)
 255     {
 256         printf("%c %5.2f",
 257             i == 0 ? ':' : ',',
 258             avenrun[i]);
 259     }
 260     lmpid = mpid;
 261 }
 262
 263 void
 264 u_loadave(int mpid, double *avenrun)
 265 {
 266     int i;
 267
 268     if (mpid != -1)
 269     {
 270         /* change screen only when value has really changed */
 271         if (mpid != lmpid)
 272         {
 273             Move_to(x_lastpid, y_lastpid);
 274             printf("%5d", mpid);
 275             lmpid = mpid;
 276         }
 277
 278         /* i remembers x coordinate to move to */
 279         i = x_loadave;
 280     }
 281     else
 282     {
 283         i = x_loadave_nompid;
 284     }
 285
 286     /* move into position for load averages */
 287     Move_to(i, y_loadave);
 288
 289     /* display new load averages */
 290     /* we should optimize this and only display changes */
 291     for (i = 0; i < 3; i++)
 292     {
 293         printf("%s%5.2f",
 294             i == 0 ? "" : ", ",
 295             avenrun[i]);
 296     }
 297 }
 298
 299 void
 300 i_timeofday(time_t *tod)
 301 {
 302     /*
 303      *  Display the current time.
 304      *  "ctime" always returns a string that looks like this:
 305      *
 306      *  Sun Sep 16 01:03:52 1973
 307      *      012345678901234567890123
 308      *            1         2
 309      *
 310      *  We want indices 11 thru 18 (length 8).
 311      */
 312
 313     if (smart_terminal)
 314     {
 315         Move_to(screen_width - 8, 0);
 316     }
 317     else
 318     {
 319         fputs("    ", stdout);
 320     }
 321 #ifdef DEBUG
 322     {
 323         char *foo;
 324         foo = ctime(tod);
 325         fputs(foo, stdout);
 326     }
 327 #endif
 328     printf("%-8.8s\n", &(ctime(tod)[11]));
 329     lastline = 1;
 330 }
 331
 332 static int ltotal = 0;
 333 static char *procstates_buffer = NULL;
 334
 335 /*
 336  *  *_procstates(total, brkdn, names) - print the process summary line
 337  *
 338  *  Assumptions:  cursor is at the beginning of the line on entry
 339  *                lastline is valid
 340  */
 341
 342 void
 343 i_procstates(int total, int *brkdn)
 344 {
 345     int i;
 346
 347     procstates_buffer = setup_buffer(procstates_buffer, 0);
 348
 349     /* write current number of processes and remember the value */
 350     printf("%d %s:", total, (ps.thread) ? "threads" :"processes");
 351     ltotal = total;
 352
 353     /* put out enough spaces to get to column 15 */
 354     i = digits(total);
 355     while (i++ < 4)
 356     {
 357         putchar(' ');
 358     }
 359
 360     /* format and print the process state summary */
 361     summary_format(procstates_buffer, brkdn, procstate_names);
 362     fputs(procstates_buffer, stdout);
 363
 364     /* save the numbers for next time */
 365     memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
 366 }
 367
 368 void
 369 u_procstates(int total, int *brkdn)
 370 {
 371     static char *new = NULL;
 372     int i;
 373
 374     new = setup_buffer(new, 0);
 375
 376     /* update number of processes only if it has changed */
 377     if (ltotal != total)
 378     {
 379         /* move and overwrite */
 380 if (x_procstate == 0) {
 381         Move_to(x_procstate, y_procstate);
 382 }
 383 else {
 384         /* cursor is already there...no motion needed */
 385         assert(lastline == 1);
 386 }
 387         printf("%d", total);
 388
 389         /* if number of digits differs, rewrite the label */
 390         if (digits(total) != digits(ltotal))
 391         {
 392             fputs(" processes:", stdout);
 393             /* put out enough spaces to get to column 15 */
 394             i = digits(total);
 395             while (i++ < 4)
 396             {
 397                 putchar(' ');
 398             }
 399             /* cursor may end up right where we want it!!! */
 400         }
 401
 402         /* save new total */
 403         ltotal = total;
 404     }
 405
 406     /* see if any of the state numbers has changed */
 407     if (memcmp(lprocstates, brkdn, num_procstates * sizeof(int)) != 0)
 408     {
 409         /* format and update the line */
 410         summary_format(new, brkdn, procstate_names);
 411         line_update(procstates_buffer, new, x_brkdn, y_brkdn);
 412         memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
 413     }
 414 }
 415
 416 void
 417 i_cpustates(int *states)
 418 {
 419     int i = 0;
 420     int value;
 421     const char * const *names;
 422     const char *thisname;
 423     int cpu;
 424
 425 for (cpu = 0; cpu < num_cpus; cpu++) {
 426     names = cpustate_names;
 427
 428     /* print tag and bump lastline */
 429     if (num_cpus == 1)
 430         printf("\nCPU: ");
 431     else {
 432         value = printf("\nCPU %d: ", cpu);
 433         while (value++ <= cpustates_column)
 434                 printf(" ");
 435     }
 436     lastline++;
 437
 438     /* now walk thru the names and print the line */
 439     while ((thisname = *names++) != NULL)
 440     {
 441         if (*thisname != '\0')
 442         {
 443             /* retrieve the value and remember it */
 444             value = *states++;
 445
 446             /* if percentage is >= 1000, print it as 100% */
 447             printf((value >= 1000 ? "%s%4.0f%% %s" : "%s%4.1f%% %s"),
 448                    (i++ % num_cpustates) == 0 ? "" : ", ",
 449                    ((float)value)/10.,
 450                    thisname);
 451         }
 452     }
 453 }
 454
 455     /* copy over values into "last" array */
 456     memcpy(lcpustates, states, num_cpustates * sizeof(int) * num_cpus);
 457 }
 458
 459 void
 460 u_cpustates(int *states)
 461 {
 462     int value;
 463     const char * const *names;
 464     const char *thisname;
 465     int *lp;
 466     int *colp;
 467     int cpu;
 468
 469 for (cpu = 0; cpu < num_cpus; cpu++) {
 470     names = cpustate_names;
 471
 472     Move_to(cpustates_column, y_cpustates + cpu);
 473     lastline = y_cpustates + cpu;
 474     lp = lcpustates + (cpu * num_cpustates);
 475     colp = cpustate_columns;
 476
 477     /* we could be much more optimal about this */
 478     while ((thisname = *names++) != NULL)
 479     {
 480         if (*thisname != '\0')
 481         {
 482             /* did the value change since last time? */
 483             if (*lp != *states)
 484             {
 485                 /* yes, move and change */
 486                 Move_to(cpustates_column + *colp, y_cpustates + cpu);
 487                 lastline = y_cpustates + cpu;
 488
 489                 /* retrieve value and remember it */
 490                 value = *states;
 491
 492                 /* if percentage is >= 1000, print it as 100% */
 493                 printf((value >= 1000 ? "%4.0f" : "%4.1f"),
 494                        ((double)value)/10.);
 495
 496                 /* remember it for next time */
 497                 *lp = value;
 498             }
 499         }
 500
 501         /* increment and move on */
 502         lp++;
 503         states++;
 504         colp++;
 505     }
 506 }
 507 }
 508
 509 void
 510 z_cpustates(void)
 511 {
 512     int i = 0;
 513     const char **names;
 514     char *thisname;
 515     int cpu, value;
 516
 517     for (cpu = 0; cpu < num_cpus; cpu++) {
 518             names = cpustate_names;
 519
 520             /* show tag and bump lastline */
 521             if (num_cpus == 1)
 522                     printf("\nCPU: ");
 523             else {
 524                     value = printf("\nCPU %d: ", cpu);
 525                     while (value++ <= cpustates_column)
 526                             printf(" ");
 527             }
 528             lastline++;
 529
 530             while ((thisname = *names++) != NULL)
 531             {
 532                     if (*thisname != '\0')
 533                     {
 534                             printf("%s    %% %s", (i++ % num_cpustates) == 0 ? "" : ", ", thisname);
 535                     }
 536             }
 537     }
 538
 539     /* fill the "last" array with all -1s, to insure correct updating */
 540         for (i = 0; i < num_cpustates * num_cpus; ++i) {
 541                 lcpustates[i] = -1;
 542     }
 543 }
 544
 545 /*
 546  *  *_memory(stats) - print "Memory: " followed by the memory summary string
 547  *
 548  *  Assumptions:  cursor is on "lastline"
 549  *                for i_memory ONLY: cursor is on the previous line
 550  */
 551
 552 static char *memory_buffer = NULL;
 553
 554 void
 555 i_memory(int *stats)
 556 {
 557     memory_buffer = setup_buffer(memory_buffer, 0);
 558
 559     fputs("\nMem: ", stdout);
 560     lastline++;
 561
 562     /* format and print the memory summary */
 563     summary_format(memory_buffer, stats, memory_names);
 564     fputs(memory_buffer, stdout);
 565 }
 566
 567 void
 568 u_memory(int *stats)
 569 {
 570     static char *new = NULL;
 571
 572     new = setup_buffer(new, 0);
 573
 574     /* format the new line */
 575     summary_format(new, stats, memory_names);
 576     line_update(memory_buffer, new, x_mem, y_mem);
 577 }
 578
 579 /*
 580  *  *_arc(stats) - print "ARC: " followed by the ARC summary string
 581  *
 582  *  Assumptions:  cursor is on "lastline"
 583  *                for i_arc ONLY: cursor is on the previous line
 584  */
 585 static char *arc_buffer = NULL;
 586
 587 void
 588 i_arc(int *stats)
 589 {
 590     arc_buffer = setup_buffer(arc_buffer, 0);
 591
 592     if (arc_names == NULL)
 593         return;
 594
 595     fputs("\nARC: ", stdout);
 596     lastline++;
 597
 598     /* format and print the memory summary */
 599     summary_format(arc_buffer, stats, arc_names);
 600     fputs(arc_buffer, stdout);
 601 }
 602
 603 void
 604 u_arc(int *stats)
 605 {
 606     static char *new = NULL;
 607
 608     new = setup_buffer(new, 0);
 609
 610     if (arc_names == NULL)
 611         return;
 612
 613     /* format the new line */
 614     summary_format(new, stats, arc_names);
 615     line_update(arc_buffer, new, x_arc, y_arc);
 616 }
 617
 618
 619 /*
 620  *  *_carc(stats) - print "Compressed ARC: " followed by the summary string
 621  *
 622  *  Assumptions:  cursor is on "lastline"
 623  *                for i_carc ONLY: cursor is on the previous line
 624  */
 625 static char *carc_buffer = NULL;
 626
 627 void
 628 i_carc(int *stats)
 629 {
 630     carc_buffer = setup_buffer(carc_buffer, 0);
 631
 632     if (carc_names == NULL)
 633         return;
 634
 635     fputs("\n     ", stdout);
 636     lastline++;
 637
 638     /* format and print the memory summary */
 639     summary_format(carc_buffer, stats, carc_names);
 640     fputs(carc_buffer, stdout);
 641 }
 642
 643 void
 644 u_carc(int *stats)
 645 {
 646     static char *new = NULL;
 647
 648     new = setup_buffer(new, 0);
 649
 650     if (carc_names == NULL)
 651         return;
 652
 653     /* format the new line */
 654     summary_format(new, stats, carc_names);
 655     line_update(carc_buffer, new, x_carc, y_carc);
 656 }
 657
 658 /*
 659  *  *_swap(stats) - print "Swap: " followed by the swap summary string
 660  *
 661  *  Assumptions:  cursor is on "lastline"
 662  *                for i_swap ONLY: cursor is on the previous line
 663  */
 664
 665 static char *swap_buffer = NULL;
 666
 667 void
 668 i_swap(int *stats)
 669 {
 670     swap_buffer = setup_buffer(swap_buffer, 0);
 671
 672     fputs("\nSwap: ", stdout);
 673     lastline++;
 674
 675     /* format and print the swap summary */
 676     summary_format(swap_buffer, stats, swap_names);
 677     fputs(swap_buffer, stdout);
 678 }
 679
 680 void
 681 u_swap(int *stats)
 682 {
 683     static char *new = NULL;
 684
 685     new = setup_buffer(new, 0);
 686
 687     /* format the new line */
 688     summary_format(new, stats, swap_names);
 689     line_update(swap_buffer, new, x_swap, y_swap);
 690 }
 691
 692 /*
 693  *  *_message() - print the next pending message line, or erase the one
 694  *                that is there.
 695  *
 696  *  Note that u_message is (currently) the same as i_message.
 697  *
 698  *  Assumptions:  lastline is consistent
 699  */
 700
 701 /*
 702  *  i_message is funny because it gets its message asynchronously (with
 703  *      respect to screen updates).
 704  */
 705
 706 #define NEXT_MSG_ADDLEN 5
 707 static char *next_msg = NULL;
 708 static int msglen = 0;
 709 /* Invariant: msglen is always the length of the message currently displayed
 710    on the screen (even when next_msg doesn't contain that message). */
 711
 712 void
 713 i_message(void)
 714 {
 715     next_msg = setup_buffer(next_msg, NEXT_MSG_ADDLEN);
 716
 717     while (lastline < y_message)
 718     {
 719         fputc('\n', stdout);
 720         lastline++;
 721     }
 722     if (next_msg[0] != '\0')
 723     {
 724         top_standout(next_msg);
 725         msglen = strlen(next_msg);
 726         next_msg[0] = '\0';
 727     }
 728     else if (msglen > 0)
 729     {
 730         (void) clear_eol(msglen);
 731         msglen = 0;
 732     }
 733 }
 734
 735 void
 736 u_message(void)
 737 {
 738     i_message();
 739 }
 740
 741 static int header_length;
 742
 743 /*
 744  * Trim a header string to the current display width and return a newly
 745  * allocated area with the trimmed header.
 746  */
 747
 748 const char *
 749 trim_header(const char *text)
 750 {
 751         char *s;
 752         int width;
 753
 754         s = NULL;
 755         width = screen_width;
 756         header_length = strlen(text);
 757         if (header_length >= width) {
 758                 s = strndup(text, width);
 759                 if (s == NULL)
 760                         return (NULL);
 761         }
 762         return (s);
 763 }
 764
 765 /*
 766  *  *_header(text) - print the header for the process area
 767  *
 768  *  Assumptions:  cursor is on the previous line and lastline is consistent
 769  */
 770
 771 void
 772 i_header(const char *text)
 773 {
 774     char *s;
 775
 776     s = trim_header(text);
 777     if (s != NULL)
 778         text = s;
 779
 780     if (header_status == ON)
 781     {
 782         putchar('\n');
 783         fputs(text, stdout);
 784         lastline++;
 785     }
 786     else if (header_status == ERASE)
 787     {
 788         header_status = OFF;
 789     }
 790     free(s);
 791 }
 792
 793 void
 794 u_header(const char *text __unused)
 795 {
 796
 797     if (header_status == ERASE)
 798     {
 799         putchar('\n');
 800         lastline++;
 801         clear_eol(header_length);
 802         header_status = OFF;
 803     }
 804 }
 805
 806 /*
 807  *  *_process(line, thisline) - print one process line
 808  *
 809  *  Assumptions:  lastline is consistent
 810  */
 811
 812 void
 813 i_process(int line, char *thisline)
 814 {
 815     char *p;
 816     char *base;
 817
 818     /* make sure we are on the correct line */
 819     while (lastline < y_procs + line)
 820     {
 821         putchar('\n');
 822         lastline++;
 823     }
 824
 825     /* truncate the line to conform to our current screen width */
 826     thisline[screen_width] = '\0';
 827
 828     /* write the line out */
 829     fputs(thisline, stdout);
 830
 831     /* copy it in to our buffer */
 832     base = smart_terminal ? screenbuf + lineindex(line) : screenbuf;
 833     p = stpcpy(base, thisline);
 834
 835     /* zero fill the rest of it */
 836     memset(p, 0, screen_width - (p - base));
 837 }
 838
 839 void
 840 u_process(int line, char *newline)
 841 {
 842     char *optr;
 843     int screen_line = line + Header_lines;
 844     char *bufferline;
 845
 846     /* remember a pointer to the current line in the screen buffer */
 847     bufferline = &screenbuf[lineindex(line)];
 848
 849     /* truncate the line to conform to our current screen width */
 850     newline[screen_width] = '\0';
 851
 852     /* is line higher than we went on the last display? */
 853     if (line >= last_hi)
 854     {
 855         /* yes, just ignore screenbuf and write it out directly */
 856         /* get positioned on the correct line */
 857         if (screen_line - lastline == 1)
 858         {
 859             putchar('\n');
 860             lastline++;
 861         }
 862         else
 863         {
 864             Move_to(0, screen_line);
 865             lastline = screen_line;
 866         }
 867
 868         /* now write the line */
 869         fputs(newline, stdout);
 870
 871         /* copy it in to the buffer */
 872         optr = stpcpy(bufferline, newline);
 873
 874         /* zero fill the rest of it */
 875         memset(optr, 0, screen_width - (optr - bufferline));
 876     }
 877     else
 878     {
 879         line_update(bufferline, newline, 0, line + Header_lines);
 880     }
 881 }
 882
 883 void
 884 u_endscreen(int hi)
 885 {
 886     int screen_line = hi + Header_lines;
 887     int i;
 888
 889     if (smart_terminal)
 890     {
 891         if (hi < last_hi)
 892         {
 893             /* need to blank the remainder of the screen */
 894             /* but only if there is any screen left below this line */
 895             if (lastline + 1 < screen_length)
 896             {
 897                 /* efficiently move to the end of currently displayed info */
 898                 if (screen_line - lastline < 5)
 899                 {
 900                     while (lastline < screen_line)
 901                     {
 902                         putchar('\n');
 903                         lastline++;
 904                     }
 905                 }
 906                 else
 907                 {
 908                     Move_to(0, screen_line);
 909                     lastline = screen_line;
 910                 }
 911
 912                 if (clear_to_end)
 913                 {
 914                     /* we can do this the easy way */
 915                     putcap(clear_to_end);
 916                 }
 917                 else
 918                 {
 919                     /* use clear_eol on each line */
 920                     i = hi;
 921                     while ((void) clear_eol(strlen(&screenbuf[lineindex(i++)])), i < last_hi)
 922                     {
 923                         putchar('\n');
 924                     }
 925                 }
 926             }
 927         }
 928         last_hi = hi;
 929
 930         /* move the cursor to a pleasant place */
 931         Move_to(x_idlecursor, y_idlecursor);
 932         lastline = y_idlecursor;
 933     }
 934     else
 935     {
 936         /* separate this display from the next with some vertical room */
 937         fputs("\n\n", stdout);
 938     }
 939 }
 940
 941 void
 942 display_header(int t)
 943 {
 944
 945     if (t)
 946     {
 947         header_status = ON;
 948     }
 949     else if (header_status == ON)
 950     {
 951         header_status = ERASE;
 952     }
 953 }
 954
 955 void
 956 new_message(int type, const char *msgfmt, ...)
 957 {
 958     va_list args;
 959     size_t i;
 960
 961     va_start(args, msgfmt);
 962
 963     /* first, format the message */
 964     vsnprintf(next_msg, setup_buffer_bufsiz + NEXT_MSG_ADDLEN,
 965                     msgfmt, args);
 966
 967     va_end(args);
 968
 969     if (msglen > 0)
 970     {
 971         /* message there already -- can we clear it? */
 972         if (!overstrike)
 973         {
 974             /* yes -- write it and clear to end */
 975             i = strlen(next_msg);
 976             if ((type & MT_delayed) == 0)
 977             {
 978                         if (type & MT_standout) {
 979                                 top_standout(next_msg);
 980                         } else {
 981                                 fputs(next_msg, stdout);
 982                         }
 983                         clear_eol(msglen - i);
 984                         msglen = i;
 985                         next_msg[0] = '\0';
 986             }
 987         }
 988     }
 989     else
 990     {
 991         if ((type & MT_delayed) == 0)
 992         {
 993                 if (type & MT_standout) {
 994                         top_standout(next_msg);
 995                 } else {
 996                         fputs(next_msg, stdout);
 997                 }
 998             msglen = strlen(next_msg);
 999             next_msg[0] = '\0';
1000         }
1001     }
1002 }
1003
1004 void
1005 clear_message(void)
1006 {
1007     if (clear_eol(msglen) == 1)
1008     {
1009         putchar('\r');
1010     }
1011 }
1012
1013 int
1014 readline(char *buffer, int size, int numeric)
1015 {
1016     char *ptr = buffer;
1017     char ch;
1018     char cnt = 0;
1019     char maxcnt = 0;
1020
1021     /* allow room for null terminator */
1022     size -= 1;
1023
1024     /* read loop */
1025     while ((fflush(stdout), read(0, ptr, 1) > 0))
1026     {
1027         /* newline means we are done */
1028         if ((ch = *ptr) == '\n' || ch == '\r')
1029         {
1030             break;
1031         }
1032
1033         /* handle special editing characters */
1034         if (ch == ch_kill)
1035         {
1036             /* kill line -- account for overstriking */
1037             if (overstrike)
1038             {
1039                 msglen += maxcnt;
1040             }
1041
1042             /* return null string */
1043             *buffer = '\0';
1044             putchar('\r');
1045             return(-1);
1046         }
1047         else if (ch == ch_erase)
1048         {
1049             /* erase previous character */
1050             if (cnt <= 0)
1051             {
1052                 /* none to erase! */
1053                 putchar('\7');
1054             }
1055             else
1056             {
1057                 fputs("\b \b", stdout);
1058                 ptr--;
1059                 cnt--;
1060             }
1061         }
1062         /* check for character validity and buffer overflow */
1063         else if (cnt == size || (numeric && !isdigit(ch)) ||
1064                 !isprint(ch))
1065         {
1066             /* not legal */
1067             putchar('\7');
1068         }
1069         else
1070         {
1071             /* echo it and store it in the buffer */
1072             putchar(ch);
1073             ptr++;
1074             cnt++;
1075             if (cnt > maxcnt)
1076             {
1077                 maxcnt = cnt;
1078             }
1079         }
1080     }
1081
1082     /* all done -- null terminate the string */
1083     *ptr = '\0';
1084
1085     /* account for the extra characters in the message area */
1086     /* (if terminal overstrikes, remember the furthest they went) */
1087     msglen += overstrike ? maxcnt : cnt;
1088
1089     /* return either inputted number or string length */
1090     putchar('\r');
1091     return(cnt == 0 ? -1 : numeric ? atoi(buffer) : cnt);
1092 }
1093
1094 /* internal support routines */
1095
1096 static void
1097 summary_format(char *str, int *numbers, const char * const *names)
1098 {
1099     char *p;
1100     int num;
1101     const char *thisname;
1102     char rbuf[6];
1103
1104     /* format each number followed by its string */
1105     p = str;
1106     while ((thisname = *names++) != NULL)
1107     {
1108         /* get the number to format */
1109         num = *numbers++;
1110
1111         /* display only non-zero numbers */
1112         if (num > 0)
1113         {
1114             /* is this number in kilobytes? */
1115             if (thisname[0] == 'K')
1116             {
1117                 /* yes: format it as a memory value */
1118                 p = stpcpy(p, format_k(num));
1119
1120                 /* skip over the K, since it was included by format_k */
1121                 p = stpcpy(p, thisname+1);
1122             }
1123             /* is this number a ratio? */
1124             else if (thisname[0] == ':')
1125             {
1126                 (void) snprintf(rbuf, sizeof(rbuf), "%.2f",
1127                     (float)*(numbers - 2) / (float)num);
1128                 p = stpcpy(p, rbuf);
1129                 p = stpcpy(p, thisname);
1130             }
1131             else
1132             {
1133                 p = stpcpy(p, itoa(num));
1134                 p = stpcpy(p, thisname);
1135             }
1136         }
1137
1138         /* ignore negative numbers, but display corresponding string */
1139         else if (num < 0)
1140         {
1141             p = stpcpy(p, thisname);
1142         }
1143     }
1144
1145     /* if the last two characters in the string are ", ", delete them */
1146     p -= 2;
1147     if (p >= str && p[0] == ',' && p[1] == ' ')
1148     {
1149         *p = '\0';
1150     }
1151 }
1152
1153 static void
1154 line_update(char *old, char *new, int start, int line)
1155 {
1156     int ch;
1157     int diff;
1158     int newcol = start + 1;
1159     int lastcol = start;
1160     char cursor_on_line = false;
1161     char *current;
1162
1163     /* compare the two strings and only rewrite what has changed */
1164     current = old;
1165 #ifdef DEBUG
1166     fprintf(debug, "line_update, starting at %d\n", start);
1167     fputs(old, debug);
1168     fputc('\n', debug);
1169     fputs(new, debug);
1170     fputs("\n-\n", debug);
1171 #endif
1172
1173     /* start things off on the right foot                   */
1174     /* this is to make sure the invariants get set up right */
1175     if ((ch = *new++) != *old)
1176     {
1177         if (line - lastline == 1 && start == 0)
1178         {
1179             putchar('\n');
1180         }
1181         else
1182         {
1183             Move_to(start, line);
1184         }
1185         cursor_on_line = true;
1186         putchar(ch);
1187         *old = ch;
1188         lastcol = 1;
1189     }
1190     old++;
1191
1192     /*
1193      *  main loop -- check each character.  If the old and new aren't the
1194      *  same, then update the display.  When the distance from the
1195      *  current cursor position to the new change is small enough,
1196      *  the characters that belong there are written to move the
1197      *  cursor over.
1198      *
1199      *  Invariants:
1200      *      lastcol is the column where the cursor currently is sitting
1201      *          (always one beyond the end of the last mismatch).
1202      */
1203     do          /* yes, a do...while */
1204     {
1205         if ((ch = *new++) != *old)
1206         {
1207             /* new character is different from old        */
1208             /* make sure the cursor is on top of this character */
1209             diff = newcol - lastcol;
1210             if (diff > 0)
1211             {
1212                 /* some motion is required--figure out which is shorter */
1213                 if (diff < 6 && cursor_on_line)
1214                 {
1215                     /* overwrite old stuff--get it out of the old buffer */
1216                     printf("%.*s", diff, &current[lastcol-start]);
1217                 }
1218                 else
1219                 {
1220                     /* use cursor addressing */
1221                     Move_to(newcol, line);
1222                     cursor_on_line = true;
1223                 }
1224                 /* remember where the cursor is */
1225                 lastcol = newcol + 1;
1226             }
1227             else
1228             {
1229                 /* already there, update position */
1230                 lastcol++;
1231             }
1232
1233             /* write what we need to */
1234             if (ch == '\0')
1235             {
1236                 /* at the end--terminate with a clear-to-end-of-line */
1237                 (void) clear_eol(strlen(old));
1238             }
1239             else
1240             {
1241                 /* write the new character */
1242                 putchar(ch);
1243             }
1244             /* put the new character in the screen buffer */
1245             *old = ch;
1246         }
1247
1248         /* update working column and screen buffer pointer */
1249         newcol++;
1250         old++;
1251
1252     } while (ch != '\0');
1253
1254     /* zero out the rest of the line buffer -- MUST BE DONE! */
1255     diff = screen_width - newcol;
1256     if (diff > 0)
1257     {
1258         memset(old, 0, diff);
1259     }
1260
1261     /* remember where the current line is */
1262     if (cursor_on_line)
1263     {
1264         lastline = line;
1265     }
1266 }
1267
1268 /*
1269  *  printable(str) - make the string pointed to by "str" into one that is
1270  *      printable (i.e.: all ascii), by converting all non-printable
1271  *      characters into '?'.  Replacements are done in place and a pointer
1272  *      to the original buffer is returned.
1273  */
1274
1275 char *
1276 printable(char str[])
1277 {
1278     char *ptr;
1279     char ch;
1280
1281     ptr = str;
1282     while ((ch = *ptr) != '\0')
1283     {
1284         if (!isprint(ch))
1285         {
1286             *ptr = '?';
1287         }
1288         ptr++;
1289     }
1290     return(str);
1291 }
1292
1293 void
1294 i_uptime(struct timeval *bt, time_t *tod)
1295 {
1296     time_t uptime;
1297     int days, hrs, mins, secs;
1298
1299     if (bt->tv_sec != -1) {
1300         uptime = *tod - bt->tv_sec;
1301         days = uptime / 86400;
1302         uptime %= 86400;
1303         hrs = uptime / 3600;
1304         uptime %= 3600;
1305         mins = uptime / 60;
1306         secs = uptime % 60;
1307
1308         /*
1309          *  Display the uptime.
1310          */
1311
1312         if (smart_terminal)
1313         {
1314             Move_to((screen_width - 24) - (days > 9 ? 1 : 0), 0);
1315         }
1316         else
1317         {
1318             fputs(" ", stdout);
1319         }
1320         printf(" up %d+%02d:%02d:%02d", days, hrs, mins, secs);
1321     }
1322 }
1323
1324 #define SETUPBUFFER_REQUIRED_ADDBUFSIZ 2
1325
1326 static char *
1327 setup_buffer(char *buffer, int addlen)
1328 {
1329         char *b = NULL;
1330
1331         if (NULL == buffer) {
1332                 setup_buffer_bufsiz = screen_width;
1333                 b = calloc(setup_buffer_bufsiz + addlen +
1334                                 SETUPBUFFER_REQUIRED_ADDBUFSIZ,
1335                                 sizeof(char));
1336         } else {
1337                 if (screen_width > setup_buffer_bufsiz) {
1338                         setup_buffer_bufsiz = screen_width;
1339                         free(buffer);
1340                         b = calloc(setup_buffer_bufsiz + addlen +
1341                                         SETUPBUFFER_REQUIRED_ADDBUFSIZ,
1342                                         sizeof(char));
1343                 } else {
1344                         b = buffer;
1345                 }
1346         }
1347
1348         if (NULL == b) {
1349                 fprintf(stderr, "%s: can't allocate sufficient memory\n",
1350                                 myname);
1351                 exit(4);
1352         }
1353
1354         return b;
1355 }