Subversion Repositories shark

/* Project:     OSLib

 * Description: The OS Construction Kit

 * Date:                1.6.2000

 * Idea by:             Luca Abeni & Gerardo Lamastra

 *

 * OSLib is an SO project aimed at developing a common, easy-to-use

 * low-level infrastructure for developing OS kernels and Embedded

 * Applications; it partially derives from the HARTIK project but it

 * currently is independently developed.

 *

 * OSLib is distributed under GPL License, and some of its code has

 * been derived from the Linux kernel source; also some important

 * ideas come from studying the DJGPP go32 extender.

 *

 * We acknowledge the Linux Community, Free Software Foundation,

 * D.J. Delorie and all the other developers who believe in the

 * freedom of software and ideas.

 *

 * For legalese, check out the included GPL license.

 */

/* DOS Interface toward disk            */

#include <ll/i386/mem.h>

#include <ll/i386/error.h>

#include <ll/string.h>

#include <ll/i386/x-dos.h>

#include <ll/i386/x-dosmem.h>

FILE(X - Dos - File);

/* Basic DOS I/O Flag */

/*#define __DEBUG__*/

#define DOS_READ        0

#define DOS_WRITE       1

#define DOS_RW          2

#define DOS_BUFSIZE     1024    /* I/O auxiliary buffer         */

#define DOS_MAXDESCR    16      /* Maximum number of DOS file   */

static DOS_FILE DOS_descr[DOS_MAXDESCR];

/* I Hope this array is initialized with 0... */

static BYTE busy[DOS_MAXDESCR];

/* The Last DOS Error occurred! */

static unsigned _DOS_error = 0;

#ifdef __NOH4__

int DOS_init(void)

{

    /* Init the DOS memory allocator */

    DOS_mem_init();

    /* TODO: Add a check if we are run through X */

    return 1;

}

#endif

unsigned DOS_error(void)

{

    unsigned v = _DOS_error;

    _DOS_error = 0;

    return (v);

}

DOS_FILE *DOS_fopen(char *name, char *mode)

{

    X_REGS16 ir, or;

    X_SREGS16 sr;

    DOS_FILE *f;

    register int i;

#ifdef __DEBUG__

    char xname[80];

#endif

    for (i = 0; busy[i] && i < DOS_MAXDESCR; i++);

    /* Return NULL if no descriptor is available... */

    if (i == DOS_MAXDESCR)

        return (NULL);

    /* Otherwise, lock the descriptor & remember the index */

    f = &DOS_descr[i];

    busy[i] = 1;

    f->index = i;

    /* Allocate a DOS buffer for the file name */

    f->n1 = DOS_alloc(80);

    strcpy(f->n2, name);

    if (mode[0] == 'r') {

        /* DOS Call: Intr 0x21

           AH = 0x3D  - Open existing file

           AL = 0,1,2 - Read,Write, R/W

         */

        f->mode = DOS_READ;

        ir.h.ah = 0x3D;

        ir.h.al = f->mode;

    } else if (mode[0] == 'w') {

        /* DOS Call: Intr 0x21

           AH = 0x3C  - Create a file

           AL = File attribute [0x20 = Standard,r/w,archive]

         */

        f->mode = DOS_WRITE;

        ir.h.ah = 0x3C;

        ir.x.cx = 0x20;

    }

    f->offset = 0;

    /* Copy th \0 also! */

    memcpy(f->n1, name, strlen(name) + 1);

#ifdef __DEBUG__

    memcpy(xname, f->n1, strlen(name) + 1);

    message("Name is : %s -- Mode : %d\n", xname, f->mode);

#endif

    /* Ask DOS to open File */

    ir.x.dx = DOS_OFF(f->n1);

    sr.ds = DOS_SEG(f->n1);

    X_callBIOS(0x21, &ir, &or, &sr);

    f->handle = (!(or.x.cflag) ? or.x.ax : -1);

    if (f->handle == -1) {

        /* DOS request failed! Release the used resources */

        DOS_free(f->n1, 80);

        busy[i] = 0;

        _DOS_error = or.x.ax;

        return (NULL);

    }

    /* Allocate the DOS buffer for temporary I/O */

    f->buf = DOS_alloc(DOS_BUFSIZE);

    return (f);

}

void DOS_fclose(DOS_FILE * f)

{

    X_REGS16 ir, or;

    X_SREGS16 sr;

    if (f == NULL || busy[f->index] == 0)

        return;

    /* DOS Call: Intr 0x21

       AH = 0x3E  - Close a file

       BX = File handle

     */

    ir.h.ah = 0x3E;

    ir.x.bx = f->handle;

    X_callBIOS(0x21, &ir, &or, &sr);

    DOS_free(f->buf, DOS_BUFSIZE);

    DOS_free(f->n1, 80);

    busy[f->index] = 0;

}

DWORD DOS_fread(void *abuf, DWORD size, DWORD num, DOS_FILE * f)

{

    X_REGS16 ir, or;

    X_SREGS16 sr;

    DWORD count = size * num, now = 0, chunk;

    BYTE done = 0;

    BYTE *buf = (BYTE *) (abuf);

    while (done == 0) {

        /* Fragment the read operation ... */

        if (count > DOS_BUFSIZE)

            chunk = DOS_BUFSIZE;

        else

            chunk = count;

        /* DOS Call: Intr 0x21

           AH = 0x3F  - Read data using a file handle

           BX = File handle

           CX = Buffer size

           DS:DX = Segment:Offset of the Buffer

         */

        ir.h.ah = 0x3F;

        ir.x.bx = f->handle;

        ir.x.cx = chunk;

        ir.x.dx = DOS_OFF(f->buf);

        sr.ds = DOS_SEG(f->buf);

        X_callBIOS(0x21, &ir, &or, &sr);

        /* If it was OK ... */

        if (!(or.x.cflag)) {

            /* Copy data into application buffer */

            memcpy(buf, f->buf, or.x.ax);

            buf += or.x.ax;

            now += or.x.ax;

            f->offset += or.x.ax;

            count -= or.x.ax;

            /*

               Finish if we have read all the data or

               if we have read less data than how expected

             */

            if (now == size * num || or.x.ax != chunk)

                done = 1;

        } else {

            done = -1;

            _DOS_error = or.x.ax;

        }

    }

    return (now);

}

DWORD DOS_fwrite(void *abuf, DWORD size, DWORD num, DOS_FILE * f)

{

    X_REGS16 ir, or;

    X_SREGS16 sr;

    DWORD count = size * num, now = 0, chunk;

    BYTE done = 0;

    BYTE *buf = (BYTE *) (abuf);

    while (done == 0) {

        /* Fragment the write operation ... */

        if (count > DOS_BUFSIZE)

            chunk = DOS_BUFSIZE;

        else

            chunk = count;

        /* Copy data from application buffer */

        memcpy(f->buf, buf, chunk);

        /* DOS Call: Intr 0x21

           AH = 0x40 - Write data using a file handle

           BX = File handle

           CX = Buffer size

           DS:DX = Segment:Offset of the Buffer

         */

        ir.h.ah = 0x40;

        ir.x.bx = f->handle;

        ir.x.cx = chunk;

        ir.x.dx = DOS_OFF(f->buf);

        sr.ds = DOS_SEG(f->buf);

        X_callBIOS(0x21, &ir, &or, &sr);

        /* If it was OK ... */

        if (!(or.x.cflag)) {

            f->offset += or.x.ax;

            count -= or.x.ax;

            buf += or.x.ax;

            now += or.x.ax;

            if (now == size * num || or.x.ax != chunk)

                done = 1;

        } else {

            done = -1;

            _DOS_error = or.x.ax;

        }

    }

    return (now);

}