top - Import DragonFly specific patches for 3.8beta1.
[dragonfly.git] / contrib / top / commands.c
CommitLineData
63d92323
JL
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
61extern const char * const sys_siglist[];
62extern 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
78extern int errno;
79
80extern char *copyright;
81
82typedef 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
98struct 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
104static struct errs errs[ERRMAX];
105static 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
120int
121err_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
141int
142str_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
167int
168str_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
201void
202err_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
269char *
270next_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
286int
287scanint(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
323int
324error_count()
325
326{
327 return(errcnt);
328}
329
330/*
331 * show_errors() - display on stdout the current log of errors.
332 */
333
334void
335show_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
355void
356kill_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
471void
472renice_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");
7af1b2bc 511 return;
63d92323
JL
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
549void
550cmd_quit(globalstate *gstate)
551
552{
553 quit(EX_OK);
554 /*NOTREACHED*/
555}
556
557int
558cmd_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
568int
569cmd_redraw(globalstate *gstate)
570
571{
572 gstate->fulldraw = Yes;
573 return CMD_REFRESH;
574}
575
576int
577cmd_color(globalstate *gstate)
578
579{
580 gstate->use_color = color_activate(-1);
581 gstate->fulldraw = Yes;
582 return CMD_REFRESH;
583}
584
585int
586cmd_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
618int
619cmd_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
636int
637cmd_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
646int
647cmd_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
669int
670cmd_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
684int
685cmd_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
710int
711cmd_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
747int
748cmd_order_cpu(globalstate *gstate)
749
750{
751 return cmd_order_x(gstate, "cpu", NULL);
752}
753
754int
755cmd_order_pid(globalstate *gstate)
756
757{
758 return cmd_order_x(gstate, "pid", NULL);
759}
760
761int
762cmd_order_mem(globalstate *gstate)
763
764{
765 return cmd_order_x(gstate, "mem", "size", NULL);
766}
767
768int
769cmd_order_time(globalstate *gstate)
770
771{
772 return cmd_order_x(gstate, "time");
773}
774
775#ifdef ENABLE_KILL
776
777int
778cmd_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
791int
792cmd_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
807int
808cmd_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
837int
838cmd_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
860int
861cmd_useruid(globalstate *gstate)
862
863{
864 gstate->pselect.usernames = !gstate->pselect.usernames;
865 display_header(2);
866 return CMD_REFRESH;
867}
868
869int
870cmd_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
882int
883cmd_system(globalstate *gstate)
884
885{
886 gstate->pselect.system = !gstate->pselect.system;
887 display_header(2);
888 return CMD_REFRESH;
889}
890
891int
892cmd_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 */
905int cmd_help(globalstate *gstate);
906
907/* command table */
908command 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
943int
944cmd_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
1018int
1019command_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}