top - Import DragonFly specific patches for 3.8beta1.
[dragonfly.git] / 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 }