[BACK]Return to sh.c CVS log [TXT][DIR] Up to [local] / prex / usr / bin / sh

Annotation of prex/usr/bin/sh/sh.c, Revision 1.1.1.1

1.1       nbrk        1: /*
                      2:  * Copyright (c) 2005-2007, Kohsuke Ohtani
                      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
                      7:  * are met:
                      8:  * 1. Redistributions of source code must retain the above copyright
                      9:  *    notice, this list of conditions and the following disclaimer.
                     10:  * 2. Redistributions in binary form must reproduce the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer in the
                     12:  *    documentation and/or other materials provided with the distribution.
                     13:  * 3. Neither the name of the author nor the names of any co-contributors
                     14:  *    may be used to endorse or promote products derived from this software
                     15:  *    without specific prior written permission.
                     16:  *
                     17:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
                     18:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     19:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     20:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
                     21:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     22:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     23:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     24:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     25:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     26:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     27:  * SUCH DAMAGE.
                     28:  */
                     29:
                     30: #include <prex/prex.h>
                     31: #include <prex/keycode.h>
                     32: #include <sys/syslog.h>
                     33:
                     34: #include <limits.h>
                     35: #include <termios.h>
                     36: #include <ctype.h>
                     37: #include <unistd.h>
                     38: #include <string.h>
                     39: #include <stdio.h>
                     40: #include <errno.h>
                     41:
                     42: #include "sh.h"
                     43:
                     44: #define        LINELEN         256
                     45: #define ARGMAX         32
                     46:
                     47: #ifdef CMDBOX
                     48: extern const struct cmd_entry builtin_cmds[];
                     49: extern int exec_builtin(cmd_func_t, int argc, char *argv[]);
                     50: #define main(argc, argv)       sh_main(argc, argv)
                     51: #endif
                     52:
                     53: extern int exec_cmd(int argc, char *argv[]);
                     54: extern const struct cmd_entry internal_cmds[];
                     55:
                     56: static char *args[ARGMAX];
                     57:
                     58: /*
                     59:  * Find command from the specifid table.
                     60:  *
                     61:  * Returns 0 if command is processed.
                     62:  * Returns -1 if no command is found.
                     63:  */
                     64: static cmd_func_t
                     65: find_cmd(const struct cmd_entry cmds[], char *cmd)
                     66: {
                     67:        int i = 0;
                     68:
                     69:        while (cmds[i].cmd != NULL) {
                     70:                if (!strcmp(cmd, cmds[i].cmd))
                     71:                        return cmds[i].func;
                     72:                i++;
                     73:        }
                     74:        return NULL;
                     75: }
                     76:
                     77: /*
                     78:  * Parse an entire given line.
                     79:  * Break it down into commands.
                     80:  */
                     81: static void
                     82: parse_line(char *line)
                     83: {
                     84:        char *p = line;
                     85:        int i, argc;
                     86:        cmd_func_t cmd;
                     87:
                     88:        /*
                     89:         * Build argument list
                     90:         */
                     91:        i = 0;
                     92:        do {
                     93:                /* Ignore whitespace at beginning */
                     94:                while (*p && isspace((int)*p))
                     95:                        p++;
                     96:                if (*p == '\0')
                     97:                        break;
                     98:                args[i] = p;
                     99:                i++;
                    100:
                    101:                /* Skip word */
                    102:                while (*p && !isspace((int)*p))
                    103:                        p++;
                    104:                if (*p == '\0')
                    105:                        break;
                    106:                *p++ = '\0';
                    107:        } while (i < ARGMAX - 1);
                    108:
                    109:        if (i == ARGMAX) {
                    110:                fprintf(stderr, "Too many args\n");
                    111:                return;
                    112:        }
                    113:        args[i] = NULL;
                    114:        argc = i;
                    115:
                    116:        /*
                    117:         * Dispatch command
                    118:         */
                    119:        if (argc > 0) {
                    120:                optind = 1;
                    121:
                    122:                /* Run it as internal command */
                    123:                cmd  = find_cmd(internal_cmds, args[0]);
                    124:                if (cmd != NULL) {
                    125:                        if ((*cmd)(argc, args) != 0) {
                    126:                                fprintf(stderr, "%s: %s\n", args[0],
                    127:                                        strerror(errno));
                    128:                        }
                    129:                        return;
                    130:                }
                    131: #ifdef CMDBOX
                    132:                /* Run it as shell built-in command */
                    133:                cmd  = find_cmd(builtin_cmds, args[0]);
                    134:                if (cmd != NULL) {
                    135:                        exec_builtin(cmd, argc, args);
                    136:                        return;
                    137:                }
                    138: #endif
                    139:                /* Next, run it as external command */
                    140:                exec_cmd(argc, args);
                    141:        }
                    142: }
                    143:
                    144: /*
                    145:  * Read command string.
                    146:  */
                    147: static char *
                    148: read_line(char *line, int len, int fd)
                    149: {
                    150:        char *p, *end;
                    151:        int c;
                    152:
                    153:        end = line + len;
                    154:        for (p = line; p < end; p++) {
                    155:                c = getchar();
                    156:                if (c == EOF) {
                    157:                        if (p == line)
                    158:                                return NULL;
                    159:                        *p = '\0';
                    160:                        return p;
                    161:                }
                    162:                if (c == '\n') {
                    163:                        *p = '\0';
                    164:                        return p;
                    165:                }
                    166:                *p = (char)c;
                    167:        }
                    168:        fprintf(stderr, "Command line overflow\n");
                    169:        return (char *)-1;
                    170: }
                    171:
                    172: int
                    173: main(int argc, char **argv)
                    174: {
                    175:        static char line[LINELEN];
                    176:        static char cwd[PATH_MAX];
                    177:        char *p;
                    178:
                    179:        signal(SIGINT, SIG_IGN);
                    180:        signal(SIGQUIT, SIG_IGN);
                    181:        signal(SIGTERM, SIG_IGN);
                    182:        signal(SIGTSTP, SIG_IGN);       /* temporary... */
                    183:
                    184:        /*
                    185:         * Command loop
                    186:         */
                    187:        for (;;) {
                    188:  next:
                    189:                /* Display prompt */
                    190:                getcwd(cwd, PATH_MAX);
                    191:                printf("\033[32m");
                    192:                printf("[prex:%s]", cwd);
                    193:                printf("\033[0m# ");
                    194:
                    195:                /* Read and parse user input */
                    196:                p = read_line(line, LINELEN, 0);
                    197:                if (p == NULL)
                    198:                        break;
                    199:                if (p == (char *)-1)
                    200:                        continue;
                    201:                while (*(p - 1) == '\\' && (p - 2) >= line
                    202:                        && *(p - 2) != '\\') {
                    203:                        *(p - 1) = ' ';
                    204:                        p = read_line(p, LINELEN - (p - line), 0);
                    205:                        if (p == NULL)
                    206:                                break;
                    207:                        if (p == (char *)-1)
                    208:                                goto next;
                    209:                }
                    210:                parse_line(line);
                    211:        }
                    212:        printf("bye!\n");
                    213:        exit(0);
                    214:        return 0;
                    215: }

CVSweb