![[BACK]](/icons/back.gif){kind=icon}
Return to cmd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / stand / boot|
Return to cmd.c CVS log | Up to [local] / sys / stand / boot |
1.1 nbrk 1: /* $OpenBSD: cmd.c,v 1.59 2007/04/27 10:08:34 tom Exp $ */
2:
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: */
28:
29: #include <sys/param.h>
30: #include <sys/reboot.h>
31:
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
39:
40: #include "cmd.h"
41:
42: #define CTRL(c) ((c)&0x1f)
43:
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);
58:
59: #ifdef CHECK_SKIP_CONF
60: extern int CHECK_SKIP_CONF(void);
61: #endif
62:
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: };
80:
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 *);
86:
87: char cmd_buf[CMD_BUFF_SIZE];
88:
89: int
90: getcmd(void)
91: {
92: cmd.cmd = NULL;
93:
94: if (!readline(cmd_buf, sizeof(cmd_buf), cmd.timeout))
95: cmd.cmd = cmd_table;
96:
97: return docmd();
98: }
99:
100: int
101: read_conf(void)
102: {
103: #ifndef INSECURE
104: struct stat sb;
105: #endif
106: int fd, rc = 0;
107:
108: #ifdef CHECK_SKIP_CONF
109: if (CHECK_SKIP_CONF()) {
110: printf("boot.conf processing skipped at operator request\n");
111: return -1; /* Pretend file wasn't found */
112: }
113: #endif
114:
115: if ((fd = open(qualify(cmd.conf), 0)) < 0) {
116: if (errno != ENOENT && errno != ENXIO) {
117: printf("open(%s): %s\n", cmd.path, strerror(errno));
118: return 0;
119: }
120: return -1;
121: }
122:
123: #ifndef INSECURE
124: (void) fstat(fd, &sb);
125: if (sb.st_uid || (sb.st_mode & 2)) {
126: printf("non-secure %s, will not proceed\n", cmd.path);
127: close(fd);
128: return -1;
129: }
130: #endif
131:
132: do {
133: char *p = cmd_buf;
134:
135: cmd.cmd = NULL;
136:
137: do {
138: rc = read(fd, p, 1);
139: } while (rc > 0 && *p++ != '\n' &&
140: (p-cmd_buf) < sizeof(cmd_buf));
141:
142: if (rc < 0) { /* Error from read() */
143: printf("%s: %s\n", cmd.path, strerror(errno));
144: break;
145: }
146:
147: if (rc == 0) { /* eof from read() */
148: if (p != cmd_buf) { /* Line w/o trailing \n */
149: *p = '\0';
150: rc = docmd();
151: break;
152: }
153: } else { /* rc > 0, read a char */
154: p--; /* Get back to last character */
155:
156: if (*p != '\n') { /* Line was too long */
157: printf("%s: line too long\n", cmd.path);
158:
159: /* Don't want to run the truncated command */
160: rc = -1;
161: }
162:
163: *p = '\0';
164: }
165:
166: } while (rc > 0 && !(rc = docmd()));
167:
168: close(fd);
169: return rc;
170: }
171:
172: int
173: docmd(void)
174: {
175: char *p = NULL;
176: const struct cmd_table *ct = cmd_table, *cs;
177:
178: cmd.argc = 1;
179: if (cmd.cmd == NULL) {
180:
181: /* command */
182: for (p = cmd_buf; *p == ' ' || *p == '\t'; p++)
183: ;
184: if (*p == '#' || *p == '\0') { /* comment or empty string */
185: #ifdef DEBUG
186: printf("rem\n");
187: #endif
188: return 0;
189: }
190: ct = cmd_table;
191: cs = NULL;
192: cmd.argv[cmd.argc] = p; /* in case it's shortcut boot */
193: p = whatcmd(&ct, p);
194: if (ct == NULL) {
195: cmd.argc++;
196: ct = cmd_table;
197: } else if (ct->cmd_type == CMDT_SET && p != NULL) {
198: cs = cmd_set;
199: #ifdef MACHINE_CMD
200: } else if (ct->cmd_type == CMDT_MDC && p != NULL) {
201: cs = MACHINE_CMD;
202: #endif
203: }
204:
205: if (cs != NULL) {
206: p = whatcmd(&cs, p);
207: if (cs == NULL) {
208: printf("%s: syntax error\n", ct->cmd_name);
209: return 0;
210: }
211: ct = cs;
212: }
213: cmd.cmd = ct;
214: }
215:
216: cmd.argv[0] = ct->cmd_name;
217: while (p && cmd.argc+1 < sizeof(cmd.argv) / sizeof(cmd.argv[0])) {
218: cmd.argv[cmd.argc++] = p;
219: p = nextword(p);
220: }
221: cmd.argv[cmd.argc] = NULL;
222:
223: #ifdef REGRESS
224: 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: }
230:
231: static char *
232: whatcmd(const struct cmd_table **ct, char *p)
233: {
234: char *q;
235: int l;
236:
237: q = nextword(p);
238:
239: for (l = 0; p[l]; l++)
240: ;
241:
242: while ((*ct)->cmd_name != NULL && strncmp(p, (*ct)->cmd_name, l))
243: (*ct)++;
244:
245: if ((*ct)->cmd_name == NULL)
246: *ct = NULL;
247:
248: return q;
249: }
250:
251: static int
252: readline(char *buf, size_t n, int to)
253: {
254: #ifdef DEBUG
255: extern int debug;
256: #endif
257: char *p = buf, ch;
258:
259: /* Only do timeout if greater than 0 */
260: if (to > 0) {
261: u_long i = 0;
262: time_t tt = getsecs() + to;
263: #ifdef DEBUG
264: if (debug > 2)
265: 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;
272:
273: if (!cnischar()) {
274: strlcpy(buf, "boot", 5);
275: putchar('\n');
276: return strlen(buf);
277: }
278: } else
279: while (!cnischar())
280: ;
281:
282: /* User has typed something. Turn off timeouts. */
283: cmd.timeout = 0;
284:
285: while (1) {
286: switch ((ch = getchar())) {
287: case CTRL('u'):
288: while (p > buf) {
289: putchar('\177');
290: p--;
291: }
292: continue;
293: case '\n':
294: case '\r':
295: p[1] = *p = '\0';
296: break;
297: case '\b':
298: case '\177':
299: if (p > buf) {
300: putchar('\177');
301: p--;
302: }
303: continue;
304: default:
305: if (ch >= ' ' && ch < '\177') {
306: if (p - buf < n-1)
307: *p++ = ch;
308: else {
309: putchar('\007');
310: putchar('\177');
311: }
312: }
313: continue;
314: }
315: break;
316: }
317:
318: return p - buf;
319: }
320:
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 *
327: nextword(char *p)
328: {
329: /* skip blanks */
330: while (*p && *p != '\t' && *p != ' ')
331: p++;
332: if (*p) {
333: *p++ = '\0';
334: while (*p == '\t' || *p == ' ')
335: p++;
336: }
337: if (*p == '\0')
338: p = NULL;
339: return p;
340: }
341:
342: static void
343: print_help(const struct cmd_table *ct)
344: {
345: for (; ct->cmd_name != NULL; ct++)
346: printf(" %s", ct->cmd_name);
347: putchar('\n');
348: }
349:
350: static int
351: Xhelp(void)
352: {
353: printf("commands:");
354: print_help(cmd_table);
355: #ifdef MACHINE_CMD
356: return Xmachine();
357: #else
358: return 0;
359: #endif
360: }
361:
362: #ifdef MACHINE_CMD
363: static int
364: Xmachine(void)
365: {
366: printf("machine:");
367: print_help(MACHINE_CMD);
368: return 0;
369: }
370: #endif
371:
372: static int
373: Xecho(void)
374: {
375: int i;
376:
377: for (i = 1; i < cmd.argc; i++)
378: printf("%s ", cmd.argv[i]);
379: putchar('\n');
380: return 0;
381: }
382:
383: static int
384: Xstty(void)
385: {
386: int sp;
387: char *cp;
388: dev_t dev;
389:
390: if (cmd.argc == 1)
391: printf("%s speed is %d\n", ttyname(0), cnspeed(0, -1));
392: else {
393: dev = ttydev(cmd.argv[1]);
394: if (dev == NODEV)
395: printf("%s not a console device\n", cmd.argv[1]);
396: else {
397: if (cmd.argc == 2)
398: printf("%s speed is %d\n", cmd.argv[1],
399: cnspeed(dev, -1));
400: else {
401: sp = 0;
402: for (cp = cmd.argv[2]; *cp && isdigit(*cp); cp++)
403: sp = sp * 10 + (*cp - '0');
404: cnspeed(dev, sp);
405: }
406: }
407: }
408:
409: return 0;
410: }
411:
412: static int
413: Xtime(void)
414: {
415: time_t tt = getsecs();
416:
417: if (cmd.argc == 1)
418: printf(ctime(&tt));
419: else {
420: }
421:
422: return 0;
423: }
424:
425: static int
426: Xls(void)
427: {
428: struct stat sb;
429: char *p;
430: int fd;
431:
432: if (stat(qualify((cmd.argv[1]? cmd.argv[1]: "/.")), &sb) < 0) {
433: printf("stat(%s): %s\n", cmd.path, strerror(errno));
434: return 0;
435: }
436:
437: if ((sb.st_mode & S_IFMT) != S_IFDIR)
438: ls(cmd.path, &sb);
439: else {
440: if ((fd = opendir(cmd.path)) < 0) {
441: printf ("opendir(%s): %s\n", cmd.path,
442: strerror(errno));
443: return 0;
444: }
445:
446: /* no strlen in lib !!! */
447: for (p = cmd.path; *p; p++)
448: ;
449: *p++ = '/';
450: *p = '\0';
451:
452: while(readdir(fd, p) >= 0) {
453: if (stat(cmd.path, &sb) < 0)
454: printf("stat(%s): %s\n", cmd.path,
455: strerror(errno));
456: else
457: ls(p, &sb);
458: }
459: closedir (fd);
460: }
461: return 0;
462: }
463:
464: #define lsrwx(mode,s) \
465: putchar ((mode) & S_IROTH? 'r' : '-'); \
466: putchar ((mode) & S_IWOTH? 'w' : '-'); \
467: putchar ((mode) & S_IXOTH? *(s): (s)[1]);
468:
469: static void
470: ls(char *name, struct stat *sb)
471: {
472: putchar("-fc-d-b---l-s-w-"[(sb->st_mode & S_IFMT) >> 12]);
473: lsrwx(sb->st_mode >> 6, (sb->st_mode & S_ISUID? "sS" : "x-"));
474: lsrwx(sb->st_mode >> 3, (sb->st_mode & S_ISGID? "sS" : "x-"));
475: lsrwx(sb->st_mode , (sb->st_mode & S_ISTXT? "tT" : "x-"));
476:
477: 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
481:
482: int doboot = 1;
483:
484: static int
485: Xnop(void)
486: {
487: if (doboot) {
488: doboot = 0;
489: return (Xboot());
490: }
491:
492: return 0;
493: }
494:
495: static int
496: Xboot(void)
497: {
498: if (cmd.argc > 1 && cmd.argv[1][0] != '-') {
499: 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;
505: snprintf(cmd.path, sizeof cmd.path, "%s:%s",
506: cmd.bootdev, cmd.image);
507: }
508:
509: return 1;
510: }
511:
512: /*
513: * Qualifies the path adding necessary dev
514: */
515:
516: static char *
517: qualify(char *name)
518: {
519: char *p;
520:
521: for (p = name; *p; p++)
522: if (*p == ':')
523: break;
524: if (*p == ':')
525: strlcpy(cmd.path, name, sizeof(cmd.path));
526: else
527: snprintf(cmd.path, sizeof cmd.path, "%s:%s",
528: cmd.bootdev, name);
529: return cmd.path;
530: }
531:
532: static int
533: Xreboot(void)
534: {
535: printf("Rebooting...\n");
536: exit();
537: return 0; /* just in case */
538: }
539: