1 /*
2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright 2019 OmniOS Community Edition (OmniOSce) Association.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31 #include <errno.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <limits.h>
37 #include <unistd.h>
38 #include <dirent.h>
39 #include <macros.h>
40 #include <sys/systeminfo.h>
41 #include <sys/linker_set.h>
42 #include <sys/queue.h>
43 #include <sys/mnttab.h>
44 #include "loader_emu.h"
45 #include "gfx_fb.h"
46 #include "ficl.h"
47
48 #define MDIR_REMOVED 0x0001
49 #define MDIR_NOHINTS 0x0002
50
51 struct moduledir {
52 char *d_path; /* path of modules directory */
53 uchar_t *d_hints; /* content of linker.hints file */
54 int d_hintsz; /* size of hints data */
55 int d_flags;
56 STAILQ_ENTRY(moduledir) d_link;
57 };
58 static STAILQ_HEAD(, moduledir) moduledir_list =
59 STAILQ_HEAD_INITIALIZER(moduledir_list);
60
61 static const char *default_searchpath = "/platform/i86pc";
62
63 static char typestr[] = "?fc?d?b? ?l?s?w";
64 static int ls_getdir(char **pathp);
65 extern char **_environ;
66
67 char *command_errmsg;
68 char command_errbuf[256];
69
70 extern void pager_open(void);
71 extern void pager_close(void);
72 extern int pager_output(const char *);
73 extern int pager_file(const char *);
74 static int page_file(char *);
75 static int include(const char *);
76
77 static int command_help(int argc, char *argv[]);
78 static int command_commandlist(int argc, char *argv[]);
79 static int command_show(int argc, char *argv[]);
80 static int command_set(int argc, char *argv[]);
81 static int command_setprop(int argc, char *argv[]);
82 static int command_unset(int argc, char *argv[]);
83 static int command_echo(int argc, char *argv[]);
84 static int command_read(int argc, char *argv[]);
85 static int command_more(int argc, char *argv[]);
86 static int command_ls(int argc, char *argv[]);
87 static int command_include(int argc, char *argv[]);
88 static int command_autoboot(int argc, char *argv[]);
89 static int command_boot(int argc, char *argv[]);
90 static int command_unload(int argc, char *argv[]);
91 static int command_load(int argc, char *argv[]);
92 static int command_reboot(int argc, char *argv[]);
93 static int command_sifting(int argc, char *argv[]);
94 static int command_framebuffer(int argc, char *argv[]);
95
96 #define BF_PARSE 100
97 #define BF_DICTSIZE 30000
98
99 /* update when loader version will change */
100 static const char bootprog_rev[] = "1.1";
101
102 /*
103 * BootForth Interface to Ficl Forth interpreter.
104 */
105
106 ficlSystem *bf_sys;
107 ficlVm *bf_vm;
108
109 /*
110 * Redistribution and use in source and binary forms, with or without
111 * modification, are permitted provided that the following conditions
112 * are met:
113 * 1. Redistributions of source code must retain the above copyright
114 * notice, this list of conditions and the following disclaimer.
115 * 2. Redistributions in binary form must reproduce the above copyright
116 * notice, this list of conditions and the following disclaimer in the
117 * documentation and/or other materials provided with the distribution.
118 *
119 * Jordan K. Hubbard
120 * 29 August 1998
121 *
122 * The meat of the simple parser.
123 */
124
125 static void clean(void);
126 static int insert(int *argcp, char *buf);
127
128 #define PARSE_BUFSIZE 1024 /* maximum size of one element */
129 #define MAXARGS 20 /* maximum number of elements */
130 static char *args[MAXARGS];
131
132 #define DIGIT(x) \
133 (isdigit(x) ? (x) - '0' : islower(x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
134
135 /*
136 * backslash: Return malloc'd copy of str with all standard "backslash
137 * processing" done on it. Original can be free'd if desired.
138 */
139 char *
backslash(char * str)140 backslash(char *str)
141 {
142 /*
143 * Remove backslashes from the strings. Turn \040 etc. into a single
144 * character (we allow eight bit values). Currently NUL is not
145 * allowed.
146 *
147 * Turn "\n" and "\t" into '\n' and '\t' characters. Etc.
148 */
149 char *new_str;
150 int seenbs = 0;
151 int i = 0;
152
153 if ((new_str = strdup(str)) == NULL)
154 return (NULL);
155
156 while (*str) {
157 if (seenbs) {
158 seenbs = 0;
159 switch (*str) {
160 case '\\':
161 new_str[i++] = '\\';
162 str++;
163 break;
164
165 /* preserve backslashed quotes, dollar signs */
166 case '\'':
167 case '"':
168 case '$':
169 new_str[i++] = '\\';
170 new_str[i++] = *str++;
171 break;
172
173 case 'b':
174 new_str[i++] = '\b';
175 str++;
176 break;
177
178 case 'f':
179 new_str[i++] = '\f';
180 str++;
181 break;
182
183 case 'r':
184 new_str[i++] = '\r';
185 str++;
186 break;
187
188 case 'n':
189 new_str[i++] = '\n';
190 str++;
191 break;
192
193 case 's':
194 new_str[i++] = ' ';
195 str++;
196 break;
197
198 case 't':
199 new_str[i++] = '\t';
200 str++;
201 break;
202
203 case 'v':
204 new_str[i++] = '\13';
205 str++;
206 break;
207
208 case 'z':
209 str++;
210 break;
211
212 case '0': case '1': case '2': case '3': case '4':
213 case '5': case '6': case '7': case '8': case '9': {
214 char val;
215
216 /* Three digit octal constant? */
217 if (*str >= '0' && *str <= '3' &&
218 *(str + 1) >= '0' && *(str + 1) <= '7' &&
219 *(str + 2) >= '0' && *(str + 2) <= '7') {
220
221 val = (DIGIT(*str) << 6) +
222 (DIGIT(*(str + 1)) << 3) +
223 DIGIT(*(str + 2));
224
225 /*
226 * Allow null value if user really
227 * wants to shoot at feet, but beware!
228 */
229 new_str[i++] = val;
230 str += 3;
231 break;
232 }
233
234 /*
235 * One or two digit hex constant?
236 * If two are there they will both be taken.
237 * Use \z to split them up if this is not
238 * wanted.
239 */
240 if (*str == '0' &&
241 (*(str + 1) == 'x' || *(str + 1) == 'X') &&
242 isxdigit(*(str + 2))) {
243 val = DIGIT(*(str + 2));
244 if (isxdigit(*(str + 3))) {
245 val = (val << 4) +
246 DIGIT(*(str + 3));
247 str += 4;
248 } else
249 str += 3;
250 /* Yep, allow null value here too */
251 new_str[i++] = val;
252 break;
253 }
254 }
255 break;
256
257 default:
258 new_str[i++] = *str++;
259 break;
260 }
261 } else {
262 if (*str == '\\') {
263 seenbs = 1;
264 str++;
265 } else
266 new_str[i++] = *str++;
267 }
268 }
269
270 if (seenbs) {
271 /*
272 * The final character was a '\'.
273 * Put it in as a single backslash.
274 */
275 new_str[i++] = '\\';
276 }
277 new_str[i] = '\0';
278 return (new_str);
279 }
280
281 /*
282 * parse: accept a string of input and "parse" it for backslash
283 * substitutions and environment variable expansions (${var}),
284 * returning an argc/argv style vector of whitespace separated
285 * arguments. Returns 0 on success, 1 on failure (ok, ok, so I
286 * wimped-out on the error codes! :).
287 *
288 * Note that the argv array returned must be freed by the caller, but
289 * we own the space allocated for arguments and will free that on next
290 * invocation. This allows argv consumers to modify the array if
291 * required.
292 *
293 * NB: environment variables that expand to more than one whitespace
294 * separated token will be returned as a single argv[] element, not
295 * split in turn. Expanded text is also immune to further backslash
296 * elimination or expansion since this is a one-pass, non-recursive
297 * parser. You didn't specify more than this so if you want more, ask
298 * me. - jkh
299 */
300
301 #define PARSE_FAIL(expr) \
302 if (expr) { \
303 printf("fail at line %d\n", __LINE__); \
304 clean(); \
305 free(copy); \
306 free(buf); \
307 return (1); \
308 }
309
310 /* Accept the usual delimiters for a variable, returning counterpart */
311 static char
isdelim(int ch)312 isdelim(int ch)
313 {
314 if (ch == '{')
315 return ('}');
316 else if (ch == '(')
317 return (')');
318 return ('\0');
319 }
320
321 static int
isquote(int ch)322 isquote(int ch)
323 {
324 return (ch == '\'');
325 }
326
327 static int
isdquote(int ch)328 isdquote(int ch)
329 {
330 return (ch == '"');
331 }
332
333 int
parse(int * argc,char *** argv,char * str)334 parse(int *argc, char ***argv, char *str)
335 {
336 int ac;
337 char *val, *p, *q, *copy = NULL;
338 size_t i = 0;
339 char token, tmp, quote, dquote, *buf;
340 enum { STR, VAR, WHITE } state;
341
342 ac = *argc = 0;
343 dquote = quote = 0;
344 if (!str || (p = copy = backslash(str)) == NULL)
345 return (1);
346
347 /* Initialize vector and state */
348 clean();
349 state = STR;
350 buf = (char *)malloc(PARSE_BUFSIZE);
351 token = 0;
352
353 /* And awaaaaaaaaay we go! */
354 while (*p) {
355 switch (state) {
356 case STR:
357 if ((*p == '\\') && p[1]) {
358 p++;
359 PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
360 buf[i++] = *p++;
361 } else if (isquote(*p)) {
362 quote = quote ? 0 : *p;
363 if (dquote) { /* keep quote */
364 PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
365 buf[i++] = *p++;
366 } else
367 ++p;
368 } else if (isdquote(*p)) {
369 dquote = dquote ? 0 : *p;
370 if (quote) { /* keep dquote */
371 PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
372 buf[i++] = *p++;
373 } else
374 ++p;
375 } else if (isspace(*p) && !quote && !dquote) {
376 state = WHITE;
377 if (i) {
378 buf[i] = '\0';
379 PARSE_FAIL(insert(&ac, buf));
380 i = 0;
381 }
382 ++p;
383 } else if (*p == '$' && !quote) {
384 token = isdelim(*(p + 1));
385 if (token)
386 p += 2;
387 else
388 ++p;
389 state = VAR;
390 } else {
391 PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
392 buf[i++] = *p++;
393 }
394 break;
395
396 case WHITE:
397 if (isspace(*p))
398 ++p;
399 else
400 state = STR;
401 break;
402
403 case VAR:
404 if (token) {
405 PARSE_FAIL((q = strchr(p, token)) == NULL);
406 } else {
407 q = p;
408 while (*q && !isspace(*q))
409 ++q;
410 }
411 tmp = *q;
412 *q = '\0';
413 if ((val = getenv(p)) != NULL) {
414 size_t len = strlen(val);
415
416 (void) strncpy(buf + i, val,
417 PARSE_BUFSIZE - (i + 1));
418 i += min(len, PARSE_BUFSIZE - 1);
419 }
420 *q = tmp; /* restore value */
421 p = q + (token ? 1 : 0);
422 state = STR;
423 break;
424 }
425 }
426 /* missing terminating ' or " */
427 PARSE_FAIL(quote || dquote);
428 /* If at end of token, add it */
429 if (i && state == STR) {
430 buf[i] = '\0';
431 PARSE_FAIL(insert(&ac, buf));
432 }
433 args[ac] = NULL;
434 *argc = ac;
435 *argv = (char **)malloc((sizeof (char *) * ac + 1));
436 bcopy(args, *argv, sizeof (char *) * ac + 1);
437 free(buf);
438 free(copy);
439 return (0);
440 }
441
442 #define MAXARGS 20
443
444 /* Clean vector space */
445 static void
clean(void)446 clean(void)
447 {
448 int i;
449
450 for (i = 0; i < MAXARGS; i++) {
451 if (args[i] != NULL) {
452 free(args[i]);
453 args[i] = NULL;
454 }
455 }
456 }
457
458 static int
insert(int * argcp,char * buf)459 insert(int *argcp, char *buf)
460 {
461 if (*argcp >= MAXARGS)
462 return (1);
463 args[(*argcp)++] = strdup(buf);
464 return (0);
465 }
466
467 static char *
isadir(void)468 isadir(void)
469 {
470 char *buf;
471 size_t bufsize = 20;
472 int ret;
473
474 if ((buf = malloc(bufsize)) == NULL)
475 return (NULL);
476 ret = sysinfo(SI_ARCHITECTURE_K, buf, bufsize);
477 if (ret == -1) {
478 free(buf);
479 return (NULL);
480 }
481 return (buf);
482 }
483
484 /*
485 * Shim for taking commands from BF and passing them out to 'standard'
486 * argv/argc command functions.
487 */
488 static void
bf_command(ficlVm * vm)489 bf_command(ficlVm *vm)
490 {
491 char *name, *line, *tail, *cp;
492 size_t len;
493 struct bootblk_command **cmdp;
494 bootblk_cmd_t *cmd;
495 int nstrings, i;
496 int argc, result;
497 char **argv;
498
499 /* Get the name of the current word */
500 name = vm->runningWord->name;
501
502 /* Find our command structure */
503 cmd = NULL;
504 SET_FOREACH(cmdp, Xcommand_set) {
505 if (((*cmdp)->c_name != NULL) &&
506 strcmp(name, (*cmdp)->c_name) == 0)
507 cmd = (*cmdp)->c_fn;
508 }
509 if (cmd == NULL)
510 printf("callout for unknown command '%s'\n", name);
511
512 /* Check whether we have been compiled or are being interpreted */
513 if (ficlStackPopInteger(ficlVmGetDataStack(vm))) {
514 /*
515 * Get parameters from stack, in the format:
516 * an un ... a2 u2 a1 u1 n --
517 * Where n is the number of strings, a/u are pairs of
518 * address/size for strings, and they will be concatenated
519 * in LIFO order.
520 */
521 nstrings = ficlStackPopInteger(ficlVmGetDataStack(vm));
522 for (i = 0, len = 0; i < nstrings; i++)
523 len += ficlStackFetch(ficlVmGetDataStack(vm),
524 i * 2).i + 1;
525 line = malloc(strlen(name) + len + 1);
526 (void) strcpy(line, name);
527
528 if (nstrings)
529 for (i = 0; i < nstrings; i++) {
530 len = ficlStackPopInteger(
531 ficlVmGetDataStack(vm));
532 cp = ficlStackPopPointer(
533 ficlVmGetDataStack(vm));
534 (void) strcat(line, " ");
535 (void) strncat(line, cp, len);
536 }
537 } else {
538 /* Get remainder of invocation */
539 tail = ficlVmGetInBuf(vm);
540 for (cp = tail, len = 0;
541 cp != vm->tib.end && *cp != 0 && *cp != '\n'; cp++, len++)
542 ;
543
544 line = malloc(strlen(name) + len + 2);
545 (void) strcpy(line, name);
546 if (len > 0) {
547 (void) strcat(line, " ");
548 (void) strncat(line, tail, len);
549 ficlVmUpdateTib(vm, tail + len);
550 }
551 }
552
553 command_errmsg = command_errbuf;
554 command_errbuf[0] = 0;
555 if (!parse(&argc, &argv, line)) {
556 result = (cmd)(argc, argv);
557 free(argv);
558 } else {
559 result = BF_PARSE;
560 }
561 free(line);
562 /*
563 * If there was error during nested ficlExec(), we may no longer have
564 * valid environment to return. Throw all exceptions from here.
565 */
566 if (result != 0)
567 ficlVmThrow(vm, result);
568 /* This is going to be thrown!!! */
569 ficlStackPushInteger(ficlVmGetDataStack(vm), result);
570 }
571
572 static char *
get_currdev(void)573 get_currdev(void)
574 {
575 int ret;
576 char *currdev;
577 FILE *fp;
578 struct mnttab mpref = {0};
579 struct mnttab mp = {0};
580
581 mpref.mnt_mountp = "/";
582 fp = fopen(MNTTAB, "r");
583
584 /* do the best we can to return something... */
585 if (fp == NULL)
586 return (strdup(":"));
587
588 ret = getmntany(fp, &mp, &mpref);
589 (void) fclose(fp);
590 if (ret == 0)
591 (void) asprintf(&currdev, "zfs:%s:", mp.mnt_special);
592 else
593 return (strdup(":"));
594
595 return (currdev);
596 }
597
598 /*
599 * Replace a word definition (a builtin command) with another
600 * one that:
601 *
602 * - Throw error results instead of returning them on the stack
603 * - Pass a flag indicating whether the word was compiled or is
604 * being interpreted.
605 *
606 * There is one major problem with builtins that cannot be overcome
607 * in anyway, except by outlawing it. We want builtins to behave
608 * differently depending on whether they have been compiled or they
609 * are being interpreted. Notice that this is *not* the interpreter's
610 * current state. For example:
611 *
612 * : example ls ; immediate
613 * : problem example ; \ "ls" gets executed while compiling
614 * example \ "ls" gets executed while interpreting
615 *
616 * Notice that, though the current state is different in the two
617 * invocations of "example", in both cases "ls" has been
618 * *compiled in*, which is what we really want.
619 *
620 * The problem arises when you tick the builtin. For example:
621 *
622 * : example-1 ['] ls postpone literal ; immediate
623 * : example-2 example-1 execute ; immediate
624 * : problem example-2 ;
625 * example-2
626 *
627 * We have no way, when we get EXECUTEd, of knowing what our behavior
628 * should be. Thus, our only alternative is to "outlaw" this. See RFI
629 * 0007, and ANS Forth Standard's appendix D, item 6.7 for a related
630 * problem, concerning compile semantics.
631 *
632 * The problem is compounded by the fact that "' builtin CATCH" is valid
633 * and desirable. The only solution is to create an intermediary word.
634 * For example:
635 *
636 * : my-ls ls ;
637 * : example ['] my-ls catch ;
638 *
639 * So, with the below implementation, here is a summary of the behavior
640 * of builtins:
641 *
642 * ls -l \ "interpret" behavior, ie,
643 * \ takes parameters from TIB
644 * : ex-1 s" -l" 1 ls ; \ "compile" behavior, ie,
645 * \ takes parameters from the stack
646 * : ex-2 ['] ls catch ; immediate \ undefined behavior
647 * : ex-3 ['] ls catch ; \ undefined behavior
648 * ex-2 ex-3 \ "interpret" behavior,
649 * \ catch works
650 * : ex-4 ex-2 ; \ "compile" behavior,
651 * \ catch does not work
652 * : ex-5 ex-3 ; immediate \ same as ex-2
653 * : ex-6 ex-3 ; \ same as ex-3
654 * : ex-7 ['] ex-1 catch ; \ "compile" behavior,
655 * \ catch works
656 * : ex-8 postpone ls ; immediate \ same as ex-2
657 * : ex-9 postpone ls ; \ same as ex-3
658 *
659 * As the definition below is particularly tricky, and it's side effects
660 * must be well understood by those playing with it, I'll be heavy on
661 * the comments.
662 *
663 * (if you edit this definition, pay attention to trailing spaces after
664 * each word -- I warned you! :-) )
665 */
666 #define BUILTIN_CONSTRUCTOR \
667 ": builtin: " \
668 ">in @ " /* save the tib index pointer */ \
669 "' " /* get next word's xt */ \
670 "swap >in ! " /* point again to next word */ \
671 "create " /* create a new definition of the next word */ \
672 ", " /* save previous definition's xt */ \
673 "immediate " /* make the new definition an immediate word */ \
674 \
675 "does> " /* Now, the *new* definition will: */ \
676 "state @ if " /* if in compiling state: */ \
677 "1 postpone literal " /* pass 1 flag to indicate compile */ \
678 "@ compile, " /* compile in previous definition */ \
679 "postpone throw " /* throw stack-returned result */ \
680 "else " /* if in interpreting state: */ \
681 "0 swap " /* pass 0 flag to indicate interpret */ \
682 "@ execute " /* call previous definition */ \
683 "throw " /* throw stack-returned result */ \
684 "then ; "
685
686 extern int ficlExecFD(ficlVm *, int);
687
688 /*
689 * Initialise the Forth interpreter, create all our commands as words.
690 */
691 ficlVm *
bf_init(const char * rc,ficlOutputFunction out)692 bf_init(const char *rc, ficlOutputFunction out)
693 {
694 struct bootblk_command **cmdp;
695 char create_buf[41]; /* 31 characters-long builtins */
696 char *buf;
697 int fd, rv;
698 ficlSystemInformation *fsi;
699 ficlDictionary *dict;
700 ficlDictionary *env;
701
702 fsi = malloc(sizeof (ficlSystemInformation));
703 ficlSystemInformationInitialize(fsi);
704 fsi->textOut = out;
705 fsi->dictionarySize = BF_DICTSIZE;
706
707 bf_sys = ficlSystemCreate(fsi);
708 free(fsi);
709 ficlSystemCompileExtras(bf_sys);
710 bf_vm = ficlSystemCreateVm(bf_sys);
711
712 buf = isadir();
713 if (buf == NULL || strcmp(buf, "amd64") != 0) {
714 (void) setenv("ISADIR", "", 1);
715 } else {
716 (void) setenv("ISADIR", buf, 1);
717 }
718 if (buf != NULL)
719 free(buf);
720 buf = get_currdev();
721 (void) setenv("currdev", buf, 1);
722 free(buf);
723 (void) setenv("console", "text", 1);
724
725 /* Put all private definitions in a "builtins" vocabulary */
726 rv = ficlVmEvaluate(bf_vm,
727 "vocabulary builtins also builtins definitions");
728 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
729 printf("error interpreting forth: %d\n", rv);
730 exit(1);
731 }
732
733 /* Builtin constructor word */
734 rv = ficlVmEvaluate(bf_vm, BUILTIN_CONSTRUCTOR);
735 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
736 printf("error interpreting forth: %d\n", rv);
737 exit(1);
738 }
739
740 /* make all commands appear as Forth words */
741 dict = ficlSystemGetDictionary(bf_sys);
742 cmdp = NULL;
743
744 SET_FOREACH(cmdp, Xcommand_set) {
745 (void) ficlDictionaryAppendPrimitive(dict,
746 (char *)(*cmdp)->c_name, bf_command, FICL_WORD_DEFAULT);
747 rv = ficlVmEvaluate(bf_vm, "forth definitions builtins");
748 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
749 printf("error interpreting forth: %d\n", rv);
750 exit(1);
751 }
752 (void) snprintf(create_buf, sizeof (create_buf), "builtin: %s",
753 (*cmdp)->c_name);
754 rv = ficlVmEvaluate(bf_vm, create_buf);
755 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
756 printf("error interpreting forth: %d\n", rv);
757 exit(1);
758 }
759 rv = ficlVmEvaluate(bf_vm, "builtins definitions");
760 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
761 printf("error interpreting forth: %d\n", rv);
762 exit(1);
763 }
764 }
765 rv = ficlVmEvaluate(bf_vm, "only forth definitions");
766 if (rv != FICL_VM_STATUS_OUT_OF_TEXT) {
767 printf("error interpreting forth: %d\n", rv);
768 exit(1);
769 }
770
771 /*
772 * Export some version numbers so that code can detect the
773 * loader/host version
774 */
775 env = ficlSystemGetEnvironment(bf_sys);
776 (void) ficlDictionarySetConstant(env, "loader_version",
777 (bootprog_rev[0] - '0') * 10 + (bootprog_rev[2] - '0'));
778
779 /* try to load and run init file if present */
780 if (rc == NULL)
781 rc = "/boot/forth/boot.4th";
782 if (*rc != '\0') {
783 fd = open(rc, O_RDONLY);
784 if (fd != -1) {
785 (void) ficlExecFD(bf_vm, fd);
786 (void) close(fd);
787 }
788 }
789
790 gfx_framework_init();
791 return (bf_vm);
792 }
793
794 void
bf_fini(void)795 bf_fini(void)
796 {
797 ficlSystemDestroy(bf_sys);
798 gfx_framework_fini();
799 }
800
801 /*
802 * Feed a line of user input to the Forth interpreter
803 */
804 int
bf_run(char * line)805 bf_run(char *line)
806 {
807 int result;
808 ficlString s;
809
810 FICL_STRING_SET_FROM_CSTRING(s, line);
811 result = ficlVmExecuteString(bf_vm, s);
812
813 switch (result) {
814 case FICL_VM_STATUS_OUT_OF_TEXT:
815 case FICL_VM_STATUS_ABORTQ:
816 case FICL_VM_STATUS_QUIT:
817 case FICL_VM_STATUS_ERROR_EXIT:
818 break;
819 case FICL_VM_STATUS_USER_EXIT:
820 break;
821 case FICL_VM_STATUS_ABORT:
822 printf("Aborted!\n");
823 break;
824 case BF_PARSE:
825 printf("Parse error!\n");
826 break;
827 default:
828 if (command_errmsg != NULL) {
829 printf("%s\n", command_errmsg);
830 command_errmsg = NULL;
831 }
832 }
833
834 (void) setenv("interpret", bf_vm->state ? "" : "ok", 1);
835
836 return (result);
837 }
838
839 char *
get_dev(const char * path)840 get_dev(const char *path)
841 {
842 FILE *fp;
843 struct mnttab mpref = {0};
844 struct mnttab mp = {0};
845 char *currdev;
846 int ret;
847 char *buf;
848 char *tmppath;
849 char *tmpdev;
850 char *cwd = NULL;
851
852 fp = fopen(MNTTAB, "r");
853
854 /* do the best we can to return something... */
855 if (fp == NULL)
856 return (strdup(path));
857
858 /*
859 * the path can have device provided, check for it
860 * and extract it.
861 */
862 buf = strrchr(path, ':');
863 if (buf != NULL) {
864 tmppath = buf+1; /* real path */
865 buf = strchr(path, ':'); /* skip zfs: */
866 buf++;
867 tmpdev = strdup(buf);
868 buf = strchr(tmpdev, ':'); /* get ending : */
869 *buf = '\0';
870 } else {
871 tmppath = (char *)path;
872 if (tmppath[0] != '/')
873 if ((cwd = getcwd(NULL, PATH_MAX)) == NULL) {
874 (void) fclose(fp);
875 return (strdup(path));
876 }
877
878 currdev = getenv("currdev");
879 buf = strchr(currdev, ':'); /* skip zfs: */
880 if (buf == NULL) {
881 (void) fclose(fp);
882 return (strdup(path));
883 }
884 buf++;
885 tmpdev = strdup(buf);
886 buf = strchr(tmpdev, ':'); /* get ending : */
887 *buf = '\0';
888 }
889
890 mpref.mnt_special = tmpdev;
891 ret = getmntany(fp, &mp, &mpref);
892 (void) fclose(fp);
893 free(tmpdev);
894
895 if (cwd == NULL)
896 (void) asprintf(&buf, "%s/%s", ret? "":mp.mnt_mountp, tmppath);
897 else {
898 (void) asprintf(&buf, "%s/%s/%s", ret? "":mp.mnt_mountp, cwd,
899 tmppath);
900 free(cwd);
901 }
902 return (buf);
903 }
904
905 static void
ngets(char * buf,int n)906 ngets(char *buf, int n)
907 {
908 int c;
909 char *lp;
910
911 for (lp = buf; ; )
912 switch (c = getchar() & 0177) {
913 case '\n':
914 case '\r':
915 *lp = '\0';
916 (void) putchar('\n');
917 return;
918 case '\b':
919 case '\177':
920 if (lp > buf) {
921 lp--;
922 (void) putchar('\b');
923 (void) putchar(' ');
924 (void) putchar('\b');
925 }
926 break;
927 case 'r'&037: {
928 char *p;
929
930 (void) putchar('\n');
931 for (p = buf; p < lp; ++p)
932 (void) putchar(*p);
933 break;
934 }
935 case 'u'&037:
936 case 'w'&037:
937 lp = buf;
938 (void) putchar('\n');
939 break;
940 default:
941 if ((n < 1) || ((lp - buf) < n - 1)) {
942 *lp++ = c;
943 (void) putchar(c);
944 }
945 }
946 /*NOTREACHED*/
947 }
948
949 static int
fgetstr(char * buf,int size,int fd)950 fgetstr(char *buf, int size, int fd)
951 {
952 char c;
953 int err, len;
954
955 size--; /* leave space for terminator */
956 len = 0;
957 while (size != 0) {
958 err = read(fd, &c, sizeof (c));
959 if (err < 0) /* read error */
960 return (-1);
961
962 if (err == 0) { /* EOF */
963 if (len == 0)
964 return (-1); /* nothing to read */
965 break;
966 }
967 if ((c == '\r') || (c == '\n')) /* line terminators */
968 break;
969 *buf++ = c; /* keep char */
970 size--;
971 len++;
972 }
973 *buf = 0;
974 return (len);
975 }
976
977 static char *
unargv(int argc,char * argv[])978 unargv(int argc, char *argv[])
979 {
980 size_t hlong;
981 int i;
982 char *cp;
983
984 for (i = 0, hlong = 0; i < argc; i++)
985 hlong += strlen(argv[i]) + 2;
986
987 if (hlong == 0)
988 return (NULL);
989
990 cp = malloc(hlong);
991 cp[0] = 0;
992 for (i = 0; i < argc; i++) {
993 (void) strcat(cp, argv[i]);
994 if (i < (argc - 1))
995 (void) strcat(cp, " ");
996 }
997
998 return (cp);
999 }
1000
1001 /*
1002 * Help is read from a formatted text file.
1003 *
1004 * Entries in the file are formatted as:
1005 * # Ttopic [Ssubtopic] Ddescription
1006 * help
1007 * text
1008 * here
1009 * #
1010 *
1011 * Note that for code simplicity's sake, the above format must be followed
1012 * exactly.
1013 *
1014 * Subtopic entries must immediately follow the topic (this is used to
1015 * produce the listing of subtopics).
1016 *
1017 * If no argument(s) are supplied by the user, the help for 'help' is displayed.
1018 */
1019 static int
help_getnext(int fd,char ** topic,char ** subtopic,char ** desc)1020 help_getnext(int fd, char **topic, char **subtopic, char **desc)
1021 {
1022 char line[81], *cp, *ep;
1023
1024 *topic = *subtopic = *desc = NULL;
1025 for (;;) {
1026 if (fgetstr(line, 80, fd) < 0)
1027 return (0);
1028
1029 if (strlen(line) < 3 || line[0] != '#' || line[1] != ' ')
1030 continue;
1031
1032 *topic = *subtopic = *desc = NULL;
1033 cp = line + 2;
1034 while (cp != NULL && *cp != 0) {
1035 ep = strchr(cp, ' ');
1036 if (*cp == 'T' && *topic == NULL) {
1037 if (ep != NULL)
1038 *ep++ = 0;
1039 *topic = strdup(cp + 1);
1040 } else if (*cp == 'S' && *subtopic == NULL) {
1041 if (ep != NULL)
1042 *ep++ = 0;
1043 *subtopic = strdup(cp + 1);
1044 } else if (*cp == 'D') {
1045 *desc = strdup(cp + 1);
1046 ep = NULL;
1047 }
1048 cp = ep;
1049 }
1050 if (*topic == NULL) {
1051 free(*subtopic);
1052 free(*desc);
1053 continue;
1054 }
1055 return (1);
1056 }
1057 }
1058
1059 static int
help_emitsummary(char * topic,char * subtopic,char * desc)1060 help_emitsummary(char *topic, char *subtopic, char *desc)
1061 {
1062 int i;
1063
1064 (void) pager_output(" ");
1065 (void) pager_output(topic);
1066 i = strlen(topic);
1067 if (subtopic != NULL) {
1068 (void) pager_output(" ");
1069 (void) pager_output(subtopic);
1070 i += strlen(subtopic) + 1;
1071 }
1072 if (desc != NULL) {
1073 do {
1074 (void) pager_output(" ");
1075 } while (i++ < 30);
1076 (void) pager_output(desc);
1077 }
1078 return (pager_output("\n"));
1079 }
1080
1081 COMMAND_SET(help, "help", "detailed help", command_help);
1082
1083 static int
command_help(int argc,char * argv[])1084 command_help(int argc, char *argv[])
1085 {
1086 char buf[81]; /* XXX buffer size? */
1087 int hfd, matched, doindex;
1088 char *topic, *subtopic, *t, *s, *d;
1089
1090 /* page the help text from our load path */
1091 (void) snprintf(buf, sizeof (buf), "/boot/loader.help");
1092 if ((hfd = open(buf, O_RDONLY)) < 0) {
1093 printf("Verbose help not available, "
1094 "use '?' to list commands\n");
1095 return (CMD_OK);
1096 }
1097
1098 /* pick up request from arguments */
1099 topic = subtopic = NULL;
1100 switch (argc) {
1101 case 3:
1102 subtopic = strdup(argv[2]);
1103 /* FALLTHROUGH */
1104 case 2:
1105 topic = strdup(argv[1]);
1106 break;
1107 case 1:
1108 topic = strdup("help");
1109 break;
1110 default:
1111 command_errmsg = "usage is 'help <topic> [<subtopic>]";
1112 (void) close(hfd);
1113 return (CMD_ERROR);
1114 }
1115
1116 /* magic "index" keyword */
1117 doindex = strcmp(topic, "index") == 0;
1118 matched = doindex;
1119
1120 /* Scan the helpfile looking for help matching the request */
1121 pager_open();
1122 while (help_getnext(hfd, &t, &s, &d)) {
1123 if (doindex) { /* dink around formatting */
1124 if (help_emitsummary(t, s, d))
1125 break;
1126
1127 } else if (strcmp(topic, t)) {
1128 /* topic mismatch */
1129 /* nothing more on this topic, stop scanning */
1130 if (matched)
1131 break;
1132 } else {
1133 /* topic matched */
1134 matched = 1;
1135 if ((subtopic == NULL && s == NULL) ||
1136 (subtopic != NULL && s != NULL &&
1137 strcmp(subtopic, s) == 0)) {
1138 /* exact match, print text */
1139 while (fgetstr(buf, 80, hfd) >= 0 &&
1140 buf[0] != '#') {
1141 if (pager_output(buf))
1142 break;
1143 if (pager_output("\n"))
1144 break;
1145 }
1146 } else if (subtopic == NULL && s != NULL) {
1147 /* topic match, list subtopics */
1148 if (help_emitsummary(t, s, d))
1149 break;
1150 }
1151 }
1152 free(t);
1153 free(s);
1154 free(d);
1155 t = s = d = NULL;
1156 }
1157 free(t);
1158 free(s);
1159 free(d);
1160 pager_close();
1161 (void) close(hfd);
1162 if (!matched) {
1163 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1164 "no help available for '%s'", topic);
1165 free(topic);
1166 free(subtopic);
1167 return (CMD_ERROR);
1168 }
1169 free(topic);
1170 free(subtopic);
1171 return (CMD_OK);
1172 }
1173
1174 COMMAND_SET(commandlist, "?", "list commands", command_commandlist);
1175
1176 static int
command_commandlist(int argc __unused,char * argv[]__unused)1177 command_commandlist(int argc __unused, char *argv[] __unused)
1178 {
1179 struct bootblk_command **cmdp;
1180 int res;
1181 char name[20];
1182
1183 res = 0;
1184 pager_open();
1185 res = pager_output("Available commands:\n");
1186 SET_FOREACH(cmdp, Xcommand_set) {
1187 if (res)
1188 break;
1189 if ((*cmdp)->c_name != NULL && (*cmdp)->c_desc != NULL) {
1190 (void) snprintf(name, sizeof (name), " %-15s ",
1191 (*cmdp)->c_name);
1192 (void) pager_output(name);
1193 (void) pager_output((*cmdp)->c_desc);
1194 res = pager_output("\n");
1195 }
1196 }
1197 pager_close();
1198 return (CMD_OK);
1199 }
1200
1201 /*
1202 * XXX set/show should become set/echo if we have variable
1203 * substitution happening.
1204 */
1205 COMMAND_SET(show, "show", "show variable(s)", command_show);
1206 COMMAND_SET(printenv, "printenv", "show variable(s)", command_show);
1207
1208 static int
command_show(int argc,char * argv[])1209 command_show(int argc, char *argv[])
1210 {
1211 char **ev;
1212 char *cp;
1213
1214 if (argc < 2) {
1215 /*
1216 * With no arguments, print everything.
1217 */
1218 pager_open();
1219 for (ev = _environ; *ev != NULL; ev++) {
1220 (void) pager_output(*ev);
1221 cp = getenv(*ev);
1222 if (cp != NULL) {
1223 (void) pager_output("=");
1224 (void) pager_output(cp);
1225 }
1226 if (pager_output("\n"))
1227 break;
1228 }
1229 pager_close();
1230 } else {
1231 if ((cp = getenv(argv[1])) != NULL) {
1232 printf("%s\n", cp);
1233 } else {
1234 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1235 "variable '%s' not found", argv[1]);
1236 return (CMD_ERROR);
1237 }
1238 }
1239 return (CMD_OK);
1240 }
1241
1242 COMMAND_SET(set, "set", "set a variable", command_set);
1243 static int
command_set(int argc,char * argv[])1244 command_set(int argc, char *argv[])
1245 {
1246 int err;
1247 char *value, *copy;
1248
1249 if (argc != 2) {
1250 command_errmsg = "wrong number of arguments";
1251 return (CMD_ERROR);
1252 } else {
1253 copy = strdup(argv[1]);
1254 if (copy == NULL) {
1255 command_errmsg = strerror(errno);
1256 return (CMD_ERROR);
1257 }
1258 if ((value = strchr(copy, '=')) != NULL)
1259 *(value++) = 0;
1260 else
1261 value = "";
1262 if ((err = setenv(copy, value, 1)) != 0) {
1263 free(copy);
1264 command_errmsg = strerror(errno);
1265 return (CMD_ERROR);
1266 }
1267 free(copy);
1268 }
1269 return (CMD_OK);
1270 }
1271
1272 COMMAND_SET(setprop, "setprop", "set a variable", command_setprop);
1273 static int
command_setprop(int argc,char * argv[])1274 command_setprop(int argc, char *argv[])
1275 {
1276 int err;
1277
1278 if (argc != 3) {
1279 command_errmsg = "wrong number of arguments";
1280 return (CMD_ERROR);
1281 } else {
1282 if ((err = setenv(argv[1], argv[2], 1)) != 0) {
1283 command_errmsg = strerror(err);
1284 return (CMD_ERROR);
1285 }
1286 }
1287 return (CMD_OK);
1288 }
1289
1290 COMMAND_SET(unset, "unset", "unset a variable", command_unset);
1291 static int
command_unset(int argc,char * argv[])1292 command_unset(int argc, char *argv[])
1293 {
1294 int err;
1295
1296 if (argc != 2) {
1297 command_errmsg = "wrong number of arguments";
1298 return (CMD_ERROR);
1299 } else {
1300 if ((err = unsetenv(argv[1])) != 0) {
1301 command_errmsg = strerror(err);
1302 return (CMD_ERROR);
1303 }
1304 }
1305 return (CMD_OK);
1306 }
1307
1308 COMMAND_SET(echo, "echo", "echo arguments", command_echo);
1309 static int
command_echo(int argc,char * argv[])1310 command_echo(int argc, char *argv[])
1311 {
1312 char *s;
1313 int nl, ch;
1314
1315 nl = 0;
1316 optind = 1;
1317 opterr = 1;
1318 while ((ch = getopt(argc, argv, "n")) != -1) {
1319 switch (ch) {
1320 case 'n':
1321 nl = 1;
1322 break;
1323 case '?':
1324 default:
1325 /* getopt has already reported an error */
1326 return (CMD_OK);
1327 }
1328 }
1329 argv += (optind);
1330 argc -= (optind);
1331
1332 s = unargv(argc, argv);
1333 if (s != NULL) {
1334 printf("%s", s);
1335 free(s);
1336 }
1337 if (!nl)
1338 printf("\n");
1339 return (CMD_OK);
1340 }
1341
1342 /*
1343 * A passable emulation of the sh(1) command of the same name.
1344 */
1345 static int
ischar(void)1346 ischar(void)
1347 {
1348 return (1);
1349 }
1350
1351 COMMAND_SET(read, "read", "read input from the terminal", command_read);
1352 static int
command_read(int argc,char * argv[])1353 command_read(int argc, char *argv[])
1354 {
1355 char *prompt;
1356 int timeout;
1357 time_t when;
1358 char *cp;
1359 char *name;
1360 char buf[256]; /* XXX size? */
1361 int c;
1362
1363 timeout = -1;
1364 prompt = NULL;
1365 optind = 1;
1366 opterr = 1;
1367 while ((c = getopt(argc, argv, "p:t:")) != -1) {
1368 switch (c) {
1369 case 'p':
1370 prompt = optarg;
1371 break;
1372 case 't':
1373 timeout = strtol(optarg, &cp, 0);
1374 if (cp == optarg) {
1375 (void) snprintf(command_errbuf,
1376 sizeof (command_errbuf),
1377 "bad timeout '%s'", optarg);
1378 return (CMD_ERROR);
1379 }
1380 break;
1381 default:
1382 return (CMD_OK);
1383 }
1384 }
1385
1386 argv += (optind);
1387 argc -= (optind);
1388 name = (argc > 0) ? argv[0]: NULL;
1389
1390 if (prompt != NULL)
1391 printf("%s", prompt);
1392 if (timeout >= 0) {
1393 when = time(NULL) + timeout;
1394 while (!ischar())
1395 if (time(NULL) >= when)
1396 return (CMD_OK); /* is timeout an error? */
1397 }
1398
1399 ngets(buf, sizeof (buf));
1400
1401 if (name != NULL)
1402 (void) setenv(name, buf, 1);
1403 return (CMD_OK);
1404 }
1405
1406 /*
1407 * File pager
1408 */
1409 COMMAND_SET(more, "more", "show contents of a file", command_more);
1410 static int
command_more(int argc,char * argv[])1411 command_more(int argc, char *argv[])
1412 {
1413 int i;
1414 int res;
1415 char line[80];
1416 char *name;
1417
1418 res = 0;
1419 pager_open();
1420 for (i = 1; (i < argc) && (res == 0); i++) {
1421 (void) snprintf(line, sizeof (line), "*** FILE %s BEGIN ***\n",
1422 argv[i]);
1423 if (pager_output(line))
1424 break;
1425 name = get_dev(argv[i]);
1426 res = page_file(name);
1427 free(name);
1428 if (!res) {
1429 (void) snprintf(line, sizeof (line),
1430 "*** FILE %s END ***\n", argv[i]);
1431 res = pager_output(line);
1432 }
1433 }
1434 pager_close();
1435
1436 if (res == 0)
1437 return (CMD_OK);
1438 return (CMD_ERROR);
1439 }
1440
1441 static int
page_file(char * filename)1442 page_file(char *filename)
1443 {
1444 int result;
1445
1446 result = pager_file(filename);
1447
1448 if (result == -1) {
1449 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1450 "error showing %s", filename);
1451 }
1452
1453 return (result);
1454 }
1455
1456 COMMAND_SET(ls, "ls", "list files", command_ls);
1457 static int
command_ls(int argc,char * argv[])1458 command_ls(int argc, char *argv[])
1459 {
1460 DIR *dir;
1461 int fd;
1462 struct stat sb;
1463 struct dirent *d;
1464 char *buf, *path;
1465 char lbuf[128]; /* one line */
1466 int result, ch;
1467 int verbose;
1468
1469 result = CMD_OK;
1470 fd = -1;
1471 verbose = 0;
1472 optind = 1;
1473 opterr = 1;
1474 while ((ch = getopt(argc, argv, "l")) != -1) {
1475 switch (ch) {
1476 case 'l':
1477 verbose = 1;
1478 break;
1479 case '?':
1480 default:
1481 /* getopt has already reported an error */
1482 return (CMD_OK);
1483 }
1484 }
1485 argv += (optind - 1);
1486 argc -= (optind - 1);
1487
1488 if (argc < 2) {
1489 path = "";
1490 } else {
1491 path = argv[1];
1492 }
1493
1494 fd = ls_getdir(&path);
1495 if (fd == -1) {
1496 result = CMD_ERROR;
1497 goto out;
1498 }
1499 dir = fdopendir(fd);
1500 pager_open();
1501 (void) pager_output(path);
1502 (void) pager_output("\n");
1503
1504 while ((d = readdir(dir)) != NULL) {
1505 if (strcmp(d->d_name, ".") && strcmp(d->d_name, "..")) {
1506 /* stat the file, if possible */
1507 if (path[0] == '\0') {
1508 (void) asprintf(&buf, "%s", d->d_name);
1509 } else {
1510 (void) asprintf(&buf, "%s/%s", path, d->d_name);
1511 }
1512 if (buf != NULL) {
1513 /* ignore return, could be symlink, etc. */
1514 if (stat(buf, &sb)) {
1515 sb.st_size = 0;
1516 sb.st_mode = 0;
1517 }
1518 free(buf);
1519 }
1520 if (verbose) {
1521 (void) snprintf(lbuf, sizeof (lbuf),
1522 " %c %8d %s\n",
1523 typestr[sb.st_mode >> 12],
1524 (int)sb.st_size, d->d_name);
1525 } else {
1526 (void) snprintf(lbuf, sizeof (lbuf),
1527 " %c %s\n",
1528 typestr[sb.st_mode >> 12], d->d_name);
1529 }
1530 if (pager_output(lbuf))
1531 goto out;
1532 }
1533 }
1534 out:
1535 pager_close();
1536 if (fd != -1)
1537 (void) closedir(dir);
1538 if (path != NULL)
1539 free(path);
1540 return (result);
1541 }
1542
1543 /*
1544 * Given (path) containing a vaguely reasonable path specification, return an fd
1545 * on the directory, and an allocated copy of the path to the directory.
1546 */
1547 static int
ls_getdir(char ** pathp)1548 ls_getdir(char **pathp)
1549 {
1550 struct stat sb;
1551 int fd;
1552 char *cp, *path;
1553
1554 fd = -1;
1555
1556 /* one extra byte for a possible trailing slash required */
1557 path = malloc(strlen(*pathp) + 2);
1558 (void) strcpy(path, *pathp);
1559
1560 /* Make sure the path is respectable to begin with */
1561 if ((cp = get_dev(path)) == NULL) {
1562 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1563 "bad path '%s'", path);
1564 goto out;
1565 }
1566
1567 /* If there's no path on the device, assume '/' */
1568 if (*cp == 0)
1569 (void) strcat(path, "/");
1570
1571 fd = open(cp, O_RDONLY);
1572 if (fd < 0) {
1573 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1574 "open '%s' failed: %s", path, strerror(errno));
1575 goto out;
1576 }
1577 if (fstat(fd, &sb) < 0) {
1578 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1579 "stat failed: %s", strerror(errno));
1580 goto out;
1581 }
1582 if (!S_ISDIR(sb.st_mode)) {
1583 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1584 "%s: %s", path, strerror(ENOTDIR));
1585 goto out;
1586 }
1587
1588 free(cp);
1589 *pathp = path;
1590 return (fd);
1591
1592 out:
1593 free(cp);
1594 free(path);
1595 *pathp = NULL;
1596 if (fd != -1)
1597 (void) close(fd);
1598 return (-1);
1599 }
1600
1601 COMMAND_SET(include, "include", "read commands from a file", command_include);
1602 static int
command_include(int argc,char * argv[])1603 command_include(int argc, char *argv[])
1604 {
1605 int i;
1606 int res;
1607 char **argvbuf;
1608
1609 /*
1610 * Since argv is static, we need to save it here.
1611 */
1612 argvbuf = (char **)calloc(argc, sizeof (char *));
1613 for (i = 0; i < argc; i++)
1614 argvbuf[i] = strdup(argv[i]);
1615
1616 res = CMD_OK;
1617 for (i = 1; (i < argc) && (res == CMD_OK); i++)
1618 res = include(argvbuf[i]);
1619
1620 for (i = 0; i < argc; i++)
1621 free(argvbuf[i]);
1622 free(argvbuf);
1623
1624 return (res);
1625 }
1626
1627 /*
1628 * Header prepended to each line. The text immediately follows the header.
1629 * We try to make this short in order to save memory -- the loader has
1630 * limited memory available, and some of the forth files are very long.
1631 */
1632 struct includeline
1633 {
1634 struct includeline *next;
1635 int line;
1636 char text[];
1637 };
1638
1639 int
include(const char * filename)1640 include(const char *filename)
1641 {
1642 struct includeline *script, *se, *sp;
1643 int res = CMD_OK;
1644 int prevsrcid, fd, line;
1645 char *cp, input[256]; /* big enough? */
1646 char *path;
1647
1648 path = get_dev(filename);
1649 if (((fd = open(path, O_RDONLY)) == -1)) {
1650 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1651 "can't open '%s': %s", filename,
1652 strerror(errno));
1653 free(path);
1654 return (CMD_ERROR);
1655 }
1656
1657 free(path);
1658 /*
1659 * Read the script into memory.
1660 */
1661 script = se = NULL;
1662 line = 0;
1663
1664 while (fgetstr(input, sizeof (input), fd) >= 0) {
1665 line++;
1666 cp = input;
1667 /* Allocate script line structure and copy line, flags */
1668 if (*cp == '\0')
1669 continue; /* ignore empty line, save memory */
1670 if (cp[0] == '\\' && cp[1] == ' ')
1671 continue; /* ignore comment */
1672
1673 sp = malloc(sizeof (struct includeline) + strlen(cp) + 1);
1674 /*
1675 * On malloc failure (it happens!), free as much as possible
1676 * and exit
1677 */
1678 if (sp == NULL) {
1679 while (script != NULL) {
1680 se = script;
1681 script = script->next;
1682 free(se);
1683 }
1684 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1685 "file '%s' line %d: memory allocation "
1686 "failure - aborting", filename, line);
1687 return (CMD_ERROR);
1688 }
1689 (void) strcpy(sp->text, cp);
1690 sp->line = line;
1691 sp->next = NULL;
1692
1693 if (script == NULL) {
1694 script = sp;
1695 } else {
1696 se->next = sp;
1697 }
1698 se = sp;
1699 }
1700 (void) close(fd);
1701
1702 /*
1703 * Execute the script
1704 */
1705
1706 prevsrcid = bf_vm->sourceId.i;
1707 bf_vm->sourceId.i = fd+1; /* 0 is user input device */
1708
1709 res = CMD_OK;
1710
1711 for (sp = script; sp != NULL; sp = sp->next) {
1712 res = bf_run(sp->text);
1713 if (res != FICL_VM_STATUS_OUT_OF_TEXT) {
1714 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1715 "Error while including %s, in the line %d:\n%s",
1716 filename, sp->line, sp->text);
1717 res = CMD_ERROR;
1718 break;
1719 } else
1720 res = CMD_OK;
1721 }
1722
1723 bf_vm->sourceId.i = -1;
1724 (void) bf_run("");
1725 bf_vm->sourceId.i = prevsrcid;
1726
1727 while (script != NULL) {
1728 se = script;
1729 script = script->next;
1730 free(se);
1731 }
1732
1733 return (res);
1734 }
1735
1736 COMMAND_SET(boot, "boot", "boot a file or loaded kernel", command_boot);
1737 static int
command_boot(int argc,char * argv[])1738 command_boot(int argc, char *argv[])
1739 {
1740 return (CMD_OK);
1741 }
1742
1743 COMMAND_SET(autoboot, "autoboot", "boot automatically after a delay",
1744 command_autoboot);
1745 static int
command_autoboot(int argc,char * argv[])1746 command_autoboot(int argc, char *argv[])
1747 {
1748 return (CMD_OK);
1749 }
1750
1751 static void
moduledir_rebuild(void)1752 moduledir_rebuild(void)
1753 {
1754 struct moduledir *mdp, *mtmp;
1755 const char *path, *cp, *ep;
1756 int cplen;
1757
1758 path = getenv("module_path");
1759 if (path == NULL)
1760 path = default_searchpath;
1761 /*
1762 * Rebuild list of module directories if it changed
1763 */
1764 STAILQ_FOREACH(mdp, &moduledir_list, d_link)
1765 mdp->d_flags |= MDIR_REMOVED;
1766
1767 for (ep = path; *ep != 0; ep++) {
1768 cp = ep;
1769 for (; *ep != 0 && *ep != ';'; ep++)
1770 ;
1771 /*
1772 * Ignore trailing slashes
1773 */
1774 for (cplen = ep - cp; cplen > 1 && cp[cplen - 1] == '/';
1775 cplen--)
1776 ;
1777 STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1778 if (strlen(mdp->d_path) != cplen ||
1779 bcmp(cp, mdp->d_path, cplen) != 0)
1780 continue;
1781 mdp->d_flags &= ~MDIR_REMOVED;
1782 break;
1783 }
1784 if (mdp == NULL) {
1785 mdp = malloc(sizeof (*mdp) + cplen + 1);
1786 if (mdp == NULL)
1787 return;
1788 mdp->d_path = (char *)(mdp + 1);
1789 bcopy(cp, mdp->d_path, cplen);
1790 mdp->d_path[cplen] = 0;
1791 mdp->d_hints = NULL;
1792 mdp->d_flags = 0;
1793 STAILQ_INSERT_TAIL(&moduledir_list, mdp, d_link);
1794 }
1795 if (*ep == 0)
1796 break;
1797 }
1798 /*
1799 * Delete unused directories if any
1800 */
1801 mdp = STAILQ_FIRST(&moduledir_list);
1802 while (mdp) {
1803 if ((mdp->d_flags & MDIR_REMOVED) == 0) {
1804 mdp = STAILQ_NEXT(mdp, d_link);
1805 } else {
1806 if (mdp->d_hints)
1807 free(mdp->d_hints);
1808 mtmp = mdp;
1809 mdp = STAILQ_NEXT(mdp, d_link);
1810 STAILQ_REMOVE(&moduledir_list, mtmp, moduledir, d_link);
1811 free(mtmp);
1812 }
1813 }
1814 }
1815
1816 static char *
file_lookup(const char * path,const char * name,int namelen)1817 file_lookup(const char *path, const char *name, int namelen)
1818 {
1819 struct stat st;
1820 char *result, *cp, *gz;
1821 int pathlen;
1822
1823 pathlen = strlen(path);
1824 result = malloc(pathlen + namelen + 2);
1825 if (result == NULL)
1826 return (NULL);
1827 bcopy(path, result, pathlen);
1828 if (pathlen > 0 && result[pathlen - 1] != '/')
1829 result[pathlen++] = '/';
1830 cp = result + pathlen;
1831 bcopy(name, cp, namelen);
1832 cp += namelen;
1833 *cp = '\0';
1834 if (stat(result, &st) == 0 && S_ISREG(st.st_mode))
1835 return (result);
1836 /* also check for gz file */
1837 (void) asprintf(&gz, "%s.gz", result);
1838 if (gz != NULL) {
1839 int res = stat(gz, &st);
1840 free(gz);
1841 if (res == 0)
1842 return (result);
1843 }
1844 free(result);
1845 return (NULL);
1846 }
1847
1848 static char *
file_search(const char * name)1849 file_search(const char *name)
1850 {
1851 struct moduledir *mdp;
1852 struct stat sb;
1853 char *result;
1854 int namelen;
1855
1856 if (name == NULL)
1857 return (NULL);
1858 if (*name == 0)
1859 return (strdup(name));
1860
1861 if (strchr(name, '/') != NULL) {
1862 char *gz;
1863 if (stat(name, &sb) == 0)
1864 return (strdup(name));
1865 /* also check for gz file */
1866 (void) asprintf(&gz, "%s.gz", name);
1867 if (gz != NULL) {
1868 int res = stat(gz, &sb);
1869 free(gz);
1870 if (res == 0)
1871 return (strdup(name));
1872 }
1873 return (NULL);
1874 }
1875
1876 moduledir_rebuild();
1877 result = NULL;
1878 namelen = strlen(name);
1879 STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1880 result = file_lookup(mdp->d_path, name, namelen);
1881 if (result)
1882 break;
1883 }
1884 return (result);
1885 }
1886
1887 COMMAND_SET(load, "load", "load a kernel or module", command_load);
1888 static int
command_load(int argc,char * argv[])1889 command_load(int argc, char *argv[])
1890 {
1891 int dofile, ch;
1892 char *typestr = NULL;
1893 char *filename;
1894 dofile = 0;
1895 optind = 1;
1896
1897 if (argc == 1) {
1898 command_errmsg = "no filename specified";
1899 return (CMD_ERROR);
1900 }
1901
1902 while ((ch = getopt(argc, argv, "kt:")) != -1) {
1903 switch (ch) {
1904 case 'k':
1905 break;
1906 case 't':
1907 typestr = optarg;
1908 dofile = 1;
1909 break;
1910 case '?':
1911 default:
1912 return (CMD_OK);
1913 }
1914 }
1915 argv += (optind - 1);
1916 argc -= (optind - 1);
1917 if (dofile) {
1918 if ((typestr == NULL) || (*typestr == 0)) {
1919 command_errmsg = "invalid load type";
1920 return (CMD_ERROR);
1921 }
1922 #if 0
1923 return (file_loadraw(argv[1], typestr, argc - 2, argv + 2, 1)
1924 ? CMD_OK : CMD_ERROR);
1925 #endif
1926 return (CMD_OK);
1927 }
1928
1929 filename = file_search(argv[1]);
1930 if (filename == NULL) {
1931 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1932 "can't find '%s'", argv[1]);
1933 return (CMD_ERROR);
1934 }
1935 (void) setenv("kernelname", filename, 1);
1936
1937 return (CMD_OK);
1938 }
1939
1940 COMMAND_SET(unload, "unload", "unload all modules", command_unload);
1941 static int
command_unload(int argc,char * argv[])1942 command_unload(int argc, char *argv[])
1943 {
1944 (void) unsetenv("kernelname");
1945 return (CMD_OK);
1946 }
1947
1948 COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
1949 static int
command_reboot(int argc,char * argv[])1950 command_reboot(int argc, char *argv[])
1951 {
1952 exit(0);
1953 return (CMD_OK);
1954 }
1955
1956 COMMAND_SET(sifting, "sifting", "find words", command_sifting);
1957 static int
command_sifting(int argc,char * argv[])1958 command_sifting(int argc, char *argv[])
1959 {
1960 if (argc != 2) {
1961 command_errmsg = "wrong number of arguments";
1962 return (CMD_ERROR);
1963 }
1964 ficlPrimitiveSiftingImpl(bf_vm, argv[1]);
1965 return (CMD_OK);
1966 }
1967
1968 /* Only implement get and list. Ignore arguments on, off and set. */
1969 COMMAND_SET(framebuffer, "framebuffer", "framebuffer mode management",
1970 command_framebuffer);
1971 static int
command_framebuffer(int argc,char * argv[])1972 command_framebuffer(int argc, char *argv[])
1973 {
1974 if (fb.fd < 0) {
1975 printf("Framebuffer is not available.\n");
1976 return (CMD_OK);
1977 }
1978
1979 if (argc == 2 && strcmp(argv[1], "get") == 0) {
1980 printf("\nSystem frame buffer: %s\n", fb.ident.name);
1981 printf("%dx%dx%d, stride=%d\n", fb.fb_width, fb.fb_height,
1982 fb.fb_depth, (fb.fb_pitch << 3) / fb.fb_depth);
1983 return (CMD_OK);
1984 }
1985 if (argc == 2 && strcmp(argv[1], "list") == 0) {
1986 printf("0: %dx%dx%d\n", fb.fb_width, fb.fb_height, fb.fb_depth);
1987 return (CMD_OK);
1988 }
1989 if (argc == 3 && strcmp(argv[1], "set") == 0)
1990 return (CMD_OK);
1991 if (argc == 2 && strcmp(argv[1], "on") == 0)
1992 return (CMD_OK);
1993 if (argc == 2 && strcmp(argv[1], "off") == 0)
1994 return (CMD_OK);
1995
1996 (void) snprintf(command_errbuf, sizeof (command_errbuf),
1997 "usage: %s get | list", argv[0]);
1998 return (CMD_ERROR);
1999 }
2000