Index: bootcd/isolinux/syslinux-6.03/com32/rosh/Makefile
===================================================================
--- bootcd/isolinux/syslinux-6.03/com32/rosh/Makefile	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
+++ bootcd/isolinux/syslinux-6.03/com32/rosh/Makefile	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
@@ -0,0 +1,59 @@
+## -----------------------------------------------------------------------
+##
+##   Copyright 2001-2008 H. Peter Anvin - All Rights Reserved
+##   Copyright 2010 Intel Corporation; author: H. Peter Anvin
+##   Copyright 2008-2010 Gene Cumm - All Rights Reserved
+##
+##   This program is free software; you can redistribute it and/or modify
+##   it under the terms of the GNU General Public License as published by
+##   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+##
+## ROSH Read Only Shell
+##
+
+LIBS = $(objdir)/com32/libutil/libutil.c32 \
+	$(objdir)/com32/lib/libcom32.c32
+
+VPATH = $(SRC)
+include $(MAKEDIR)/rosh.mk
+
+# from com32/sysdump/Makefile
+# The DATE is set on the make command line when building binaries for
+# official release.  Otherwise, substitute a hex string that is pretty much
+# guaranteed to be unique to be unique from build to build.
+ifndef HEXDATE
+HEXDATE := $(shell $(PERL) $(topdir)/now.pl $(SRCS) $(wildcard *.h))
+endif
+ifndef DATE
+DATE    := $(shell sh $(topdir)/gen-id.sh $(VERSION) $(HEXDATE))
+endif
+
+CFLAGS		+= -DDATE='"$(DATE)"'
+LNXCFLAGS	+= -DDATE='"$(DATE)"'
+
+all:	rosh.c32
+
+rosh.o:	rosh.h
+
+rosh.lo:	rosh.h
+
+allgrc:	rosh.c32 rosh.lnx
+
+tidy dist:
+	rm -f *.o *.lo *.a *.lst *.elf .*.d *.tmp
+
+clean: tidy
+	rm -f *.lnx
+
+spotless: clean
+	rm -f *.lss *.c32 *.com
+	rm -f *~ \#*
+
+install:
+
+-include .*.d
Index: bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.c
===================================================================
--- bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.c	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
+++ bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.c	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
@@ -0,0 +1,1363 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2008-2011 Gene Cumm - All Rights Reserved
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rosh.c
+ *
+ * Read-Only shell; Simple shell system designed for SYSLINUX-derivitives.
+ * Provides minimal commands utilizing the console via stdout/stderr as the
+ * sole output devices.  Designed to compile for Linux for testing/debugging.
+ */
+
+/*
+ * ToDos:
+ * prompt:	Allow left/right arrow, home/end and more?
+ * commands	Break into argv/argc-like array
+ * rosh_cfg:	allow -s <file> to change config
+ * rosh_ls():	sorted; then multiple columns
+ * prompt:	Possibly honor timeout on initial entry for usage as UI
+ *		Also possibly honor totaltimeout
+ */
+
+/*#define DO_DEBUG 1
+//*/
+/* Uncomment the above line for debugging output; Comment to remove */
+/*#define DO_DEBUG2 1
+//*/
+/* Uncomment the above line for super-debugging output; Must have regular
+ * debugging enabled; Comment to remove.
+ */
+#include "rosh.h"
+#include "version.h"
+
+#define APP_LONGNAME	"Read-Only Shell"
+#define APP_NAME	"rosh"
+#define APP_AUTHOR	"Gene Cumm"
+#define APP_YEAR	"2010"
+#define APP_VER		"beta-b090"
+
+/* Print version information to stdout
+ */
+void rosh_version(int vtype)
+{
+    char env[256];
+    env[0] = 0;
+    printf("%s v %s; (c) %s %s.\n\tFrom Syslinux %s, %s\n", APP_LONGNAME, APP_VER, APP_YEAR, APP_AUTHOR, VERSION_STR, DATE);
+    switch (vtype) {
+    case 1:
+	rosh_get_env_ver(env, 256);
+	printf("\tRunning on %s\n", env);
+    }
+}
+
+/* Print beta message and if DO_DEBUG/DO_DEBUG2 are active
+ */
+void print_beta(void)
+{
+    puts(rosh_beta_str);
+    ROSH_DEBUG("DO_DEBUG active\n");
+    ROSH_DEBUG2("DO_DEBUG2 active\n");
+}
+
+/* Search a string for first non-space (' ') character, starting at ipos
+ *	istr	input string to parse
+ *	ipos	input position to start at
+ */
+int rosh_search_nonsp(const char *istr, const int ipos)
+{
+    int curpos;
+    char c;
+
+    curpos = ipos;
+    c = istr[curpos];
+    while (c && isspace(c))
+	c = istr[++curpos];
+    return curpos;
+}
+
+/* Search a string for space (' '), returning the position of the next space
+ * or the '\0' at end of string
+ *	istr	input string to parse
+ *	ipos	input position to start at
+ */
+int rosh_search_sp(const char *istr, const int ipos)
+{
+    int curpos;
+    char c;
+
+    curpos = ipos;
+    c = istr[curpos];
+    while (c && !(isspace(c)))
+	c = istr[++curpos];
+    return curpos;
+}
+
+/* Parse a string for the first non-space string, returning the end position
+ * from src
+ *	dest	string to contain the first non-space string
+ *	src	string to parse
+ *	ipos	Position to start in src
+ */
+int rosh_parse_sp_1(char *dest, const char *src, const int ipos)
+{
+    int bpos, epos;		/* beginning and ending position of source string
+				   to copy to destination string */
+
+    bpos = 0;
+    epos = 0;
+/* //HERE-error condition checking */
+    bpos = rosh_search_nonsp(src, ipos);
+    epos = rosh_search_sp(src, bpos);
+    if (epos > bpos) {
+	memcpy(dest, src + bpos, epos - bpos);
+	if (dest[epos - bpos] != 0)
+	    dest[epos - bpos] = 0;
+    } else {
+	epos = strlen(src);
+	dest[0] = 0;
+    }
+    return epos;
+}
+
+/*
+ * parse_args1: Try 1 at parsing a string to an argc/argv pair.  use free_args1 to free memory malloc'd
+ *
+ * Derived from com32/lib/sys/argv.c:__parse_argv()
+ *   Copyright 2004-2009 H. Peter Anvin - All Rights Reserved
+ *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+ */
+int parse_args1(char ***iargv, const char *istr)
+{
+    int argc  = 0;
+    const char *p;
+    char *q, *r, *args, **arg;
+    int sp = 1;	//, qt = 0;		/* Was a space; inside a quote */
+
+    /* Scan 1: Length */
+    /* I could eliminate this if I knew a max length, like strncpy() */
+    int len = strlen(istr);
+
+    /* Scan 2: Copy, nullify and make argc */
+    if (!(args = malloc(len + 1)))
+	goto fail_args;
+    q = args;
+    for (p = istr;; p++) {
+	if (*p <= ' ') {
+	    if (!sp) {
+		sp = 1;
+		*q++ = '\0';
+	    }
+	} else {
+	    if (sp) {
+		argc++;
+		sp = 0;
+	    }
+	    *q++ = *p;
+	}
+	if (!*p)
+	    break;
+    }
+
+    q--;			/* Point q to final null */
+    /* Scan 3: Build array of pointers */
+    if (!(*iargv = malloc((argc + 1) * sizeof(char *))))
+	goto fail_args_ptr;
+    arg = *iargv;
+    arg[argc] = NULL;		/* Nullify the last pointer */
+    if (*args != '\0')
+	    *arg++ = args;
+    for (r = args; r < q ; r++) {
+	if (*r == '\0') {
+	    *arg++ = r + 1;
+	}
+    }
+
+fail_args:
+    return argc;
+fail_args_ptr:
+    free(args);
+    return 0;
+}
+
+/* Free argv created by parse_args1()
+ *	argv	Argument Values
+ */
+void free_args1(char ***argv)
+{
+    char *s;
+    s = **argv;
+    free(*argv);
+    free(s);
+}
+
+/* Convert a string to an argc/argv pair
+ *	str	String to parse
+ *	argv	Argument Values
+ *	returns	Argument Count
+ */
+int rosh_str2argv(char ***argv, const char *str)
+{
+    return parse_args1(argv, str);
+}
+
+/* Free an argv created by rosh_str2argv()
+ *	argv	Argument Values to free
+ */
+void rosh_free_argv(char ***argv)
+{
+     free_args1(argv);
+}
+
+/* Print the contents of an argc/argv pair
+ *	argc	Argument Count
+ *	argv	Argument Values
+ */
+void rosh_pr_argv(int argc, char *argv[])
+{
+    int i;
+    for (i = 0; i < argc; i++) {
+	printf("%s%s", argv[i], (i < argc)? " " : "");
+    }
+    puts("");
+}
+
+/* Print the contents of an argc/argv pair verbosely
+ *	argc	Argument Count
+ *	argv	Argument Values
+ */
+void rosh_pr_argv_v(int argc, char *argv[])
+{
+    int i;
+    for (i = 0; i < argc; i++) {
+	printf("%4d '%s'\n", i, argv[i]);
+    }
+}
+
+/* Reset the getopt() environment
+ */
+void rosh_getopt_reset(void)
+{
+    optind = 0;
+    optopt = 0;
+}
+
+/* Display help
+ *	type	Help type
+ *	cmdstr	Command for which help is requested
+ */
+void rosh_help(int type, const char *cmdstr)
+{
+    switch (type) {
+    case 2:
+	if ((cmdstr == NULL) || (strcmp(cmdstr, "") == 0)) {
+	    rosh_version(0);
+	    puts(rosh_help_str2);
+	} else {
+	    switch (cmdstr[0]) {
+	    case 'c':
+		puts(rosh_help_cd_str);
+		break;
+	    case 'l':
+		puts(rosh_help_ls_str);
+		break;
+	    default:
+		printf(rosh_help_str_adv, cmdstr);
+	    }
+	}
+	break;
+    case 1:
+    default:
+	if (cmdstr)
+	    printf("%s: %s: unknown command\n", APP_NAME, cmdstr);
+	rosh_version(0);
+	puts(rosh_help_str1);
+    }
+}
+
+/* Handle most/all errors
+ *	ierrno	Input Error number
+ *	cmdstr	Command being executed to cause error
+ *	filestr	File/parameter causing error
+ */
+void rosh_error(const int ierrno, const char *cmdstr, const char *filestr)
+{
+    printf("--ERROR: %s '%s': ", cmdstr, filestr);
+    switch (ierrno) {
+    case 0:
+	puts("NO ERROR");
+	break;
+    case ENOENT:
+	puts("not found");
+	/* SYSLinux-3.72 COM32 API returns this for a
+	   directory or empty file */
+	ROSH_COM32("  (COM32) could be a directory or empty file\n");
+	break;
+    case EIO:
+	puts("I/O Error");
+	break;
+    case EBADF:
+	puts("Bad File Descriptor");
+	break;
+    case EACCES:
+	puts("Access DENIED");
+	break;
+    case ENOTDIR:
+	puts("not a directory");
+	ROSH_COM32("  (COM32) could be directory\n");
+	break;
+    case EISDIR:
+	puts("IS a directory");
+	break;
+    case ENOSYS:
+	puts("not implemented");
+	break;
+    default:
+	printf("returns error; errno=%d\n", ierrno);
+    }
+}				/* rosh_error */
+
+/* Concatenate command line arguments into one string
+ *	cmdstr	Output command string
+ *	cmdlen	Length of cmdstr
+ *	argc	Argument Count
+ *	argv	Argument Values
+ *	barg	Beginning Argument
+ */
+int rosh_argcat(char *cmdstr, const int cmdlen, const int argc, char *argv[],
+		const int barg)
+{
+    int i, arglen, curpos;	/* index, argument length, current position
+				   in cmdstr */
+    curpos = 0;
+    cmdstr[0] = '\0';		/* Nullify string just to be sure */
+    for (i = barg; i < argc; i++) {
+	arglen = strlen(argv[i]);
+	/* Theoretically, this should never be met in SYSLINUX */
+	if ((curpos + arglen) > (cmdlen - 1))
+	    arglen = (cmdlen - 1) - curpos;
+	memcpy(cmdstr + curpos, argv[i], arglen);
+	curpos += arglen;
+	if (curpos >= (cmdlen - 1)) {
+	    /* Hopefully, curpos should not be greater than
+	       (cmdlen - 1) */
+	    /* Still need a '\0' at the last character */
+	    cmdstr[(cmdlen - 1)] = 0;
+	    break;		/* Escape out of the for() loop;
+				   We can no longer process anything more */
+	} else {
+	    cmdstr[curpos] = ' ';
+	    curpos += 1;
+	    cmdstr[curpos] = 0;
+	}
+    }
+    /* If there's a ' ' at the end, remove it.  This is normal unless
+       the maximum length is met/exceeded. */
+    if (cmdstr[curpos - 1] == ' ')
+	cmdstr[--curpos] = 0;
+    return curpos;
+}				/* rosh_argcat */
+
+/*
+ * Prints a lot of the data in a struct termios
+ */
+/*
+void rosh_print_tc(struct termios *tio)
+{
+	printf("  -- termios: ");
+	printf(".c_iflag=%04X ", tio->c_iflag);
+	printf(".c_oflag=%04X ", tio->c_oflag);
+	printf(".c_cflag=%04X ", tio->c_cflag);
+	printf(".c_lflag=%04X ", tio->c_lflag);
+	printf(".c_cc[VTIME]='%d' ", tio->c_cc[VTIME]);
+	printf(".c_cc[VMIN]='%d'", tio->c_cc[VMIN]);
+	printf("\n");
+}
+*/
+
+/*
+ * Attempts to get a single key from the console
+ *	returns	key pressed
+ */
+int rosh_getkey(void)
+{
+    int inc;
+
+    inc = KEY_NONE;
+    while (inc == KEY_NONE)
+	inc = get_key(stdin, 6000);
+    return inc;
+}				/* rosh_getkey */
+
+/*
+ * Qualifies a filename relative to the working directory
+ *	filestr	Filename to qualify
+ *	pwdstr	working directory
+ *	returns	qualified file name string
+ */
+void rosh_qualify_filestr(char *filestr, const char *ifilstr,
+			  const char *pwdstr)
+{
+    int filepos = 0;
+    if ((filestr) && (pwdstr) && (ifilstr)) {
+	if (ifilstr[0] != SEP) {
+	    strcpy(filestr, pwdstr);
+	    filepos = strlen(pwdstr);
+	    if (filestr[filepos - 1] != SEP)
+		filestr[filepos++] = SEP;
+	}
+	strcpy(filestr + filepos, ifilstr);
+	ROSH_DEBUG("--'%s'\n", filestr);
+    }
+}
+
+/* Concatenate multiple files to stdout
+ *	argc	Argument Count
+ *	argv	Argument Values
+ */
+void rosh_cat(int argc, char *argv[])
+{
+    FILE *f;
+    char buf[ROSH_BUF_SZ];
+    int i, numrd;
+
+    for (i = 0; i < argc; i++) {
+	printf("--File = '%s'\n", argv[i]);
+	errno = 0;
+	f = fopen(argv[i], "r");
+	if (f != NULL) {
+	    numrd = fread(buf, 1, ROSH_BUF_SZ, f);
+	    while (numrd > 0) {
+		fwrite(buf, 1, numrd, stdout);
+		numrd = fread(buf, 1, ROSH_BUF_SZ, f);
+	    }
+	    fclose(f);
+	} else {
+	    rosh_error(errno, "cat", argv[i]);
+	    errno = 0;
+	}
+    }
+}				/* rosh_cat */
+
+/* Change PWD (Present Working Directory)
+ *	argc	Argument count
+ *	argv	Argument values
+ *	ipwdstr	Initial PWD
+ */
+void rosh_cd(int argc, char *argv[], const char *ipwdstr)
+{
+    int rv = 0;
+#ifdef DO_DEBUG
+    char filestr[ROSH_PATH_SZ];
+#endif /* DO_DEBUG */
+    ROSH_DEBUG("CMD: \n");
+    ROSH_DEBUG_ARGV_V(argc, argv);
+    errno = 0;
+    if (argc == 2)
+	rv = chdir(argv[1]);
+    else if (argc == 1)
+	rv = chdir(ipwdstr);
+    else
+	rosh_help(2, argv[0]);
+    if (rv != 0) {
+	if (argc == 2)
+	    rosh_error(errno, "cd", argv[1]);
+	else
+	    rosh_error(errno, "cd", ipwdstr);
+	errno = 0;
+    } else {
+#ifdef DO_DEBUG
+	if (getcwd(filestr, ROSH_PATH_SZ))
+	    ROSH_DEBUG("  %s\n", filestr);
+#endif /* DO_DEBUG */
+    }
+}				/* rosh_cd */
+
+/* Print the syslinux config file name
+ */
+void rosh_cfg(void)
+{
+    printf("CFG:     '%s'\n", syslinux_config_file());
+}				/* rosh_cfg */
+
+/* Echo a string back to the screen
+ *	cmdstr	command string to process
+ */
+void rosh_echo(const char *cmdstr)
+{
+    int bpos = 0;
+    ROSH_DEBUG("CMD: '%s'\n", cmdstr);
+    bpos = rosh_search_nonsp(cmdstr, rosh_search_sp(cmdstr, 0));
+    if (bpos > 1) {
+	ROSH_DEBUG("  bpos=%d\n", bpos);
+	printf("'%s'\n", cmdstr + bpos);
+    } else {
+	puts("");
+    }
+}				/* rosh_echo */
+
+/* Process argc/argv to optarr
+ *	argc	Argument count
+ *	argv	Argument values
+ *	optarr	option array to populate
+ */
+void rosh_ls_arg_opt(int argc, char *argv[], int optarr[])
+{
+    int rv = 0;
+
+    optarr[0] = -1;
+    optarr[1] = -1;
+    optarr[2] = -1;
+    rosh_getopt_reset();
+    while (rv != -1) {
+	ROSH_DEBUG2("getopt optind=%d rv=%d\n", optind, rv);
+	rv = getopt(argc, argv, rosh_ls_opt_str);
+	switch (rv) {
+	case 'l':
+	case 0:
+	    optarr[0] = 1;
+	    break;
+	case 'F':
+	case 1:
+	    optarr[1] = 1;
+	    break;
+	case 'i':
+	case 2:
+	    optarr[2] = 1;
+	    break;
+	case '?':
+	case -1:
+	default:
+	    ROSH_DEBUG2("getopt optind=%d rv=%d\n", optind, rv);
+	    break;
+	}
+    }
+    ROSH_DEBUG2(" end getopt optind=%d rv=%d\n", optind, rv);
+    ROSH_DEBUG2("\tIn rosh_ls_arg_opt() opt[0]=%d\topt[1]=%d\topt[2]=%d\n", optarr[0], optarr[1],
+	       optarr[2]);
+}				/* rosh_ls_arg_opt */
+
+/* Retrieve the size of a file argument
+ *	filestr	directory name of directory entry
+ *	de	directory entry
+ */
+int rosh_ls_de_size(const char *filestr, struct dirent *de)
+{
+    int de_size;
+    char filestr2[ROSH_PATH_SZ];
+    int fd2, file2pos;
+    struct stat fdstat;
+
+    filestr2[0] = 0;
+    file2pos = -1;
+    if (filestr) {
+	file2pos = strlen(filestr);
+	memcpy(filestr2, filestr, file2pos);
+	filestr2[file2pos] = '/';
+    }
+    strcpy(filestr2 + file2pos + 1, de->d_name);
+    fd2 = open(filestr2, O_RDONLY);
+    fstat(fd2, &fdstat);
+    fd2 = close(fd2);
+    de_size = (int)fdstat.st_size;
+    return de_size;
+}				/* rosh_ls_de_size */
+
+/* Retrieve the size and mode of a file
+ *	filestr	directory name of directory entry
+ *	de	directory entry
+ */
+int rosh_ls_de_size_mode(const char *filestr, struct dirent *de, mode_t * st_mode)
+{
+    int de_size;
+    char filestr2[ROSH_PATH_SZ];
+    int file2pos;
+    struct stat fdstat;
+    int status;
+
+    filestr2[0] = 0;
+    file2pos = -1;
+    memset(&fdstat, 0, sizeof fdstat);
+    ROSH_DEBUG2("ls:dsm(%s, %s) ", filestr, de->d_name);
+    if (filestr) {
+	/* FIXME: prevent string overflow */
+	file2pos = strlen(filestr);
+	memcpy(filestr2, filestr, file2pos);
+	if (( filestr2[file2pos - 1] == SEP )) {
+	    file2pos--;
+	} else {
+	    filestr2[file2pos] = SEP;
+	}
+    }
+    strcpy(filestr2 + file2pos + 1, de->d_name);
+    errno = 0;
+    ROSH_DEBUG2("stat(%s) ", filestr2);
+    status = stat(filestr2, &fdstat);
+    (void)status;
+    ROSH_DEBUG2("\t--stat()=%d\terr=%d\n", status, errno);
+    if (errno) {
+	rosh_error(errno, "ls:szmd.stat", de->d_name);
+	errno = 0;
+    }
+    de_size = (int)fdstat.st_size;
+    *st_mode = fdstat.st_mode;
+    return de_size;
+}				/* rosh_ls_de_size_mode */
+
+/* Returns the Inode number if fdstat contains it
+ *	fdstat	struct to extract inode from if not COM32, for now
+ */
+long rosh_ls_d_ino(struct stat *fdstat)
+{
+    long de_ino;
+#ifdef __COM32__
+    if (fdstat)
+	de_ino = -1;
+    else
+	de_ino = 0;
+#else /* __COM32__ */
+    de_ino = fdstat->st_ino;
+#endif /* __COM32__ */
+    return de_ino;
+}
+
+/* Convert a d_type to a single char in human readable format
+ *	d_type	d_type to convert
+ *	returns human readable single character; a space if other
+ */
+char rosh_d_type2char_human(unsigned char d_type)
+{
+    char ret;
+    switch (d_type) {
+    case DT_UNKNOWN:
+	ret = 'U';
+	break;			/* Unknown */
+    case DT_FIFO:
+	ret = 'F';
+	break;			/* FIFO */
+    case DT_CHR:
+	ret = 'C';
+	break;			/* Char Dev */
+    case DT_DIR:
+	ret = 'D';
+	break;			/* Directory */
+    case DT_BLK:
+	ret = 'B';
+	break;			/* Block Dev */
+    case DT_REG:
+	ret = 'R';
+	break;			/* Regular File */
+    case DT_LNK:
+	ret = 'L';
+	break;			/* Link, Symbolic */
+    case DT_SOCK:
+	ret = 'S';
+	break;			/* Socket */
+    case DT_WHT:
+	ret = 'W';
+	break;			/* UnionFS Whiteout */
+    default:
+	ret = ' ';
+    }
+    return ret;
+}				/* rosh_d_type2char_human */
+
+/* Convert a d_type to a single char by ls's prefix standards for -l
+ *	d_type	d_type to convert
+ *	returns ls style single character; a space if other
+ */
+char rosh_d_type2char_lspre(unsigned char d_type)
+{
+    char ret;
+    switch (d_type) {
+    case DT_FIFO:
+	ret = 'p';
+	break;
+    case DT_CHR:
+	ret = 'c';
+	break;
+    case DT_DIR:
+	ret = 'd';
+	break;
+    case DT_BLK:
+	ret = 'b';
+	break;
+    case DT_REG:
+	ret = '-';
+	break;
+    case DT_LNK:
+	ret = 'l';
+	break;
+    case DT_SOCK:
+	ret = 's';
+	break;
+    default:
+	ret = '?';
+    }
+    return ret;
+}				/* rosh_d_type2char_lspre */
+
+/* Convert a d_type to a single char by ls's classify (-F) suffix standards
+ *	d_type	d_type to convert
+ *	returns ls style single character; a space if other
+ */
+char rosh_d_type2char_lssuf(unsigned char d_type)
+{
+    char ret;
+    switch (d_type) {
+    case DT_FIFO:
+	ret = '|';
+	break;
+    case DT_DIR:
+	ret = '/';
+	break;
+    case DT_LNK:
+	ret = '@';
+	break;
+    case DT_SOCK:
+	ret = '=';
+	break;
+    default:
+	ret = ' ';
+    }
+    return ret;
+}				/* rosh_d_type2char_lssuf */
+
+/* Converts data in the "other" place of st_mode to a ls-style string
+ *	st_mode	Mode in other to analyze
+ *	st_mode_str	string to hold converted string
+ */
+void rosh_st_mode_am2str(mode_t st_mode, char *st_mode_str)
+{
+    st_mode_str[0] = ((st_mode & S_IROTH) ? 'r' : '-');
+    st_mode_str[1] = ((st_mode & S_IWOTH) ? 'w' : '-');
+    st_mode_str[2] = ((st_mode & S_IXOTH) ? 'x' : '-');
+}
+
+/* Converts st_mode to an ls-style string
+ *	st_mode	mode to convert
+ *	st_mode_str	string to hold converted string
+ */
+void rosh_st_mode2str(mode_t st_mode, char *st_mode_str)
+{
+    st_mode_str[0] = rosh_d_type2char_lspre(IFTODT(st_mode));
+    rosh_st_mode_am2str((st_mode & S_IRWXU) >> 6, st_mode_str + 1);
+    rosh_st_mode_am2str((st_mode & S_IRWXG) >> 3, st_mode_str + 4);
+    rosh_st_mode_am2str(st_mode & S_IRWXO, st_mode_str + 7);
+    st_mode_str[10] = 0;
+}				/* rosh_st_mode2str */
+
+/* Output a single entry
+ *	filestr	directory name to list
+ *	de	directory entry
+ *	optarr	Array of options
+ */
+void rosh_ls_arg_dir_de(const char *filestr, struct dirent *de, const int *optarr)
+{
+    int de_size;
+    mode_t st_mode;
+    char st_mode_str[11];
+    st_mode = 0;
+    ROSH_DEBUG2("+");
+    if (optarr[2] > -1)
+	printf("%10d ", (int)(de->d_ino));
+    if (optarr[0] > -1) {
+	de_size = rosh_ls_de_size_mode(filestr, de, &st_mode);
+	rosh_st_mode2str(st_mode, st_mode_str);
+	ROSH_DEBUG2("%04X ", st_mode);
+	printf("%s %10d ", st_mode_str, de_size);
+    }
+    ROSH_DEBUG("'");
+    printf("%s", de->d_name);
+    ROSH_DEBUG("'");
+    if (optarr[1] > -1)
+	printf("%c", rosh_d_type2char_lssuf(de->d_type));
+    printf("\n");
+}				/* rosh_ls_arg_dir_de */
+
+/* Output listing of a regular directory
+ *	filestr	directory name to list
+ *	d	the open DIR
+ *	optarr	Array of options
+	NOTE:This is where I could use qsort
+ */
+void rosh_ls_arg_dir(const char *filestr, DIR * d, const int *optarr)
+{
+    struct dirent *de;
+    int filepos;
+
+    filepos = 0;
+    errno = 0;
+    while ((de = readdir(d))) {
+	filepos++;
+	rosh_ls_arg_dir_de(filestr, de, optarr);
+    }
+    if (errno) {
+	rosh_error(errno, "ls:arg_dir", filestr);
+	errno = 0;
+    } else { if (filepos == 0)
+	ROSH_DEBUG("0 files found");
+    }
+}				/* rosh_ls_arg_dir */
+
+/* Simple directory listing for one argument (file/directory) based on
+ * filestr and pwdstr
+ *	ifilstr	input filename/directory name to list
+ *	pwdstr	Present Working Directory string
+ *	optarr	Option Array
+ */
+void rosh_ls_arg(const char *filestr, const int *optarr)
+{
+    struct stat fdstat;
+    int status;
+//     char filestr[ROSH_PATH_SZ];
+//     int filepos;
+    DIR *d;
+    struct dirent de;
+
+    /* Initialization; make filestr based on leading character of ifilstr
+       and pwdstr */
+//     rosh_qualify_filestr(filestr, ifilstr, pwdstr);
+    fdstat.st_mode = 0;
+    fdstat.st_size = 0;
+    ROSH_DEBUG("\topt[0]=%d\topt[1]=%d\topt[2]=%d\n", optarr[0], optarr[1],
+	       optarr[2]);
+
+    /* Now, the real work */
+    errno = 0;
+    status = stat(filestr, &fdstat);
+    if (status == 0) {
+	if (S_ISDIR(fdstat.st_mode)) {
+	    ROSH_DEBUG("PATH '%s' is a directory\n", filestr);
+	    if ((d = opendir(filestr))) {
+		rosh_ls_arg_dir(filestr, d, optarr);
+		closedir(d);
+	    } else {
+		rosh_error(errno, "ls", filestr);
+		errno = 0;
+	    }
+	} else {
+	    de.d_ino = rosh_ls_d_ino(&fdstat);
+	    de.d_type = (IFTODT(fdstat.st_mode));
+	    strcpy(de.d_name, filestr);
+	    if (S_ISREG(fdstat.st_mode)) {
+		ROSH_DEBUG("PATH '%s' is a regular file\n", filestr);
+	    } else {
+		ROSH_DEBUG("PATH '%s' is some other file\n", filestr);
+	    }
+	    rosh_ls_arg_dir_de(NULL, &de, optarr);
+/*	    if (ifilstr[0] == SEP)
+		rosh_ls_arg_dir_de(NULL, &de, optarr);
+	    else
+		rosh_ls_arg_dir_de(pwdstr, &de, optarr);*/
+	}
+    } else {
+	rosh_error(errno, "ls", filestr);
+	errno = 0;
+    }
+    return;
+}				/* rosh_ls_arg */
+
+/* Parse options that may be present in the cmdstr
+ *	filestr	Possible option string to parse
+ *	optstr	Current options
+ *	returns 1 if filestr does not begin with '-' else 0
+ */
+int rosh_ls_parse_opt(const char *filestr, char *optstr)
+{
+    int ret;
+    if (filestr[0] == '-') {
+	ret = 0;
+	if (optstr)
+	    strcat(optstr, filestr + 1);
+    } else {
+	ret = 1;
+    }
+    ROSH_DEBUG("ParseOpt: '%s'\n\topt: '%s'\n\tret: %d\n", filestr, optstr,
+	       ret);
+    return ret;
+}				/* rosh_ls_parse_opt */
+
+/* List Directory
+ *	argc	Argument count
+ *	argv	Argument values
+ */
+void rosh_ls(int argc, char *argv[])
+{
+    int optarr[3];
+    int i;
+
+    rosh_ls_arg_opt(argc, argv, optarr);
+    ROSH_DEBUG2("In ls()\n");
+    ROSH_DEBUG2_ARGV_V(argc, argv);
+#ifdef DO_DEBUG
+    optarr[0] = 2;
+#endif /* DO_DEBUG */
+    ROSH_DEBUG2("  argc=%d; optind=%d\n", argc, optind);
+    if (optind >= argc)
+	rosh_ls_arg(".", optarr);
+    for (i = optind; i < argc; i++) {
+	rosh_ls_arg(argv[i], optarr);
+    }
+}				/* rosh_ls */
+
+/* Simple directory listing; calls rosh_ls()
+ *	argc	Argument count
+ *	argv	Argument values
+ */
+void rosh_dir(int argc, char *argv[])
+{
+    ROSH_DEBUG("  dir implemented as ls\n");
+    rosh_ls(argc, argv);
+}				/* rosh_dir */
+
+/* Page through a buffer string
+ *	buf	Buffer to page through
+ */
+void rosh_more_buf(char *buf, int buflen, int rows, int cols, char *scrbuf)
+{
+    char *bufp, *bufeol, *bufeol2;	/* Pointer to current and next
+					   end-of-line position in buffer */
+    int bufpos, bufcnt;		/* current position, count characters */
+    int inc;
+    int i, numln;		/* Index, Number of lines */
+    int elpl;		/* Extra lines per line read */
+
+    (void)cols;
+
+    bufpos = 0;
+    bufp = buf + bufpos;
+    bufeol = bufp;
+    numln = rows - 1;
+    ROSH_DEBUG("--(%d)\n", buflen);
+    while (bufpos < buflen) {
+	for (i = 0; i < numln; i++) {
+	    bufeol2 = strchr(bufeol, '\n');
+	    if (bufeol2 == NULL) {
+		bufeol = buf + buflen;
+		i = numln;
+	    } else {
+		elpl = ((bufeol2 - bufeol - 1) / cols);
+		if (elpl < 0)
+		    elpl = 0;
+		i += elpl;
+		ROSH_DEBUG2("  %d/%d  ", elpl, i+1);
+		/* If this will not push too much, use it */
+		/* but if it's the first line, use it */
+		/* //HERE: We should probably snip the line off */
+		if ((i < numln) || (i == elpl))
+		    bufeol = bufeol2 + 1;
+	    }
+	}
+	ROSH_DEBUG2("\n");
+	bufcnt = bufeol - bufp;
+	printf("--(%d/%d @%d)\n", bufcnt, buflen, bufpos);
+	memcpy(scrbuf, bufp, bufcnt);
+	scrbuf[bufcnt] = 0;
+	printf("%s", scrbuf);
+	bufp = bufeol;
+	bufpos += bufcnt;
+	if (bufpos == buflen)
+	    break;
+	inc = rosh_getkey();
+	numln = 1;
+	switch (inc) {
+	case KEY_CTRL('c'):
+	case 'q':
+	case 'Q':
+	    bufpos = buflen;
+	    break;
+	case ' ':
+	    numln = rows - 1;
+	}
+    }
+}				/* rosh_more_buf */
+
+/* Page through a single file using the open file stream
+ *	fd	File Descriptor
+ */
+void rosh_more_fd(int fd, int rows, int cols, char *scrbuf)
+{
+    struct stat fdstat;
+    char *buf;
+    int bufpos;
+    int numrd;
+    FILE *f;
+
+    fstat(fd, &fdstat);
+    if (S_ISREG(fdstat.st_mode)) {
+	buf = malloc((int)fdstat.st_size);
+	if (buf != NULL) {
+	    f = fdopen(fd, "r");
+	    bufpos = 0;
+	    numrd = fread(buf, 1, (int)fdstat.st_size, f);
+	    while (numrd > 0) {
+		bufpos += numrd;
+		numrd = fread(buf + bufpos, 1,
+			      ((int)fdstat.st_size - bufpos), f);
+	    }
+	    fclose(f);
+	    rosh_more_buf(buf, bufpos, rows, cols, scrbuf);
+	}
+    } else {
+    }
+
+}				/* rosh_more_fd */
+
+/* Page through a file like the more command
+ *	argc	Argument Count
+ *	argv	Argument Values
+ */
+void rosh_more(int argc, char *argv[])
+{
+    int fd, i;
+/*    char filestr[ROSH_PATH_SZ];
+    int cmdpos;*/
+    int rows, cols;
+    char *scrbuf;
+    int ret;
+
+    ROSH_DEBUG_ARGV_V(argc, argv);
+    ret = getscreensize(1, &rows, &cols);
+    if (ret) {
+	ROSH_DEBUG("getscreensize() fail(%d); fall back\n", ret);
+	ROSH_DEBUG("\tROWS='%d'\tCOLS='%d'\n", rows, cols);
+	/* If either fail, go under normal size, just in case */
+	if (!rows)
+	    rows = 20;
+	if (!cols)
+	    cols = 75;
+    }
+    ROSH_DEBUG("\tUSE ROWS='%d'\tCOLS='%d'\n", rows, cols);
+    /* 32 bit align beginning of row and over allocate */
+    scrbuf = malloc(rows * ((cols+3)&(INT_MAX - 3)));
+    if (!scrbuf)
+	return;
+
+    if (argc) {
+	/* There is no need to mess up the console if we don't have a
+	   file */
+	rosh_console_raw();
+	for (i = 0; i < argc; i++) {
+	    printf("--File = '%s'\n", argv[i]);
+	    errno = 0;
+	    fd = open(argv[i], O_RDONLY);
+	    if (fd != -1) {
+		rosh_more_fd(fd, rows, cols, scrbuf);
+		close(fd);
+	    } else {
+		rosh_error(errno, "more", argv[i]);
+		errno = 0;
+	    }
+	}
+	rosh_console_std();
+    }
+    free(scrbuf);
+}				/* rosh_more */
+
+/* Page a file with rewind
+ *	argc	Argument Count
+ *	argv	Argument Values
+ */
+void rosh_less(int argc, char *argv[])
+{
+    printf("  less implemented as more (for now)\n");
+    rosh_more(argc, argv);
+}				/* rosh_less */
+
+/* Show PWD
+ */
+void rosh_pwd(void)
+{
+    char pwdstr[ROSH_PATH_SZ];
+    errno = 0;
+    if (getcwd(pwdstr, ROSH_PATH_SZ)) {
+	printf("%s\n", pwdstr);
+    } else {
+	rosh_error(errno, "pwd", "");
+	errno = 0;
+    }
+}				/* rosh_pwd */
+
+/* Reboot; use warm reboot if one of certain options set
+ *	argc	Argument count
+ *	argv	Argument values
+ */
+void rosh_reboot(int argc, char *argv[])
+{
+    int rtype = 0;
+    if (argc) {
+	/* For now, just use the first */
+	switch (argv[0][0]) {
+	case '1':
+	case 's':
+	case 'w':
+	    rtype = 1;
+	    break;
+	case '-':
+	    switch (argv[0][1]) {
+	    case '1':
+	    case 's':
+	    case 'w':
+		rtype = 1;
+		break;
+	    }
+	    break;
+	}
+    }
+    syslinux_reboot(rtype);
+}				/* rosh_reboot */
+
+/* Run a boot string, calling syslinux_run_command
+ *	argc	Argument count
+ *	argv	Argument values
+ */
+void rosh_run(int argc, char *argv[])
+{
+    char cmdstr[ROSH_CMD_SZ];
+    int len;
+
+    len = rosh_argcat(cmdstr, ROSH_CMD_SZ, argc, argv, 0);
+    if (len) {
+	printf("--run: '%s'\n", cmdstr);
+	syslinux_run_command(cmdstr);
+    } else {
+	printf(APP_NAME ":run: No arguments\n");
+    }
+}				/* rosh_run */
+
+/* Process an argc/argv pair and call handling function
+ *	argc	Argument count
+ *	argv	Argument values
+ *	ipwdstr	Initial Present Working Directory string
+ *	returns	Whether to exit prompt
+ */
+char rosh_command(int argc, char *argv[], const char *ipwdstr)
+{
+    char do_exit = false;
+    int tlen;
+    tlen = strlen(argv[0]);
+    ROSH_DEBUG_ARGV_V(argc, argv);
+    switch (argv[0][0]) {
+    case 'e':
+    case 'E':
+    case 'q':
+    case 'Q':
+	switch (argv[0][1]) {
+	case 0:
+	case 'x':
+	case 'X':
+	case 'u':
+	case 'U':
+	    if ((strncasecmp("exit", argv[0], tlen) == 0) ||
+		(strncasecmp("quit", argv[0], tlen) == 0))
+		do_exit = true;
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'c':
+	case 'C':
+	    if (strncasecmp("echo", argv[0], tlen) == 0)
+		rosh_pr_argv(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	default:
+	    rosh_help(1, argv[0]);
+	}
+	break;
+    case 'c':
+    case 'C':			/* run 'cd' 'cat' 'cfg' */
+	switch (argv[0][1]) {
+	case 'a':
+	case 'A':
+	    if (strncasecmp("cat", argv[0], tlen) == 0)
+		rosh_cat(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'd':
+	case 'D':
+	    if (strncasecmp("cd", argv[0], tlen) == 0)
+		rosh_cd(argc, argv, ipwdstr);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'f':
+	case 'F':
+	    if (strncasecmp("cfg", argv[0], tlen) == 0)
+		rosh_cfg();
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	default:
+	    rosh_help(1, argv[0]);
+	}
+	break;
+    case 'd':
+    case 'D':			/* run 'dir' */
+	if (strncasecmp("dir", argv[0], tlen) == 0)
+	    rosh_dir(argc - 1, &argv[1]);
+	else
+	    rosh_help(1, argv[0]);
+	break;
+    case 'h':
+    case 'H':
+    case '?':
+	if ((strncasecmp("help", argv[0], tlen) == 0) || (tlen == 1))
+	    rosh_help(2, argv[1]);
+	else
+	    rosh_help(1, NULL);
+	break;
+    case 'l':
+    case 'L':			/* run 'ls' 'less' */
+	switch (argv[0][1]) {
+	case 0:
+	case 's':
+	case 'S':
+	    if (strncasecmp("ls", argv[0], tlen) == 0)
+		rosh_ls(argc, argv);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'e':
+	case 'E':
+	    if (strncasecmp("less", argv[0], tlen) == 0)
+		rosh_less(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	default:
+	    rosh_help(1, argv[0]);
+	}
+	break;
+    case 'm':
+    case 'M':
+	switch (argv[0][1]) {
+	case 'a':
+	case 'A':
+	    if (strncasecmp("man", argv[0], tlen) == 0)
+		rosh_help(2, argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'o':
+	case 'O':
+	    if (strncasecmp("more", argv[0], tlen) == 0)
+		rosh_more(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	default:
+	    rosh_help(1, argv[0]);
+	}
+	break;
+    case 'p':
+    case 'P':			/* run 'pwd' */
+	if (strncasecmp("pwd", argv[0], tlen) == 0)
+	    rosh_pwd();
+	else
+	    rosh_help(1, argv[0]);
+	break;
+    case 'r':
+    case 'R':			/* run 'run' */
+	switch (argv[0][1]) {
+	case 0:
+	case 'e':
+	case 'E':
+	    if (strncasecmp("reboot", argv[0], tlen) == 0)
+		rosh_reboot(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	case 'u':
+	case 'U':
+	    if (strncasecmp("run", argv[0], tlen) == 0)
+		rosh_run(argc - 1, &argv[1]);
+	    else
+		rosh_help(1, argv[0]);
+	    break;
+	default:
+	    rosh_help(1, argv[0]);
+	}
+	break;
+    case 'v':
+    case 'V':
+	if (strncasecmp("version", argv[0], tlen) == 0)
+	    rosh_version(1);
+	else
+	    rosh_help(1, argv[0]);
+	break;
+    case 0:
+    case '\n':
+	break;
+    default:
+	rosh_help(1, argv[0]);
+    }				/* switch(argv[0][0]) */
+    return do_exit;
+}				/* rosh_command */
+
+/* Process the prompt for commands as read from stdin and call rosh_command
+ * to process command line string
+ *	icmdstr	Initial command line string
+ *	returns	Exit status
+ */
+int rosh_prompt(int iargc, char *iargv[])
+{
+    int rv;
+    char cmdstr[ROSH_CMD_SZ];
+    char ipwdstr[ROSH_PATH_SZ];
+    char do_exit;
+    char **argv;
+    int argc;
+
+    rv = 0;
+    do_exit = false;
+    if (!getcwd(ipwdstr, ROSH_PATH_SZ))
+	strcpy(ipwdstr, "./");
+    if (iargc > 1)
+	do_exit = rosh_command(iargc - 1, &iargv[1], ipwdstr);
+    while (!(do_exit)) {
+	/* Extra preceeding newline */
+	printf("\nrosh: ");
+	/* Read a line from console */
+	if (fgets(cmdstr, ROSH_CMD_SZ, stdin)) {
+	    argc = rosh_str2argv(&argv, cmdstr);
+	    do_exit = rosh_command(argc, argv, ipwdstr);
+	    rosh_free_argv(&argv);
+	} else {
+	    do_exit = false;
+	}
+    }
+    return rv;
+}
+
+int main(int argc, char *argv[])
+{
+    int rv;
+
+    /* Initialization */
+    rv = 0;
+    rosh_console_std();
+    if (argc == 1) {
+	rosh_version(0);
+	print_beta();
+    } else {
+#ifdef DO_DEBUG
+	char cmdstr[ROSH_CMD_SZ];
+	rosh_argcat(cmdstr, ROSH_CMD_SZ, argc, argv, 1);
+	ROSH_DEBUG("arg='%s'\n", cmdstr);
+#endif
+    }
+    rv = rosh_prompt(argc, argv);
+    printf("--Exiting '" APP_NAME "'\n");
+    return rv;
+}
Index: bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.h
===================================================================
--- bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.h	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
+++ bootcd/isolinux/syslinux-6.03/com32/rosh/rosh.h	(revision e16e8f2a41938d263af54a9fd6b4020d6c0d69fa)
@@ -0,0 +1,282 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2008-2009 Gene Cumm - All Rights Reserved
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * rosh.h
+ *
+ * Read-Only shell; Header
+ */
+
+/*
+ * History
+ * b034	Improve debug functions to simpler code
+ * b021	Move much PreProcessing stuff to rosh.h
+ * b018	Create rosh_debug() macro
+ * b012	Version of rosh.c at time of creating this file.
+ */
+
+#ifndef ROSH_H
+#define ROSH_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>		/* macro: true false */
+#include <string.h>		/* strcpy() strlen() memcpy() strchr() */
+#include <sys/types.h>
+#include <limits.h>
+#include <sys/stat.h>		/* fstat() */
+#include <fcntl.h>		/* open(); open mode macros */
+#include <dirent.h>		/* fdopendir() opendir() readdir() closedir() DIR */
+#include <unistd.h>		/* getcwd() getopt() */
+#include <errno.h>		/* errno; error macros */
+#include <netinet/in.h>		/* For htonl/ntohl/htons/ntohs */
+#include <ctype.h>		/* isspace() */
+
+#include <getkey.h>
+#include <consoles.h>		/* console_ansi_raw() console_ansi_std() */
+// #include <getopt.h>		/* getopt_long() */
+
+#ifdef DO_DEBUG
+# define ROSH_DEBUG	printf
+# define ROSH_DEBUG_ARGV_V	rosh_pr_argv_v
+/* define ROSH_DEBUG(f, ...)	printf (f, ## __VA_ARGS__) */
+# ifdef DO_DEBUG2
+#  define ROSH_DEBUG2	printf
+#  define ROSH_DEBUG2_ARGV_V	rosh_pr_argv_v
+# else /* DO_DEBUG2 */
+	/* This forces a format argument into the function call */
+#  define ROSH_DEBUG2(f, ...)	((void)0)
+#  define ROSH_DEBUG2_ARGV_V(argc, argv)	((void)0)
+# endif	/* DO_DEBUG2 */
+#else /* DO_DEBUG */
+# define ROSH_DEBUG(f, ...)	((void)0)
+# define ROSH_DEBUG_ARGV_V(argc, argv)	((void)0)
+# define ROSH_DEBUG2(f, ...)	((void)0)
+# define ROSH_DEBUG2_ARGV_V(argc, argv)	((void)0)
+#endif /* DO_DEBUG */
+#define ROSH_DEBUG2_STAT(f, ...)	((void)0)
+// #define ROSH_DEBUG2_STAT	ROSH_DEBUG2
+
+#ifdef __COM32__
+#define ROSH_IS_COM32	1
+#include <console.h>		/* openconsole() */
+#include <syslinux/config.h>	/* Has info on the SYSLINUX variant */
+#include <syslinux/boot.h>	/* syslinux_run_command() */
+#include <syslinux/reboot.h>
+#define ROSH_COM32(f, ...)	printf (f, ## __VA_ARGS__)
+#define rosh_console_std()		console_ansi_std()
+#define rosh_console_raw()		console_ansi_raw()
+
+int stat(const char *pathname, struct stat *buf)
+{
+    int fd, status, ret = -1;
+    DIR *d;
+
+    ROSH_DEBUG2_STAT("stat:opendir(%s) ", pathname);
+    d = opendir(pathname);
+    if (d != NULL) {
+	ROSH_DEBUG2_STAT("stat:closedir() ");
+	closedir(d);
+	ret = 0;
+	buf->st_mode = S_IFDIR | 0555;
+	buf->st_size = 0;
+    } else if ((errno == 0) || (errno == ENOENT) || (errno == ENOTDIR)) {
+	ROSH_DEBUG2_STAT("(%d)stat:open() ", errno);
+	fd = open(pathname, O_RDONLY);
+	if (fd != -1) {
+	    ROSH_DEBUG2_STAT("(%d)stat:fstat() ", fd);
+	    status = fstat(fd, buf);
+	    (void)status;
+	    ROSH_DEBUG2_STAT("stat:close() ");
+	    close(fd);
+	    ret = 0;
+	}
+    }
+    return ret;
+}
+
+int rosh_get_env_ver(char *dest, size_t n)
+{
+    const struct syslinux_version *slv = syslinux_version();
+    strncpy(dest, slv->version_string, n);
+    return 0;
+}
+
+#else
+#  include <termios.h>
+#  include <sys/ioctl.h>
+#  include <sys/utsname.h>
+#  define ROSH_IS_COM32	0
+
+static inline char *syslinux_config_file(void)
+{
+    return "";
+}
+
+int rosh_get_env_ver(char *dest, size_t n)
+{
+    int ret, len;
+    struct utsname env;
+    ret= uname(&env);
+    if (ret >= 0) {
+	strncpy(dest, env.sysname, n);
+	len = strlen(dest);
+	strncpy(dest + len, " ", (n - len));
+	len = strlen(dest);
+	strncpy(dest + len, env.release, (n - len));
+    }
+    return ret;
+}
+
+static inline int getscreensize(int fd, int *rows, int *cols)
+{
+    char *str;
+    int rv;
+    struct winsize ws;
+    if (rows)
+	*rows = 0;
+    if (cols)
+	*cols = 0;
+    str = NULL;
+    if (fd == 1) {
+	ioctl(0, TIOCGWINSZ, &ws);
+	if (rows)
+	    *rows = ws.ws_row;
+	if (cols)
+	    *cols = ws.ws_col;
+	if (rows && !*rows) {
+	    str = getenv("LINES");
+	    if (str)
+		*rows = atoi(str);
+	}
+	if (cols && !*cols) {
+	    str = getenv("COLUMNS");
+	    if (str)
+		*cols = atoi(str);
+	}
+    }
+    if (!rows || !cols)
+	rv = -1;
+    else if (!*rows || !*cols)
+	rv = -2;
+    else
+	rv = 0;
+    return rv;
+}
+
+/*
+ * Switches console over to raw input mode.  Allows get_key to get just
+ * 1 key sequence (without delay or display)
+ */
+void rosh_console_raw(void)
+{
+    struct termios tio;
+
+    console_ansi_raw();		/* Allows get_key to get just 1 key sequence
+				   (w/o delay or display */
+    /* Deal with the changes that haven't been replicated to ansiraw.c */
+    tcgetattr(0, &tio);
+    tio.c_iflag &= ~IGNCR;
+    tcsetattr(0, TCSAFLUSH, &tio);
+}
+
+/*
+ * Switches back to standard getline mode.
+ */
+void rosh_console_std(void)
+{
+    struct termios tio;
+
+    console_ansi_std();
+    tcgetattr(0, &tio);
+    tio.c_iflag |= ICRNL;
+    tio.c_iflag &= ~IGNCR;
+    tcsetattr(0, TCSANOW, &tio);
+}
+
+void syslinux_reboot(int warm)
+{
+    printf("Test Reboot(%d)\n", warm);
+}
+
+#define ROSH_COM32(f, ...)	((void)0)
+#define syslinux_run_command(f)	((void)0)
+#endif /* __COM32__ */
+
+#define SEP	'/'
+
+/* Size of buffer string */
+#define ROSH_BUF_SZ	16384
+/* Size of screen output buffer (80*40) //HERE */
+#define ROSH_SBUF_SZ	((80 + 2) * 40)
+
+/* Size of command buffer string */
+#ifdef MAX_CMDLINE_LEN
+#  define ROSH_CMD_SZ		MAX_CMDLINE_LEN
+#elif COMMAND_LINE_SIZE
+#  define ROSH_CMD_SZ		COMMAND_LINE_SIZE
+#else
+#  define ROSH_CMD_SZ_LG2	12
+#  define ROSH_CMD_SZ		(1 << ROSH_CMD_SZ_LG2)
+#endif /* MAX_CMDLINE_LEN */
+
+/* Size of path buffer string */
+#ifdef PATH_MAX
+#  define ROSH_PATH_SZ		PATH_MAX
+#elif NAME_MAX
+#  define ROSH_PATH_SZ		NAME_MAX
+#elif FILENAME_MAX
+#  define ROSH_PATH_SZ		FILENAME_MAX
+#else
+#  define ROSH_PATH_SZ_LG2	8
+#  define ROSH_PATH_SZ		(1 << ROSH_PATH_SZ_LG2)
+#endif /* PATH_MAX */
+
+#define ROSH_OPT_SZ	8
+
+const char rosh_beta_str[] =
+    "  ROSH is currently beta.  Constructive feedback is appreciated";
+
+const char rosh_cd_norun_str[] =
+    " -- cd (Change Directory) not implemented for use with run and exit.\n";
+
+const char rosh_help_cd_str[] = "cd    Change directory\n\
+   with no argument, return to original directory from entry to rosh\n\
+   with one argument, change to that directory";
+
+const char rosh_help_ls_str[] = "ls    List contents of current directory\n\
+  -l  Long format\n\
+  -i  Inode; print Inode of file\n\
+  -F  Classify; Add a 1-character suffix to classify files";
+
+const char rosh_help_str1[] =
+    "Commands: ? cat cd cfg dir exit help less ls man more pwd run quit ver";
+
+const char rosh_help_str2[] =
+    "Commands: (short generally non-ambiguous abreviations are also allowed)\n\
+  h     HELP\n     ALSO ? help man\n     ALSO help <command>\n\
+  cat   Concatenate file to console\n    cat <file>\n\
+  cd    Change to directory <dir>\n    cd <dir>\n\
+  less  Page a file with rewind\n\
+  ls    List contents of current directory\n    ls <dir>\n\
+    ALSO l dir\n\
+  more  Page a file\n\
+  pwd   display Present Working Directory\n\
+  run   Run a program/kernel with options\n\
+  r     Reboot (if COM32)\n        Also reboot\n\
+  exit  Exit to previous environment\n    ALSO quit";
+
+const char rosh_help_str_adv[] = "No additional help available for '%s'";
+
+const char rosh_ls_opt_str[] = "lFi";
+
+#endif /* Not ROSH_H */
