Subversion Repositories SvarDOS

/* This file is part of the SvarCOM project and is published under the terms

 * of the MIT license.

 *

 * Copyright (C) 2021-2024 Mateusz Viste

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#include <dos.h>

#include <stdio.h>

#include <string.h>

#include "svarlang.lib/svarlang.h"

#include "cmd.h"

#include "env.h"

#include "helpers.h"

#include "redir.h"

#include "rmodinit.h"

#include "sayonara.h"

#include "version.h"

#include "rmodcore.h" /* rmod binary inside a BUFFER array */

/* this version byte is used to tag RMOD so I can easily make sure that

 * the RMOD struct I find in memory is one that I know. Should the version

 * mismatch, then it would likely mean that SvarCOM has been upgraded and

 * RMOD should not be accessed as its structure might no longer be in sync

 * with what I think it is.

 *          *** INCREMENT THIS AT EACH NEW SVARCOM RELEASE! ***

 *            (or at least whenever RMOD's struct is changed)            */

#define BYTE_VERSION 7

struct config {

  unsigned char flags; /* command.com flags, as defined in rmodinit.h */

  char *execcmd;

  unsigned short envsiz;

};

/* max length of the cmdline storage (bytes) - includes also max length of

 * line loaded from a BAT file (no more than 255 bytes!) */

#define CMDLINE_MAXLEN 255

/* sets guard values at a few places in memory for later detection of

 * overflows via memguard_check() */

static void memguard_set(char *cmdlinebuf) {

  BUFFER[sizeof(BUFFER) - 1] = 0xC7;

  cmdlinebuf[CMDLINE_MAXLEN] = 0xC7;

}

/* checks for valguards at specific memory locations, returns 0 on success */

static int memguard_check(unsigned short rmodseg, char *cmdlinebuf) {

  /* check RMOD signature (would be overwritten in case of stack overflow */

  static char msg[] = "!! MEMORY CORRUPTION ## DETECTED !!";

  unsigned short far *rmodsig = MK_FP(rmodseg, 0x100 + 6);

  unsigned char far *rmod = MK_FP(rmodseg, 0);

  if (*rmodsig != 0x2019) {

    msg[22] = '1';

    goto FAIL;

  }

  /* check last BUFFER byte */

  if (BUFFER[sizeof(BUFFER) - 1] != 0xC7) {

    msg[22] = '2';

    goto FAIL;

  }

  /* check last cmdlinebuf byte */

  if (cmdlinebuf[CMDLINE_MAXLEN] != 0xC7) {

    msg[22] = '3';

    goto FAIL;

  }

  /* check rmod exec buf */

  if (rmod[RMOD_OFFSET_EXECPROG + 127] != 0) {

    msg[22] = '4';

    goto FAIL;

  }

  /* check rmod exec stdin buf */

  if (rmod[RMOD_OFFSET_STDINFILE + 127] != 0) {

    msg[22] = '5';

    goto FAIL;

  }

  /* check rmod exec stdout buf */

  if (rmod[RMOD_OFFSET_STDOUTFILE + 127] != 0) {

    msg[22] = '6';

    goto FAIL;

  }

  /* else all good */

  return(0);

  /* error handling */

  FAIL:

  outputnl(msg);

  return(1);

}

/* exit do DOS with exist code */

static void EXIT(char code);

#pragma aux EXIT = \

"mov ah, 0x4c" \

"int 0x21" \

parm [al]

/* DR-DOS specific boot processing: check for F5/F8 boot key presses and reset

 * the wild pointer to DR-DOS kernel (CONFIG.SYS) environment because it is not

 * allocated memory hence will be overwritten soon.

 * details: https://github.com/SvarDOS/edrdos/issues/83

 * this function returns 0, FLAG_SKIP_AUTOEXEC or FLAG_STEPBYSTEP */

static void drdos_init(struct config *cfg) {

  unsigned short kernenvseg = 0;

  unsigned char far *e;

  unsigned short far *scancode;

  /* If I am init then query kernel's private data via INT 21,4458 (DR-DOS).

   * On success (CF not set) ES:BX contains a pointer to the private data.

   * Segment of kernel's environment is at offset 12h. This environment may

   * be terminated by a 1Ah code followed by a boot key scan code to record

   * an F5 or F8 key press during boot time. */

  _asm {

    push ax

    push bx

    push es

    mov ax, 0x4458       /* DR-DOS 5+ get ptr to internal variable table */

    int 0x21             /* ES:BX contains the ptr to the var table */

    jc FAIL              /* not DR-DOS */

    add bx, 0x12

    mov ax, es:[bx]      /* read the segment of the kernel environment */

    mov kernenvseg, ax   /* save the kern env segment for later */

    mov word ptr [es:bx], 0  /* reset the pointer to kernel env as done by DR COMMAND.COM */

    /* if DR-DOS env is at seg 0x60 then overwrite my own env in PSP with this.

     * Seg 0x60 is used since https://github.com/SvarDOS/edrdos/issues/88 and

     * it is safe to be used as it won't be overwritten */

    cmp ax, 0x60

    jne FAIL

    mov bx, 0x2C         /* environment segment field in my PSP */

    mov [bx], ax

    FAIL:

    pop es

    pop bx

    pop ax

  }

  if (kernenvseg == 0) return; /* either not DR-DOS, or kern env was read already or something failed */

  /* now I know that 1) I am running under (E)DR-DOS and 2) I am init, so /P implied */

  cfg->flags |= FLAG_PERMANENT;

  /* DR-DOS kernel environment present: make sure to ask SvarCOM to alloc its

   * own environment, because the kernel's environment might vanish eventually */

  if (cfg->envsiz < 256) cfg->envsiz = 256;

  e = MK_FP(kernenvseg, 0);

/*

  printf("kernel env seg is at %04X and starts with bytes 0x%02X 0x%02X 0x%02X 0x%02X\r\n", kernenvseg, e[0], e[1], e[2], e[3]);

  {

    int i;

    printf("=== KERNEL ENV BEGINS ===\r\n");

    for (i = 0; i < 100; i++) {

      printf("%c", e[i]);

    }

    printf("\r\n=== KERNEL ENV ENDS, DUMP FOLLOWS ===\r\n");

    for (i = 0; i < 260; i++) {

      if ((i > 0) && ((i % 26) == 0)) printf("\r\n");

      printf("%02X ", e[i]);

    }

    printf("\r\n=== DUMP ENDS ===\r\n");

  }

*/

  /* move forward until the DRDOS' environment 1Ah terminator is found */

  while (*e != 0x1A) e++;

  e++;

  /* next I have the boot key press scancode: either 0x0000, 0x3F00 or 0x4200

   * 0x3F00 means "F5 was pressed" while 0x4200 is for F8 */

  scancode = (void far *)e;

  if (*scancode == 0x3F00) {

    cfg->flags |= FLAG_SKIP_AUTOEXEC;

  } else if (*scancode == 0x4200) {

    cfg->flags |= FLAG_STEPBYSTEP;

  }

}

/* parses command line the hard way (directly from PSP) */

static void parse_argv(struct config *cfg) {

  unsigned char *cmdlinelen = (void *)0x80;

  char *cmdline = (void *)0x81;

  /* The arg tail at [81h] needs some care when being processed.

   *

   * Its length should be provided in [80h], but it is not always exact:

   * https://github.com/SvarDOS/bugz/issues/67

   *

   * The tail string itself is usually terminated by a CR character. But

   * sometimes it might be terminated by a nul. Or by nothing at all.

   *

   * The cautious approach is therefore to read the tail up until the length

   * mentionned at [80h] or to first CR or nul, whichever comes first.

   */

  bzero(cfg, sizeof(*cfg));

  /* Make sure that the advertised cmdline length is no more than 126 bytes

   * because the PSP ends at [0xff] and there ought to be at least 1 byte of

   * room for the CR-terminator.

   * According to Matthias Paul cmdlines longer than 126 (and even longer than

   * 127) might happen with some buggy implementations. */

  if (*cmdlinelen > 126) *cmdlinelen = 126;

  /* trim out any trailing CR garbage (see the issue 67 mentioned above) */

  while ((*cmdlinelen > 0) && (cmdline[*cmdlinelen - 1] == '\r')) (*cmdlinelen)--;

  /* normalize the cmd so it is nul-terminated - this is expected later in a

   * few places in the codeflow, among others in run_as_external() */

  cmdline[*cmdlinelen] = 0;

  /* process the parameters given to COMMAND.COM */

  while (*cmdline != 0) {

    /* skip over any leading spaces */

    if (*cmdline == ' ') {

      cmdline++;

      continue;

    }

    if (*cmdline != '/') {

      nls_output(0,6); /* "Invalid parameter" */

      output(": ");

      outputnl(cmdline);

      goto SKIP_TO_NEXT_ARG;

    }

    /* got a slash */

    cmdline++;  /* skip the slash */

    switch (*cmdline) {

      case 'c': /* /C = execute command and quit */

      case 'C':

        cfg->flags |= FLAG_EXEC_AND_QUIT;

        /* FALLTHRU */

      case 'k': /* /K = execute command and keep running */

      case 'K':

        cmdline++;

        cfg->execcmd = cmdline;

        return; /* further arguments are for the executed program, not for me */

      case 'y': /* /Y = execute batch file step-by-step (with /P, /K or /C) */

      case 'Y':

        cfg->flags |= FLAG_STEPBYSTEP;

        break;

      case 'd': /* /D = skip autoexec.bat processing */

      case 'D':

        cfg->flags |= FLAG_SKIP_AUTOEXEC;

        break;

      case 'e': /* preset the initial size of the environment block */

      case 'E':

        cmdline++;

        if (*cmdline == ':') cmdline++; /* could be /E:size */

        atous(&(cfg->envsiz), cmdline);

        if (cfg->envsiz < 64) cfg->envsiz = 0;

        break;

      case 'p': /* permanent shell (can't exit + run autoexec.bat) */

      case 'P':

        cfg->flags |= FLAG_PERMANENT;

        break;

      case '?':

        nls_outputnl(1,0); /* "Starts the SvarCOM command interpreter" */

        outputnl("");

        nls_outputnl(1,1); /* "COMMAND /E:nnn [/[C|K] [/P] [/D] command]" */

        outputnl("");

        nls_outputnl(1,2); /* "/D      Skip AUTOEXEC.BAT processing (makes sense only with /P)" */

        nls_outputnl(1,3); /* "/E:nnn  Sets the environment size to nnn bytes" */

        nls_outputnl(1,4); /* "/P      Makes the new command interpreter permanent and run AUTOEXEC.BAT" */

        nls_outputnl(1,5); /* "/C      Executes the specified command and returns" */

        nls_outputnl(1,6); /* "/K      Executes the specified command and continues running" */

        nls_outputnl(1,7); /* "/Y      Executes the batch program step by step" */

        EXIT(1);

        break;

      default:

        nls_output(0,2); /* invalid switch */

        output(": /");

        outputnl(cmdline);

        break;

    }

    /* move to next argument or quit processing if end of cmdline */

    SKIP_TO_NEXT_ARG:

    while ((*cmdline != 0) && (*cmdline != ' ') && (*cmdline != '/')) cmdline++;

  }

}

/* returns current DOS drive (0 = A: ; 1 = B: etc) */

static unsigned char _dosgetcurdrive(void);

#pragma aux _dosgetcurdrive = \

"mov ah, 0x19"    /* DOS 1+ - GET CURRENT DRIVE */ \

"int 0x21" \

modify [ah] \

value [al]

static void _dosgetcurdir(char near *s);

#pragma aux _dosgetcurdir = \

"mov ah, 0x47"    /* DOS 2+ - CWD - GET CURRENT DIRECTORY */ \

"xor dl, dl"      /* DL = drive number (00h = default, 01h = A:, etc) */ \

"mov [si], 0"     /* set empty dir in case of failure (unformatted floppy) */ \

"int 0x21" \

parm [si] \

modify [ax dl]

/* builds the prompt string and displays it. buff is filled with a zero-terminated copy of the prompt. */

static void build_and_display_prompt(char *buff, unsigned short envseg) {

  char *s = buff;

  /* locate the prompt variable or use the default pattern */

  const char far *fmt = env_lookup_val(envseg, "PROMPT");

  if ((fmt == NULL) || (*fmt == 0)) fmt = "$p$g"; /* fallback to default if empty */

  /* build the prompt string based on pattern */

  for (; *fmt != 0; fmt++) {

    if (*fmt != '$') {

      *s = *fmt;

      s++;

      continue;

    }

    /* escape code ($P, etc) */

    fmt++;

    switch (*fmt) {

      case 'Q':  /* $Q = = (equal sign) */

      case 'q':

        *s = '=';

        s++;

        break;

      case '$':  /* $$ = $ (dollar sign) */

        *s = '$';

        s++;

        break;

      case 'T':  /* $t = current time */

      case 't':

      {

        struct nls_patterns nls;

        unsigned char h, m, sec;

        if (nls_getpatterns(&nls) != 0) {

          s += sprintf(s, "ERR");

        } else {

          dos_get_time(&h, &m, &sec);

          s += nls_format_time(s, h, m, sec, &nls);

        }

        break;

      }

      case 'D':  /* $D = current date */

      case 'd':

      {

        struct nls_patterns nls;

        unsigned short y;

        unsigned char m, d;

        if (nls_getpatterns(&nls) != 0) {

          s += sprintf(s, "ERR");

        } else {

          dos_get_date(&y, &m, &d);

          s += nls_format_date(s, y, m, d, &nls);

        }

        break;

      }

      case 'P':  /* $P = current drive and path */

      case 'p':

        *s = _dosgetcurdrive() + 'A';

        s++;

        *s = ':';

        s++;

        *s = '\\';

        s++;

        _dosgetcurdir(s);

        /* move s ptr forward to end (0-termintor) of pathname */

        while (*s != 0) s++;

        break;

      case 'V':  /* $V = version number */

      case 'v':

        s += sprintf(s, PVER);

        break;

      case 'N':  /* $N = current drive */

      case 'n':

        *s = _dosgetcurdrive() + 'A';

        s++;

        break;

      case 'G':  /* $G = > (greater-than sign) */

      case 'g':

        *s = '>';

        s++;

        break;

      case 'L':  /* $L = < (less-than sign) */

      case 'l':

        *s = '<';

        s++;

        break;

      case 'B':  /* $B = | (pipe) */

      case 'b':

        *s = '|';

        s++;

        break;

      case 'H':  /* $H = backspace (erases previous character) */

      case 'h':

        *s = '\b';

        s++;

        break;

      case 'E':  /* $E = Escape code (ASCII 27) */

      case 'e':

        *s = 27;

        s++;

        break;

      case '_':  /* $_ = CR+LF */

        *s = '\r';

        s++;

        *s = '\n';

        s++;

        break;

    }

  }

  *s = 0;

  output(buff);

}

static void dos_fname2fcb(char far *fcb, const char near *cmd);

#pragma aux dos_fname2fcb = \

"mov ax, 0x2900"   /* DOS 1+ - parse filename into FCB (DS:SI=fname, ES:DI=FCB) */ \

"int 0x21" \

parm [es di] [si] \

modify [ax si]

/* parses cmdtail and fills fcb1 and fcb2 with first and second arguments,

 * respectively. an FCB is 12 bytes long:

 * drive (0=default, 1=A, 2=B, etc)

 * fname (8 chars, blank-padded)

 * fext (3 chars, blank-padded) */

static void cmdtail_to_fcb(char far *fcb1, char far *fcb2, const char *cmdtail) {

  /* skip any leading spaces */

  while (*cmdtail == ' ') cmdtail++;

  /* convert first arg */

  dos_fname2fcb(fcb1, cmdtail);

  /* skip to next arg */

  while ((*cmdtail != ' ') && (*cmdtail != 0)) cmdtail++;

  while (*cmdtail == ' ') cmdtail++;

  /* convert second arg */

  dos_fname2fcb(fcb2, cmdtail);

}

/* a few internal flags */

#define DELETE_STDIN_FILE 1

#define CALL_FLAG         2

#define LOADHIGH_FLAG     4

static void run_as_external(char *buff, const char *cmdline, unsigned short envseg, struct rmod_props far *rmod, struct redir_data *redir, unsigned char flags) {

  char *cmdfile = buff + 512;

  const char far *pathptr;

  int lookup;

  unsigned short i;

  const char *ext;

  char *cmd = buff + 1024;

  const char *cmdtail;

  char far *rmod_execprog = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPROG);

  char far *rmod_cmdtail = MK_FP(rmod->rmodseg, 0x81);

  _Packed struct {

    unsigned short envseg;

    unsigned long cmdtail;

    unsigned long fcb1;

    unsigned long fcb2;

  } far *ExecParam = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXECPARAM);

  /* find cmd and cmdtail */

  i = 0;

  cmdtail = cmdline;

  while (*cmdtail == ' ') cmdtail++; /* skip any leading spaces */

  while ((*cmdtail != ' ') && (*cmdtail != '/') && (*cmdtail != '+') && (*cmdtail != 0)) {

    cmd[i++] = *cmdtail;

    cmdtail++;

  }

  cmd[i] = 0;

  /* is this a command in curdir? */

  lookup = lookup_cmd(cmdfile, cmd, NULL, &ext);

  if (lookup == 0) {

    /* printf("FOUND LOCAL EXEC FILE: '%s'\r\n", cmdfile); */

    goto RUNCMDFILE;

  } else if (lookup == -2) {

    /* puts("NOT FOUND"); */

    return;

  }

  /* try matching something in PATH */

  pathptr = env_lookup_val(envseg, "PATH");

  /* try each path in %PATH% */

  while (pathptr) {

    for (i = 0;; i++) {

      buff[i] = *pathptr;

      if ((buff[i] == 0) || (buff[i] == ';')) break;

      pathptr++;

    }

    buff[i] = 0;

    lookup = lookup_cmd(cmdfile, cmd, buff, &ext);

    if (lookup == 0) goto RUNCMDFILE;

    if (lookup == -2) return;

    if (*pathptr == ';') {

      pathptr++;

    } else {

      break;

    }

  }

  /* last chance: is it an executable link? (trim extension from cmd first) */

  for (i = 0; (cmd[i] != 0) && (cmd[i] != '.') && (i < 9); i++) buff[128 + i] = cmd[i];

  buff[128 + i] = 0;

  if ((i < 9) && (link_computefname(buff, buff + 128, envseg) == 0)) {

    /* try opening the link file (if it exists) and read it into buff */

    i = 0;

    _asm {

      push ax

      push bx

      push cx

      push dx

      mov ax, 0x3d00  /* DOS 2+ - OPEN EXISTING FILE, READ-ONLY */

      mov dx, buff    /* file name */

      int 0x21

      jc ERR_FOPEN

      /* file handle in AX, read from file now */

      mov bx, ax      /* file handle */

      mov ah, 0x3f    /* Read from file via handle bx */

      mov cx, 128     /* up to 128 bytes */

      /* mov dx, buff */ /* dest buffer (already set) */

      int 0x21        /* read up to 256 bytes from file and write to buff */

      jc ERR_READ

      mov i, ax

      ERR_READ:

      mov ah, 0x3e    /* close file handle in BX */

      int 0x21

      ERR_FOPEN:

      pop dx

      pop cx

      pop bx

      pop ax

    }

    /* did I read anything? */

    if (i != 0) {

      buff[i] = 0;

      /* trim buff at first \n or \r, just in case someone fiddled with the

       * link file using a text editor */

      for (i = 0; (buff[i] != 0) && (buff[i] != '\r') && (buff[i] != '\n'); i++);

      buff[i] = 0;

      /* lookup check */

      if (buff[0] != 0) {

        lookup = lookup_cmd(cmdfile, cmd, buff, &ext);

        if (lookup == 0) goto RUNCMDFILE;

      }

    }

  }

  /* all failed (ie. executable file not found) */

  return;

  RUNCMDFILE:

  /* special handling of batch files */

  if ((ext != NULL) && (imatch(ext, "bat"))) {

    struct batctx far *newbat;

    /* remember the echo flag (in case bat file disables echo, only when starting first bat) */

    if (rmod->bat == NULL) {

      rmod->flags &= ~FLAG_ECHO_BEFORE_BAT;

      if (rmod->flags & FLAG_ECHOFLAG) rmod->flags |= FLAG_ECHO_BEFORE_BAT;

    }

    /* if bat is not called via a CALL, then free the bat-context linked list */

    if ((flags & CALL_FLAG) == 0) rmod_free_bat_llist(rmod);

    /* allocate a new bat context */

    newbat = rmod_fcalloc(sizeof(struct batctx), rmod->rmodseg, "SVBATCTX");

    if (newbat == NULL) {

      nls_outputnl_doserr(8); /* insufficient memory */

      return;

    }

    /* fill the newly allocated batctx structure */

    _fstrcpy(newbat->fname, cmdfile); /* truename of the BAT file */

    newbat->flags = flags & FLAG_STEPBYSTEP;

    /* explode args of the bat file and store them in rmod buff */

    cmd_explode(buff, cmdline, NULL);

    _fmemcpy(newbat->argv, buff, sizeof(newbat->argv));

    /* push the new bat to the top of rmod's linked list */

    newbat->parent = rmod->bat;

    rmod->bat = newbat;

    return;

  }

  /* copy full filename to execute, along with redirected files (if any) */

  _fstrcpy(rmod_execprog, cmdfile);

  /* copy stdin file if a redirection is needed */

  if (redir->stdinfile) {

    char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDINFILE);

    char far *delstdin = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDIN_DEL);

    _fstrcpy(farptr, redir->stdinfile);

    if (flags & DELETE_STDIN_FILE) {

      *delstdin = redir->stdinfile[0];

    } else {

      *delstdin = 0;

    }

  }

  /* same for stdout file */

  if (redir->stdoutfile) {

    char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDOUTFILE);

    unsigned short far *farptr16 = MK_FP(rmod->rmodseg, RMOD_OFFSET_STDOUTAPP);

    _fstrcpy(farptr, redir->stdoutfile);

    /* openflag */

    *farptr16 = redir->stdout_openflag;

  }

  /* copy cmdtail to rmod's PSP and compute its len */

  for (i = 0; cmdtail[i] != 0; i++) rmod_cmdtail[i] = cmdtail[i];

  rmod_cmdtail[i] = '\r';

  rmod_cmdtail[-1] = i;

  /* set up rmod to execute the command */

  /* loadhigh? */

  if (flags & LOADHIGH_FLAG) {

    unsigned char far *farptr = MK_FP(rmod->rmodseg, RMOD_OFFSET_EXEC_LH);

    *farptr = 1;

  }

  ExecParam->envseg = envseg;

  ExecParam->cmdtail = (unsigned long)MK_FP(rmod->rmodseg, 0x80); /* farptr, must be in PSP format (lenbyte args \r) */

  /* far pointers to unopened FCB entries (stored in RMOD's own PSP) */

  {

    char far *farptr;

    /* prep the unopened FCBs */

    farptr = MK_FP(rmod->rmodseg, 0x5C);

    _fmemset(farptr, 0, 36); /* first FCB is 16 bytes long, second is 20 bytes long */

    cmdtail_to_fcb(farptr, farptr + 16, cmdtail);

    /* set (far) pointers in the ExecParam block */

    ExecParam->fcb1 = (unsigned long)MK_FP(rmod->rmodseg, 0x5C);

    ExecParam->fcb2 = (unsigned long)MK_FP(rmod->rmodseg, 0x6C);

  }

  EXIT(0); /* let rmod do the job now */

}

static void set_comspec_to_self(unsigned short envseg) {

  unsigned short *psp_envseg = (void *)(0x2c); /* pointer to my env segment field in the PSP */

  char far *myenv = MK_FP(*psp_envseg, 0);

  unsigned short varcount;

  char buff[256] = "COMSPEC=";

  char *buffptr = buff + 8;

  /* who am i? look into my own environment, at the end of it should be my EXEPATH string */

  while (*myenv != 0) {

    /* consume a NULL-terminated string */

    while (*myenv != 0) myenv++;

    /* move to next string */

    myenv++;

  }

  /* get next word, if 1 then EXEPATH follows */

  myenv++;

  varcount = *myenv;

  myenv++;

  varcount |= (*myenv << 8);

  myenv++;

  if (varcount != 1) return; /* NO EXEPATH FOUND */

  while (*myenv != 0) {

    *buffptr = *myenv;

    buffptr++;

    myenv++;

  }

  *buffptr = 0;

  /* printf("EXEPATH: '%s'\r\n", buff); */

  env_setvar(envseg, buff);

}

/* wait for user input */

static void cmdline_getinput(unsigned short inpseg, unsigned short inpoff);

#pragma aux cmdline_getinput = \

"push ds" \

/* set up buffered input to inpseg:inpoff */ \

"push ax" \

"pop ds" \

\

/* is DOSKEY support present? (INT 2Fh, AX=4800h, returns non-zero in AL if present) */ \

"mov ax, 0x4800" \

"int 0x2f" \

\

/* execute either DOS input or DOSKEY */ \

"test al, al" /* al=0 if no DOSKEY present */ \

"jnz DOSKEY" \

\

/* buffered string input */ \

"mov ah, 0x0a" \

"int 0x21" \

"jmp short DONE" \

\

"DOSKEY:" \

"mov ax, 0x4810" \

"int 0x2f" \

\

"DONE:" \

/* terminate command with a CR/LF */ \

"mov ah, 0x02" /* display character in dl */ \

"mov dl, 0x0d" \

"int 0x21" \

"mov dl, 0x0a" \

"int 0x21" \

"pop ds" \

parm [ax] [dx] \

modify [ax dl]

/* fetches a line from batch file and write it to buff (NULL-terminated),

 * increments rmod counter and returns 0 on success. */

static int getbatcmd(char *buff, unsigned char buffmaxlen, struct rmod_props far *rmod) {

  unsigned short i;

  unsigned short batname_seg = FP_SEG(rmod->bat->fname);

  unsigned short batname_off = FP_OFF(rmod->bat->fname);

  unsigned short filepos_cx = rmod->bat->nextline >> 16;

  unsigned short filepos_dx = rmod->bat->nextline & 0xffff;

  unsigned char blen = 0;

  unsigned short errv = 0;

  /* open file, jump to offset filpos, and read data into buff.

   * result in blen (unchanged if EOF or failure). */

  _asm {

    push ax

    push bx

    push cx

    push dx

    /* open file (read-only) */

    mov bx, 0xffff        /* preset BX to 0xffff to detect error conditions */

    mov dx, batname_off

    mov ax, batname_seg

    push ds     /* save DS */