freebsd-skq/usr.bin/doscmd/intff.c

/*
 * Copyright (c) 1992, 1993, 1996
 *	Berkeley Software Design, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Berkeley Software
 *	Design, Inc.
 *
 * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	BSDI intff.c,v 2.2 1996/04/08 19:32:56 bostic Exp
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <ctype.h>
#include <unistd.h>

#include "doscmd.h"
#include "cwd.h"
#include "dispatch.h"

static LOL	*lol = 0;		/* DOS list-of-lists */
static SDA	*sda = 0;		/* DOS swappable data area */

/******************************************************************************
** redirector functions
**
**
** These are set up on entry to the redirector each time, and are referenced
** by the functions here.
*/
static int	r_drive,n_drive = 0;
static CDS	*r_cds;
static SFT	*r_sft;


/*
** 2f:11:0
**
** Installation check
*/
static int
int2f11_00(regcontext_t *REGS)
{
    R_AL = 0xff;
    R_AH = 'U';		/* and why not? 8) */
    return(0);
}

/*
** 2f:11:1 2f:11:2 2f:11:3 2f:11:4 2f:11:5 2f:11:11 2f:11:13
**
** Directory functions
*/
static int
int2f11_dirfn(regcontext_t *REGS)
{
    char	fname[PATH_MAX], tname[PATH_MAX];
    int		error;

    error = translate_filename(sda->filename1, fname, &r_drive);
    if (error)
	return(error);
    
    if (dos_readonly(r_drive) && (R_AL != 0x05))
	return(WRITE_PROT_DISK);

    switch(R_AL) {
    case 0x01:				/* rmdir */
    case 0x02:
	debug(D_REDIR,"rmdir(%s)\n",fname);
	error = rmdir(fname);
	break;
    case 0x03:				/* mkdir */
    case 0x04:
	debug(D_REDIR,"mkdir(%s)\n",fname);
	error = mkdir(fname,0777);
	break;
    case 0x05:				/* chdir */
	debug(D_REDIR,"chdir(%s)\n",fname);
	/* Note returns DOS error directly */
	return(dos_setcwd(sda->filename1));
	
    case 0x11:				/* rename */
	error = translate_filename(sda->filename2, tname, &r_drive);
	if (!error) {
	    debug(D_REDIR,"rename(%s,%s)\n",fname,tname);
	    error = rename(fname, tname);
	}
	break;

    case 0x13:				/* unlink */
	debug(D_REDIR,"unlink(%s)\n",fname);
	error = unlink(fname);
	break;
	
    default:
	fatal("called int2f11_dirfn on unknown function %x\n",R_AL);
    }
    
    if (error < 0) {
	switch(errno) {
	case ENOTDIR:
	case ENOENT:
	    return(PATH_NOT_FOUND);
	case EXDEV:
	    return(NOT_SAME_DEV);
	default:
	    return(ACCESS_DENIED);
	}
    }
    return(0);
}

/*
** 2f:11:6
**
** Close
*/
static int
int2f11_close(regcontext_t *REGS __unused)
{
    int		fd;

    fd = r_sft->fd;
    debug(D_REDIR, "close(%d)\n", fd);
    
    r_sft->nfiles--;
    if (r_sft->nfiles) {
	debug(D_REDIR, "not last close\n");
	return(0);
    }
    if (close(fd) < 0)
	return(HANDLE_INVALID);
    return(0);
}

/*
** 2f:11:8 2f:11:9
**
** read/write
*/
static int
int2f11_rdwr(regcontext_t *REGS __unused)
{
    int		fd;
    char	*addr;
    int		nbytes;
    int		n;

    fd = r_sft->fd;
    if (lseek(fd, r_sft->offset, SEEK_SET) < 0)
	return(SEEK_ERROR);

    addr = (char *)MAKEPTR(sda->dta_seg, sda->dta_off);
    nbytes = R_CX;
    
    switch(R_AL) {
    case 0x08:				/* read */
	debug(D_REDIR, "read(%d, %d)\n", fd, nbytes);
	n = read(fd, addr, nbytes);
	if (n < 0)
	    return(READ_FAULT);
	break;
    case 0x09:
	debug(D_REDIR, "write(%d, %d)\n", fd, nbytes);
	n = write(fd, addr, nbytes);
	if (n < 0)
	    return(WRITE_FAULT);
	break;
    default:
	fatal("called int2f11_rdwr on unknown function %x\n",R_AL);
    }
    
    R_CX = n;				/* report count */
    r_sft->offset += n;
    if (r_sft->offset > r_sft->size)
	r_sft->size = r_sft->offset;
    debug(D_REDIR, "offset now %ld\n", r_sft->offset);
    return(0);
}

/*
** 2f:11:c
**
** Get free space (like 21:36)
*/
static int
int2f11_free(regcontext_t *REGS __unused)
{
    fsstat_t	fs;
    int		error;
    
    error = get_space(r_drive, &fs);
    if (error)
	return (error);
    R_AX = fs.sectors_cluster;
    R_BX = fs.total_clusters;
    R_CX = fs.bytes_sector;
    R_DX = fs.avail_clusters;
    return(0);
}

/*
** 2f:11:f
**
** get size and mode
*/
static int
int2f11_stat(regcontext_t *REGS __unused)
{
    char	fname[PATH_MAX];
    struct stat	sb;
    int		error;
    
    error = translate_filename(sda->filename1, fname, &r_drive);
    if (error)
	return(error);
    
    if (stat(fname, &sb) < 0)
	return(FILE_NOT_FOUND);
    
    R_AX = to_dos_attr(sb.st_mode);
    R_BX = sb.st_size >> 16;
    R_DI = sb.st_size & 0xffff;
    return(0);
}

/*
** 2f:11:16 2f:11:17 2f:11:18 2f:11:2e
**
** Open/create a file, closely resembles int21_open.
*/
static int
int2f11_open(regcontext_t *REGS)
{
    char	fname[PATH_MAX];
    struct stat sb;
    int		error;
    int		mode;			/* open mode */
    int		attr;			/* attributes of created file */
    int		action;			/* what to do about file */
    u_char	*p, *e;
    int		i;
    int		omode;			/* mode to say we opened in */
    int		status;
    int		fd;
    
    error = translate_filename(sda->filename1, fname, &r_drive);
    if (error)
	return(error);

    /* 
    ** get attributes/access mode off stack : low byte is attribute, high
    ** byte is (sometimes) used in conjunction with 'action'
    */
    attr = *(u_short *)MAKEPTR(R_SS, R_SP) & 0xff;

    /* which style? */
    switch(R_AL) {
    case 0x16:				/* open */
	action = 0x01;			/* fail if does not exist */
	switch (sda->open_mode & 3) {
	case 0:
	    mode = O_RDONLY;
	    break;
	case 1:
	    mode = O_WRONLY;
	    break;
	case 2:
	    mode = O_RDWR;
	    break;
	default:
	    return (FUNC_NUM_IVALID);
	}
	omode = sda->open_mode & 0x7f;
	debug(D_REDIR,"open");
	break;

    case 0x17:				/* creat/creat new */
    case 0x18:				/* creat/creat new (no CDS, but we don't care)*/
	mode = O_RDWR;
	omode = 3;
	if (attr & 0x100) {		/* creat new */
	    action = 0x10;		/* create if not exist, fail if exists */
	    debug(D_REDIR, "creat_new");
	} else {			/* creat */
	    action = 0x12;		/* create and destroy */
	    debug(D_REDIR, "creat");
	}
	break;

    case 0x2e:				/* multipurpose */
	attr = sda->ext_attr;
	action = sda->ext_action;
	switch (sda->ext_mode & 3) {
	case 0:
	    mode = O_RDONLY;
	    break;
	case 1:
	    mode = O_WRONLY;
	    break;
	case 2:
	    mode = O_RDWR;
	    break;
	default:
	    return (FUNC_NUM_IVALID);
	}
	omode = sda->ext_mode & 0x7f;
	debug(D_REDIR,"mopen");
	break;

    default:
	fatal("called int2f11_open for unknown function %x\n",R_AL);
    }
    if (action & 0x02)	/* replace/open mode */
	mode |= O_TRUNC;
    debug(D_REDIR, "(%s) action 0x%x  mode 0x%x  attr 0x%x omode 0x%x \n", 
	  fname, action, mode, attr, omode);
	
    if (ustat(fname, &sb) < 0) {			/* file does not exist */
	if ((action & 0x10) || (attr & 0x100)) {	/* create it */
	    sb.st_ino = 0;
	    mode |= O_CREAT;				/* have to create as we go */
	    status = 0x02;				/* file created */
	} else {
	    return(FILE_NOT_FOUND);			/* fail */
	}
    } else {
	if (S_ISDIR(sb.st_mode))
	    return(ACCESS_DENIED);
	if ((action & 0x03) && !(attr & 0x100)) {	/* exists, work with it */
	    if (action & 0x02) {
		if (!S_ISREG(sb.st_mode)) {		/* only allowed for files */
		    debug(D_FILE_OPS,"attempt to truncate non-regular file\n");
		    return(ACCESS_DENIED);
		}
		status = 0x03;				/* we're going to truncate it */
	    } else {
		status = 0x01;				/* just open it */
	    }
	} else {
	    return(FILE_ALREADY_EXISTS);		/* exists, fail */
	}
    }

    if ((fd = open(fname, mode, from_dos_attr(attr))) < 0) {
	debug(D_FILE_OPS,"failed to open %s : %s\n",fname,strerror(errno));
	return (ACCESS_DENIED);
    }

    if (R_AL == 0x2e)			/* extended wants status returned */
	R_CX = status;

    /* black magic to populate the SFT */

    e = p = sda->filename1 + 2;		/* parse name */
    while (*p) {
	if (*p++ == '\\')		/* look for beginning of filename */
	    e = p;
    }

    for (i = 0; i < 8; ++i) {		/* copy name and pad with spaces */
	if (*e && *e != '.')
	    r_sft->name[i] = *e++;
	else
	    r_sft->name[i] = ' ';
    }

    if (*e == '.')			/* skip period on short names */
	++e;
    
    for (i = 0; i < 3; ++i) {		/* copy extension and pad with spaces */
	if (*e)
	    r_sft->ext[i] = *e++;
	else
	    r_sft->ext[i] = ' ';
    }

    if (ustat(fname, &sb) < 0)		/* re-stat to be accurate */
	return(WRITE_FAULT);		/* any better ideas?! */

    r_sft->open_mode = omode;		/* file open mode */
    *(u_long *)r_sft->ddr_dpb = 0;	/* no parameter block */
    r_sft->size = sb.st_size;		/* current size */
    r_sft->fd = fd;			/* our fd for it (hidden in starting cluster number) */
    r_sft->offset = 0;			/* current offset is 0 */
    *(u_short *)r_sft->dir_sector = 0;	/* not local file, ignored */
    r_sft->dir_entry = 0;		/* not local file, ignored */
    r_sft->attribute = attr & 0xff;	/* file attributes as requested */
    r_sft->info = r_drive + 0x8040;	/* hide drive number here for later reference */
    encode_dos_file_time(sb.st_mtime, &r_sft->date, &r_sft->time);
    debug(D_REDIR,"success, fd %d  status %x\n", fd, status);
    return(0);
}

/*
** 2f:11:19 2f:11:1b
**
** find first
*/
static int
int2f11_findfirst(regcontext_t *REGS __unused)
{
    return(find_first(sda->filename1,sda->attrmask,
		      (dosdir_t *)sda->foundentry,
		      (find_block_t *)sda->findfirst));
}

/*
** 2f:11:1c
**
** find next
*/
static int
int2f11_findnext(regcontext_t *REGS __unused)
{
    return(find_next((dosdir_t *)sda->foundentry,
		     (find_block_t *)sda->findfirst));
}

/*
** 2f:11:21
**
** lseek
*/
static int
int2f11_lseek(regcontext_t *REGS)
{
    int		fd;
    off_t	offset;

    fd = r_sft->fd;
    offset = (off_t) ((int) ((R_CX << 16) + R_DX));
    
    debug(D_REDIR,"lseek(%d, 0x%qx, SEEK_END)\n", fd, offset);
    
    if ((offset = lseek(fd, offset, SEEK_END)) < 0) {
	if (errno == EBADF)
	    return(HANDLE_INVALID);
	else
	    return(SEEK_ERROR);
    }
    r_sft->offset = offset;		/* update offset in SFT */
    R_DX = offset >> 16;
    R_AX = offset;
    return(0);
}

/*
** 2f:11:23
**
** qualify filename
*/
static int
int2f11_fnqual(regcontext_t *REGS)
{
    char	*fname;
    char	*tname;
    static char errmsg[] = "(failed)";
    int		savedrive;
    int		error;

    return(PATH_NOT_FOUND);
    
    savedrive = diskdrive;		/* to get CWD for network drive */
    diskdrive = n_drive;
    fname = (char *)MAKEPTR(R_DS, R_SI);	/* path pointers */
    tname = (char *)MAKEPTR(R_ES, R_DI);
    
    error = dos_makepath(fname, tname);
    if (error)
	tname = errmsg;

    diskdrive = savedrive;		/* restore correct drive */
    
    debug(D_REDIR, "qualify '%s' -> '%s'\n", fname, tname);
    return(error);
}

/*
** 2f:11:??
**
** Null function - we know about it but do nothing
*/
static int
int2f11_NULLFUNC(regcontext_t *REGS __unused)
{
    return(0);
}

/*
** 2f:11:??
**
** no function - not handled here (error)
*/
static int
int2f11_NOFUNC(regcontext_t *REGS __unused)
{
    return(-1);
}

struct intfunc_table int2f11_table[] = {
    { 0x00,	IFT_NOSUBFUNC,	int2f11_00,		"installation check"},
    { 0x01,	IFT_NOSUBFUNC,	int2f11_dirfn,		"rmdir"},
    { 0x02,	IFT_NOSUBFUNC,	int2f11_dirfn,		"rmdir"},
    { 0x03,	IFT_NOSUBFUNC,	int2f11_dirfn,		"mkdir"},
    { 0x04,	IFT_NOSUBFUNC,	int2f11_dirfn,		"mkdir"},
    { 0x05,	IFT_NOSUBFUNC,	int2f11_dirfn,		"chdir"},
    { 0x06,	IFT_NOSUBFUNC,	int2f11_close,		"close"},
    { 0x07,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"commit file"},
    { 0x08,	IFT_NOSUBFUNC,	int2f11_rdwr,		"read"},
    { 0x09,	IFT_NOSUBFUNC,	int2f11_rdwr,		"write"},
    { 0x0a,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"lock region"},
    { 0x0b,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"unlock region"},
    { 0x0c,	IFT_NOSUBFUNC,	int2f11_free,		"free space"},
    { 0x0e,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"chmod"},
    { 0x0f,	IFT_NOSUBFUNC,	int2f11_stat,		"stat"},
    { 0x11,	IFT_NOSUBFUNC,	int2f11_dirfn,		"rename"},
    { 0x13,	IFT_NOSUBFUNC,	int2f11_dirfn,		"unlink"},
    { 0x16,	IFT_NOSUBFUNC,	int2f11_open,		"open"},
    { 0x17,	IFT_NOSUBFUNC,	int2f11_open,		"creat"},
    { 0x18,	IFT_NOSUBFUNC,	int2f11_open,		"creat"},
    { 0x19,	IFT_NOSUBFUNC,	int2f11_findfirst,	"find first"},
    { 0x1b,	IFT_NOSUBFUNC,	int2f11_findfirst,	"find first"},
    { 0x1c,	IFT_NOSUBFUNC,	int2f11_findnext,	"find next"},
    { 0x1d,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"close all (abort)"},
    { 0x1e,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"do redirection"},
    { 0x1f,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"printer setup"},
    { 0x20,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"flush all buffers"},
    { 0x21,	IFT_NOSUBFUNC,	int2f11_lseek,		"lseek"},
    { 0x22,	IFT_NOSUBFUNC,	int2f11_NULLFUNC,	"process terminated"},
    { 0x23,	IFT_NOSUBFUNC,	int2f11_fnqual,		"qualify filename"},
    { 0x24,	IFT_NOSUBFUNC,	int2f11_NOFUNC,		"turn off printer"},
    { 0x25,	IFT_NOSUBFUNC,	int2f11_NOFUNC,		"printer mode"},
    { 0x2d,	IFT_NOSUBFUNC,	int2f11_NOFUNC,		"extended attributes"},
    { 0x2e,	IFT_NOSUBFUNC,	int2f11_open,		"extended open/create"},
    { -1,	0,		NULL,			NULL}
};

static int int2f11_fastlookup[256];

/******************************************************************************
** 2f:11
**
** The DOS redirector interface.
*/

/*
** Verify that the drive being referenced is one we are handling, and
** establish some state for upcoming functions.
** 
** Returns 1 if we should handle this request.
**
** XXX this is rather inefficient, but much easier to read than the previous
** incarnation 8(
*/
static int
int2f11_validate(regcontext_t *REGS)
{
    int		func = R_AL;
    const char	*path = NULL;
    int		doit = 0;

    /* defaults may help trap problems */
    r_cds = NULL;
    r_sft = NULL;
    r_drive = -1;
    
    /* some functions we accept regardless */
    switch (func) {
    case 0x00:		/* installation check */
    case 0x23:		/* qualify path */
    case 0x1c:		/* XXX really only valid if a search already started... */
	return(1);
    }
    
    /* Where's the CDS? */
    switch(func) {
    case 0x01:		/* referenced by the SDA */
    case 0x02:
    case 0x03:
    case 0x04:
    case 0x05:
    case 0x0e:
    case 0x0f:
    case 0x11:
    case 0x13:
    case 0x17:
    case 0x1b:
	r_cds = (CDS *)MAKEPTR(sda->cds_seg, sda->cds_off);
	break;

    case 0x0c:		/* in es:di */
    case 0x1c:
	r_cds = (CDS *)MAKEPTR(R_ES, R_DI);
	break;
    }

    /* Where's the SFT? */
    switch(func) {
    case 0x06:		/* in es:di */
    case 0x07:
    case 0x08:
    case 0x09:
    case 0x0a:
    case 0x0b:
    case 0x16:
    case 0x17:
    case 0x18:
    case 0x21:
    case 0x2d:
    case 0x2e:
	r_sft = (SFT *)MAKEPTR(R_ES, R_DI);
	break;
    }
    
    /* What drive? */
    switch(func) {
    case 0x01:		/* get drive from fully-qualified path in SDA */
    case 0x02:
    case 0x03:
    case 0x04:
    case 0x05:
    case 0x0c:
    case 0x0e:
    case 0x0f:
    case 0x11:
    case 0x13:
    case 0x16:
    case 0x17:
    case 0x18:
    case 0x19:
    case 0x1b:
    case 0x2e:
	path = sda->filename1;
	break;
	
    case 0x06:		/* get drive from SFT (we put it here when file was opened) */
    case 0x07:
    case 0x08:
    case 0x09:
    case 0x0a:
    case 0x0b:
    case 0x21:
    case 0x2d:
	r_drive = r_sft->info & 0x1f;
	break;
    }

    if (path) {		/* we have a path and need to determine the drive it refers to */

	if (path[1] != ':') {	/* must be fully qualified; we cannot handle this */
	    debug(D_REDIR,"attempt to work non-absolute path %s\n",path);
	    return(0);
	}

	/* translate letter to drive number */
	r_drive = drlton(path[0]);
    } else {
	path = "(no path)";
    }
        
    /* do we handle this drive? */
    if (dos_getcwd(r_drive)) {
	n_drive = r_drive;		/* XXX GROSTIC HACK ALERT */
	doit = 1;
    }
    
    debug(D_REDIR,"%s -> drive %c func %x (%sus)\n",
	  path, drntol(r_drive), func, doit?"":"not ");
    
    /* so do we deal with this one? */
    return(doit);
}

    
int 
int2f_11(regcontext_t *REGS)
{
    int		idx;
    int		error;
    
    if (!sda) {		/* not initialised yet */
	error = FUNC_NUM_IVALID;
    } else {

	idx = intfunc_find(int2f11_table, int2f11_fastlookup, R_AL, 0);
	if (idx == -1) {
	    debug(D_ALWAYS,"no handler for int2f:11:%x\n", R_AL);
	    return(0);
	}
	reset_poll();
	

	if (!int2f11_validate(REGS)) {		/* determine whether we handle this request */
	    error = -1;				/* not handled by us */
	} else {
	    debug(D_REDIR, "REDIR: %02x (%s)\n", 
		      int2f11_table[idx].func, int2f11_table[idx].desc);
	    /* call the handler */
	    error = int2f11_table[idx].handler(REGS);
	    if (error != -1)
		debug(D_REDIR, "REDIR: returns %d (%s)\n", 
		      error, ((error >= 0) && (error <= dos_ret_size)) ? dos_return[error] : "unknown");
	}
    }

    if (error == -1)
	return (0);
    if (error) {
	R_AX = error;
	R_FLAGS |= PSL_C;
    } else
	R_FLAGS &= ~PSL_C;
    return (1);
}

/******************************************************************************
** intff handler.
**
** intff is the (secret, proprietary, internal, evil) call to 
** initialise the redirector.
*/
static void
install_drive(int drive, u_char *path)
{
    CDS *cds;

    /* check that DOS considers this a valid drive */
    if (drive < 0 || drive >= lol->lastdrive) {
	debug(D_REDIR, "Drive %c beyond limit of %c\n",
	      drntol(drive), drntol(lol->lastdrive - 1));
	return;
    }

    /* get the CDS for this drive */
    cds = (CDS *)MAKEPTR(lol->cds_seg, lol->cds_offset);
    cds += drive;

#if 0	/* XXX looks OK to me - mjs */
    if (cds->flag & (CDS_remote | CDS_ready)) {
	debug(D_REDIR, "Drive %c already installed\n", drntol(drive));
	return;
    }
#endif

    debug(D_REDIR, "Installing %c: as %s\n", drntol(drive), path);

    cds->flag |= CDS_remote | CDS_ready | CDS_notnet;
    cds->path[0] = drntol(drive);
    cds->path[1] = ':';
    cds->path[2] = '\\';
    cds->path[3] = '\0';
    cds->offset = 2;	/* offset of \ in current path field */
}

static void
init_drives(void)
{
    int drive;
    u_char *path;

    /* for all possible drives */
    for (drive = 0; drive < 26; ++drive) {
	if ((path = dos_getpath(drive)) != 0)	/* assigned to a path? */
	    install_drive(drive, path);		/* make it visible to DOS */
    }	
}


void
intff(regcontext_t *REGS)
{

    if (lol && sda) {				/* already been called? */
	debug(D_REDIR, "redirector duplicate install ignored");
	return;
    }
    lol = (LOL *)MAKEPTR(R_BX, R_DX);	/* where DOS keeps its goodies */
    sda = (SDA *)MAKEPTR(R_DI, R_SI);
    init_drives();
    
    /* initialise dispatcher */
    intfunc_init(int2f11_table, int2f11_fastlookup);
}