root/stand/boot/cmd.c

DEFINITIONS

1. getcmd
2. read_conf
3. docmd
4. whatcmd
5. readline
6. nextword
7. print_help
8. Xhelp
9. Xmachine
10. Xecho
11. Xstty
12. Xtime
13. Xls
14. ls
15. Xnop
16. Xboot
17. qualify
18. Xreboot

    1 /*      $OpenBSD: cmd.c,v 1.59 2007/04/27 10:08:34 tom Exp $    */
    3 /*
    4  * Copyright (c) 1997-1999 Michael Shalayeff
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   29 #include <sys/param.h>
   30 #include <sys/reboot.h>
   32 #ifdef REGRESS
   33 #include <sys/stat.h>
   34 #include <errno.h>
   35 #else
   36 #include <libsa.h>
   37 #include <lib/libkern/funcs.h>
   38 #endif
   40 #include "cmd.h"
   42 #define CTRL(c) ((c)&0x1f)
   44 static int Xboot(void);
   45 static int Xecho(void);
   46 static int Xhelp(void);
   47 static int Xls(void);
   48 static int Xnop(void);
   49 static int Xreboot(void);
   50 static int Xstty(void);
   51 static int Xtime(void);
   52 #ifdef MACHINE_CMD
   53 static int Xmachine(void);
   54 extern const struct cmd_table MACHINE_CMD[];
   55 #endif
   56 extern int Xset(void);
   57 extern int Xenv(void);
   59 #ifdef CHECK_SKIP_CONF
   60 extern int CHECK_SKIP_CONF(void);
   61 #endif
   63 extern const struct cmd_table cmd_set[];
   64 const struct cmd_table cmd_table[] = {
   65         {"#",      CMDT_CMD, Xnop},  /* XXX must be first */
   66         {"boot",   CMDT_CMD, Xboot},
   67         {"echo",   CMDT_CMD, Xecho},
   68         {"env",    CMDT_CMD, Xenv},
   69         {"help",   CMDT_CMD, Xhelp},
   70         {"ls",     CMDT_CMD, Xls},
   71 #ifdef MACHINE_CMD
   72         {"machine",CMDT_MDC, Xmachine},
   73 #endif
   74         {"reboot", CMDT_CMD, Xreboot},
   75         {"set",    CMDT_SET, Xset},
   76         {"stty",   CMDT_CMD, Xstty},
   77         {"time",   CMDT_CMD, Xtime},
   78         {NULL, 0},
   79 };
   81 static void ls(char *, struct stat *);
   82 static int readline(char *, size_t, int);
   83 char *nextword(char *);
   84 static char *whatcmd(const struct cmd_table **ct, char *);
   85 static char *qualify(char *);
   87 char cmd_buf[CMD_BUFF_SIZE];
   89 int
getcmd(void)
   91 {
cmd.cmd = NULL;
   94         if (!readline(cmd_buf, sizeof(cmd_buf), cmd.timeout))
cmd.cmd = cmd_table;
   97         return docmd();
   98 }
  100 int
read_conf(void)
  102 {
  103 #ifndef INSECURE
  104         struct stat sb;
  105 #endif
  106         int fd, rc = 0;
  108 #ifdef CHECK_SKIP_CONF
  109         if (CHECK_SKIP_CONF()) {
printf("boot.conf processing skipped at operator request\n");
  111                 return -1;              /* Pretend file wasn't found */
  112         }
  113 #endif
  115         if ((fd = open(qualify(cmd.conf), 0)) < 0) {
  116                 if (errno != ENOENT && errno != ENXIO) {
printf("open(%s): %s\n", cmd.path, strerror(errno));
  118                         return 0;
  119                 }
  120                 return -1;
  121         }
  123 #ifndef INSECURE
  124         (void) fstat(fd, &sb);
  125         if (sb.st_uid || (sb.st_mode & 2)) {
printf("non-secure %s, will not proceed\n", cmd.path);
close(fd);
  128                 return -1;
  129         }
  130 #endif
  132         do {
  133                 char *p = cmd_buf;
cmd.cmd = NULL;
  137                 do {
rc = read(fd, p, 1);
  139                 } while (rc > 0 && *p++ != '\n' &&
  140                     (p-cmd_buf) < sizeof(cmd_buf));
  142                 if (rc < 0) {                   /* Error from read() */
printf("%s: %s\n", cmd.path, strerror(errno));
  144                         break;
  145                 }
  147                 if (rc == 0) {                  /* eof from read() */
  148                         if (p != cmd_buf) {     /* Line w/o trailing \n */
  149                                 *p = '\0';
rc = docmd();
  151                                 break;
  152                         }
  153                 } else {                        /* rc > 0, read a char */
p--;                    /* Get back to last character */
  156                         if (*p != '\n') {       /* Line was too long */
printf("%s: line too long\n", cmd.path);
  159                                 /* Don't want to run the truncated command */
rc = -1;
  161                         }
  163                         *p = '\0';
  164                 }
  166         } while (rc > 0 && !(rc = docmd()));
close(fd);
  169         return rc;
  170 }
  172 int
docmd(void)
  174 {
  175         char *p = NULL;
  176         const struct cmd_table *ct = cmd_table, *cs;
cmd.argc = 1;
  179         if (cmd.cmd == NULL) {
  181                 /* command */
  182                 for (p = cmd_buf; *p == ' ' || *p == '\t'; p++)
  183                         ;
  184                 if (*p == '#' || *p == '\0') { /* comment or empty string */
  185 #ifdef DEBUG
printf("rem\n");
  187 #endif
  188                         return 0;
  189                 }
ct = cmd_table;
cs = NULL;
cmd.argv[cmd.argc] = p; /* in case it's shortcut boot */
p = whatcmd(&ct, p);
  194                 if (ct == NULL) {
cmd.argc++;
ct = cmd_table;
  197                 } else if (ct->cmd_type == CMDT_SET && p != NULL) {
cs = cmd_set;
  199 #ifdef MACHINE_CMD
  200                 } else if (ct->cmd_type == CMDT_MDC && p != NULL) {
cs = MACHINE_CMD;
  202 #endif
  203                 }
  205                 if (cs != NULL) {
p = whatcmd(&cs, p);
  207                         if (cs == NULL) {
printf("%s: syntax error\n", ct->cmd_name);
  209                                 return 0;
  210                         }
ct = cs;
  212                 }
cmd.cmd = ct;
  214         }
cmd.argv[0] = ct->cmd_name;
  217         while (p && cmd.argc+1 < sizeof(cmd.argv) / sizeof(cmd.argv[0])) {
cmd.argv[cmd.argc++] = p;
p = nextword(p);
  220         }
cmd.argv[cmd.argc] = NULL;
  223 #ifdef REGRESS
printf("%s %s\n", cmd.argv[0],
  225             (cmd.argv[1] == NULL) ? "(null)" : cmd.argv[1]);
  226 #else
  227         return (*cmd.cmd->cmd_exec)();
  228 #endif
  229 }
  231 static char *
whatcmd(const struct cmd_table **ct, char *p)
  233 {
  234         char *q;
  235         int l;
q = nextword(p);
  239         for (l = 0; p[l]; l++)
  240                 ;
  242         while ((*ct)->cmd_name != NULL && strncmp(p, (*ct)->cmd_name, l))
  243                 (*ct)++;
  245         if ((*ct)->cmd_name == NULL)
  246                 *ct = NULL;
  248         return q;
  249 }
  251 static int
readline(char *buf, size_t n, int to)
  253 {
  254 #ifdef DEBUG
  255         extern int debug;
  256 #endif
  257         char *p = buf, ch;
  259         /* Only do timeout if greater than 0 */
  260         if (to > 0) {
u_long i = 0;
time_t tt = getsecs() + to;
  263 #ifdef DEBUG
  264                 if (debug > 2)
printf ("readline: timeout(%d) at %u\n", to, tt);
  266 #endif
  267                 /* check for timeout expiration less often
  268                    (for some very constrained archs) */
  269                 while (!cnischar())
  270                         if (!(i++ % 1000) && (getsecs() >= tt))
  271                                 break;
  273                 if (!cnischar()) {
strlcpy(buf, "boot", 5);
putchar('\n');
  276                         return strlen(buf);
  277                 }
  278         } else
  279                 while (!cnischar())
  280                         ;
  282         /* User has typed something.  Turn off timeouts. */
cmd.timeout = 0;
  285         while (1) {
  286                 switch ((ch = getchar())) {
  287                 case CTRL('u'):
  288                         while (p > buf) {
putchar('\177');
p--;
  291                         }
  292                         continue;
  293                 case '\n':
  294                 case '\r':
p[1] = *p = '\0';
  296                         break;
  297                 case '\b':
  298                 case '\177':
  299                         if (p > buf) {
putchar('\177');
p--;
  302                         }
  303                         continue;
  304                 default:
  305                         if (ch >= ' ' && ch < '\177') {
  306                                 if (p - buf < n-1)
  307                                         *p++ = ch;
  308                                 else {
putchar('\007');
putchar('\177');
  311                                 }
  312                         }
  313                         continue;
  314                 }
  315                 break;
  316         }
  318         return p - buf;
  319 }
  321 /*
  322  * Search for spaces/tabs after the current word. If found, \0 the
  323  * first one.  Then pass a pointer to the first character of the
  324  * next word, or NULL if there is no next word.
  325  */
  326 char *
nextword(char *p)
  328 {
  329         /* skip blanks */
  330         while (*p && *p != '\t' && *p != ' ')
p++;
  332         if (*p) {
  333                 *p++ = '\0';
  334                 while (*p == '\t' || *p == ' ')
p++;
  336         }
  337         if (*p == '\0')
p = NULL;
  339         return p;
  340 }
  342 static void
print_help(const struct cmd_table *ct)
  344 {
  345         for (; ct->cmd_name != NULL; ct++)
printf(" %s", ct->cmd_name);
putchar('\n');
  348 }
  350 static int
Xhelp(void)
  352 {
printf("commands:");
print_help(cmd_table);
  355 #ifdef MACHINE_CMD
  356         return Xmachine();
  357 #else
  358         return 0;
  359 #endif
  360 }
  362 #ifdef MACHINE_CMD
  363 static int
Xmachine(void)
  365 {
printf("machine:");
print_help(MACHINE_CMD);
  368         return 0;
  369 }
  370 #endif
  372 static int
Xecho(void)
  374 {
  375         int i;
  377         for (i = 1; i < cmd.argc; i++)
printf("%s ", cmd.argv[i]);
putchar('\n');
  380         return 0;
  381 }
  383 static int
Xstty(void)
  385 {
  386         int sp;
  387         char *cp;
dev_t dev;
  390         if (cmd.argc == 1)
printf("%s speed is %d\n", ttyname(0), cnspeed(0, -1));
  392         else {
dev = ttydev(cmd.argv[1]);
  394                 if (dev == NODEV)
printf("%s not a console device\n", cmd.argv[1]);
  396                 else {
  397                         if (cmd.argc == 2)
printf("%s speed is %d\n", cmd.argv[1],
cnspeed(dev, -1));
  400                         else {
sp = 0;
  402                                 for (cp = cmd.argv[2]; *cp && isdigit(*cp); cp++)
sp = sp * 10 + (*cp - '0');
cnspeed(dev, sp);
  405                         }
  406                 }
  407         }
  409         return 0;
  410 }
  412 static int
Xtime(void)
  414 {
time_t tt = getsecs();
  417         if (cmd.argc == 1)
printf(ctime(&tt));
  419         else {
  420         }
  422         return 0;
  423 }
  425 static int
Xls(void)
  427 {
  428         struct stat sb;
  429         char *p;
  430         int fd;
  432         if (stat(qualify((cmd.argv[1]? cmd.argv[1]: "/.")), &sb) < 0) {
printf("stat(%s): %s\n", cmd.path, strerror(errno));
  434                 return 0;
  435         }
  437         if ((sb.st_mode & S_IFMT) != S_IFDIR)
ls(cmd.path, &sb);
  439         else {
  440                 if ((fd = opendir(cmd.path)) < 0) {
printf ("opendir(%s): %s\n", cmd.path,
strerror(errno));
  443                         return 0;
  444                 }
  446                 /* no strlen in lib !!! */
  447                 for (p = cmd.path; *p; p++)
  448                         ;
  449                 *p++ = '/';
  450                 *p = '\0';
  452                 while(readdir(fd, p) >= 0) {
  453                         if (stat(cmd.path, &sb) < 0)
printf("stat(%s): %s\n", cmd.path,
strerror(errno));
  456                         else
ls(p, &sb);
  458                 }
closedir (fd);
  460         }
  461         return 0;
  462 }
  464 #define lsrwx(mode,s) \
putchar ((mode) & S_IROTH? 'r' : '-'); \
putchar ((mode) & S_IWOTH? 'w' : '-'); \
putchar ((mode) & S_IXOTH? *(s): (s)[1]);
  469 static void
ls(char *name, struct stat *sb)
  471 {
putchar("-fc-d-b---l-s-w-"[(sb->st_mode & S_IFMT) >> 12]);
lsrwx(sb->st_mode >> 6, (sb->st_mode & S_ISUID? "sS" : "x-"));
lsrwx(sb->st_mode >> 3, (sb->st_mode & S_ISGID? "sS" : "x-"));
lsrwx(sb->st_mode     , (sb->st_mode & S_ISTXT? "tT" : "x-"));
printf (" %u,%u\t%lu\t%s\n", sb->st_uid, sb->st_gid,
  478             (u_long)sb->st_size, name);
  479 }
  480 #undef lsrwx
  482 int doboot = 1;
  484 static int
Xnop(void)
  486 {
  487         if (doboot) {
doboot = 0;
  489                 return (Xboot());
  490         }
  492         return 0;
  493 }
  495 static int
Xboot(void)
  497 {
  498         if (cmd.argc > 1 && cmd.argv[1][0] != '-') {
qualify((cmd.argv[1]? cmd.argv[1]: cmd.image));
  500                 if (bootparse(2))
  501                         return 0;
  502         } else {
  503                 if (bootparse(1))
  504                         return 0;
snprintf(cmd.path, sizeof cmd.path, "%s:%s",
cmd.bootdev, cmd.image);
  507         }
  509         return 1;
  510 }
  512 /*
  513  * Qualifies the path adding necessary dev
  514  */
  516 static char *
qualify(char *name)
  518 {
  519         char *p;
  521         for (p = name; *p; p++)
  522                 if (*p == ':')
  523                         break;
  524         if (*p == ':')
strlcpy(cmd.path, name, sizeof(cmd.path));
  526         else
snprintf(cmd.path, sizeof cmd.path, "%s:%s",
cmd.bootdev, name);
  529         return cmd.path;
  530 }
  532 static int
Xreboot(void)
  534 {
printf("Rebooting...\n");
exit();
  537         return 0; /* just in case */
  538 }