xref: /csrg-svn/usr.bin/tn3270/distribution/sys_dos/spintc.c (revision 31152)

#define	LINT_ARGS

#include <stdio.h>
#include <dos.h>
#include <stdlib.h>

#include "../ntn3270/general.h"
#include "spint.h"

#define	PSP_ENVIRONMENT		0x2c
#define	PSP_FCB1		0x5c
#define	PSP_FCB2		0x6c

typedef struct {
    int
	environment,		/* Segment address of environment */
	cmd_ptr_offset,		/* Offset of command to execute */
	cmd_ptr_segment,	/* Segment where command lives */
	fcb1_ptr_offset,	/* Offset of FCB 1 */
	fcb1_ptr_segment,	/* Segment of FCB 1 */
	fcb2_ptr_offset,	/* Offset of FCB 2 */
	fcb2_ptr_segment;	/* Segment of FCB 2 */
} ExecList;

void
do_spawn(command, spawn)
char *command;
Spawn *spawn;
{
    ExecList mylist;
    char *comspec;
    void int_spawn();
    int int_offset, int_segment;

    /*
     * Get comspec.
     */
    comspec = getenv("COMSPEC");
    if (comspec == 0) {			/* Can't find where command.com is */
	fprintf(stderr, "Unable to find COMSPEC in the environment.");
	spawn->done = 1;
	spawn->rc = 99;	/* XXX */
	return;
    }

    /*
     * Now, hook up our interrupt routine.
     */

    spawn->regs.h.ah = 0x35;
    spawn->regs.h.al = spawn->int_no;
    intdosx(&spawn->regs, &spawn->regs, &spawn->sregs);

    /* Save old routine */
    int_offset = spawn->regs.x.bx;
    int_segment = spawn->sregs.es;

    spawn->regs.h.ah = 0x25;
    spawn->regs.h.al = spawn->int_no;
    spawn->regs.x.dx = (int) int_spawn;
    segread(&spawn->sregs);
    spawn->sregs.ds = spawn->sregs.cs;
    intdosx(&spawn->regs, &spawn->regs, &spawn->sregs);

    /*
     * Read in segment registers.
     */

    segread(&spawn->sregs);

    /*
     * Set up registers for the EXEC call.
     */

    spawn->regs.h.ah = 0x4b;
    spawn->regs.h.al = 0;
    spawn->regs.x.dx = (int) comspec;
    spawn->sregs.es = spawn->sregs.ds;		/* Superfluous, probably */
    spawn->regs.x.bx = (int) &mylist;

    /*
     * Set up EXEC parameter list.
     */

    ClearElement(mylist);
    mylist.cmd_ptr_offset = (int) command;
    mylist.cmd_ptr_segment = spawn->sregs.ds;
    mylist.fcb1_ptr_offset = PSP_FCB1;
    mylist.fcb1_ptr_segment = _psp;
    mylist.fcb2_ptr_offset = PSP_FCB2;
    mylist.fcb2_ptr_segment = _psp;
    mylist.environment = *((int far *)(((long)_psp<<16)|PSP_ENVIRONMENT));

    /*
     * Call to assembly language routine to actually set up for
     * the spawn.
     */

    start_spawn(spawn);
    spawn->done = 1;			/* XXX */

    if (spawn->done == 0) {
	return;				/* Not done yet */
    }

    if (spawn->regs.x.cflag) {
	fprintf(stderr, "0x%x return code from EXEC.\n", spawn->regs.x.ax);
	spawn->done = 1;
	spawn->rc = 99;
	return;
    }

    spawn->regs.h.ah = 0x4d;			/* Get return code */

    intdos(&spawn->regs, &spawn->regs);

    spawn->rc = spawn->regs.x.ax;

    /*
     * Restore old interrupt handler.
     */

    spawn->regs.h.ah = 0x25;
    spawn->regs.h.al = spawn->int_no;
    spawn->regs.x.dx = int_offset;
    spawn->sregs.ds = int_segment;
    intdosx(&spawn->regs, &spawn->regs, &spawn->sregs);
}

/* XXX */

#define	INTERRUPT_NUMBER	73

main(argc, argv, envp)
int	argc;				/* Number of passed arguments */
char	*argv[];			/* Arguments passed */
char	*envp[];			/* Inherited environment */
{
    Spawn spawned;
    static char command[256];

    ClearElement(spawned);
    spawned.int_no = INTERRUPT_NUMBER;
    if (argc == 1) {
	command[0] = 0;
    } else {
	char *cmdptr;
	int length;

	argc--;
	argv++;
	strcpy(command, " /c");
	cmdptr = command+strlen(command);
	while (argc) {
	    if ((cmdptr+strlen(*argv)) >= (command+sizeof command)) {
		fprintf(stderr, "Argument list too long at argument *%s*.\n",
			    *argv);
		return 0;
	    }
	    *cmdptr++ = ' ';		/* Blank separators */
	    strcpy(cmdptr, *argv);
	    cmdptr += strlen(cmdptr);
	    argc--;
	    argv++;
	}
	length = strlen(command)-1;
	if (length < 0) {
	    length = 0;
	}
	command[0] = length;
    }

    /*
     * do_spawn() returns when either the command has finished, or when
     * the required interrupt comes in.  In the latter case, the appropriate
     * thing to do is to process the interrupt, and then return to
     * the interrupt issuer by calling continue_spawn().
     */
    do_spawn(command, &spawned);
    while (spawned.done == 0) {
	/* Process request */
	spawned.regs.h.al = 0;
	spawned.regs.x.cflag = 0;		/* No errors (yet) */
	switch (spawned.regs.h.ah) {
	case 1:			/* Add */
	    spawned.regs.x.bx += spawned.regs.x.cx;
	    break;
	case 2:			/* Subtract */
	    spawned.regs.x.bx -= spawned.regs.x.cx;
	    break;
	case 3:			/* Multiply */
	    spawned.regs.x.bx *= spawned.regs.x.cx;
	    break;
	case 4:			/* Divide */
	    spawned.regs.x.bx /= spawned.regs.x.cx;
	    break;
	default:
	    spawned.regs.h.al = -1;	/* Error */
	    spawned.regs.x.cflag = 1;
	    break;
	}
	spawned.regs.h.ah = 0;			/* We saw this */
	continue_spawn(&spawned);
    }
    if (spawned.rc != 0) {
	fprintf(stderr, "Process generated a return code of 0x%x.\n",
								spawned.rc);
    }
}