contrib/top/commands.c

   1 /*
   2  * Copyright (c) 1984 through 2008, William LeFebvre
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *
  16  *     * Neither the name of William LeFebvre nor the names of other
  17  * contributors may be used to endorse or promote products derived from
  18  * this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  *  Top users/processes display for Unix
  35  *  Version 3
  36  */
  37
  38 /*
  39  *  This file contains the routines that implement some of the interactive
  40  *  mode commands.  Note that some of the commands are implemented in-line
  41  *  in "main".  This is necessary because they change the global state of
  42  *  "top" (i.e.:  changing the number of processes to display).
  43  */
  44
  45 #include "os.h"
  46 #include <ctype.h>
  47 #include <signal.h>
  48 #include <stdarg.h>
  49 #include <unistd.h>
  50 #include <color.h>
  51 #include <errno.h>
  52 #ifdef HAVE_SYS_RESOURCE_H
  53 #include <sys/resource.h>
  54 #endif
  55
  56 #if defined(HAVE_DECL_SYS_SIGLIST) & defined(HAVE_STRCASECMP)
  57 #define USE_SYS_SIGLIST
  58 #endif
  59
  60 #ifdef USE_SYS_SIGLIST
  61 extern const char * const sys_siglist[];
  62 extern const char * const sys_signame[];
  63 #else
  64 #include "sigdesc.h"            /* generated automatically */
  65 #endif
  66 #include "top.h"
  67 #include "machine.h"
  68 #include "globalstate.h"
  69 #include "boolean.h"
  70 #include "color.h"
  71 #include "commands.h"
  72 #include "display.h"
  73 #include "screen.h"
  74 #include "username.h"
  75 #include "utils.h"
  76 #include "version.h"
  77
  78 extern int  errno;
  79
  80 extern char *copyright;
  81
  82 typedef struct command {
  83     int ch;
  84     int (*cmd_func)(globalstate *);
  85     char *help;
  86 } command;
  87
  88 /*
  89  *  Some of the commands make system calls that could generate errors.
  90  *  These errors are collected up in an array of structures for later
  91  *  contemplation and display.  Such routines return a string containing an
  92  *  error message, or NULL if no errors occurred.  We need an upper limit on
  93  *  the number of errors, so we arbitrarily choose 20.
  94  */
  95
  96 #define ERRMAX 20
  97
  98 struct errs             /* structure for a system-call error */
  99 {
 100     int  errnum;        /* value of errno (that is, the actual error) */
 101     char *arg;          /* argument that caused the error */
 102 };
 103
 104 static struct errs errs[ERRMAX];
 105 static int errcnt;
 106
 107 /* These macros get used to reset and log the errors */
 108 #define ERR_RESET   errcnt = 0
 109 #define ERROR(p, e) if (errcnt < ERRMAX) \
 110                     { \
 111                         errs[errcnt].arg = (p); \
 112                         errs[errcnt++].errnum = (e); \
 113                     }
 114
 115 /*
 116  *  err_compar(p1, p2) - comparison routine used by "qsort"
 117  *      for sorting errors.
 118  */
 119
 120 int
 121 err_compar(const void *p1, const void *p2)
 122
 123 {
 124     register int result;
 125
 126     if ((result = ((struct errs *)p1)->errnum -
 127          ((struct errs *)p2)->errnum) == 0)
 128     {
 129         return(strcmp(((struct errs *)p1)->arg,
 130                       ((struct errs *)p2)->arg));
 131     }
 132     return(result);
 133 }
 134
 135 /*
 136  *  str_adderr(str, len, err) - add an explanation of error "err" to
 137  *      the string "str" without overflowing length "len".  return
 138  *      number of characters remaining in str, or 0 if overflowed.
 139  */
 140
 141 int
 142 str_adderr(char *str, int len, int err)
 143
 144 {
 145     register char *msg;
 146     register int  msglen;
 147
 148     msg = err == 0 ? "Not a number" : errmsg(err);
 149     msglen = strlen(msg) + 2;
 150     if (len <= msglen)
 151     {
 152         return(0);
 153     }
 154     (void) strcat(str, ": ");
 155     (void) strcat(str, msg);
 156     return(len - msglen);
 157 }
 158
 159 /*
 160  *  str_addarg(str, len, arg, first) - add the string argument "arg" to
 161  *      the string "str" without overflowing length "len".  This is the
 162  *      first in the group when "first" is set (indicating that a comma
 163  *      should NOT be added to the front).  Return number of characters
 164  *      remaining in str, or 0 if overflowed.
 165  */
 166
 167 int
 168 str_addarg(char *str, int len, char *arg, int first)
 169
 170 {
 171     register int arglen;
 172
 173     arglen = strlen(arg);
 174     if (!first)
 175     {
 176         arglen += 2;
 177     }
 178     if (len <= arglen)
 179     {
 180         return(0);
 181     }
 182     if (!first)
 183     {
 184         (void) strcat(str, ", ");
 185     }
 186     (void) strcat(str, arg);
 187     return(len - arglen);
 188 }
 189
 190 /*
 191  * void err_string()
 192  *
 193  * Use message_error to log errors in the errs array.  This function
 194  * will combine identical errors to make the message short, but if
 195  * there is more than one type of error it will call message_error
 196  * for each one.
 197  */
 198
 199 #define STRMAX 80
 200
 201 void
 202 err_string()
 203
 204 {
 205     register struct errs *errp;
 206     register int  cnt = 0;
 207     register int  first = Yes;
 208     register int  currerr = -1;
 209     int stringlen = 0;          /* characters still available in "string" */
 210     char string[STRMAX];
 211
 212     /* if there are no errors, our job is easy */
 213     if (errcnt == 0)
 214     {
 215         return;
 216     }
 217
 218     /* sort the errors */
 219     qsort((char *)errs, errcnt, sizeof(struct errs), err_compar);
 220
 221     /* initialize the buffer (probably not necessary) */
 222     string[0] = '\0';
 223     stringlen = STRMAX - 1;
 224
 225     /* loop thru the sorted list, logging errors */
 226     while (cnt < errcnt)
 227     {
 228         /* point to the current error */
 229         errp = &(errs[cnt++]);
 230
 231         /* note that on overflow "stringlen" will become 0 and all
 232            subsequent calls to str_addarg or str_adderr will return 0 */
 233
 234         /* if the error number is different then add the error string */
 235         if (errp->errnum != currerr)
 236         {
 237             if (currerr != -1)
 238             {
 239                 /* add error string and log the error */
 240                 stringlen = str_adderr(string, stringlen, currerr);
 241                 message_error(" %s", string);
 242
 243             }
 244             /* reset the buffer */
 245             string[0] = '\0';
 246             stringlen = STRMAX - 1;
 247
 248             /* move to next error num */
 249             currerr = errp->errnum;
 250             first = Yes;
 251         }
 252
 253         /* add this arg */
 254         stringlen = str_addarg(string, stringlen, errp->arg, first);
 255         first = No;
 256     }
 257
 258     /* add final message */
 259     stringlen = str_adderr(string, stringlen, currerr);
 260
 261     /* write the error string */
 262     message_error(" %s", string);
 263 }
 264
 265 /*
 266  *  Utility routines that help with some of the commands.
 267  */
 268
 269 char *
 270 next_field(char *str)
 271
 272
 273 {
 274     if ((str = strchr(str, ' ')) == NULL)
 275     {
 276         return(NULL);
 277     }
 278     *str = '\0';
 279     while (*++str == ' ') /* loop */;
 280
 281     /* if there is nothing left of the string, return NULL */
 282     /* This fix is dedicated to Greg Earle */
 283     return(*str == '\0' ? NULL : str);
 284 }
 285
 286 int
 287 scanint(char *str, int *intp)
 288
 289 {
 290     register int val = 0;
 291     register int ch;
 292
 293     /* if there is nothing left of the string, flag it as an error */
 294     /* This fix is dedicated to Greg Earle */
 295     if (*str == '\0')
 296     {
 297         return(-1);
 298     }
 299
 300     while ((ch = *str++) != '\0')
 301     {
 302         if (isdigit(ch))
 303         {
 304             val = val * 10 + (ch - '0');
 305         }
 306         else if (isspace(ch))
 307         {
 308             break;
 309         }
 310         else
 311         {
 312             return(-1);
 313         }
 314     }
 315     *intp = val;
 316     return(0);
 317 }
 318
 319 /*
 320  *  error_count() - return the number of errors currently logged.
 321  */
 322
 323 int
 324 error_count()
 325
 326 {
 327     return(errcnt);
 328 }
 329
 330 /*
 331  *  show_errors() - display on stdout the current log of errors.
 332  */
 333
 334 void
 335 show_errors()
 336
 337 {
 338     register int cnt = 0;
 339     register struct errs *errp = errs;
 340
 341     printf("%d error%s:\n\n", errcnt, errcnt == 1 ? "" : "s");
 342     while (cnt++ < errcnt)
 343     {
 344         printf("%5s: %s\n", errp->arg,
 345             errp->errnum == 0 ? "Not a number" : errmsg(errp->errnum));
 346         errp++;
 347     }
 348 }
 349
 350 /*
 351  *  kill_procs(str) - send signals to processes, much like the "kill"
 352  *              command does; invoked in response to 'k'.
 353  */
 354
 355 void
 356 kill_procs(char *str)
 357
 358 {
 359     register char *nptr;
 360     int signum = SIGTERM;       /* default */
 361     int procnum;
 362     int uid;
 363     int owner;
 364 #ifndef USE_SYS_SIGLIST
 365     struct sigdesc *sigp;
 366 #endif
 367
 368     /* reset error array */
 369     ERR_RESET;
 370
 371     /* remember our uid */
 372     uid = getuid();
 373
 374     /* skip over leading white space */
 375     while (isspace((int)*str)) str++;
 376
 377     if (str[0] == '-')
 378     {
 379         /* explicit signal specified */
 380         if ((nptr = next_field(str)) == NULL)
 381         {
 382             message_error(" kill: no processes specified");
 383             return;
 384         }
 385
 386         str++;
 387         if (isdigit((int)str[0]))
 388         {
 389             (void) scanint(str, &signum);
 390             if (signum <= 0 || signum >= NSIG)
 391             {
 392                 message_error(" kill: invalid signal number");
 393                 return;
 394             }
 395         }
 396         else
 397         {
 398             /* translate the name into a number */
 399 #ifdef USE_SYS_SIGLIST
 400             for (signum = 1; signum < NSIG; signum++)
 401             {
 402                 if (strcasecmp(sys_signame[signum], str) == 0)
 403                 {
 404                     break;
 405                 }
 406             }
 407             if (signum == NSIG)
 408             {
 409                 message_error(" kill: bad signal name");
 410                 return;
 411             }
 412 #else
 413             for (sigp = sigdesc; sigp->name != NULL; sigp++)
 414             {
 415 #ifdef HAVE_STRCASECMP
 416                 if (strcasecmp(sigp->name, str) == 0)
 417 #else
 418                 if (strcmp(sigp->name, str) == 0)
 419 #endif
 420                 {
 421                     signum = sigp->number;
 422                     break;
 423                 }
 424             }
 425
 426             /* was it ever found */
 427             if (sigp->name == NULL)
 428             {
 429                 message_error(" kill: bad signal name");
 430                 return;
 431             }
 432 #endif
 433         }
 434         /* put the new pointer in place */
 435         str = nptr;
 436     }
 437
 438     /* loop thru the string, killing processes */
 439     do
 440     {
 441         if (scanint(str, &procnum) == -1)
 442         {
 443             ERROR(str, 0);
 444         }
 445         else
 446         {
 447             /* check process owner if we're not root */
 448             owner = proc_owner(procnum);
 449             if (uid && (uid != owner))
 450             {
 451                 ERROR(str, owner == -1 ? ESRCH : EACCES);
 452             }
 453             /* go in for the kill */
 454             else if (kill(procnum, signum) == -1)
 455             {
 456                 /* chalk up an error */
 457                 ERROR(str, errno);
 458             }
 459         }
 460     } while ((str = next_field(str)) != NULL);
 461
 462     /* process errors */
 463     err_string();
 464 }
 465
 466 /*
 467  *  renice_procs(str) - change the "nice" of processes, much like the
 468  *              "renice" command does; invoked in response to 'r'.
 469  */
 470
 471 void
 472 renice_procs(char *str)
 473
 474 {
 475     register char negate;
 476     int prio;
 477     int procnum;
 478     int uid;
 479
 480     ERR_RESET;
 481     uid = getuid();
 482
 483     /* allow for negative priority values */
 484     if ((negate = (*str == '-')) != 0)
 485     {
 486         /* move past the minus sign */
 487         str++;
 488     }
 489
 490     /* use procnum as a temporary holding place and get the number */
 491     procnum = scanint(str, &prio);
 492
 493     /* negate if necessary */
 494     if (negate)
 495     {
 496         prio = -prio;
 497     }
 498
 499 #if defined(PRIO_MIN) && defined(PRIO_MAX)
 500     /* check for validity */
 501     if (procnum == -1 || prio < PRIO_MIN || prio > PRIO_MAX)
 502     {
 503         message_error(" renice: bad priority value");
 504     }
 505 #endif
 506
 507     /* move to the first process number */
 508     if ((str = next_field(str)) == NULL)
 509     {
 510         message_error(" remice: no processes specified");
 511         return;
 512     }
 513
 514 #ifdef HAVE_SETPRIORITY
 515     /* loop thru the process numbers, renicing each one */
 516     do
 517     {
 518         if (scanint(str, &procnum) == -1)
 519         {
 520             ERROR(str, 0);
 521         }
 522
 523         /* check process owner if we're not root */
 524         else if (uid && (uid != proc_owner(procnum)))
 525         {
 526             ERROR(str, EACCES);
 527         }
 528         else if (setpriority(PRIO_PROCESS, procnum, prio) == -1)
 529         {
 530             ERROR(str, errno);
 531         }
 532     } while ((str = next_field(str)) != NULL);
 533     err_string();
 534 #else
 535     message_error(" renice operation not supported");
 536 #endif
 537 }
 538
 539 /* COMMAND ROUTINES */
 540
 541 /*
 542  * Each command routine is called by command_process and is passed a
 543  * pointer to the current global state.  Command routines are free
 544  * to change anything in the global state, although changes to the
 545  * statics structure are discouraged.  Whatever a command routine
 546  * returns will be returned by command_process.
 547  */
 548
 549 void
 550 cmd_quit(globalstate *gstate)
 551
 552 {
 553     quit(EX_OK);
 554     /*NOTREACHED*/
 555 }
 556
 557 int
 558 cmd_update(globalstate *gstate)
 559
 560 {
 561     /* go home for visual feedback */
 562     screen_home();
 563     fflush(stdout);
 564     message_expire();
 565     return CMD_REFRESH;
 566 }
 567
 568 int
 569 cmd_redraw(globalstate *gstate)
 570
 571 {
 572     gstate->fulldraw = Yes;
 573     return CMD_REFRESH;
 574 }
 575
 576 int
 577 cmd_color(globalstate *gstate)
 578
 579 {
 580     gstate->use_color = color_activate(-1);
 581     gstate->fulldraw = Yes;
 582     return CMD_REFRESH;
 583 }
 584
 585 int
 586 cmd_number(globalstate *gstate)
 587
 588 {
 589     int newval;
 590     char tmpbuf[20];
 591
 592     message_prompt("Number of processes to show: ");
 593     newval = readline(tmpbuf, 8, Yes);
 594     if (newval > -1)
 595     {
 596         if (newval > gstate->max_topn)
 597         {
 598             message_error(" This terminal can only display %d processes",
 599                           gstate->max_topn);
 600         }
 601
 602         if (newval == 0)
 603         {
 604             /* inhibit the header */
 605             display_header(No);
 606         }
 607
 608         else if (gstate->topn == 0)
 609         {
 610             display_header(Yes);
 611         }
 612
 613         gstate->topn = newval;
 614     }
 615     return CMD_REFRESH;
 616 }
 617
 618 int
 619 cmd_delay(globalstate *gstate)
 620
 621 {
 622     int newval;
 623     char tmpbuf[20];
 624
 625     message_prompt("Seconds to delay: ");
 626     if ((newval = readline(tmpbuf, 8, Yes)) > -1)
 627     {
 628         if ((gstate->delay = newval) == 0 && getuid() != 0)
 629         {
 630             gstate->delay = 1;
 631         }
 632     }
 633     return CMD_REFRESH;
 634 }
 635
 636 int
 637 cmd_idle(globalstate *gstate)
 638
 639 {
 640     gstate->pselect.idle = !gstate->pselect.idle;
 641     message_error(" %sisplaying idle processes.",
 642                   gstate->pselect.idle ? "D" : "Not d");
 643     return CMD_REFRESH;
 644 }
 645
 646 int
 647 cmd_displays(globalstate *gstate)
 648
 649 {
 650     int i;
 651     char tmpbuf[20];
 652
 653     message_prompt("Displays to show (currently %s): ",
 654                    gstate->displays == -1 ? "infinite" :
 655                    itoa(gstate->displays));
 656
 657     if ((i = readline(tmpbuf, 10, Yes)) > 0)
 658     {
 659         gstate->displays = i;
 660     }
 661     else if (i == 0)
 662     {
 663         quit(EX_OK);
 664         /*NOTREACHED*/
 665     }
 666     return CMD_OK;
 667 }
 668
 669 int
 670 cmd_cmdline(globalstate *gstate)
 671
 672 {
 673     if (gstate->statics->flags.fullcmds)
 674     {
 675         gstate->pselect.fullcmd = !gstate->pselect.fullcmd;
 676         message_error(" %sisplaying full command lines.",
 677                       gstate->pselect.fullcmd ? "D" : "Not d");
 678         return CMD_REFRESH;
 679     }
 680     message_error(" Full command display not supported.");
 681     return CMD_OK;
 682 }
 683
 684 int
 685 cmd_order(globalstate *gstate)
 686
 687 {
 688     char tmpbuf[MAX_COLS];
 689     int i;
 690
 691     if (gstate->statics->order_names != NULL)
 692     {
 693         message_prompt("Column to sort: ");
 694         if (readline(tmpbuf, sizeof(tmpbuf), No) > 0)
 695         {
 696             if ((i = string_index(tmpbuf, gstate->statics->order_names)) == -1)
 697             {
 698                 message_error(" Sort order \"%s\" not recognized", tmpbuf);
 699             }
 700             else
 701             {
 702                 gstate->order_index = i;
 703                 return CMD_REFRESH;
 704             }
 705         }
 706     }
 707     return CMD_OK;
 708 }
 709
 710 int
 711 cmd_order_x(globalstate *gstate, char *name, ...)
 712
 713 {
 714     va_list ap;
 715     char *p;
 716     char **names;
 717     int i;
 718
 719     names = gstate->statics->order_names;
 720     if (names != NULL)
 721     {
 722         if ((i = string_index(name, names)) == -1)
 723         {
 724             /* check the alternate list */
 725             va_start(ap, name);
 726             p = va_arg(ap, char *);
 727             while (p != NULL)
 728             {
 729                 if ((i = string_index(p, names)) != -1)
 730                 {
 731                     gstate->order_index = i;
 732                     return CMD_REFRESH;
 733                 }
 734                 p = va_arg(ap, char *);
 735             }
 736             message_error(" Sort order not recognized");
 737         }
 738         else
 739         {
 740             gstate->order_index = i;
 741             return CMD_REFRESH;
 742         }
 743     }
 744     return CMD_OK;
 745 }
 746
 747 int
 748 cmd_order_cpu(globalstate *gstate)
 749
 750 {
 751     return cmd_order_x(gstate, "cpu", NULL);
 752 }
 753
 754 int
 755 cmd_order_pid(globalstate *gstate)
 756
 757 {
 758     return cmd_order_x(gstate, "pid", NULL);
 759 }
 760
 761 int
 762 cmd_order_mem(globalstate *gstate)
 763
 764 {
 765     return cmd_order_x(gstate, "mem", "size", NULL);
 766 }
 767
 768 int
 769 cmd_order_time(globalstate *gstate)
 770
 771 {
 772     return cmd_order_x(gstate, "time");
 773 }
 774
 775 #ifdef ENABLE_KILL
 776
 777 int
 778 cmd_kill(globalstate *gstate)
 779
 780 {
 781     char tmpbuf[MAX_COLS];
 782
 783     message_prompt_plain("kill ");
 784     if (readline(tmpbuf, sizeof(tmpbuf), No) > 0)
 785     {
 786         kill_procs(tmpbuf);
 787     }
 788     return CMD_OK;
 789 }
 790
 791 int
 792 cmd_renice(globalstate *gstate)
 793
 794 {
 795     char tmpbuf[MAX_COLS];
 796
 797     message_prompt_plain("renice ");
 798     if (readline(tmpbuf, sizeof(tmpbuf), No) > 0)
 799     {
 800         renice_procs(tmpbuf);
 801     }
 802     return CMD_OK;
 803 }
 804
 805 #endif
 806
 807 int
 808 cmd_user(globalstate *gstate)
 809
 810 {
 811     char linebuf[MAX_COLS];
 812     int i;
 813     int ret = CMD_OK;
 814
 815     message_prompt("Username to show: ");
 816     if (readline(linebuf, sizeof(linebuf), No) > 0)
 817     {
 818         if (linebuf[0] == '+' &&
 819             linebuf[1] == '\0')
 820         {
 821             gstate->pselect.uid = -1;
 822             ret = CMD_REFRESH;
 823         }
 824         else if ((i = userid(linebuf)) == -1)
 825         {
 826             message_error(" %s: unknown user", linebuf);
 827         }
 828         else
 829         {
 830             gstate->pselect.uid = i;
 831             ret = CMD_REFRESH;
 832         }
 833     }
 834     return ret;
 835 }
 836
 837 int
 838 cmd_command(globalstate *gstate)
 839
 840 {
 841     char linebuf[MAX_COLS];
 842
 843     if (gstate->pselect.command != NULL)
 844     {
 845         free(gstate->pselect.command);
 846         gstate->pselect.command = NULL;
 847     }
 848
 849     message_prompt("Command to show: ");
 850     if (readline(linebuf, sizeof(linebuf), No) > 0)
 851     {
 852         if (linebuf[0] != '\0')
 853         {
 854             gstate->pselect.command = strdup(linebuf);
 855         }
 856     }
 857     return CMD_REFRESH;
 858 }
 859
 860 int
 861 cmd_useruid(globalstate *gstate)
 862
 863 {
 864     gstate->pselect.usernames = !gstate->pselect.usernames;
 865     display_header(2);
 866     return CMD_REFRESH;
 867 }
 868
 869 int
 870 cmd_mode(globalstate *gstate)
 871
 872 {
 873     if (gstate->statics->modemax <= 1)
 874     {
 875         return CMD_NA;
 876     }
 877     gstate->pselect.mode = (gstate->pselect.mode + 1) % gstate->statics->modemax;
 878     display_header(2);
 879     return CMD_REFRESH;
 880 }
 881
 882 int
 883 cmd_system(globalstate *gstate)
 884
 885 {
 886     gstate->pselect.system = !gstate->pselect.system;
 887     display_header(2);
 888     return CMD_REFRESH;
 889 }
 890
 891 int
 892 cmd_threads(globalstate *gstate)
 893
 894 {
 895     if (gstate->statics->flags.threads)
 896     {
 897         gstate->pselect.threads = !gstate->pselect.threads;
 898         display_header(2);
 899         return CMD_REFRESH;
 900     }
 901     return CMD_NA;
 902 }
 903
 904 /* forward reference for cmd_help, as it needs to see the command_table */
 905 int cmd_help(globalstate *gstate);
 906
 907 /* command table */
 908 command command_table[] = {
 909     { '\014', cmd_redraw, "redraw screen" },
 910     { ' ', cmd_update, "update screen" },
 911     { '?', cmd_help, "help; show this text" },
 912     { 'h', cmd_help, NULL },
 913     { 'C', cmd_color, "toggle the use of color" },
 914     { 'H', cmd_threads, "toggle the display of individual threads" },
 915     { 't', cmd_threads, NULL },
 916     { 'M', cmd_order_mem, "sort by memory usage" },
 917     { 'N', cmd_order_pid, "sort by process id" },
 918     { 'P', cmd_order_cpu, "sort by CPU usage" },
 919     { 'S', cmd_system, "toggle the display of system processes" },
 920     { 'T', cmd_order_time, "sort by CPU time" },
 921     { 'U', cmd_useruid, "toggle the display of usernames or uids" },
 922     { 'c', cmd_command, "display processes by command name" },
 923     { 'd', cmd_displays, "change number of displays to show" },
 924     { 'f', cmd_cmdline, "toggle the display of full command paths" },
 925     { 'i', cmd_idle, "toggle the displaying of idle processes" },
 926     { 'I', cmd_idle, NULL },
 927 #ifdef ENABLE_KILL
 928     { 'k', cmd_kill, "kill processes; send a signal to a list of processes" },
 929 #endif
 930     { 'm', cmd_mode, "toggle between display modes" },
 931     { 'n', cmd_number, "change number of processes to display" },
 932     { '#', cmd_number, NULL },
 933     { 'o', cmd_order, "specify sort order (see below)" },
 934     { 'q', (int (*)(globalstate *))cmd_quit, "quit" },
 935 #ifdef ENABLE_KILL
 936     { 'r', cmd_renice, "renice a process" },
 937 #endif
 938     { 's', cmd_delay, "change number of seconds to delay between updates" },
 939     { 'u', cmd_user, "display processes for only one user (+ selects all users)" },
 940     { '\0', NULL, NULL },
 941 };
 942
 943 int
 944 cmd_help(globalstate *gstate)
 945
 946 {
 947     command *c;
 948     char buf[12];
 949     char *p;
 950     char *help;
 951
 952     display_pagerstart();
 953
 954     display_pager("Top version %s, %s\n", version_string(), copyright);
 955     display_pager("Platform module: %s\n\n", MODULE);
 956     display_pager("A top users display for Unix\n\n");
 957     display_pager("These single-character commands are available:\n\n");
 958
 959     c = command_table;
 960     while (c->cmd_func != NULL)
 961     {
 962         /* skip null help strings */
 963         if ((help = c->help) == NULL)
 964         {
 965             continue;
 966         }
 967
 968         /* translate character in to something readable */
 969         if (c->ch < ' ')
 970         {
 971             buf[0] = '^';
 972             buf[1] = c->ch + '@';
 973             buf[2] = '\0';
 974         }
 975         else if (c->ch == ' ')
 976         {
 977             strcpy(buf, "<sp>");
 978         }
 979         else
 980         {
 981             buf[0] = c->ch;
 982             buf[1] = '\0';
 983         }
 984
 985         /* if the next command is the same, fold them onto one line */
 986         if ((c+1)->cmd_func == c->cmd_func)
 987         {
 988             strcat(buf, " or ");
 989             p = buf + strlen(buf);
 990             *p++ = (c+1)->ch;
 991             *p = '\0';
 992             c++;
 993         }
 994
 995         display_pager("%-7s - %s\n", buf, help);
 996         c++;
 997     }
 998
 999     display_pager("\nNot all commands are available on all systems.\n\n");
1000     display_pager("Available sort orders: %s\n", gstate->order_namelist);
1001     display_pagerend();
1002     gstate->fulldraw = Yes;
1003     return CMD_REFRESH;
1004 }
1005
1006 /*
1007  * int command_process(globalstate *gstate, int cmd)
1008  *
1009  * Process the single-character command "cmd".  The global state may
1010  * be modified by the command to alter the output.  Returns CMD_ERROR
1011  * if there was a serious error that requires an immediate exit, CMD_OK
1012  * to indicate success, CMD_REFRESH to indicate that the screen needs
1013  * to be refreshed immediately, CMD_UNKNOWN when the command is not known,
1014  * and CMD_NA when the command is not available.  Error messages for
1015  * CMD_NA and CMD_UNKNOWN must be handled by the caller.
1016  */
1017
1018 int
1019 command_process(globalstate *gstate, int cmd)
1020
1021 {
1022     command *c;
1023
1024     c = command_table;
1025     while (c->cmd_func != NULL)
1026     {
1027         if (c->ch == cmd)
1028         {
1029             return (c->cmd_func)(gstate);
1030         }
1031         c++;
1032     }
1033
1034     return CMD_UNKNOWN;
1035 }