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