device.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DOS_DEVICE_NODE
struct	_DOS_DRIVER
struct	_DOS_REQUEST_HEADER
struct	_DOS_INIT_REQUEST
struct	_DOS_IOCTL_RW_REQUEST
struct	_DOS_RW_REQUEST
struct	_DOS_PEEK_REQUEST
struct	_DOS_OUTPUT_BUSY_REQUEST

Macros
#define	MAX_DEVICE_NAME   8
#define	DEVICE_CODE_SIZE   10
#define	DEVICE_PRIVATE_AREA(Driver)   (Driver + sizeof(DOS_DRIVER) + DEVICE_CODE_SIZE)
#define	BOP_DRV_STRATEGY   0x42
#define	BOP_DRV_INTERRUPT   0x43
#define	DOS_DEVATTR_STDIN   (1 << 0)
#define	DOS_DEVATTR_STDOUT   (1 << 1)
#define	DOS_DEVATTR_NUL   (1 << 2)
#define	DOS_DEVATTR_CLOCK   (1 << 3)
#define	DOS_DEVATTR_CON   (1 << 4)
#define	DOS_DEVATTR_OPENCLOSE   (1 << 11)
#define	DOS_DEVATTR_SPECIAL   (1 << 13)
#define	DOS_DEVATTR_IOCTL   (1 << 14)
#define	DOS_DEVATTR_CHARACTER   (1 << 15)
#define	DOS_DEVCMD_INIT   0
#define	DOS_DEVCMD_MEDIACHK   1
#define	DOS_DEVCMD_BUILDBPB   2
#define	DOS_DEVCMD_IOCTL_READ   3
#define	DOS_DEVCMD_READ   4
#define	DOS_DEVCMD_PEEK   5
#define	DOS_DEVCMD_INSTAT   6
#define	DOS_DEVCMD_FLUSH_INPUT   7
#define	DOS_DEVCMD_WRITE   8
#define	DOS_DEVCMD_WRITE_VERIFY   9
#define	DOS_DEVCMD_OUTSTAT   10
#define	DOS_DEVCMD_FLUSH_OUTPUT   11
#define	DOS_DEVCMD_IOCTL_WRITE   12
#define	DOS_DEVCMD_OPEN   13
#define	DOS_DEVCMD_CLOSE   14
#define	DOS_DEVCMD_REMOVABLE   15
#define	DOS_DEVCMD_OUTPUT_BUSY   16
#define	DOS_DEVSTAT_DONE   (1 << 8)
#define	DOS_DEVSTAT_BUSY   (1 << 9)
#define	DOS_DEVSTAT_ERROR   (1 << 15)
#define	DOS_DEVERR_WRITE_PROTECT   0
#define	DOS_DEVERR_UNKNOWN_UNIT   1
#define	DOS_DEVERR_NOT_READY   2
#define	DOS_DEVERR_UNKNOWN_COMMAND   3
#define	DOS_DEVERR_BAD_DATA_CRC   4
#define	DOS_DEVERR_BAD_REQUEST   5
#define	DOS_DEVERR_INVALID_SEEK   6
#define	DOS_DEVERR_UNKNOWN_MEDIUM   7
#define	DOS_DEVERR_BAD_BLOCK   8
#define	DOS_DEVERR_OUT_OF_PAPER   9
#define	DOS_DEVERR_WRITE_FAULT   10
#define	DOS_DEVERR_READ_FAULT   11
#define	DOS_DEVERR_GENERAL   12
#define	DOS_DEVERR_BAD_MEDIA_CHANGE   15

Typedefs
typedef struct _DOS_DEVICE_NODE	DOS_DEVICE_NODE
typedef struct _DOS_DEVICE_NODE *	PDOS_DEVICE_NODE
typedef WORD(NTAPI *	PDOS_DEVICE_GENERIC_ROUTINE) (PDOS_DEVICE_NODE DeviceNode)
typedef WORD(NTAPI *	PDOS_DEVICE_IO_ROUTINE) (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
typedef WORD(NTAPI *	PDOS_DEVICE_PEEK_ROUTINE) (PDOS_DEVICE_NODE DeviceNode, PBYTE Character)
typedef struct _DOS_DRIVER	DOS_DRIVER
typedef struct _DOS_DRIVER *	PDOS_DRIVER
typedef struct _DOS_REQUEST_HEADER	DOS_REQUEST_HEADER
typedef struct _DOS_REQUEST_HEADER *	PDOS_REQUEST_HEADER
typedef struct _DOS_INIT_REQUEST	DOS_INIT_REQUEST
typedef struct _DOS_INIT_REQUEST *	PDOS_INIT_REQUEST
typedef struct _DOS_IOCTL_RW_REQUEST	DOS_IOCTL_RW_REQUEST
typedef struct _DOS_IOCTL_RW_REQUEST *	PDOS_IOCTL_RW_REQUEST
typedef struct _DOS_RW_REQUEST	DOS_RW_REQUEST
typedef struct _DOS_RW_REQUEST *	PDOS_RW_REQUEST
typedef struct _DOS_PEEK_REQUEST	DOS_PEEK_REQUEST
typedef struct _DOS_PEEK_REQUEST *	PDOS_PEEK_REQUEST
typedef struct _DOS_OUTPUT_BUSY_REQUEST	DOS_OUTPUT_BUSY_REQUEST
typedef struct _DOS_OUTPUT_BUSY_REQUEST *	PDOS_OUTPUT_BUSY_REQUEST

Functions
	C_ASSERT (sizeof(DOS_DRIVER)==0x12)
PDOS_DEVICE_NODE	DosGetDriverNode (DWORD Driver)
PDOS_DEVICE_NODE	DosGetDevice (LPCSTR DeviceName)
PDOS_DEVICE_NODE	DosCreateDevice (WORD Attributes, PCHAR DeviceName)
PDOS_DEVICE_NODE	DosCreateDeviceEx (WORD Attributes, PCHAR DeviceName, WORD PrivateDataSize)
VOID	DosDeleteDevice (PDOS_DEVICE_NODE DeviceNode)
VOID	DeviceStrategyBop (VOID)
VOID	DeviceInterruptBop (VOID)
DWORD	DosLoadDriver (LPCSTR DriverFile)

Macro Definition Documentation

BOP_DRV_INTERRUPT

#define BOP_DRV_INTERRUPT   0x43

Definition at line 19 of file device.h.

BOP_DRV_STRATEGY

#define BOP_DRV_STRATEGY   0x42

Definition at line 18 of file device.h.

DEVICE_CODE_SIZE

#define DEVICE_CODE_SIZE   10

Definition at line 15 of file device.h.

DEVICE_PRIVATE_AREA

#define DEVICE_PRIVATE_AREA

(

Driver

)

(Driver + sizeof(DOS_DRIVER) + DEVICE_CODE_SIZE)

Definition at line 16 of file device.h.

DOS_DEVATTR_CHARACTER

#define DOS_DEVATTR_CHARACTER   (1 << 15)

Definition at line 29 of file device.h.

DOS_DEVATTR_CLOCK

#define DOS_DEVATTR_CLOCK   (1 << 3)

Definition at line 24 of file device.h.

DOS_DEVATTR_CON

#define DOS_DEVATTR_CON   (1 << 4)

Definition at line 25 of file device.h.

DOS_DEVATTR_IOCTL

#define DOS_DEVATTR_IOCTL   (1 << 14)

Definition at line 28 of file device.h.

DOS_DEVATTR_NUL

#define DOS_DEVATTR_NUL   (1 << 2)

Definition at line 23 of file device.h.

DOS_DEVATTR_OPENCLOSE

#define DOS_DEVATTR_OPENCLOSE   (1 << 11)

Definition at line 26 of file device.h.

DOS_DEVATTR_SPECIAL

#define DOS_DEVATTR_SPECIAL   (1 << 13)

Definition at line 27 of file device.h.

DOS_DEVATTR_STDIN

#define DOS_DEVATTR_STDIN   (1 << 0)

Definition at line 21 of file device.h.

DOS_DEVATTR_STDOUT

#define DOS_DEVATTR_STDOUT   (1 << 1)

Definition at line 22 of file device.h.

DOS_DEVCMD_BUILDBPB

#define DOS_DEVCMD_BUILDBPB   2

Definition at line 33 of file device.h.

DOS_DEVCMD_CLOSE

#define DOS_DEVCMD_CLOSE   14

Definition at line 45 of file device.h.

DOS_DEVCMD_FLUSH_INPUT

#define DOS_DEVCMD_FLUSH_INPUT   7

Definition at line 38 of file device.h.

DOS_DEVCMD_FLUSH_OUTPUT

#define DOS_DEVCMD_FLUSH_OUTPUT   11

Definition at line 42 of file device.h.

DOS_DEVCMD_INIT

#define DOS_DEVCMD_INIT   0

Definition at line 31 of file device.h.

DOS_DEVCMD_INSTAT

#define DOS_DEVCMD_INSTAT   6

Definition at line 37 of file device.h.

DOS_DEVCMD_IOCTL_READ

#define DOS_DEVCMD_IOCTL_READ   3

Definition at line 34 of file device.h.

DOS_DEVCMD_IOCTL_WRITE

#define DOS_DEVCMD_IOCTL_WRITE   12

Definition at line 43 of file device.h.

DOS_DEVCMD_MEDIACHK

#define DOS_DEVCMD_MEDIACHK   1

Definition at line 32 of file device.h.

DOS_DEVCMD_OPEN

#define DOS_DEVCMD_OPEN   13

Definition at line 44 of file device.h.

DOS_DEVCMD_OUTPUT_BUSY

#define DOS_DEVCMD_OUTPUT_BUSY   16

Definition at line 47 of file device.h.

DOS_DEVCMD_OUTSTAT

#define DOS_DEVCMD_OUTSTAT   10

Definition at line 41 of file device.h.

DOS_DEVCMD_PEEK

#define DOS_DEVCMD_PEEK   5

Definition at line 36 of file device.h.

DOS_DEVCMD_READ

#define DOS_DEVCMD_READ   4

Definition at line 35 of file device.h.

DOS_DEVCMD_REMOVABLE

#define DOS_DEVCMD_REMOVABLE   15

Definition at line 46 of file device.h.

DOS_DEVCMD_WRITE

#define DOS_DEVCMD_WRITE   8

Definition at line 39 of file device.h.

DOS_DEVCMD_WRITE_VERIFY

#define DOS_DEVCMD_WRITE_VERIFY   9

Definition at line 40 of file device.h.

DOS_DEVERR_BAD_BLOCK

#define DOS_DEVERR_BAD_BLOCK   8

Definition at line 61 of file device.h.

DOS_DEVERR_BAD_DATA_CRC

#define DOS_DEVERR_BAD_DATA_CRC   4

Definition at line 57 of file device.h.

DOS_DEVERR_BAD_MEDIA_CHANGE

#define DOS_DEVERR_BAD_MEDIA_CHANGE   15

Definition at line 66 of file device.h.

DOS_DEVERR_BAD_REQUEST

#define DOS_DEVERR_BAD_REQUEST   5

Definition at line 58 of file device.h.

DOS_DEVERR_GENERAL

#define DOS_DEVERR_GENERAL   12

Definition at line 65 of file device.h.

DOS_DEVERR_INVALID_SEEK

#define DOS_DEVERR_INVALID_SEEK   6

Definition at line 59 of file device.h.

DOS_DEVERR_NOT_READY

#define DOS_DEVERR_NOT_READY   2

Definition at line 55 of file device.h.

DOS_DEVERR_OUT_OF_PAPER

#define DOS_DEVERR_OUT_OF_PAPER   9

Definition at line 62 of file device.h.

DOS_DEVERR_READ_FAULT

#define DOS_DEVERR_READ_FAULT   11

Definition at line 64 of file device.h.

DOS_DEVERR_UNKNOWN_COMMAND

#define DOS_DEVERR_UNKNOWN_COMMAND   3

Definition at line 56 of file device.h.

DOS_DEVERR_UNKNOWN_MEDIUM

#define DOS_DEVERR_UNKNOWN_MEDIUM   7

Definition at line 60 of file device.h.

DOS_DEVERR_UNKNOWN_UNIT

#define DOS_DEVERR_UNKNOWN_UNIT   1

Definition at line 54 of file device.h.

DOS_DEVERR_WRITE_FAULT

#define DOS_DEVERR_WRITE_FAULT   10

Definition at line 63 of file device.h.

DOS_DEVERR_WRITE_PROTECT

#define DOS_DEVERR_WRITE_PROTECT   0

Definition at line 53 of file device.h.

DOS_DEVSTAT_BUSY

#define DOS_DEVSTAT_BUSY   (1 << 9)

Definition at line 50 of file device.h.

DOS_DEVSTAT_DONE

#define DOS_DEVSTAT_DONE   (1 << 8)

Definition at line 49 of file device.h.

DOS_DEVSTAT_ERROR

#define DOS_DEVSTAT_ERROR   (1 << 15)

Definition at line 51 of file device.h.

MAX_DEVICE_NAME

#define MAX_DEVICE_NAME   8

Definition at line 14 of file device.h.

Typedef Documentation

DOS_DEVICE_NODE

typedef struct _DOS_DEVICE_NODE DOS_DEVICE_NODE

Definition at line 68 of file device.h.

DOS_DRIVER

typedef struct _DOS_DRIVER DOS_DRIVER

DOS_INIT_REQUEST

typedef struct _DOS_INIT_REQUEST DOS_INIT_REQUEST

DOS_IOCTL_RW_REQUEST

typedef struct _DOS_IOCTL_RW_REQUEST DOS_IOCTL_RW_REQUEST

DOS_OUTPUT_BUSY_REQUEST

typedef struct _DOS_OUTPUT_BUSY_REQUEST DOS_OUTPUT_BUSY_REQUEST

DOS_PEEK_REQUEST

typedef struct _DOS_PEEK_REQUEST DOS_PEEK_REQUEST

DOS_REQUEST_HEADER

typedef struct _DOS_REQUEST_HEADER DOS_REQUEST_HEADER

DOS_RW_REQUEST

typedef struct _DOS_RW_REQUEST DOS_RW_REQUEST

PDOS_DEVICE_GENERIC_ROUTINE

typedef WORD(NTAPI * PDOS_DEVICE_GENERIC_ROUTINE) (PDOS_DEVICE_NODE DeviceNode)

Definition at line 70 of file device.h.

PDOS_DEVICE_IO_ROUTINE

typedef WORD(NTAPI * PDOS_DEVICE_IO_ROUTINE) (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)

Definition at line 72 of file device.h.

PDOS_DEVICE_NODE

typedef struct _DOS_DEVICE_NODE * PDOS_DEVICE_NODE

Definition at line 68 of file device.h.

PDOS_DEVICE_PEEK_ROUTINE

typedef WORD(NTAPI * PDOS_DEVICE_PEEK_ROUTINE) (PDOS_DEVICE_NODE DeviceNode, PBYTE Character)

Definition at line 79 of file device.h.

PDOS_DRIVER

typedef struct _DOS_DRIVER * PDOS_DRIVER

PDOS_INIT_REQUEST

typedef struct _DOS_INIT_REQUEST * PDOS_INIT_REQUEST

PDOS_IOCTL_RW_REQUEST

typedef struct _DOS_IOCTL_RW_REQUEST * PDOS_IOCTL_RW_REQUEST

PDOS_OUTPUT_BUSY_REQUEST

typedef struct _DOS_OUTPUT_BUSY_REQUEST * PDOS_OUTPUT_BUSY_REQUEST

PDOS_PEEK_REQUEST

typedef struct _DOS_PEEK_REQUEST * PDOS_PEEK_REQUEST

PDOS_REQUEST_HEADER

typedef struct _DOS_REQUEST_HEADER * PDOS_REQUEST_HEADER

PDOS_RW_REQUEST

typedef struct _DOS_RW_REQUEST * PDOS_RW_REQUEST

Function Documentation

C_ASSERT()

C_ASSERT

(

sizeof(DOS_DRIVER)

= =0x12

)

DeviceInterruptBop()

VOID DeviceInterruptBop

(

VOID

)

Definition at line 436 of file device.c.

{
    PLIST_ENTRY i;
    PDOS_DEVICE_NODE Node;
    DWORD DriverAddress = (getCS() << 4) + getIP() - sizeof(DOS_DRIVER) - 9;
 
    /* Get the device node for this driver */
    for (i = DeviceList.Flink; i != &DeviceList; i = i->Flink)
    {
        Node = CONTAINING_RECORD(i, DOS_DEVICE_NODE, Entry);
        if (TO_LINEAR(HIWORD(Node->Driver), LOWORD(Node->Driver)) == DriverAddress) break;
    }
 
    if (i == &DeviceList)
    {
        DPRINT1("Device interrupt BOP from an unknown location.\n");
        return;
    }
 
    switch (DeviceRequest->CommandCode)
    {
        case DOS_DEVCMD_IOCTL_READ:
        {
            PDOS_IOCTL_RW_REQUEST Request = (PDOS_IOCTL_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->IoctlReadRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_READ:
        {
            PDOS_RW_REQUEST Request = (PDOS_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->ReadRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_PEEK:
        {
            PDOS_PEEK_REQUEST Request = (PDOS_PEEK_REQUEST)DeviceRequest;
            DeviceRequest->Status = Node->PeekRoutine(Node, &Request->Character);
            break;
        }
 
        case DOS_DEVCMD_INSTAT:
        {
            DeviceRequest->Status = Node->InputStatusRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_FLUSH_INPUT:
        {
            DeviceRequest->Status = Node->FlushInputRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_IOCTL_WRITE:
        {
            PDOS_IOCTL_RW_REQUEST Request = (PDOS_IOCTL_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->IoctlWriteRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_WRITE:
        {
            PDOS_RW_REQUEST Request = (PDOS_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->WriteRoutine(Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_OUTSTAT:
        {
            DeviceRequest->Status = Node->OutputStatusRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_FLUSH_OUTPUT:
        {
            DeviceRequest->Status = Node->FlushOutputRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_OPEN:
        {
            DeviceRequest->Status = Node->OpenRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_CLOSE:
        {
            DeviceRequest->Status = Node->CloseRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_OUTPUT_BUSY:
        {
            PDOS_OUTPUT_BUSY_REQUEST Request = (PDOS_OUTPUT_BUSY_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->OutputUntilBusyRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        default:
        {
            DPRINT1("Unknown device command code: %u\n", DeviceRequest->CommandCode);
        }
    }
}

Referenced by DosSystemBop().

DeviceStrategyBop()

VOID DeviceStrategyBop

(

VOID

)

Definition at line 430 of file device.c.

{
    /* Save ES:BX */
    DeviceRequest = (PDOS_REQUEST_HEADER)SEG_OFF_TO_PTR(getES(), getBX());
}

Referenced by DosSystemBop().

DosCreateDevice()

PDOS_DEVICE_NODE DosCreateDevice	(	WORD	Attributes,
		PCHAR	DeviceName
	)

Definition at line 413 of file device.c.

{
    /* Call the extended API */
    return DosCreateDeviceEx(Attributes, DeviceName, 0);
}

Referenced by ConDrvInitialize().

DosCreateDeviceEx()

PDOS_DEVICE_NODE DosCreateDeviceEx	(	WORD	Attributes,
		PCHAR	DeviceName,
		WORD	PrivateDataSize
	)

Definition at line 361 of file device.c.

{
    BYTE i;
    WORD Segment;
    PDOS_DRIVER DriverHeader;
    PDOS_DEVICE_NODE Node;
 
    /* Make sure this is a character device */
    if (!(Attributes & DOS_DEVATTR_CHARACTER))
    {
        DPRINT1("ERROR: Block devices are not supported.\n");
        return NULL;
    }
 
    /* Create a driver header for this device */
    Segment = DosAllocateMemory(sizeof(DOS_DRIVER) + DEVICE_CODE_SIZE + PrivateDataSize, NULL);
    if (Segment == 0) return NULL;
 
    /* Fill the header with data */
    DriverHeader = SEG_OFF_TO_PTR(Segment, 0);
    DriverHeader->Link = MAXDWORD;
    DriverHeader->DeviceAttributes = Attributes;
    DriverHeader->StrategyRoutine = sizeof(DOS_DRIVER);
    DriverHeader->InterruptRoutine = sizeof(DOS_DRIVER) + sizeof(StrategyRoutine);
 
    RtlFillMemory(DriverHeader->DeviceName, MAX_DEVICE_NAME, ' ');
    for (i = 0; i < MAX_DEVICE_NAME; i++)
    {
        if (DeviceName[i] == '\0' || DeviceName[i] == ' ') break;
        DriverHeader->DeviceName[i] = DeviceName[i];
    }
 
    /* Write the routines */
    RtlMoveMemory(SEG_OFF_TO_PTR(Segment, DriverHeader->StrategyRoutine),
                  StrategyRoutine,
                  sizeof(StrategyRoutine));
    RtlMoveMemory(SEG_OFF_TO_PTR(Segment, DriverHeader->InterruptRoutine),
                  InterruptRoutine,
                  sizeof(InterruptRoutine));
 
    /* Create the node */
    Node = DosCreateDeviceNode(MAKELONG(0, Segment));
    if (Node == NULL)
    {
        DosFreeMemory(Segment);
        return NULL;
    }
 
    DosAddDriver(Node->Driver);
    return Node;
}

Referenced by DosCreateDevice(), EmsDrvInitialize(), and XmsInitialize().

DosDeleteDevice()

VOID DosDeleteDevice

(

PDOS_DEVICE_NODE

DeviceNode

)

Definition at line 419 of file device.c.

{
    DosRemoveDriver(DeviceNode->Driver);
 
    ASSERT(LOWORD(DeviceNode->Driver) == 0);
    DosFreeMemory(HIWORD(DeviceNode->Driver));
 
    RemoveEntryList(&DeviceNode->Entry);
    RtlFreeHeap(RtlGetProcessHeap(), 0, DeviceNode);
}

Referenced by ConDrvCleanup(), EmsDrvCleanup(), and XmsCleanup().

DosGetDevice()

PDOS_DEVICE_NODE DosGetDevice

(

LPCSTR

DeviceName

)

Definition at line 342 of file device.c.

{
    DWORD CurrentDriver = MAKELONG(DOS_DATA_OFFSET(SysVars.NullDevice), DOS_DATA_SEGMENT);
    ANSI_STRING DeviceNameString;
 
    RtlInitAnsiString(&DeviceNameString, DeviceName);
 
    while (LOWORD(CurrentDriver) != 0xFFFF)
    {
        PDOS_DEVICE_NODE Node = DosGetDriverNode(CurrentDriver);
        PDOS_DRIVER DriverHeader = (PDOS_DRIVER)FAR_POINTER(CurrentDriver);
 
        if (RtlEqualString(&Node->Name, &DeviceNameString, TRUE)) return Node;
        CurrentDriver = DriverHeader->Link;
    }
 
    return NULL;
}

Referenced by DosCreateFile(), DosCreateFileEx(), and DosOpenFile().

DosGetDriverNode()

PDOS_DEVICE_NODE DosGetDriverNode

(

DWORD

Driver

)

Definition at line 305 of file device.c.

{
    PLIST_ENTRY i;
    PDOS_DEVICE_NODE Node;
 
    for (i = DeviceList.Flink; i != &DeviceList; i = i->Flink)
    {
        Node = CONTAINING_RECORD(i, DOS_DEVICE_NODE, Entry);
        if (Node->Driver == Driver) break;
    }
 
    if (i == &DeviceList)
    {
        DPRINT1("The driver at %04X:%04X has no associated device node. "
                "Installing automagically.\n",
                HIWORD(Driver),
                LOWORD(Driver));
 
        /* Create the device node */
        Node = DosCreateDeviceNode(Driver);
        Node->IoctlReadRoutine = DosDriverDispatchIoctlRead;
        Node->ReadRoutine = DosDriverDispatchRead;
        Node->PeekRoutine = DosDriverDispatchPeek;
        Node->InputStatusRoutine = DosDriverDispatchInputStatus;
        Node->FlushInputRoutine = DosDriverDispatchFlushInput;
        Node->IoctlWriteRoutine = DosDriverDispatchIoctlWrite;
        Node->WriteRoutine = DosDriverDispatchWrite;
        Node->OutputStatusRoutine = DosDriverDispatchOutputStatus;
        Node->FlushOutputRoutine = DosDriverDispatchFlushOutput;
        Node->OpenRoutine = DosDriverDispatchOpen;
        Node->CloseRoutine = DosDriverDispatchClose;
        Node->OutputUntilBusyRoutine = DosDriverDispatchOutputUntilBusy;
    }
 
    return Node;
}

Referenced by DosCheckInput(), DosCloseHandle(), DosCopyHandleTable(), DosDeviceIoControl(), DosFlushFileBuffers(), DosGetDevice(), DosReadFile(), DosReadLineBuffered(), and DosWriteFile().

DosLoadDriver()

DWORD DosLoadDriver

(

LPCSTR

DriverFile

)

Definition at line 571 of file device.c.

{
    DWORD Result = ERROR_SUCCESS;
    HANDLE FileHandle = INVALID_HANDLE_VALUE, FileMapping = NULL;
    LPBYTE Address = NULL;
    DWORD Driver;
    PDOS_DRIVER DriverHeader;
    WORD Segment = 0;
    DWORD FileSize;
    DWORD DriversLoaded = 0;
    DOS_INIT_REQUEST Request;
    PDOS_DEVICE_NODE DeviceNode;
 
    /* Open a handle to the driver file */
    FileHandle = CreateFileA(DriverFile,
                             GENERIC_READ,
                             FILE_SHARE_READ,
                             NULL,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);
    if (FileHandle == INVALID_HANDLE_VALUE)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Get the file size */
    FileSize = GetFileSize(FileHandle, NULL);
 
    /* Allocate DOS memory for the driver */
    Segment = DosAllocateMemory(FileSize >> 4, NULL);
    if (Segment == 0)
    {
        Result = Sda->LastErrorCode;
        goto Cleanup;
    }
 
    /* Create a mapping object for the file */
    FileMapping = CreateFileMapping(FileHandle,
                                    NULL,
                                    PAGE_READONLY,
                                    0,
                                    0,
                                    NULL);
    if (FileMapping == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Map the file into memory */
    Address = (LPBYTE)MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 0);
    if (Address == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Copy the entire file to the DOS memory */
    Driver = MAKELONG(0, Segment);
    DriverHeader = (PDOS_DRIVER)FAR_POINTER(Driver);
    RtlCopyMemory(DriverHeader, Address, FileSize);
 
    /* Loop through all the drivers in this file */
    while (TRUE)
    {
        if (!(DriverHeader->DeviceAttributes & DOS_DEVATTR_CHARACTER))
        {
            DPRINT1("Error loading driver at %04X:%04X: "
                    "Block device drivers are not supported.\n",
                    HIWORD(Driver),
                    LOWORD(Driver));
            goto Next;
        }
 
        /* Send the driver an init request */
        RtlZeroMemory(&Request, sizeof(Request));
        Request.Header.RequestLength = sizeof(DOS_INIT_REQUEST);
        Request.Header.CommandCode = DOS_DEVCMD_INIT;
        // TODO: Set Request.DeviceString to the appropriate line in CONFIG.NT!
        DosCallDriver(Driver, &Request.Header);
 
        if (Request.Header.Status & DOS_DEVSTAT_ERROR)
        {
            DPRINT1("Error loading driver at %04X:%04X: "
                    "Initialization routine returned error %u.\n",
                    HIWORD(Driver),
                    LOWORD(Driver),
                    Request.Header.Status & 0x7F);
            goto Next;
        }
 
        /* Create the device node */
        DeviceNode = DosCreateDeviceNode(Driver);
        DeviceNode->IoctlReadRoutine = DosDriverDispatchIoctlRead;
        DeviceNode->ReadRoutine = DosDriverDispatchRead;
        DeviceNode->PeekRoutine = DosDriverDispatchPeek;
        DeviceNode->InputStatusRoutine = DosDriverDispatchInputStatus;
        DeviceNode->FlushInputRoutine = DosDriverDispatchFlushInput;
        DeviceNode->IoctlWriteRoutine = DosDriverDispatchIoctlWrite;
        DeviceNode->WriteRoutine = DosDriverDispatchWrite;
        DeviceNode->OutputStatusRoutine = DosDriverDispatchOutputStatus;
        DeviceNode->FlushOutputRoutine = DosDriverDispatchFlushOutput;
        DeviceNode->OpenRoutine = DosDriverDispatchOpen;
        DeviceNode->CloseRoutine = DosDriverDispatchClose;
        DeviceNode->OutputUntilBusyRoutine = DosDriverDispatchOutputUntilBusy;
 
        DosAddDriver(Driver);
        DriversLoaded++;
 
Next:
        if (LOWORD(DriverHeader->Link) == 0xFFFF) break;
        Driver = DriverHeader->Link;
        DriverHeader = (PDOS_DRIVER)FAR_POINTER(Driver);
    }
 
    DPRINT1("%u drivers loaded from %s.\n", DriversLoaded, DriverFile);
 
Cleanup:
    if (Result != ERROR_SUCCESS)
    {
        /* It was not successful, cleanup the DOS memory */
        if (Segment) DosFreeMemory(Segment);
    }
 
    /* Unmap the file */
    if (Address != NULL) UnmapViewOfFile(Address);
 
    /* Close the file mapping object */
    if (FileMapping != NULL) CloseHandle(FileMapping);
 
    /* Close the file handle */
    if (FileHandle != INVALID_HANDLE_VALUE) CloseHandle(FileHandle);
 
    return Result;
}