xref: /illumos-gate/usr/src/common/ficl/loader.c (revision 0570e35b) 
1 /*
2  * Copyright (c) 2000 Daniel Capo Sobral
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  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  *	$FreeBSD$
27  */
28 
29 /*
30  * l o a d e r . c
31  * Additional FICL words designed for FreeBSD's loader
32  */
33 
34 #ifndef STAND
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <dirent.h>
38 #include <fcntl.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <strings.h>
43 #include <termios.h>
44 #else
45 #include <stand.h>
46 #ifdef __i386__
47 #include <machine/cpufunc.h>
48 #endif
49 #include "bootstrap.h"
50 #endif
51 #ifdef STAND
52 #include <uuid.h>
53 #else
54 #include <uuid/uuid.h>
55 #endif
56 #include <string.h>
57 #include "ficl.h"
58 
59 extern int biospci_count_device_type(uint32_t);
60 extern int biospci_write_config(uint32_t, int, int, uint32_t);
61 extern int biospci_read_config(uint32_t, int, int, uint32_t *);
62 extern int biospci_find_devclass(uint32_t, int, uint32_t *);
63 extern int biospci_find_device(uint32_t, int, uint32_t *);
64 extern uint32_t biospci_locator(uint8_t, uint8_t, uint8_t);
65 
66 /*
67  *		FreeBSD's loader interaction words and extras
68  *
69  *		setenv      ( value n name n' -- )
70  *		setenv?     ( value n name n' flag -- )
71  *		getenv      ( addr n -- addr' n' | -1 )
72  *		unsetenv    ( addr n -- )
73  *		copyin      ( addr addr' len -- )
74  *		copyout     ( addr addr' len -- )
75  *		findfile    ( name len type len' -- addr )
76  *		pnpdevices  ( -- addr )
77  *		pnphandlers ( -- addr )
78  *		ccall       ( [[...[p10] p9] ... p1] n addr -- result )
79  *		uuid-from-string ( addr n -- addr' )
80  *		uuid-to-string ( addr' -- addr n | -1 )
81  *		.#	    ( value -- )
82  */
83 
84 void
85 ficlSetenv(ficlVm *pVM)
86 {
87 	char *name, *value;
88 	char *namep, *valuep;
89 	int names, values;
90 
91 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 0);
92 
93 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
94 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
95 	values = ficlStackPopInteger(ficlVmGetDataStack(pVM));
96 	valuep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
97 
98 	name = (char *)ficlMalloc(names+1);
99 	if (!name)
100 		ficlVmThrowError(pVM, "Error: out of memory");
101 	strncpy(name, namep, names);
102 	name[names] = '\0';
103 	value = (char *)ficlMalloc(values+1);
104 	if (!value)
105 		ficlVmThrowError(pVM, "Error: out of memory");
106 	strncpy(value, valuep, values);
107 	value[values] = '\0';
108 
109 	setenv(name, value, 1);
110 	ficlFree(name);
111 	ficlFree(value);
112 }
113 
114 void
115 ficlSetenvq(ficlVm *pVM)
116 {
117 	char *name, *value;
118 	char *namep, *valuep;
119 	int names, values, overwrite;
120 
121 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 5, 0);
122 
123 	overwrite = ficlStackPopInteger(ficlVmGetDataStack(pVM));
124 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
125 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
126 	values = ficlStackPopInteger(ficlVmGetDataStack(pVM));
127 	valuep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
128 
129 	name = (char *)ficlMalloc(names+1);
130 	if (!name)
131 		ficlVmThrowError(pVM, "Error: out of memory");
132 	strncpy(name, namep, names);
133 	name[names] = '\0';
134 	value = (char *)ficlMalloc(values+1);
135 	if (!value)
136 		ficlVmThrowError(pVM, "Error: out of memory");
137 	strncpy(value, valuep, values);
138 	value[values] = '\0';
139 
140 	setenv(name, value, overwrite);
141 	ficlFree(name);
142 	ficlFree(value);
143 }
144 
145 void
146 ficlGetenv(ficlVm *pVM)
147 {
148 	char *name, *value;
149 	char *namep;
150 	int names;
151 
152 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 2);
153 
154 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
155 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
156 
157 	name = (char *)ficlMalloc(names+1);
158 	if (!name)
159 		ficlVmThrowError(pVM, "Error: out of memory");
160 	strncpy(name, namep, names);
161 	name[names] = '\0';
162 
163 	value = getenv(name);
164 	ficlFree(name);
165 
166 	if (value != NULL) {
167 		ficlStackPushPointer(ficlVmGetDataStack(pVM), value);
168 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(value));
169 	} else
170 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
171 }
172 
173 void
174 ficlUnsetenv(ficlVm *pVM)
175 {
176 	char *name;
177 	char *namep;
178 	int names;
179 
180 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
181 
182 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
183 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
184 
185 	name = (char *)ficlMalloc(names+1);
186 	if (!name)
187 		ficlVmThrowError(pVM, "Error: out of memory");
188 	strncpy(name, namep, names);
189 	name[names] = '\0';
190 
191 	unsetenv(name);
192 	ficlFree(name);
193 }
194 
195 void
196 ficlCopyin(ficlVm *pVM)
197 {
198 #ifdef STAND
199 	void*		src;
200 	vm_offset_t	dest;
201 	size_t		len;
202 #endif
203 
204 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 0);
205 
206 #ifdef STAND
207 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
208 	dest = ficlStackPopInteger(ficlVmGetDataStack(pVM));
209 	src = ficlStackPopPointer(ficlVmGetDataStack(pVM));
210 	archsw.arch_copyin(src, dest, len);
211 #else
212 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
213 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
214 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
215 #endif
216 }
217 
218 void
219 ficlCopyout(ficlVm *pVM)
220 {
221 #ifdef STAND
222 	void*		dest;
223 	vm_offset_t	src;
224 	size_t		len;
225 #endif
226 
227 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 0);
228 
229 #ifdef STAND
230 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
231 	dest = ficlStackPopPointer(ficlVmGetDataStack(pVM));
232 	src = ficlStackPopInteger(ficlVmGetDataStack(pVM));
233 	archsw.arch_copyout(src, dest, len);
234 #else
235 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
236 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
237 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
238 #endif
239 }
240 
241 void
242 ficlFindfile(ficlVm *pVM)
243 {
244 #ifdef STAND
245 	char	*name, *type;
246 	char	*namep, *typep;
247 	int	names, types;
248 #endif
249 	struct	preloaded_file *fp;
250 
251 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 1);
252 
253 #ifdef STAND
254 	types = ficlStackPopInteger(ficlVmGetDataStack(pVM));
255 	typep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
256 	names = ficlStackPopInteger(ficlVmGetDataStack(pVM));
257 	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
258 
259 	name = (char *)ficlMalloc(names+1);
260 	if (!name)
261 		ficlVmThrowError(pVM, "Error: out of memory");
262 	strncpy(name, namep, names);
263 	name[names] = '\0';
264 	type = (char *)ficlMalloc(types+1);
265 	if (!type)
266 		ficlVmThrowError(pVM, "Error: out of memory");
267 	strncpy(type, typep, types);
268 	type[types] = '\0';
269 
270 	fp = file_findfile(name, type);
271 #else
272 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
273 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
274 	(void) ficlStackPopInteger(ficlVmGetDataStack(pVM));
275 	(void) ficlStackPopPointer(ficlVmGetDataStack(pVM));
276 
277 	fp = NULL;
278 #endif
279 	ficlStackPushPointer(ficlVmGetDataStack(pVM), fp);
280 }
281 
282 #ifdef STAND
283 #ifdef HAVE_PNP
284 
285 void
286 ficlPnpdevices(ficlVm *pVM)
287 {
288 	static int pnp_devices_initted = 0;
289 
290 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
291 
292 	if (!pnp_devices_initted) {
293 		STAILQ_INIT(&pnp_devices);
294 		pnp_devices_initted = 1;
295 	}
296 
297 	ficlStackPushPointer(ficlVmGetDataStack(pVM), &pnp_devices);
298 }
299 
300 void
301 ficlPnphandlers(ficlVm *pVM)
302 {
303 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
304 
305 	ficlStackPushPointer(ficlVmGetDataStack(pVM), pnphandlers);
306 }
307 
308 #endif
309 #endif /* ifdef STAND */
310 
311 void
312 ficlCcall(ficlVm *pVM)
313 {
314 	int (*func)(int, ...);
315 	int result, p[10];
316 	int nparam, i;
317 
318 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
319 
320 	func = (int (*)(int, ...))ficlStackPopPointer(ficlVmGetDataStack(pVM));
321 	nparam = ficlStackPopInteger(ficlVmGetDataStack(pVM));
322 
323 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), nparam, 1);
324 
325 	for (i = 0; i < nparam; i++)
326 		p[i] = ficlStackPopInteger(ficlVmGetDataStack(pVM));
327 
328 	result = func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8],
329 	    p[9]);
330 
331 	ficlStackPushInteger(ficlVmGetDataStack(pVM), result);
332 }
333 
334 void
335 ficlUuidFromString(ficlVm *pVM)
336 {
337 	char	*uuid;
338 	char	*uuid_ptr;
339 	int	uuid_size;
340 	uuid_t	*u;
341 #ifdef STAND
342 	uint32_t status;
343 #else
344 	int status;
345 #endif
346 
347 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
348 
349 	uuid_size = ficlStackPopInteger(ficlVmGetDataStack(pVM));
350 	uuid_ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));
351 
352 	uuid = ficlMalloc(uuid_size + 1);
353 	if (!uuid)
354 		ficlVmThrowError(pVM, "Error: out of memory");
355 	(void) memcpy(uuid, uuid_ptr, uuid_size);
356 	uuid[uuid_size] = '\0';
357 
358 	u = ficlMalloc(sizeof (*u));
359 #ifdef STAND
360 	uuid_from_string(uuid, u, &status);
361 	ficlFree(uuid);
362 	if (status != uuid_s_ok) {
363 		ficlFree(u);
364 		u = NULL;
365 	}
366 #else
367 	status = uuid_parse(uuid, *u);
368 	ficlFree(uuid);
369 	if (status != 0) {
370 		ficlFree(u);
371 		u = NULL;
372 	}
373 #endif
374 	ficlStackPushPointer(ficlVmGetDataStack(pVM), u);
375 }
376 
377 void
378 ficlUuidToString(ficlVm *pVM)
379 {
380 	char	*uuid;
381 	uuid_t	*u;
382 #ifdef STAND
383 	uint32_t status;
384 #endif
385 
386 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
387 
388 	u = ficlStackPopPointer(ficlVmGetDataStack(pVM));
389 #ifdef STAND
390 	uuid_to_string(u, &uuid, &status);
391 	if (status == uuid_s_ok) {
392 		ficlStackPushPointer(ficlVmGetDataStack(pVM), uuid);
393 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(uuid));
394 	} else
395 #else
396 	uuid = ficlMalloc(UUID_PRINTABLE_STRING_LENGTH);
397 	if (uuid != NULL) {
398 		uuid_unparse(*u, uuid);
399 		ficlStackPushPointer(ficlVmGetDataStack(pVM), uuid);
400 		ficlStackPushInteger(ficlVmGetDataStack(pVM), strlen(uuid));
401 	} else
402 #endif
403 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
404 }
405 
406 /*
407  * f i c l E x e c F D
408  * reads in text from file fd and passes it to ficlExec()
409  * returns FICL_VM_STATUS_OUT_OF_TEXT on success or the ficlExec() error
410  * code on failure.
411  */
412 #define	nLINEBUF	256
413 int
414 ficlExecFD(ficlVm *pVM, int fd)
415 {
416 	char cp[nLINEBUF];
417 	int nLine = 0, rval = FICL_VM_STATUS_OUT_OF_TEXT;
418 	char ch;
419 	ficlCell id;
420 	ficlString s;
421 
422 	id = pVM->sourceId;
423 	pVM->sourceId.i = fd+1; /* in loader we can get 0, there is no stdin */
424 
425 	/* feed each line to ficlExec */
426 	while (1) {
427 		int status, i;
428 
429 		i = 0;
430 		while ((status = read(fd, &ch, 1)) > 0 && ch != '\n')
431 			cp[i++] = ch;
432 		nLine++;
433 		if (!i) {
434 			if (status < 1)
435 				break;
436 			continue;
437 		}
438 		if (cp[i] == '\n')
439 			cp[i] = '\0';
440 
441 		FICL_STRING_SET_POINTER(s, cp);
442 		FICL_STRING_SET_LENGTH(s, i);
443 
444 		rval = ficlVmExecuteString(pVM, s);
445 		if (rval != FICL_VM_STATUS_QUIT &&
446 		    rval != FICL_VM_STATUS_USER_EXIT &&
447 		    rval != FICL_VM_STATUS_OUT_OF_TEXT) {
448 			pVM->sourceId = id;
449 			(void) ficlVmEvaluate(pVM, "");
450 			return (rval);
451 		}
452 	}
453 	pVM->sourceId = id;
454 
455 	/*
456 	 * Pass an empty line with SOURCE-ID == -1 to flush
457 	 * any pending REFILLs (as required by FILE wordset)
458 	 */
459 	(void) ficlVmEvaluate(pVM, "");
460 
461 	if (rval == FICL_VM_STATUS_USER_EXIT)
462 		ficlVmThrow(pVM, FICL_VM_STATUS_USER_EXIT);
463 
464 	return (rval);
465 }
466 
467 static void displayCellNoPad(ficlVm *pVM)
468 {
469 	ficlCell c;
470 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
471 
472 	c = ficlStackPop(ficlVmGetDataStack(pVM));
473 	ficlLtoa((c).i, pVM->pad, pVM->base);
474 	ficlVmTextOut(pVM, pVM->pad);
475 }
476 
477 /*
478  * isdir? - Return whether an fd corresponds to a directory.
479  *
480  * isdir? ( fd -- bool )
481  */
482 static void
483 isdirQuestion(ficlVm *pVM)
484 {
485 	struct stat sb;
486 	ficlInteger flag;
487 	int fd;
488 
489 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 1);
490 
491 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
492 	flag = FICL_FALSE;
493 	do {
494 		if (fd < 0)
495 			break;
496 		if (fstat(fd, &sb) < 0)
497 			break;
498 		if (!S_ISDIR(sb.st_mode))
499 			break;
500 		flag = FICL_TRUE;
501 	} while (0);
502 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
503 }
504 
505 /*
506  * fopen - open a file and return new fd on stack.
507  *
508  * fopen ( ptr count mode -- fd )
509  */
510 extern char *get_dev(const char *);
511 
512 static void
513 pfopen(ficlVm *pVM)
514 {
515 	int mode, fd, count;
516 	char *ptr, *name;
517 #ifndef STAND
518 	char *tmp;
519 #endif
520 
521 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
522 
523 	mode = ficlStackPopInteger(ficlVmGetDataStack(pVM));	/* get mode */
524 	count = ficlStackPopInteger(ficlVmGetDataStack(pVM));	/* get count */
525 	ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));	/* get ptr */
526 
527 	if ((count < 0) || (ptr == NULL)) {
528 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
529 		return;
530 	}
531 
532 	/* ensure that the string is null terminated */
533 	name = (char *)malloc(count+1);
534 	bcopy(ptr, name, count);
535 	name[count] = 0;
536 #ifndef STAND
537 	tmp = get_dev(name);
538 	free(name);
539 	name = tmp;
540 #endif
541 
542 	/* open the file */
543 	fd = open(name, mode);
544 	free(name);
545 	ficlStackPushInteger(ficlVmGetDataStack(pVM), fd);
546 }
547 
548 /*
549  * fclose - close a file who's fd is on stack.
550  * fclose ( fd -- )
551  */
552 static void
553 pfclose(ficlVm *pVM)
554 {
555 	int fd;
556 
557 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
558 
559 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
560 	if (fd != -1)
561 		close(fd);
562 }
563 
564 /*
565  * fread - read file contents
566  * fread  ( fd buf nbytes  -- nread )
567  */
568 static void
569 pfread(ficlVm *pVM)
570 {
571 	int fd, len;
572 	char *buf;
573 
574 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
575 
576 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM));
577 	buf = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get buffer */
578 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
579 	if (len > 0 && buf && fd != -1)
580 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
581 		    read(fd, buf, len));
582 	else
583 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
584 }
585 
586 /*
587  * fopendir - open directory
588  *
589  * fopendir ( addr len -- ptr TRUE | FALSE )
590  */
591 static void pfopendir(ficlVm *pVM)
592 {
593 #ifndef STAND
594 	DIR *dir;
595 	char *tmp;
596 #else
597 	struct stat sb;
598 	int fd;
599 #endif
600 	int count;
601 	char *ptr, *name;
602 	ficlInteger flag = FICL_FALSE;
603 
604 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 1);
605 
606 	count = ficlStackPopInteger(ficlVmGetDataStack(pVM));
607 	ptr = ficlStackPopPointer(ficlVmGetDataStack(pVM));	/* get ptr */
608 
609 	if ((count < 0) || (ptr == NULL)) {
610 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
611 		return;
612 	}
613 	/* ensure that the string is null terminated */
614 	name = (char *)malloc(count+1);
615 	bcopy(ptr, name, count);
616 	name[count] = 0;
617 #ifndef STAND
618 	tmp = get_dev(name);
619 	free(name);
620 	name = tmp;
621 #else
622 	fd = open(name, O_RDONLY);
623 	free(name);
624 	do {
625 		if (fd < 0)
626 			break;
627 		if (fstat(fd, &sb) < 0)
628 			break;
629 		if (!S_ISDIR(sb.st_mode))
630 			break;
631 		flag = FICL_TRUE;
632 		ficlStackPushInteger(ficlVmGetDataStack(pVM), fd);
633 		ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
634 		return;
635 	} while (0);
636 
637 	if (fd >= 0)
638 		close(fd);
639 
640 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
641 		return;
642 #endif
643 #ifndef STAND
644 	dir = opendir(name);
645 	if (dir == NULL) {
646 		ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
647 		return;
648 	} else
649 		flag = FICL_TRUE;
650 
651 	ficlStackPushPointer(ficlVmGetDataStack(pVM), dir);
652 	ficlStackPushInteger(ficlVmGetDataStack(pVM), flag);
653 #endif
654 }
655 
656 /*
657  * freaddir - read directory contents
658  * freaddir ( fd -- ptr len TRUE | FALSE )
659  */
660 static void
661 pfreaddir(ficlVm *pVM)
662 {
663 #ifndef STAND
664 	static DIR *dir = NULL;
665 #else
666 	int fd;
667 #endif
668 	struct dirent *d = NULL;
669 
670 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 3);
671 	/*
672 	 * libstand readdir does not always return . nor .. so filter
673 	 * them out to have consistent behaviour.
674 	 */
675 #ifndef STAND
676 	dir = ficlStackPopPointer(ficlVmGetDataStack(pVM));
677 	if (dir != NULL)
678 		do {
679 			d = readdir(dir);
680 			if (d != NULL && strcmp(d->d_name, ".") == 0)
681 				continue;
682 			if (d != NULL && strcmp(d->d_name, "..") == 0)
683 				continue;
684 			break;
685 		} while (d != NULL);
686 #else
687 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
688 	if (fd != -1)
689 		do {
690 			d = readdirfd(fd);
691 			if (d != NULL && strcmp(d->d_name, ".") == 0)
692 				continue;
693 			if (d != NULL && strcmp(d->d_name, "..") == 0)
694 				continue;
695 			break;
696 		} while (d != NULL);
697 #endif
698 	if (d != NULL) {
699 		ficlStackPushPointer(ficlVmGetDataStack(pVM), d->d_name);
700 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
701 		    strlen(d->d_name));
702 		ficlStackPushInteger(ficlVmGetDataStack(pVM), FICL_TRUE);
703 	} else {
704 		ficlStackPushInteger(ficlVmGetDataStack(pVM), FICL_FALSE);
705 	}
706 }
707 
708 /*
709  * fclosedir - close a dir on stack.
710  *
711  * fclosedir ( fd -- )
712  */
713 static void
714 pfclosedir(ficlVm *pVM)
715 {
716 #ifndef STAND
717 	DIR *dir;
718 #else
719 	int fd;
720 #endif
721 
722 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
723 
724 #ifndef STAND
725 	dir = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get dir */
726 	if (dir != NULL)
727 		closedir(dir);
728 #else
729 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
730 	if (fd != -1)
731 		close(fd);
732 #endif
733 }
734 
735 /*
736  * fload - interpret file contents
737  *
738  * fload  ( fd -- )
739  */
740 static void pfload(ficlVm *pVM)
741 {
742 	int fd;
743 
744 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
745 
746 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
747 	if (fd != -1)
748 		ficlExecFD(pVM, fd);
749 }
750 
751 /*
752  * fwrite - write file contents
753  *
754  * fwrite  ( fd buf nbytes  -- nwritten )
755  */
756 static void
757 pfwrite(ficlVm *pVM)
758 {
759 	int fd, len;
760 	char *buf;
761 
762 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
763 
764 	len = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* bytes to read */
765 	buf = ficlStackPopPointer(ficlVmGetDataStack(pVM)); /* get buffer */
766 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM)); /* get fd */
767 	if (len > 0 && buf && fd != -1)
768 		ficlStackPushInteger(ficlVmGetDataStack(pVM),
769 		    write(fd, buf, len));
770 	else
771 		ficlStackPushInteger(ficlVmGetDataStack(pVM), -1);
772 }
773 
774 /*
775  * fseek - seek to a new position in a file
776  *
777  * fseek  ( fd ofs whence  -- pos )
778  */
779 static void
780 pfseek(ficlVm *pVM)
781 {
782 	int fd, pos, whence;
783 
784 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
785 
786 	whence = ficlStackPopInteger(ficlVmGetDataStack(pVM));
787 	pos = ficlStackPopInteger(ficlVmGetDataStack(pVM));
788 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
789 	ficlStackPushInteger(ficlVmGetDataStack(pVM), lseek(fd, pos, whence));
790 }
791 
792 /*
793  * key - get a character from stdin
794  *
795  * key ( -- char )
796  */
797 static void
798 key(ficlVm *pVM)
799 {
800 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
801 
802 	ficlStackPushInteger(ficlVmGetDataStack(pVM), getchar());
803 }
804 
805 /*
806  * key? - check for a character from stdin (FACILITY)
807  * key? ( -- flag )
808  */
809 static void
810 keyQuestion(ficlVm *pVM)
811 {
812 #ifndef STAND
813 	char ch = -1;
814 	struct termios oldt;
815 	struct termios newt;
816 #endif
817 
818 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
819 
820 #ifndef STAND
821 	tcgetattr(STDIN_FILENO, &oldt);
822 	newt = oldt;
823 	newt.c_lflag &= ~(ICANON | ECHO);
824 	newt.c_cc[VMIN] = 0;
825 	newt.c_cc[VTIME] = 0;
826 	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
827 	ch = getchar();
828 	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
829 
830 	if (ch != -1)
831 		(void) ungetc(ch, stdin);
832 
833 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
834 	    ch != -1? FICL_TRUE : FICL_FALSE);
835 #else
836 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
837 	    ischar()? FICL_TRUE : FICL_FALSE);
838 #endif
839 }
840 
841 /*
842  * seconds - gives number of seconds since beginning of time
843  *
844  * beginning of time is defined as:
845  *
846  *	BTX	- number of seconds since midnight
847  *	FreeBSD	- number of seconds since Jan 1 1970
848  *
849  * seconds ( -- u )
850  */
851 static void
852 pseconds(ficlVm *pVM)
853 {
854 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 0, 1);
855 
856 	ficlStackPushUnsigned(ficlVmGetDataStack(pVM),
857 	    (ficlUnsigned) time(NULL));
858 }
859 
860 /*
861  * ms - wait at least that many milliseconds (FACILITY)
862  * ms ( u -- )
863  */
864 static void
865 ms(ficlVm *pVM)
866 {
867 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 0);
868 
869 #ifndef STAND
870 	usleep(ficlStackPopUnsigned(ficlVmGetDataStack(pVM)) * 1000);
871 #else
872 	delay(ficlStackPopUnsigned(ficlVmGetDataStack(pVM)) * 1000);
873 #endif
874 }
875 
876 /*
877  * fkey - get a character from a file
878  * fkey ( file -- char )
879  */
880 static void
881 fkey(ficlVm *pVM)
882 {
883 	int i, fd;
884 	char ch;
885 
886 	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 1);
887 
888 	fd = ficlStackPopInteger(ficlVmGetDataStack(pVM));
889 	i = read(fd, &ch, 1);
890 	ficlStackPushInteger(ficlVmGetDataStack(pVM), i > 0 ? ch : -1);
891 }
892 
893 
894 #ifdef STAND
895 #ifdef __i386__
896 
897 /*
898  * outb ( port# c -- )
899  * Store a byte to I/O port number port#
900  */
901 void
902 ficlOutb(ficlVm *pVM)
903 {
904 	uint8_t c;
905 	uint32_t port;
906 
907 	port = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
908 	c = ficlStackPopInteger(ficlVmGetDataStack(pVM));
909 	outb(port, c);
910 }
911 
912 /*
913  * inb ( port# -- c )
914  * Fetch a byte from I/O port number port#
915  */
916 void
917 ficlInb(ficlVm *pVM)
918 {
919 	uint8_t c;
920 	uint32_t port;
921 
922 	port = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
923 	c = inb(port);
924 	ficlStackPushInteger(ficlVmGetDataStack(pVM), c);
925 }
926 
927 /*
928  * pcibios-device-count (devid -- count)
929  *
930  * Returns the PCI BIOS' count of how many devices matching devid are
931  * in the system. devid is the 32-bit vendor + device.
932  */
933 static void
934 ficlPciBiosCountDevices(ficlVm *pVM)
935 {
936 	uint32_t devid;
937 	int i;
938 
939 	devid = ficlStackPopInteger(ficlVmGetDataStack(pVM));
940 
941 	i = biospci_count_device_type(devid);
942 
943 	ficlStackPushInteger(ficlVmGetDataStack(pVM), i);
944 }
945 
946 /*
947  * pcibios-write-config (locator offset width value -- )
948  *
949  * Writes the specified config register.
950  * Locator is bus << 8 | device << 3 | fuction
951  * offset is the pci config register
952  * width is 0 for byte, 1 for word, 2 for dword
953  * value is the value to write
954  */
955 static void
956 ficlPciBiosWriteConfig(ficlVm *pVM)
957 {
958 	uint32_t value, width, offset, locator;
959 
960 	value = ficlStackPopInteger(ficlVmGetDataStack(pVM));
961 	width = ficlStackPopInteger(ficlVmGetDataStack(pVM));
962 	offset = ficlStackPopInteger(ficlVmGetDataStack(pVM));
963 	locator = ficlStackPopInteger(ficlVmGetDataStack(pVM));
964 
965 	biospci_write_config(locator, offset, width, value);
966 }
967 
968 /*
969  * pcibios-read-config (locator offset width -- value)
970  *
971  * Reads the specified config register.
972  * Locator is bus << 8 | device << 3 | fuction
973  * offset is the pci config register
974  * width is 0 for byte, 1 for word, 2 for dword
975  * value is the value to read from the register
976  */
977 static void
978 ficlPciBiosReadConfig(ficlVm *pVM)
979 {
980 	uint32_t value, width, offset, locator;
981 
982 	width = ficlStackPopInteger(ficlVmGetDataStack(pVM));
983 	offset = ficlStackPopInteger(ficlVmGetDataStack(pVM));
984 	locator = ficlStackPopInteger(ficlVmGetDataStack(pVM));
985 
986 	biospci_read_config(locator, offset, width, &value);
987 
988 	ficlStackPushInteger(ficlVmGetDataStack(pVM), value);
989 }
990 
991 /*
992  * pcibios-find-devclass (class index -- locator)
993  *
994  * Finds the index'th instance of class in the pci tree.
995  * must be an exact match.
996  * class is the class to search for.
997  * index 0..N (set to 0, increment until error)
998  *
999  * Locator is bus << 8 | device << 3 | fuction (or -1 on error)
1000  */
1001 static void
1002 ficlPciBiosFindDevclass(ficlVm *pVM)
1003 {
1004 	uint32_t index, class, locator;
1005 
1006 	index = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1007 	class = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1008 
1009 	if (biospci_find_devclass(class, index, &locator))
1010 		locator = 0xffffffff;
1011 
1012 	ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
1013 }
1014 
1015 /*
1016  * pcibios-find-device(devid index -- locator)
1017  *
1018  * Finds the index'th instance of devid in the pci tree.
1019  * must be an exact match.
1020  * class is the class to search for.
1021  * index 0..N (set to 0, increment until error)
1022  *
1023  * Locator is bus << 8 | device << 3 | fuction (or -1 on error)
1024  */
1025 static void
1026 ficlPciBiosFindDevice(ficlVm *pVM)
1027 {
1028 	uint32_t index, devid, locator;
1029 
1030 	index = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1031 	devid = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1032 
1033 	if (biospci_find_device(devid, index, &locator))
1034 		locator = 0xffffffff;
1035 
1036 	ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
1037 }
1038 
1039 /*
1040  * pcibios-find-device(bus device function -- locator)
1041  *
1042  * converts bus, device, function to locator.
1043  *
1044  * Locator is bus << 8 | device << 3 | fuction
1045  */
1046 static void
1047 ficlPciBiosLocator(ficlVm *pVM)
1048 {
1049 	uint32_t bus, device, function, locator;
1050 
1051 	function = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1052 	device = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1053 	bus = ficlStackPopInteger(ficlVmGetDataStack(pVM));
1054 
1055 	locator = biospci_locator(bus, device, function);
1056 
1057 	ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
1058 }
1059 #endif
1060 #endif
1061 
1062 /*
1063  * Retrieves free space remaining on the dictionary
1064  */
1065 static void
1066 freeHeap(ficlVm *pVM)
1067 {
1068 	ficlStackPushInteger(ficlVmGetDataStack(pVM),
1069 	    ficlDictionaryCellsAvailable(ficlVmGetDictionary(pVM)));
1070 }
1071 
1072 /*
1073  * f i c l C o m p i l e P l a t f o r m
1074  * Build FreeBSD platform extensions into the system dictionary
1075  */
1076 void
1077 ficlSystemCompilePlatform(ficlSystem *pSys)
1078 {
1079 	ficlDictionary *dp = ficlSystemGetDictionary(pSys);
1080 	ficlDictionary *env = ficlSystemGetEnvironment(pSys);
1081 
1082 	FICL_SYSTEM_ASSERT(pSys, dp);
1083 	FICL_SYSTEM_ASSERT(pSys, env);
1084 
1085 	ficlDictionarySetPrimitive(dp, ".#", displayCellNoPad,
1086 	    FICL_WORD_DEFAULT);
1087 	ficlDictionarySetPrimitive(dp, "isdir?", isdirQuestion,
1088 	    FICL_WORD_DEFAULT);
1089 	ficlDictionarySetPrimitive(dp, "fopen", pfopen, FICL_WORD_DEFAULT);
1090 	ficlDictionarySetPrimitive(dp, "fclose", pfclose, FICL_WORD_DEFAULT);
1091 	ficlDictionarySetPrimitive(dp, "fread", pfread, FICL_WORD_DEFAULT);
1092 	ficlDictionarySetPrimitive(dp, "fopendir", pfopendir,
1093 	    FICL_WORD_DEFAULT);
1094 	ficlDictionarySetPrimitive(dp, "freaddir", pfreaddir,
1095 	    FICL_WORD_DEFAULT);
1096 	ficlDictionarySetPrimitive(dp, "fclosedir", pfclosedir,
1097 	    FICL_WORD_DEFAULT);
1098 	ficlDictionarySetPrimitive(dp, "fload", pfload, FICL_WORD_DEFAULT);
1099 	ficlDictionarySetPrimitive(dp, "fkey", fkey, FICL_WORD_DEFAULT);
1100 	ficlDictionarySetPrimitive(dp, "fseek", pfseek, FICL_WORD_DEFAULT);
1101 	ficlDictionarySetPrimitive(dp, "fwrite", pfwrite, FICL_WORD_DEFAULT);
1102 	ficlDictionarySetPrimitive(dp, "key", key, FICL_WORD_DEFAULT);
1103 	ficlDictionarySetPrimitive(dp, "key?", keyQuestion, FICL_WORD_DEFAULT);
1104 	ficlDictionarySetPrimitive(dp, "ms", ms, FICL_WORD_DEFAULT);
1105 	ficlDictionarySetPrimitive(dp, "seconds", pseconds, FICL_WORD_DEFAULT);
1106 	ficlDictionarySetPrimitive(dp, "heap?", freeHeap, FICL_WORD_DEFAULT);
1107 
1108 	ficlDictionarySetPrimitive(dp, "setenv", ficlSetenv, FICL_WORD_DEFAULT);
1109 	ficlDictionarySetPrimitive(dp, "setenv?", ficlSetenvq,
1110 	    FICL_WORD_DEFAULT);
1111 	ficlDictionarySetPrimitive(dp, "getenv", ficlGetenv, FICL_WORD_DEFAULT);
1112 	ficlDictionarySetPrimitive(dp, "unsetenv", ficlUnsetenv,
1113 	    FICL_WORD_DEFAULT);
1114 	ficlDictionarySetPrimitive(dp, "copyin", ficlCopyin, FICL_WORD_DEFAULT);
1115 	ficlDictionarySetPrimitive(dp, "copyout", ficlCopyout,
1116 	    FICL_WORD_DEFAULT);
1117 	ficlDictionarySetPrimitive(dp, "findfile", ficlFindfile,
1118 	    FICL_WORD_DEFAULT);
1119 	ficlDictionarySetPrimitive(dp, "ccall", ficlCcall, FICL_WORD_DEFAULT);
1120 	ficlDictionarySetPrimitive(dp, "uuid-from-string", ficlUuidFromString,
1121 	    FICL_WORD_DEFAULT);
1122 	ficlDictionarySetPrimitive(dp, "uuid-to-string", ficlUuidToString,
1123 	    FICL_WORD_DEFAULT);
1124 #ifdef STAND
1125 #ifdef __i386__
1126 	ficlDictionarySetPrimitive(dp, "outb", ficlOutb, FICL_WORD_DEFAULT);
1127 	ficlDictionarySetPrimitive(dp, "inb", ficlInb, FICL_WORD_DEFAULT);
1128 #endif
1129 #ifdef HAVE_PNP
1130 	ficlDictionarySetPrimitive(dp, "pnpdevices", ficlPnpdevices,
1131 	    FICL_WORD_DEFAULT);
1132 	ficlDictionarySetPrimitive(dp, "pnphandlers", ficlPnphandlers,
1133 	    FICL_WORD_DEFAULT);
1134 #endif
1135 #ifdef __i386__
1136 	ficlDictionarySetPrimitive(dp, "pcibios-device-count",
1137 	    ficlPciBiosCountDevices, FICL_WORD_DEFAULT);
1138 	ficlDictionarySetPrimitive(dp, "pcibios-read-config",
1139 	    ficlPciBiosReadConfig, FICL_WORD_DEFAULT);
1140 	ficlDictionarySetPrimitive(dp, "pcibios-write-config",
1141 	    ficlPciBiosWriteConfig, FICL_WORD_DEFAULT);
1142 	ficlDictionarySetPrimitive(dp, "pcibios-find-devclass",
1143 	    ficlPciBiosFindDevclass, FICL_WORD_DEFAULT);
1144 	ficlDictionarySetPrimitive(dp, "pcibios-find-device",
1145 	    ficlPciBiosFindDevice, FICL_WORD_DEFAULT);
1146 	ficlDictionarySetPrimitive(dp, "pcibios-locator", ficlPciBiosLocator,
1147 	    FICL_WORD_DEFAULT);
1148 #endif
1149 #endif
1150 
1151 #if defined(__i386__) || defined(__amd64__)
1152 	ficlDictionarySetConstant(env, "arch-i386", FICL_TRUE);
1153 	ficlDictionarySetConstant(env, "arch-sparc", FICL_FALSE);
1154 #endif
1155 #ifdef __sparc
1156 	ficlDictionarySetConstant(env, "arch-i386", FICL_FALSE);
1157 	ficlDictionarySetConstant(env, "arch-sparc", FICL_TRUE);
1158 #endif
1159 }
1160