windows-xp/Source/XPSP1/NT/base/mvdm/vdmredir/vrdlc5c.c

/*++

Copyright (c) 1991  Microsoft Corporation
Copyright (c) 1991  Nokia Data Systems

Module Name:

    vrdlc5c.c

Abstract:

    This module handles DLC INT 5Ch calls from a VDM

    Contents:
        VrDlc5cHandler
        (ValidateDosAddress)
        (AutoOpenAdapter)
        (ProcessImmediateCommand)
        (MapDosCommandsToNt)
        CompleteCcbProcessing
        (InitializeAdapterSupport)
        (SaveExceptions)
        (RestoreExceptions)
        (CopyDosBuffersToDescriptorArray)
        (BufferCreate)
        (SetExceptionFlags)
        LlcCommand
        (OpenAdapter)
        (CloseAdapter)
        (OpenDirectStation)
        (CloseDirectStation)
        BufferFree
        (VrDlcInit)
        VrVdmWindowInit
        (GetAdapterType)
        (LoadDlcDll)
        TerminateDlcEmulation
        InitializeDlcWorkerThread
        VrDlcWorkerThread
        DlcCallWorker

Author:

    Antti Saarenheimo (o-anttis) 26-DEC-1991

Revision History:

    16-Jul-1992 Richard L Firth (rfirth)
        Rewrote large parts - separated functions into categories (complete
        in DLL, complete in driver, complete asynchronously); allocate NT
        CCBs for commands which complete asynchronously; fixed asynchronous
        processing; added extra debugging; condensed various per-adapter data
        structures into Adapters data structure; made processing closer to IBM
        LAN Tech. Ref. specification

--*/

#include <nt.h>
#include <ntrtl.h>      // ASSERT, DbgPrint
#include <nturtl.h>
#include <windows.h>
#include <softpc.h>     // x86 virtual machine definitions
#include <vrdlctab.h>
#include <vdmredir.h>
#include <smbgtpt.h>
#include <dlcapi.h>     // Official DLC API definition
#include <ntdddlc.h>    // IOCTL commands
#include <dlcio.h>      // Internal IOCTL API interface structures
#include <vrdefld.h>    // VDM_LOAD_INFO
#include "vrdlc.h"
#include "vrdebug.h"
#include "vrdlcdbg.h"

//
// defines
//

//
// for each DLC command, a flags byte in DlcFunctionalCharacteristics uses these
// bits to indicate properties of the command processing
//

#define POINTERS_IN_TABLE   0x01    // pointers in parameter table
#define OUTPUT_PARMS        0x02    // parameters returned from DLC
#define SECONDARY_TABLE     0x04    // parameter table has pointers to secondary table(s)
#define IMMEDIATE_COMMAND   0x20    // command executes without call to DLC DLL
#define SYNCHRONOUS_COMMAND 0x40    // command executes in workstation
#define UNSUPPORTED_COMMAND 0x80    // command is not supported in DOS DLC

//
// macros
//

//
// IS_IMMEDIATE_COMMAND - the following commands are those which complete
// 'immediately' - i.e. without having to submit the CCB to AcsLan or NtAcsLan.
// Immediate commands may read and write the parameter table though
//

#define IS_IMMEDIATE_COMMAND(c) (((c) == LLC_BUFFER_FREE)            || \
                                 ((c) == LLC_BUFFER_GET)             || \
                                 ((c) == LLC_DIR_INTERRUPT)          || \
                                 ((c) == LLC_DIR_MODIFY_OPEN_PARMS)  || \
                                 ((c) == LLC_DIR_RESTORE_OPEN_PARMS) || \
                                 ((c) == LLC_DIR_SET_USER_APPENDAGE)    \
                                 )

//
// private prototypes
//

LLC_STATUS
ValidateDosAddress(
    IN DOS_ADDRESS Address,
    IN WORD Size,
    IN LLC_STATUS ErrorCode
    );

LLC_STATUS
AutoOpenAdapter(
    IN UCHAR AdapterNumber
    );

LLC_STATUS
ProcessImmediateCommand(
    IN UCHAR AdapterNumber,
    IN UCHAR Command,
    IN LLC_DOS_PARMS UNALIGNED * pParms
    );

LLC_STATUS
MapDosCommandsToNt(
    IN PLLC_CCB pDosCcb,
    IN DOS_ADDRESS dpOriginalCcbAddress,
    OUT LLC_DOS_CCB UNALIGNED * pOutputCcb
    );

LLC_STATUS
InitializeAdapterSupport(
    IN UCHAR AdapterNumber,
    IN DOS_DLC_DIRECT_PARMS UNALIGNED * pDirectParms OPTIONAL
    );

VOID
SaveExceptions(
    IN UCHAR AdapterNumber,
    IN LPDWORD pulExceptionFlags
    );

LPDWORD
RestoreExceptions(
    IN UCHAR AdapterNumber
    );

LLC_STATUS
CopyDosBuffersToDescriptorArray(
    IN OUT PLLC_TRANSMIT_DESCRIPTOR pDescriptors,
    IN PLLC_XMIT_BUFFER pDlcBufferQueue,
    IN OUT LPDWORD pIndex
    );

LLC_STATUS
BufferCreate(
    IN UCHAR AdapterNumber,
    IN PVOID pVirtualMemoryBuffer,
    IN DWORD ulVirtualMemorySize,
    IN DWORD ulMinFreeSizeThreshold,
    OUT HANDLE* phBufferPoolHandle
    );

LLC_STATUS
SetExceptionFlags(
    IN UCHAR AdapterNumber,
    IN DWORD ulAdapterCheckFlag,
    IN DWORD ulNetworkStatusFlag,
    IN DWORD ulPcErrorFlag,
    IN DWORD ulSystemActionFlag
    );

LLC_STATUS
OpenAdapter(
    IN UCHAR AdapterNumber
    );

VOID
CloseAdapter(
    IN UCHAR AdapterNumber
    );

LLC_STATUS
OpenDirectStation(
    IN UCHAR AdapterNumber
    );

VOID
CloseDirectStation(
    IN UCHAR AdapterNumber
    );

LLC_STATUS
VrDlcInit(
    VOID
    );

ADAPTER_TYPE
GetAdapterType(
    IN UCHAR AdapterNumber
    );

BOOLEAN
LoadDlcDll(
    VOID
    );

BOOLEAN
InitializeDlcWorkerThread(
    VOID
    );

VOID
VrDlcWorkerThread(
    IN LPVOID Parameters
    );

LLC_STATUS
DlcCallWorker(
    PLLC_CCB pInputCcb,
    PLLC_CCB pOriginalCcb,
    PLLC_CCB pOutputCcb
    );

//
// public data
//

//
// lpVdmWindow is the flat 32-bit address of the VDM_REDIR_DOS_WINDOW structure
// in DOS memory (in the redir TSR)
//

LPVDM_REDIR_DOS_WINDOW lpVdmWindow = 0;

//
// dpVdmWindow is the DOS address (ssssoooo, s=segment, o=offset) of the
// VDM_REDIR_DOS_WINDOW structure in DOS memory (in the redir TSR)
//

DOS_ADDRESS dpVdmWindow = 0;

DWORD OpenedAdapters = 0;

//
// Adapters - for each adapter supported by DOS emulation (maximum 2 adapters -
// primary & secondary) there is a structure which maintains adapter specific
// information - like whether the adapter has been opened, etc.
//

DOS_ADAPTER Adapters[DOS_DLC_MAX_ADAPTERS];

//
// all functions in DLCAPI.DLL are now called indirected through function pointer
// create these typedefs to avoid compiler warnings
//

typedef ACSLAN_STATUS (*ACSLAN_FUNC_PTR)(IN OUT PLLC_CCB, OUT PLLC_CCB*);
ACSLAN_FUNC_PTR lpAcsLan;

typedef LLC_STATUS (*DLC_CALL_DRIVER_FUNC_PTR)(IN UINT, IN UINT, IN PVOID, IN UINT, OUT PVOID, IN UINT);
DLC_CALL_DRIVER_FUNC_PTR lpDlcCallDriver;

typedef LLC_STATUS (*NTACSLAN_FUNC_PTR)(IN PLLC_CCB, IN PVOID, OUT PLLC_CCB, IN HANDLE OPTIONAL);
NTACSLAN_FUNC_PTR lpNtAcsLan;

//
// private data
//

static LLC_EXTENDED_ADAPTER_PARMS DefaultExtendedParms = {
    NULL,                       // hBufferPool
    NULL,                       // pSecurityDescriptor
    LLC_ETHERNET_TYPE_DEFAULT   // LlcEthernetType
};

//
// DlcFunctionCharacteristics - for each DOS DLC command, tells us the size of
// the parameter table to copy and whether there are pointers in the parameter
// table. Segmented 16-bit pointers in the parameter table must be converted to
// flat 32-bit pointers. The Flags byte tells us - at a glance - the following:
//
//  - if this command is supported a) in DOS DLC, b) in our implementation
//  - if this command has parameters
//  - if there are (DOS) pointers in the parameter table
//  - if this command receives output parameters (ie written to parameter table)
//  - if the parameter table has secondary parameter tables (DIR.OPEN.ADAPTER)
//  - if this command is synchronous (ie does not return 0xFF)
//

struct {
    BYTE    ParamSize;  // no parameter tables >255 bytes long
    BYTE    Flags;
} DlcFunctionCharacteristics[] = {
    {0, IMMEDIATE_COMMAND},                         // 0x00, DIR.INTERRUPT
    {
        sizeof(LLC_DIR_MODIFY_OPEN_PARMS),
        IMMEDIATE_COMMAND
    },                                              // 0x01, DIR.MODIFY.OPEN.PARMS
    {0, IMMEDIATE_COMMAND},                         // 0x02, DIR.RESTORE.OPEN.PARMS
    {
        sizeof(LLC_DIR_OPEN_ADAPTER_PARMS),
        SYNCHRONOUS_COMMAND
        | SECONDARY_TABLE
        | OUTPUT_PARMS
        | POINTERS_IN_TABLE
    },                                              // 0x03, DIR.OPEN.ADAPTER
    {0, 0x00},                                      // 0x04, DIR.CLOSE.ADAPTER
    {0, UNSUPPORTED_COMMAND},                       // 0x05, ?
    {0, SYNCHRONOUS_COMMAND},                       // 0x06, DIR.SET.GROUP.ADDRESS
    {0, SYNCHRONOUS_COMMAND},                       // 0x07, DIR.SET.FUNCTIONAL.ADDRESS
    {0, SYNCHRONOUS_COMMAND},                       // 0x08, READ.LOG
    {0, UNSUPPORTED_COMMAND},                       // 0x09, NT: TRANSMIT.FRAME
    {
        sizeof(LLC_TRANSMIT_PARMS),
        POINTERS_IN_TABLE
    },                                              // 0x0a, TRANSMIT.DIR.FRAME
    {
        sizeof(LLC_TRANSMIT_PARMS),
        POINTERS_IN_TABLE
    },                                              // 0x0b, TRANSMIT.I.FRAME
    {0, UNSUPPORTED_COMMAND},                       // 0x0c, ?
    {sizeof(LLC_TRANSMIT_PARMS), POINTERS_IN_TABLE},// 0x0d, TRANSMIT.UI.FRAME
    {sizeof(LLC_TRANSMIT_PARMS), POINTERS_IN_TABLE},// 0x0e, TRANSMIT.XID.CMD
    {sizeof(LLC_TRANSMIT_PARMS), POINTERS_IN_TABLE},// 0x0f, TRANSMIT.XID.RESP.FINAL
    {sizeof(LLC_TRANSMIT_PARMS), POINTERS_IN_TABLE},// 0x10, TRANSMIT.XID.RESP.NOT.FINAL
    {sizeof(LLC_TRANSMIT_PARMS), POINTERS_IN_TABLE},// 0x11, TRANSMIT.TEST.CMD
    {0, UNSUPPORTED_COMMAND},                       // 0x12, ?
    {0, UNSUPPORTED_COMMAND},                       // 0x13, ?
    {0, 0x00},                                      // 0x14, DLC.RESET
    {
        sizeof(LLC_DLC_OPEN_SAP_PARMS),
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
        | POINTERS_IN_TABLE
    },                                              // 0x15, DLC.OPEN.SAP
    {0, 0x00},                                      // 0x16, DLC.CLOSE.SAP
    {0, SYNCHRONOUS_COMMAND},                       // 0x17, DLC_REALLOCATE
    {0, UNSUPPORTED_COMMAND},                       // 0x18, ?
    {
        sizeof(LLC_DLC_OPEN_STATION_PARMS),
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
        | POINTERS_IN_TABLE
    },                                              // 0x19, DLC.OPEN.STATION
    {0, 0x00},                                      // 0x1a, DLC.CLOSE.STATION
    {
        sizeof(LLC_DLC_CONNECT_PARMS),
        POINTERS_IN_TABLE
    },                                              // 0x1b, DLC.CONNECT.STATION
    {
        sizeof(LLC_DLC_MODIFY_PARMS),
        SYNCHRONOUS_COMMAND
        | POINTERS_IN_TABLE
    },                                              // 0x1c, DLC.MODIFY
    {0, SYNCHRONOUS_COMMAND},                       // 0x1d, DLC.FLOW.CONTROL
    {
        sizeof(LLC_DLC_STATISTICS_PARMS),
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
        | POINTERS_IN_TABLE
    },                                              // 0x1e, DLC.STATISTICS
    {0, UNSUPPORTED_COMMAND},                       // 0x1f, ?
    {
        sizeof(LLC_DOS_DIR_INITIALIZE_PARMS),
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
    },                                              // 0x20, DIR.INITIALIZE
    {
        sizeof(DOS_DIR_STATUS_PARMS) - 2,
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
        | POINTERS_IN_TABLE
    },                                              // 0x21, DIR.STATUS
    {0, 0x00},                                      // 0x22, DIR.TIMER.SET
    {0, SYNCHRONOUS_COMMAND},                       // 0x23, DIR.TIMER.CANCEL
    {0, UNSUPPORTED_COMMAND},                       // 0x24, PDT.TRACE.ON / DLC_TRACE_INITIALIZE
    {0, UNSUPPORTED_COMMAND},                       // 0x25, PDT.TRACE.OFF
    {
        sizeof(LLC_BUFFER_GET_PARMS),
        IMMEDIATE_COMMAND
        | OUTPUT_PARMS
    },                                              // 0x26, BUFFER.GET
    {
        sizeof(LLC_BUFFER_FREE_PARMS),
        IMMEDIATE_COMMAND
        | POINTERS_IN_TABLE
    },                                              // 0x27, BUFFER.FREE
    {sizeof(LLC_DOS_RECEIVE_PARMS), OUTPUT_PARMS},  // 0x28, RECEIVE
    {0, SYNCHRONOUS_COMMAND},                       // 0x29, RECEIVE.CANCEL
    {
        sizeof(LLC_DOS_RECEIVE_MODIFY_PARMS),
        SYNCHRONOUS_COMMAND
        | OUTPUT_PARMS
    },                                              // 0x2a, RECEIVE.MODIFY
    {0, UNSUPPORTED_COMMAND},                       // 0x2b, DIR.DEFINE.MIF.ENVIRONMENT
    {0, SYNCHRONOUS_COMMAND},                       // 0x2c, DLC.TIMER.CANCEL.GROUP
    {
        sizeof(LLC_DIR_SET_EFLAG_PARMS),
        IMMEDIATE_COMMAND
    }                                               // 0x2d, DIR.SET.USER.APPENDAGE
};

//
// routines
//


VOID
VrDlc5cHandler(
    VOID
    )

/*++

Routine Description:

    Receives control from the INT 5Ch BOP provided by the DOS redir TSR. The
    DLC calls can be subdivided into the following categories:

        * complete within this translation layer
        * complete synchronously in a call to AcsLan
        * complete asynchronously after calling AcsLan

    The latter type complete when a READ (which we submit when the adapter is
    opened) completes. Control transfers to an ISR in the DOS redir TSR via
    the EventHandlerThread (in vrdlcpst.c)

    The calls can be further subdivided:

        * calls which return parameters in the parameter table
        * calls which do not return parameters in the parameter table

    For the former type of call, we have to copy the parameter table from
    DOS memory and copy the returned parameters back to DOS memory

    With the exception of a few DLC commands, we assume that the parameter
    tables are exactly the same size between DOS and NT, even if the don't
    contain exactly the same information

Arguments:

    None.

Return Value:

    None, LLC_STATUS is return in AL register.

--*/

{
    LLC_CCB ccb;    // should be NT CCB for NtAcsLan
    LLC_PARMS parms;
    LLC_DOS_CCB UNALIGNED * pOutputCcb;
    LLC_DOS_PARMS UNALIGNED * pDosParms;
    DOS_ADDRESS dpOriginalCcbAddress;
    BOOLEAN parmsCopied;
    WORD paramSize;
    LLC_STATUS status;
    UCHAR command;
    UCHAR adapter;
    BYTE functionFlags;

    static BOOLEAN IsDlcDllLoaded = FALSE;

    IF_DEBUG(DLC) {
        DPUT("VrDlc5cHandler entered\n");
    }

    //
    // DLCAPI.DLL is now dynamically loaded
    //

    if (!IsDlcDllLoaded) {
        if (!LoadDlcDll()) {
            setAL(LLC_STATUS_COMMAND_CANCELLED_FAILURE);
            return;
        } else {
            IsDlcDllLoaded = TRUE;
        }
    }

    //
    // dpOriginalCcbAddress is the segmented 16-bit address stored as a DWORD
    // eg. a CCB1 address of 1234:abcd gets stored as 0x1234abcd. This will
    // be used in asynchronous command completion to get back the address of
    // the original DOS CCB
    //

    dpOriginalCcbAddress = (DOS_ADDRESS)MAKE_DWORD(getES(), getBX());

    //
    // pOutputCcb is the flat 32-bit address of the DOS CCB. We can use this
    // to read and write byte fields only (unaligned)
    //

    pOutputCcb = POINTER_FROM_WORDS(getES(), getBX());
    pOutputCcb->uchDlcStatus = (UCHAR)LLC_STATUS_PENDING;

    //
    // zero the CCB_POINTER (pNext) field. CCB1 cannot have chained CCBs on
    // input: this is just for returning (cancelled) pending CCBs. If we don't
    // zero it & the app leaves garbage there, then NtAcsLan can think it is
    // a pointer to a chain of CCBs (CCB2 can be chained), which is bogus
    //

    WRITE_DWORD(&pOutputCcb->pNext, 0);

    IF_DEBUG(CRITICAL) {
        CRITDUMP(("INPUT CCB @%04x:%04x command=%02x\n", getES(), getBX(), pOutputCcb->uchDlcCommand));
    }

    IF_DEBUG(DOS_CCB_IN) {

        //
        // dump the input CCB1 - gives us an opportunity to check out what
        // the DOS app is sending us, even if its garbage
        //

        DUMPCCB(pOutputCcb,
                TRUE,                           // DumpAll
                TRUE,                           // CcbIsInput
                TRUE,                           // IsDos
                HIWORD(dpOriginalCcbAddress),   // segment
                LOWORD(dpOriginalCcbAddress)    // offset
                );
    }

    //
    // first check that the adapter is 0 or 1 - DOS only supports 2 adapters -
    // and check that the request code in the CCB is not off the end of our
    // table. Unsupported requests will be filtered out in the BIG switch
    // statement below
    //

    adapter = pOutputCcb->uchAdapterNumber;
    command = pOutputCcb->uchDlcCommand;

    if (adapter >= DOS_DLC_MAX_ADAPTERS) {

        //
        // adapter is not 0 or 1 - return 0x1D
        //

        status = LLC_STATUS_INVALID_ADAPTER;
        pOutputCcb->uchDlcStatus = (UCHAR)status;
    } else if (command > LAST_ELEMENT(DlcFunctionCharacteristics)) {

        //
        // command is off end of supported list - return 0x01
        //

        status = LLC_STATUS_INVALID_COMMAND;
        pOutputCcb->uchDlcStatus = (UCHAR)status;
    } else {

        //
        // the command is in range. Get the parameter table size and flags from
        // the function characteristics array
        //

        functionFlags = DlcFunctionCharacteristics[command].Flags;
        paramSize = DlcFunctionCharacteristics[command].ParamSize;

        //
        // if we don't support this command, return an error
        //

        status = LLC_STATUS_SUCCESS;
        if (functionFlags & UNSUPPORTED_COMMAND) {
            status = LLC_STATUS_INVALID_COMMAND;
            pOutputCcb->uchDlcStatus = LLC_STATUS_INVALID_COMMAND;
        } else {

            //
            // command is supported. If it has a parameter table, check that
            // the address is in range for 0x1B error check
            //

            if (paramSize) {
                status = ValidateDosAddress((DOS_ADDRESS)(pOutputCcb->u.pParms),
                                            paramSize,
                                            LLC_STATUS_INVALID_PARAMETER_TABLE
                                            );
            }

            //
            // we allow the adapter to be opened as a consequence of another
            // request since DOS apps could assume that the adapter has already
            // been opened (by NetBIOS). If the command is DIR.OPEN.ADAPTER or
            // DIR.CLOSE.ADAPTER then let it go through
            //

            if (status == LLC_STATUS_SUCCESS
            && !Adapters[adapter].IsOpen
            && !(command == LLC_DIR_OPEN_ADAPTER || command == LLC_DIR_CLOSE_ADAPTER)) {
                status = AutoOpenAdapter(adapter);
            } else {
                status = LLC_STATUS_SUCCESS;
            }
        }

        //
        // if we have a valid command, an ok-looking parameter table pointer
        // and an open adapter (or a command which will open or close it) then
        // process the command
        //

        if (status == LLC_STATUS_SUCCESS) {

            //
            // get a 32-bit pointer to the DOS parameter table. This may be
            // an unaligned address!
            //

            pDosParms = READ_FAR_POINTER(&pOutputCcb->u.pParms);

            //
            // the CCB commands are subdivided into those which do not need the
            // CCB to be mapped from DOS memory to NT memory and which complete
            // 'immediately' in this DLL, and those which must be mapped from
            // DOS to NT and which may complete synchronously or asynchronously
            //

            if (functionFlags & IMMEDIATE_COMMAND) {

                IF_DEBUG(DLC) {
                    DPUT("VrDlc5cHandler: request is IMMEDIATE command\n");
                }

                status = ProcessImmediateCommand(adapter, command, pDosParms);

                //
                // the following is safe - it is a single byte write
                //

                pOutputCcb->uchDlcStatus = (char)status;

                //
                // the 'immediate' case is now complete, and control can be
                // returned to the VDM
                //

            } else {

                //
                // the CCB is not one which can be completed immediately. We
                // have to copy (and align) the DOS CCB (and the parameter
                // table, if there is one) into 32-bit address space.
                // Note that since we are going to call AcsLan or NtAcsLan
                // with this CCB then we supply the correct CCB format - 2,
                // not 1 as it was previously. However, handing in a CCB1
                // didn't *seem* to cause any problems (yet)
                //

                RtlCopyMemory(&ccb, pOutputCcb, sizeof(*pOutputCcb));

                //
                // zero the unused fields
                //

                ccb.hCompletionEvent = 0;
                ccb.uchReserved2 = 0;
                ccb.uchReadFlag = 0;
                ccb.usReserved3 = 0;

                parmsCopied = FALSE;
                if (paramSize) {

                    //
                    // if the parameter table contains (segmented) pointers
                    // (which we need to convert to flat-32 bit pointers) OR
                    // the parameter table is not DWORD aligned, copy the whole
                    // parameter table to 32-bit memory . If we need to modify
                    // pointers, do it in the specific case in the switch
                    // statement in MapDosCommandsToNt
                    //
                    // Note: DIR.OPEN.ADAPTER is a special case because its
                    // parameter table just points to 4 other parameter tables.
                    // We take care of this in MapDosCommandsToNt and
                    // CompleteCcbProcessing
                    //

                    if ((functionFlags & POINTERS_IN_TABLE)) {
                        RtlCopyMemory(&parms, pDosParms, paramSize);
                        ccb.u.pParameterTable = &parms;
                        parmsCopied = TRUE;
                    } else {

                        //
                        // didn't need to copy parameter table - leave it in
                        // DOS memory. It is safe to read & write this table
                        //

                        ccb.u.pParameterTable = (PLLC_PARMS)pDosParms;
                    }
                }

                //
                // submit the synchronous/asynchronous CCB for processing
                //

                status = MapDosCommandsToNt(&ccb, dpOriginalCcbAddress, pOutputCcb);
                if (status == STATUS_PENDING) {
                    status = LLC_STATUS_PENDING;
                }

                IF_DEBUG(CRITICAL) {
                    CRITDUMP(("CCB submitted: returns %02x\n", status));
                }

                IF_DEBUG(DLC) {
                    DPUT2("VrDlc5cHandler: MapDosCommandsToNt returns %#x (%d)\n", status, status);
                }

                //
                // if status is not LLC_STATUS_PENDING then the CCB completed
                // synchronously. We can complete the processing here
                //

                if (status != LLC_STATUS_PENDING) {
                    if ((functionFlags & OUTPUT_PARMS) && parmsCopied) {

                        //
                        // if there are no pointers in the parameter table then
                        // we can simply copy the 32-bit parameters to 16-bit
                        // memory. If there are pointers, then they will be in
                        // an incorrect format for DOS. We must update these
                        // parameter tables individually
                        //

                        if (!(functionFlags & POINTERS_IN_TABLE)) {
                            RtlCopyMemory(pDosParms, &parms, paramSize);
                        } else {
                            CompleteCcbProcessing(status, pOutputCcb, &parms);
                        }
                    }

                    //
                    // set the CCB status. It will be marked as PENDING if
                    // LLC_STATUS_PENDING returned from MapDosCommandsToNt
                    //

                    pOutputCcb->uchDlcStatus = (UCHAR)status;
                }
            }
        } else {
            pOutputCcb->uchDlcStatus = (UCHAR)status;
        }
    }

    //
    // return the DLC status in AL
    //

    setAL((UCHAR)status);

#if DBG
    IF_DEBUG(DOS_CCB_OUT) {

        DPUT2("VrDlc5cHandler: returning AL=%02x CCB.RETCODE=%02x\n",
                status,
                pOutputCcb->uchDlcStatus
                );

        //
        // dump the CCB being returned to the DOS app
        //

        DumpCcb(pOutputCcb,
                TRUE,                           // DumpAll
                FALSE,                          // CcbIsInput
                TRUE,                           // IsDos
                HIWORD(dpOriginalCcbAddress),   // segment
                LOWORD(dpOriginalCcbAddress)    // offset
                );
    }

    //
    // make sure (in debug version) that the error code being returned is valid
    // for this particular command. Doesn't necessarily mean the return code is
    // semantically correct, just that it belongs to the set of allowed DLC
    // return codes for the DLC command being processed
    //

    IF_DEBUG(DLC) {
        if (!IsCcbErrorCodeAllowable(pOutputCcb->uchDlcCommand, pOutputCcb->uchDlcStatus)) {
            DPUT2("Returning bad error code: Command=%02x, Retcode=%02x\n",
                    pOutputCcb->uchDlcCommand,
                    pOutputCcb->uchDlcStatus
                    );
            DEBUG_BREAK();
        }
    }
#endif
}


LLC_STATUS
ValidateDosAddress(
    IN DOS_ADDRESS Address,
    IN WORD Size,
    IN LLC_STATUS ErrorCode
    )

/*++

Routine Description:

    IBM DLC performs some checking of pointers - if the address points into
    the IVT or is close enough to the end of a segment that the address would
    wrap then we return an error

    This is a useless test, but we do it for compatibility (just in case an
    app tests for the specific error code). There are a million other addresses
    in DOS memory that need to be checked. The tests in this routine will only
    protect against scribbling over the interrupt vectors, but would allow e.g.
    scribbling over DOS's code segment

Arguments:

    Address     - DOS address to check (ssssoooo, s=segment, o=offset)
    Size        - word size of structure at Address
    ErrorCode   - which error code to return. This function called to validate
                  A) the parameter table pointer, in which case the error code
                  to return is LLC_STATUS_INVALID_PARAMETER_TABLE (0x1B) or
                  B) pointers within the parameter table, in which case the
                  error to return is LLC_STATUS_INVALID_POINTER_IN_CCB (0x1C)

Return Value:

    LLC_STATUS

--*/

{
    //
    // convert segment:offset into 20-bit real-mode linear address
    //

    DWORD linearAddress = HIWORD(Address) * 16 + LOWORD(Address);

    //
    // the Interrupt Vector Table (IVT) in real-mode occupies addresses 0
    // through 400h
    //

    if ((linearAddress < 0x400L) || (((DWORD)LOWORD(Address) + Size) < (DWORD)LOWORD(Address))) {
        return ErrorCode;
    }
    return LLC_STATUS_SUCCESS;
}


LLC_STATUS
AutoOpenAdapter(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Opens the adapter as a consequence of a request other than DIR.OPEN.ADAPTER

Arguments:

    AdapterNumber - which adapter to open

Return Value:

    LLC_STATUS
        Success - LLC_STATUS_SUCCESS
        Failure -

--*/

{
    LLC_STATUS status;

    //
    // Any DLC command except DIR.OPEN.ADAPTER or DIR.INITIALIZE automatically
    // opens the adapter. There are three reasons to do this:
    //
    //  1. DIR.STATUS command can be issued before DIR.OPEN.ADAPTER in DOS.
    //     In Windows/Nt this is not possible. Therefore, DIR.STATUS should
    //     open the adapter
    //
    //  2. An application may assume that the adapter is always opened
    //     by NetBIOS and that it can't open the adapter itself if it
    //     has already been opened
    //
    //  3. A DOS DLC application may initialize (= hw reset) a closed
    //     adapter before the open and that takes 5 - 10 seconds.
    //

    IF_DEBUG(DLC) {
        DPUT1("AutoOpenAdapter: automatically opening adapter %d\n", AdapterNumber);
    }

    status = OpenAdapter(AdapterNumber);
    if (status == LLC_STATUS_SUCCESS) {

        //
        // initialize the buffer pool for the direct station on this
        // adapter. If this succeeds, open the direct station. If that
        // succeeds, preset the ADAPTER_PARMS and DLC_PARMS structures
        // in the DOS_ADAPTER with default values
        //

        status = InitializeAdapterSupport(AdapterNumber, NULL);
        if (status == LLC_STATUS_SUCCESS) {
            status = OpenDirectStation(AdapterNumber);
            if (status == LLC_STATUS_SUCCESS) {

            }
        }

        if (status != LLC_STATUS_SUCCESS) {

            IF_DEBUG(DLC) {
                DPUT("AutoOpenAdapter: InitializeAdapterSupport failed\n");
            }

        }
    } else {

        IF_DEBUG(DLC) {
            DPUT("AutoOpenAdapter: auto open adapter failed\n");
        }

    }

    return status;
}


LLC_STATUS
ProcessImmediateCommand(
    IN UCHAR AdapterNumber,
    IN UCHAR Command,
    IN LLC_DOS_PARMS UNALIGNED * pParms
    )

/*++

Routine Description:

    Processes CCB requests which complete 'immediately'. An immediate completion
    is one where the CCB does not have to be submitted to the DLC driver. There
    may be other calls to the driver as a consequence of the immediate command,
    but the CCB itself is not submitted. Immediate command completion requires
    the parameter table only. We may return parameters into the DOS parameter
    table

Arguments:

    AdapterNumber   - which adapter to process command for
    Command         - command to process
    pParms          - pointer to parameter table (in DOS memory)

Return Value:

    LLC_STATUS
        Completion status of the 'immediate' command

--*/

{
    LLC_STATUS status;
    WORD cBuffersLeft;
    WORD stationId;
    DPLLC_DOS_BUFFER buffer;

    switch (Command) {
    case LLC_BUFFER_FREE:

        IF_DEBUG(DLC) {
            DPUT("LLC_BUFFER_FREE\n");
        }

        //
        // if the FIRST_BUFFER field is 0:0 then this request returns success
        //

        buffer = (DPLLC_DOS_BUFFER)READ_DWORD(&pParms->BufferFree.pFirstBuffer);
        if (!buffer) {
            status = LLC_STATUS_SUCCESS;
            break;
        }

        //
        // Windows/Nt doesn't need station id for buffer pool operation =>
        // thus the field is reserved
        //

        stationId = READ_WORD(&pParms->BufferFree.usReserved1);
        status = FreeBuffers(GET_POOL_INDEX(AdapterNumber, stationId),
                             buffer,
                             &cBuffersLeft
                             );

        IF_DEBUG(CRITICAL) {
            CRITDUMP(("LLC_BUFFER_FREE: %d\n", status));
        }

        if (status == LLC_STATUS_SUCCESS) {

            //
            // write the number of buffers left to the parameter table using
            // WRITE_WORD macro, since the table may not be aligned on a WORD
            // boundary
            //

            WRITE_WORD(&pParms->BufferFree.cBuffersLeft, cBuffersLeft);

            //
            // p3-4 of the IBM LAN Tech. Ref. states that the FIRST_BUFFER
            // field will be set to zero when the request is completed
            //

            WRITE_DWORD(&pParms->BufferFree.pFirstBuffer, 0);

            //
            // note that a successful BUFFER.FREE has been executed for this
            // adapter
            //

            Adapters[AdapterNumber].BufferFree = TRUE;

            //
            // perform half of the local-busy reset processing. This only has
            // an effect if the link is in emulated local-busy(buffer) state.
            // This is required because we need 2 events to get us out of local
            // busy buffer state - a BUFFER.FREE and a DLC.FLOW.CONTROL command
            // Apps don't always issue these in the correct sequence
            //

            ResetEmulatedLocalBusyState(AdapterNumber, stationId, LLC_BUFFER_FREE);

            //
            // this here because Extra! for Windows gets its state machine in a
            // knot if we go buffer busy too quickly after a flow control
            //

            if (AllBuffersInPool(GET_POOL_INDEX(AdapterNumber, stationId))) {
                ResetEmulatedLocalBusyState(AdapterNumber, stationId, LLC_DLC_FLOW_CONTROL);
            }
        }
        break;

    case LLC_BUFFER_GET:

        IF_DEBUG(DLC) {
            DPUT("LLC_BUFFER_GET\n");
        }

        status = GetBuffers(
                    GET_POOL_INDEX(AdapterNumber, READ_WORD(&pParms->BufferGet.usReserved1)),
                    READ_WORD(&pParms->BufferGet.cBuffersToGet),
                    &buffer,
                    &cBuffersLeft,
                    FALSE,
                    NULL
                    );

        //
        // if GetBuffers fails, buffer is returned as 0
        //

        WRITE_WORD(&pParms->BufferGet.cBuffersLeft, cBuffersLeft);
        WRITE_DWORD(&pParms->BufferGet.pFirstBuffer, buffer);
        break;

    case LLC_DIR_INTERRUPT:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_INTERRUPT\n");
        }

        //
        // We may consider, that the adapter is always initialized!
        // I hope, that the apps doesn't use an appendage routine
        // in DIR_INTERRUPT, because it would be very difficult to
        // call from here.
        //

        status = LLC_STATUS_SUCCESS;
        break;

    case LLC_DIR_MODIFY_OPEN_PARMS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_MODIFY_OPEN_PARMS\n");
        }

        //
        // this command is rejected if a BUFFER.FREE has been issued for this
        // adapter or there is a RECEIVE active at the direct interface
        //

        if (Adapters[AdapterNumber].BufferFree || Adapters[AdapterNumber].DirectReceive) {

            //
            // BUGBUG - this can't be correct error code. Check what is
            //          returned by IBM DOS DLC stack
            //

            status = LLC_STATUS_INVALID_COMMAND;
        } else if (Adapters[AdapterNumber].WaitingRestore) {

            //
            // BUGBUG - this can't be correct error code. Check what is
            //          returned by IBM DOS DLC stack
            //

            status = LLC_STATUS_INVALID_COMMAND;
        } else {

            //
            // Create a buffer pool, if there are no buffers in
            // the current one, set the exception flags (or dos appendage
            // routines), if the operation was success
            //

            status = CreateBufferPool(
                        (DWORD)GET_POOL_INDEX(AdapterNumber, 0),
                        (DOS_ADDRESS)READ_DWORD(&pParms->DirModifyOpenParms.dpPoolAddress),
                        READ_WORD(&pParms->DirModifyOpenParms.cPoolBlocks),
                        READ_WORD(&pParms->DirModifyOpenParms.usBufferSize)
                        );

            if (status == LLC_STATUS_SUCCESS) {

                //
                // SaveExceptions uses RtlCopyMemory, so its okay to pass in a possibly
                // unaligned pointer to the exception handlers
                //

                SaveExceptions(AdapterNumber,
                    (LPDWORD)&pParms->DirModifyOpenParms.dpAdapterCheckExit
                    );

                //
                // set the exception handlers as the exception flags in the
                // DLC driver
                //

                status = SetExceptionFlags(
                            AdapterNumber,
                            READ_DWORD(&pParms->DirModifyOpenParms.dpAdapterCheckExit),
                            READ_DWORD(&pParms->DirModifyOpenParms.dpNetworkStatusExit),
                            READ_DWORD(&pParms->DirModifyOpenParms.dpPcErrorExit),
                            0
                            );
            }

            //
            // mark this adapter as waiting for a DIR.RESTORE.OPEN.PARMS before
            // we can process the next DIR.MODIFY.OPEN.PARMS
            //

            if (status == LLC_STATUS_SUCCESS) {
                Adapters[AdapterNumber].WaitingRestore = TRUE;
            }
        }
        break;

    case LLC_DIR_RESTORE_OPEN_PARMS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_RESTORE_OPEN_PARMS\n");
        }

        //
        // if a DIR.MODIFY.OPEN.PARMS has not been successfully processed for
        // this adapter then return an error
        //

        if (!Adapters[AdapterNumber].WaitingRestore) {
            status = LLC_STATUS_INVALID_OPTION;
        } else {

            //
            // Delete the current buffer pool and restore the previous exception
            // handlers
            //

            DeleteBufferPool(GET_POOL_INDEX(AdapterNumber, 0));
            pParms = (PLLC_DOS_PARMS)RestoreExceptions(AdapterNumber);
            status = SetExceptionFlags(
                        AdapterNumber,
                        READ_DWORD(&pParms->DirSetExceptionFlags.ulAdapterCheckFlag),
                        READ_DWORD(&pParms->DirSetExceptionFlags.ulNetworkStatusFlag),
                        READ_DWORD(&pParms->DirSetExceptionFlags.ulPcErrorFlag),
                        0
                        );

            //
            // if the restore succeeded, mark this adapter as able to accept
            // the next DIR.MODIFY.OPEN.PARMS request
            //

            if (status == LLC_STATUS_SUCCESS) {
                Adapters[AdapterNumber].WaitingRestore = FALSE;
            }
        }
        break;

    case LLC_DIR_SET_USER_APPENDAGE:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_SET_USER_APPENDAGE\n");
        }

        if (pParms == NULL) {
            pParms = (PLLC_DOS_PARMS)RestoreExceptions(AdapterNumber);
        } else {
            SaveExceptions(AdapterNumber, (LPDWORD)&pParms->DirSetUserAppendage);
        }
        status = SetExceptionFlags(
                    AdapterNumber,
                    READ_DWORD(&pParms->DirSetUserAppendage.dpAdapterCheckExit),
                    READ_DWORD(&pParms->DirSetUserAppendage.dpNetworkStatusExit),
                    READ_DWORD(&pParms->DirSetUserAppendage.dpPcErrorExit),
                    0
                    );
        break;

#if DBG
    default:
        DPUT1("ProcessImmediateCommand: Error: Command is NOT immediate (%x)\n", Command);
        DbgBreakPoint();
#endif

    }

    return status;
}


LLC_STATUS
MapDosCommandsToNt(
    IN PLLC_CCB pDosCcb,
    IN DOS_ADDRESS dpOriginalCcbAddress,
    OUT LLC_DOS_CCB UNALIGNED * pOutputCcb
    )

/*++

Routine Description:

    This function handles DOS CCBs which must be submitted to the DLC driver.
    The CCBs may complete synchronously - i.e. the DLC driver returns a
    success or failure indication, or they complete asyncronously - i.e. the
    DLC driver returns a pending status.

    This function processes CCBs which may have parameter tables. The parameter
    tables will have been mapped to 32-bit memory unless they are already aligned
    on a DWORD boundary

Architecture
------------

    There is a major difference in the adapter initialization between DOS and
    NT (or OS/2) DLC applications.  A DOS DLC application could assume that
    the adapter is always open (opened by NetBIOS).  It might directly check
    the type of adapter with DIR.STATUS command, open SAP stations and setup
    a link session to a host. Usually a DOS app uses DIR.INTERRUPT to check if
    the adapter is already initialized.  There are also commands to redefine
    new parameters for the direct interface and restore the old ones when the
    application completes.  Only one application may be simultaneously using
    the direct station or a SAP.

    In Windows/NT each DLC application is a process having its own separate
    virtual image of the DLC interface. They must first make a logical open for
    the adapter to access DLC services and close the adapter when they are
    terminating. Process exit automatically closes any open DLC objects.

    A Windows/NT MVDM process does not allocate any DLC resources until it
    issues the first DLC command, which opens the adapter and initializes its
    buffer pool.


DLC Commands Different In Windows/NT And DOS
--------------------------------------------

    BUFFER.FREE, BUFFER.GET
     -  separate buffer pools ...

    DIR.DEFINE.MIF.ENVIRONMENT
     -  not supported, a special api for
        IBM Netbios running on DLC.

    DIR.INITIALIZE
     -  We will always return OK status from DIR.INITIALIZE: the app should not
        call this very often. We don't need to care about the exception handlers
        set in DIR.INITIALIZE, because they are never used. DOS DLC and OS/2 DLC
        states can be mapped thus:

            DOS DLC             OS/2 DLC
            ----------------------------
            uninitialized       Closed
            Initialized         Closed
            Open                Open

        DIR.OPEN.ADAPTER defines new exception handlers, thus the values
        set by DIR.INITIALIZE are valid only when the adapter is closed.
        Therefore, nothing untoward can happen if we just ignore them

    DIR.INTERRUPT
     -  This command opens the adapter, if it has not yet been opened
        and returns the successful status.

    DIR.MODIFY.OPEN.PARMS
     -  Defines buffers pool for the direct station, if it was not defined
        in DIR.OPEN.ADAPTER, and defines DLC exception handlers.

    DIR.OPEN.ADAPTER
     -  Can be executed only immediately after DIR.CLOSE.ADAPTER
        and DIR.INITIALIZE. We must support the special DOS Direct Open Parms.

    DIR.OPEN.DIRECT, DIR.CLOSE.DIRECT
     -  Not supported for DOS

    DIR.SET.USER.APPENDAGE == DIR.SET.EXCEPTION.FLAGS (- system action flag)
     -  This is just one of those many functions to set the exception handlers
        for DOS DLC (you may set them when adapter is opened, you may set
        them when adapter is closed, you may restore the old values and
        set the new values if the buffer pool was uninitialized or if they
        were restored ... (I become crazy)

    DIR.STATUS
     -  (We must fill MicroCodeLevel with a sensible string and set
        AdapterConfigAddress to point a some constant code in DOS
        DLC handler) Not yet implemented!!!
     -  DOS DLC stub code should hook the timer tick interrupt and
        update the timer counter.
     -  We must also set the correct adapter data rate in AdapterConfig
        (this should be done by the DLC driver!).
     -  We must convert the Nt (and OS/2) adapter type to a DOS type
        (ethernet have a different value in IBM DOS and OS/2 DLC
        implementations)

    PDT.TRACE.ON, PDT.TRACE.OFF
     -  Not Supported

    RECEIVE.MODIFY
     -  This function is not supported in the first implementation,
        Richard may have to do this later, if a DOS DLC application
        uses the function.

    RECEIVE
     -  DOS uses shorter RECEIVE parameter table, than NT (or OS/2).
        Thus we cannot directly use DOS CCBs.  We also need the pointer
        of the original receive CCB and the DOS receive appendage is called.
        On the other hand, the only original CCB can be linked to the
        other CCBs (using the original DOS pointer).
        Solution:
        The Input CCB and its parameter table are always allocated from the
        stack. Output CCB is the original DOS CCB mapped to 32-bit address space.
        The receive flag in the input CCB parameter table is the output CCB
        pointer.  The actual receive data appendage can be read from
        the output CCB. DOS DLC driver completes and links the receive CCB
        correctly, because we use the original receive CCB as an output buffer
        and DOS CCB address.
        This method would not work if we had to receive any parameters
        to the parameter table (actually we could get it to work by
        calling directly DLC driver with a correct parameter table address
        in the CCB structure of the input parameter block. The actual
        input parameters would be modified (receive data appendage)).


Adapter Exception Handlers
--------------------------

    The exception handler setting and resetting is very confusing in DOS DLC,
    but the main idea seems to be this: a temporary DOS DLC application must
    restore the exception handlers set by a TSR, because otherwise the next
    network exception would call the random memory.  On the other hand, a newer
    TSR may always overwrite the previous exception handlers (because it never
    restores the old values).  We may assume, that any DOS DLC application
    process resets its exception handlers and restores the original addresses.
    Solution: we have two tables, both initially reset: any set operation
    copies first table 1 to table 2 and saves the new values back to table 1.
    A restore operation copies table 2 back to table 1 and sets its values to DLC.
    We don't make any difference between set/reset by DIR.SET.USER.APPENDAGE or
    doing the same operation with DIR.MODIFY.OPEN.PARMS and DIR.RESTORE.OPEN.PARMS.
    We don't try to save the buffer pool definitions, because it is unnecessary.


DLC Status
----------

    A DOS DLC status indication returns a pointer to a link specific DLC
    status table.  DOS DLC application may keep this pointer and use it
    later for example to find the remote node address and SAP (not very likely).
    On the other hand, the link may expect the status table to be stable
    until another DOS task (eg. from timer tick) has responded to it.
    If we used only one status table for all links, a new overwrite the old
    status, because it has been handled by DOS.
    For example, losing a local buffer busy indication would hang up the link
    station permamently. Thus we cannot use just one link status table.
    Allocating 20 bytes for each 2 * 255 link station would take 10 kB
    DOS memory.  Limiting the number of available link stations would
    be also too painful to implement and manage by installation program.
    Thus we will implement a compromise:
        1. We allocate 5 permanent DLC status tables for the first link stations
           on both adapters.
        2. All other link stations (on both adapters) share the last
           5 status tables

    => We need to allocate only 300 bytes DOS memory for the DLC status tables.
    This will not work, if a DOS application assumes having permanent pointers
    to status tables and uses more than 5 DLC sessions for an adapter or
    if an application has again over 5 link stations on an adapter and
    it gets very rapidily more than 5 DLC status indications (it may lose
    the first DLC indications).

    Actually this should work quite well, because DLC applications should
    save (by copying) the DLC status in the DLC status appendage routine,
    because a new DLC status indication for the same adapter could overwrite
    the previous status.

Arguments:

    pDosCcb             - aligned DOS DLC Command control block (NT CCB)
    dpOriginalCcbAddress- the original
    pOutputCcb          - the original DLC Command control block

Return Value:

    LLC_STATUS

--*/

{
    UCHAR adapter = pDosCcb->uchAdapterNumber;
    UCHAR command = pDosCcb->uchDlcCommand;
    DWORD InputBufferSize;
    UCHAR FrameType;
    DWORD cElement;
    DWORD i;
    PLLC_CCB pNewCcb;
    LLC_STATUS Status;
    NT_DLC_PARMS NtDlcParms;
    LLC_DOS_PARMS UNALIGNED * pParms = (PLLC_DOS_PARMS)pDosCcb->u.pParameterTable;
    PDOS_DLC_DIRECT_PARMS pDirectParms;
    PLLC_PARMS pNtParms;

    //
    // adapterOpenParms and dlcParms are used to take the place of the DOS
    // ADAPTER_PARMS and DLC_PARMS structures in DIR.OPEN.ADAPTER
    //

    LLC_ADAPTER_OPEN_PARMS adapterParms;
    LLC_DLC_PARMS dlcParms;
    DWORD groupAddress;
    DWORD functionalAddress;

    IF_DEBUG(DLC) {
        DPUT("MapDosCommandsToNt\n");
    }

    //
    // check that the command code in the CCB is a valid CCB1 command - this
    // will error if its one of the disallowed OS/2 (CCB2) commands or an
    // unsupported DOS (CCB1) command (eg PDT.TRACE.ON)
    //

    CHECK_CCB_COMMAND(pDosCcb);

    //
    // preset the CCB to PENDING
    //

    pOutputCcb->uchDlcStatus = (UCHAR)LLC_STATUS_PENDING;

    //
    // This large switch statement will convert individual DOS format parameter
    // tables to NT format. Functions that can be handled entirely in VdmRedir
    // return early, else we need to make a call into DlcApi (AcsLan or NtAcsLan)
    //
    // We must convert all 16:16 DOS pointers to flat 32-bit pointers.
    // We must copy all changed data structures (that includes pointers)
    // to stack, because we don't want to change them back, when
    // the command completes.  All transmit commands are changed to
    // the new generic transmit.
    //

    switch (command) {
    default:

        IF_DEBUG(DLC) {
            DPUT("*** Shouldn't be here - this command should be caught already ***\n");
        }

        return LLC_STATUS_INVALID_COMMAND;

    //
    // *** everything below here has been sanctioned ***
    //

    case LLC_DIR_CLOSE_ADAPTER:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_CLOSE_ADAPTER\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DIR_INITIALIZE:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_INITIALIZE\n");
        }

        break;

    case LLC_DIR_OPEN_ADAPTER:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_OPEN_ADAPTER\n");
        }

        //
        // copy the adapter parms and DLC parms to 32-bit memory. If there is no
        // adapter parms or direct parms pointer then return an error
        //

        if (!(pParms->DirOpenAdapter.pAdapterParms && pParms->DirOpenAdapter.pExtendedParms)) {
            return LLC_STATUS_PARAMETER_MISSING;
        }

        //
        // copy the DOS ADAPTER_PARMS table to an NT ADAPTER_PARMS table. The
        // NT table is larger, so zero the uncopied part
        //

        RtlCopyMemory(&adapterParms,
                      DOS_PTR_TO_FLAT(pParms->DirOpenAdapter.pAdapterParms),
                      sizeof(ADAPTER_PARMS)
                      );
        RtlZeroMemory(&adapterParms.usReserved3[0],
                      sizeof(LLC_ADAPTER_OPEN_PARMS) - (DWORD)&((PLLC_ADAPTER_OPEN_PARMS)0)->usReserved3
                      );
        pParms->DirOpenAdapter.pAdapterParms = &adapterParms;

        //
        // make a note of the group and functional addresses. We have to set
        // these later if they're not 0x00000000. We have to save these, because
        // the addresses in the table will get blasted when DIR.OPEN.ADAPTER
        // (in DLCAPI.DLL/DLC.SYS) writes the current (0) values to the table
        //

        groupAddress = *(UNALIGNED DWORD *)adapterParms.auchGroupAddress;
        functionalAddress = *(UNALIGNED DWORD *)adapterParms.auchFunctionalAddress;

        //
        // the DLC_PARMS table doesn't HAVE to be supplied - if we just want to
        // use the direct station, we don't need these parameters. However, if
        // they were supplied, copy them to 32-bit memory. The tables are the
        // same size in DOS and NT
        //

        if (pParms->DirOpenAdapter.pDlcParms) {
            RtlCopyMemory(&dlcParms,
                          DOS_PTR_TO_FLAT(pParms->DirOpenAdapter.pDlcParms),
                          sizeof(dlcParms)
                          );
            pParms->DirOpenAdapter.pDlcParms = &dlcParms;
        }

        //
        // set the default values for ADAPTER_PARMS. Not sure about these
        //
        //  usReserved1 == NUMBER_RCV_BUFFERS
        //  usReserved2 == RCV_BUFFER_LEN
        //  usMaxFrameSize == DHB_BUFFER_LENGTH
        //  usReserved3[0] == DATA_HOLD_BUFFERS
        //

        if (pParms->DirOpenAdapter.pAdapterParms->usReserved1 < 2) {
            pParms->DirOpenAdapter.pAdapterParms->usReserved1 = DD_NUMBER_RCV_BUFFERS;
        }
        if (pParms->DirOpenAdapter.pAdapterParms->usReserved2 == 0) {
            pParms->DirOpenAdapter.pAdapterParms->usReserved2 = DD_RCV_BUFFER_LENGTH;
        }
        if (pParms->DirOpenAdapter.pAdapterParms->usMaxFrameSize == 0) {
            pParms->DirOpenAdapter.pAdapterParms->usReserved1 = DD_DHB_BUFFER_LENGTH;
        }
        if (*(PBYTE)&pParms->DirOpenAdapter.pAdapterParms->usReserved3 == 0) {
            pParms->DirOpenAdapter.pAdapterParms->usReserved1 = DD_DATA_HOLD_BUFFERS;
        }

        //
        // if we have DLC_PARMS then set the defaults, else reset the flag
        //

        if (pParms->DirOpenAdapter.pDlcParms) {
            if (pParms->DirOpenAdapter.pDlcParms->uchDlcMaxSaps == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchDlcMaxSaps = DD_DLC_MAX_SAP;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchDlcMaxStations == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchDlcMaxStations = DD_DLC_MAX_STATIONS;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchDlcMaxGroupSaps == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchDlcMaxGroupSaps = DD_DLC_MAX_GSAP;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchT1_TickOne == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchT1_TickOne = DD_DLC_T1_TICK_ONE;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchT2_TickOne == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchT2_TickOne = DD_DLC_T2_TICK_ONE;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchTi_TickOne == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchTi_TickOne = DD_DLC_Ti_TICK_ONE;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchT1_TickTwo == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchT1_TickTwo = DD_DLC_T1_TICK_TWO;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchT2_TickTwo == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchT2_TickTwo = DD_DLC_T2_TICK_TWO;
            }
            if (pParms->DirOpenAdapter.pDlcParms->uchTi_TickTwo == 0) {
                pParms->DirOpenAdapter.pDlcParms->uchTi_TickTwo = DD_DLC_Ti_TICK_TWO;
            }
            Adapters[adapter].DlcSpecified = TRUE;
        } else {
            Adapters[adapter].DlcSpecified = FALSE;
        }

        //
        // replace DIRECT_PARMS with the EXTENDED_ADAPTER_PARMS
        //

        pDirectParms = (PDOS_DLC_DIRECT_PARMS)
                       READ_FAR_POINTER(&pParms->DirOpenAdapter.pExtendedParms);
        pParms->DirOpenAdapter.pExtendedParms = &DefaultExtendedParms;
        break;

    case LLC_DIR_READ_LOG:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_READ_LOG\n");
        }

        pParms->DirReadLog.pLogBuffer = DOS_PTR_TO_FLAT(pParms->DirReadLog.pLogBuffer);
        break;

    case LLC_DIR_SET_FUNCTIONAL_ADDRESS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_SET_FUNCTIONAL_ADDRESS\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DIR_SET_GROUP_ADDRESS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_SET_GROUP_ADDRESS\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DIR_STATUS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_STATUS\n");
        }

        break;

    case LLC_DIR_TIMER_CANCEL:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_TIMER_CANCEL\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DIR_TIMER_CANCEL_GROUP:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_TIMER_CANCEL_GROUP\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DIR_TIMER_SET:

        IF_DEBUG(DLC) {
            DPUT("LLC_DIR_TIMER_SET\n");
        }

        //
        // no parameter table
        //

        //
        // Debug code is too slow - commands keep timing out. Multiply the
        // timer value by 2 to give us a chance!
        //

        IF_DEBUG(DOUBLE_TICKS) {
            pDosCcb->u.dir.usParameter0 *= 2;
        }

        break;

    case LLC_DLC_CLOSE_SAP:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_CLOSE_SAP\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DLC_CLOSE_STATION:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_CLOSE_STATION\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DLC_CONNECT_STATION:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_CONNECT_STATION\n");
        }

        pParms->DlcConnectStation.pRoutingInfo = DOS_PTR_TO_FLAT(pParms->DlcConnectStation.pRoutingInfo);
        break;

    case LLC_DLC_FLOW_CONTROL:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_FLOW_CONTROL\n");
        }

        //
        // if we are resetting the local-busy(buffer) state then we clear the
        // emulated state. When all deferred I-Frames are indicated to the app
        // the real local-busy(buffer) state will be reset in the driver
        //
        // If we don't think the indicated link station is in emulated local
        // busy(buffer) state then let the driver handle the request. If we
        // reset the emulated state then return success
        //

        if ((LOBYTE(pDosCcb->u.dlc.usParameter) & LLC_RESET_LOCAL_BUSY_BUFFER) == LLC_RESET_LOCAL_BUSY_BUFFER) {
            if (ResetEmulatedLocalBusyState(adapter, pDosCcb->u.dlc.usStationId, LLC_DLC_FLOW_CONTROL)) {
                return LLC_STATUS_SUCCESS;
            } else {

                IF_DEBUG(DLC) {
                    DPUT2("MapDosCommandsToNt: ERROR: Adapter %d StationId %04x not in local-busy(buffer) state\n",
                          adapter,
                          pDosCcb->u.dlc.usStationId
                          );
                }

                return LLC_STATUS_SUCCESS;
            }
        }

        //
        // let AcsLan/driver handle any other type of flow control request
        //

        break;

    case LLC_DLC_MODIFY:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_MODIFY\n");
        }

        pParms->DlcModify.pGroupList = DOS_PTR_TO_FLAT(pParms->DlcModify.pGroupList);
        break;

    case LLC_DLC_OPEN_SAP:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_OPEN_SAP\n");
        }

        //
        // convert segmented group list pointer to flat-32
        //

        pParms->DlcOpenSap.pGroupList = DOS_PTR_TO_FLAT(pParms->DlcOpenSap.pGroupList);

        //
        // Initialize the DOS DLC buffer pool for the SAP station. If this fails
        // return error immediately else call the NT driver to create the SAP
        // proper. If that fails, then the buffer pool created here will be
        // destroyed
        //

        Status = CreateBufferPool(
                    POOL_INDEX_FROM_SAP(pParms->DosDlcOpenSap.uchSapValue, adapter),
                    pParms->DosDlcOpenSap.dpPoolAddress,
                    pParms->DosDlcOpenSap.cPoolBlocks,
                    pParms->DosDlcOpenSap.usBufferSize
                    );
        if (Status != LLC_STATUS_SUCCESS) {

            IF_DEBUG(DLC) {
                DPUT1("MapDosCommandsToNt: Couldn't create buffer pool for DLC.OPEN.SAP (%x)\n", Status);
            }

            return Status;
        }

        //
        // trim the timer parameters to the range expected by the DLC driver
        //

        if (pParms->DlcOpenSap.uchT1 > 10) {
            pParms->DlcOpenSap.uchT1 = 10;
        }
        if (pParms->DlcOpenSap.uchT2 > 10) {
            pParms->DlcOpenSap.uchT2 = 10;
        }
        if (pParms->DlcOpenSap.uchTi > 10) {
            pParms->DlcOpenSap.uchTi = 10;
        }
        break;

    case LLC_DLC_OPEN_STATION:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_OPEN_STATION\n");
        }

        pParms->DlcOpenStation.pRemoteNodeAddress = DOS_PTR_TO_FLAT(pParms->DlcOpenStation.pRemoteNodeAddress);
        break;

    case LLC_DLC_REALLOCATE_STATIONS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_REALLOCATE_STATIONS\n");
        }

        break;

    case LLC_DLC_RESET:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_RESET\n");
        }

        //
        // no parameter table
        //

        break;

    case LLC_DLC_STATISTICS:

        IF_DEBUG(DLC) {
            DPUT("LLC_DLC_STATISTICS\n");
        }

        pParms->DlcStatistics.pLogBuf = DOS_PTR_TO_FLAT(pParms->DlcStatistics.pLogBuf);
        break;


    //
    // RECEIVE processing
    //

    case LLC_RECEIVE:

        IF_DEBUG(DLC) {
            DPUT("LLC_RECEIVE\n");
        }

        //
        // we have to replace the DOS RECEIVE with an NT RECEIVE for 2 reasons:
        // (i) NT assumes an NT RECEIVE parameter table which is longer than
        // the DOS RECEIVE parameter table: if we send the DOS pointers through
        // NT may write RECEIVE parameter information where we don't want it;
        // (ii) NT will complete the RECEIVE with NT buffers which we need to
        // convert to DOS buffers anyway in the event completion processing
        //
        // NOTE: we no longer chain receive frames on the SAP since this doesn't
        // really improve performance because we generate the same number of VDM
        // interrupts if we don't chain frames, and it just serves to complicate
        // completion event processing
        //

        pNewCcb = (PLLC_CCB)LocalAlloc(LMEM_FIXED,
                                       sizeof(LLC_CCB)
                                       + sizeof(LLC_DOS_RECEIVE_PARMS_EX)
                                       );
        if (pNewCcb == NULL) {
            return LLC_STATUS_NO_MEMORY;
        } else {

            IF_DEBUG(DLC) {
                DPUT1("VrDlc5cHandler: allocated Extended RECEIVE+parms @ %08x\n", pNewCcb);
            }

        }
        RtlCopyMemory(pNewCcb, pDosCcb, sizeof(LLC_DOS_CCB));
        RtlCopyMemory((PVOID)(pNewCcb + 1), (PVOID)pParms, sizeof(LLC_DOS_RECEIVE_PARMS));
        pNewCcb->hCompletionEvent = NULL;
        pNewCcb->uchReserved2 = 0;
        pNewCcb->uchReadFlag = 0;
        pNewCcb->usReserved3 = 0;
        pDosCcb = pNewCcb;
        pNtParms = (PLLC_PARMS)(pNewCcb + 1);
        pDosCcb->u.pParameterTable = pNtParms;
        ((PLLC_DOS_RECEIVE_PARMS_EX)pNtParms)->dpOriginalCcbAddress = dpOriginalCcbAddress;
        ((PLLC_DOS_RECEIVE_PARMS_EX)pNtParms)->dpCompletionFlag = 0;
        dpOriginalCcbAddress = (DOS_ADDRESS)pOutputCcb = (DOS_ADDRESS)pDosCcb;

        //
        // point the notification flag at the extended RECEIVE CCB. This is how
        // we get back to the extended RECEIVE CCB when a READ completes with a
        // receive event. From this CCB pointer, we can find our way to the
        // extended parameter table and from there the original DOS CCB address
        // and from there the original DOS RECEIVE parameter table
        //

        pNtParms->Receive.ulReceiveFlag = (DWORD)dpOriginalCcbAddress;

        //
        // uchRcvReadOption of 0x00 means DO NOT chain received frames. DOS DLC
        // cannot handle more than 1 frame at a time
        //

        pNtParms->Receive.uchRcvReadOption = 0;

        //
        // indicate, using LLC_DOS_SPECIAL_COMMAND as the completion flags, that
        // this RECEIVE CCB & parameter table were allocated on behalf of the
        // VDM, in this emulator, and should be freed when the command completes.
        // This also indicates that the parameter table is the extended receive
        // parameter table and as such contains the address of the original DOS
        // CCB which we must complete with the same information which completes
        // the NT RECEIVE we are about to submit
        //

        pNewCcb->ulCompletionFlag = LLC_DOS_SPECIAL_COMMAND;

#if DBG

        //
        // clear out the first-buffer field to stop the debug code displaying
        // a ton of garbage if the field is left uninitialized
        //

        WRITE_DWORD(&pOutputCcb->u.pParms->DosReceive.pFirstBuffer, 0);
        pNtParms->Receive.pFirstBuffer = NULL;
#endif

        break;

    case LLC_RECEIVE_CANCEL:

        IF_DEBUG(DLC) {
            DPUT("LLC_RECEIVE_CANCEL\n");
        }

        break;

    case LLC_RECEIVE_MODIFY:

        IF_DEBUG(DLC) {
            DPUT("LLC_RECEIVE_MODIFY\n");
        }

        break;


    //
    // TRANSMIT processing. All transmit commands (7 flavours) are collapsed
    // into the new TRANSMIT command
    //

    case LLC_TRANSMIT_DIR_FRAME:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_DIR_FRAME\n");
        }

        FrameType = LLC_DIRECT_TRANSMIT;
        goto TransmitHandling;

    case LLC_TRANSMIT_I_FRAME:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_I_FRAME\n");
        }

        FrameType = LLC_I_FRAME;
        goto TransmitHandling;

    case LLC_TRANSMIT_TEST_CMD:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_TEST_CMD\n");
        }

        FrameType = LLC_TEST_COMMAND_POLL;
        goto TransmitHandling;

    case LLC_TRANSMIT_UI_FRAME:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_UI_FRAME\n");
        }

        FrameType = LLC_UI_FRAME;
        goto TransmitHandling;

    case LLC_TRANSMIT_XID_CMD:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_XID_CMD\n");
        }

        FrameType = LLC_XID_COMMAND_POLL;
        goto TransmitHandling;

    case LLC_TRANSMIT_XID_RESP_FINAL:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_XID_RESP_FINAL\n");
        }

        FrameType = LLC_XID_RESPONSE_FINAL;
        goto TransmitHandling;

    case LLC_TRANSMIT_XID_RESP_NOT_FINAL:

        IF_DEBUG(DLC) {
            DPUT("LLC_TRANSMIT_XID_RESP_NOT_FINAL\n");
        }

        FrameType = LLC_XID_RESPONSE_NOT_FINAL;

TransmitHandling:

        //
        // Copy the DOS CCB to the input buffer, save the original DOS address
        // of the CCB and fix the parameter table address (to a flat address)
        // Copy the link list headers to the descriptor array and build NT CCB
        //

        WRITE_DWORD(&pOutputCcb->pNext, dpOriginalCcbAddress);
        RtlCopyMemory((PCHAR)&NtDlcParms.Async.Ccb, (PCHAR)pOutputCcb, sizeof(NT_DLC_CCB));
        NtDlcParms.Async.Ccb.u.pParameterTable = DOS_PTR_TO_FLAT(NtDlcParms.Async.Ccb.u.pParameterTable);
        NtDlcParms.Async.Parms.Transmit.StationId = pParms->Transmit.usStationId;
        NtDlcParms.Async.Parms.Transmit.RemoteSap = pParms->Transmit.uchRemoteSap;
        NtDlcParms.Async.Parms.Transmit.XmitReadOption = LLC_CHAIN_XMIT_COMMANDS_ON_SAP;
        NtDlcParms.Async.Parms.Transmit.FrameType = FrameType;

        cElement = 0;

        if (pParms->Transmit.pXmitQueue1) {
            Status = CopyDosBuffersToDescriptorArray(
                        NtDlcParms.Async.Parms.Transmit.XmitBuffer,
                        (PLLC_XMIT_BUFFER)pParms->Transmit.pXmitQueue1,
                        &cElement
                        );
            if (Status != LLC_STATUS_SUCCESS) {
                return Status;
            }
        }

        if (pParms->Transmit.pXmitQueue2) {
            Status = CopyDosBuffersToDescriptorArray(
                        NtDlcParms.Async.Parms.Transmit.XmitBuffer,
                        (PLLC_XMIT_BUFFER)pParms->Transmit.pXmitQueue2,
                        &cElement
                        );
            if (Status != LLC_STATUS_SUCCESS) {
                return Status;
            }
        }

        if (pParms->Transmit.cbBuffer1) {
            if (cElement == MAX_TRANSMIT_SEGMENTS) {
                return LLC_STATUS_TRANSMIT_ERROR;
            }

            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].pBuffer = DOS_PTR_TO_FLAT(pParms->Transmit.pBuffer1);
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].cbBuffer = pParms->Transmit.cbBuffer1;
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].boolFreeBuffer = FALSE;
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].eSegmentType = LLC_NEXT_DATA_SEGMENT;
            cElement++;
        }

        if (pParms->Transmit.cbBuffer2) {
            if (cElement == MAX_TRANSMIT_SEGMENTS) {
                return LLC_STATUS_TRANSMIT_ERROR;
            }

            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].cbBuffer = pParms->Transmit.cbBuffer2;
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].pBuffer = DOS_PTR_TO_FLAT(pParms->Transmit.pBuffer2);
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].boolFreeBuffer = FALSE;
            NtDlcParms.Async.Parms.Transmit.XmitBuffer[cElement].eSegmentType = LLC_NEXT_DATA_SEGMENT;
            cElement++;
        }

        NtDlcParms.Async.Parms.Transmit.XmitBuffer[0].eSegmentType = LLC_FIRST_DATA_SEGMENT;
        NtDlcParms.Async.Parms.Transmit.XmitBufferCount = cElement;

        InputBufferSize = sizeof(LLC_TRANSMIT_DESCRIPTOR) * cElement
                        + sizeof(NT_DLC_TRANSMIT_PARMS)
                        + sizeof(NT_DLC_CCB)
                        - sizeof(LLC_TRANSMIT_DESCRIPTOR);

        //
        // We don't need return FrameCopied status, when sending
        // I-frames.  We save an extra memory locking, when we use
        // TRANSMIT2 with the I- frames.
        //

        return lpDlcCallDriver((DWORD)adapter,
                               //(FrameType == LLC_I_FRAME)
                               // ? IOCTL_DLC_TRANSMIT2
                               // : IOCTL_DLC_TRANSMIT,
                               IOCTL_DLC_TRANSMIT,
                               &NtDlcParms,
                               InputBufferSize,
                               pOutputCcb,
                               sizeof(NT_DLC_CCB_OUTPUT)
                               );
    }

    //
    // Call the common DLC API entry point for DOS and Windows/Nt
    //

    Status = DlcCallWorker((PLLC_CCB)pDosCcb,    // aligned input CCB pointer
                           (PLLC_CCB)dpOriginalCcbAddress,
                           (PLLC_CCB)pOutputCcb  // possibly unaligned output CCB pointer
                           );

    IF_DEBUG(DLC) {
        DPUT2("MapDosCommandsToNt: NtAcsLan returns %#x (%d)\n", Status, Status);
    }

    switch (pDosCcb->uchDlcCommand) {
    case LLC_DIR_CLOSE_ADAPTER:
    case LLC_DIR_INITIALIZE:
        OpenedAdapters--;

        //
        // NtAcsLan converts DIR.INITIALIZE to DIR.CLOSE.ADAPTER. The former
        // completes "in the workstation", whereas the latter completes
        // asynchronously. Interpret LLC_STATUS_PENDING as LLC_STATUS_SUCCESS
        // in this case, otherwise we may not fully uninitialize the adapter
        //

        if (Status == LLC_STATUS_SUCCESS || Status == LLC_STATUS_PENDING) {

            //
            // We may free all virtual memory in NT buffer pool
            //

            Adapters[adapter].IsOpen = FALSE;
            LocalFree(Adapters[adapter].BufferPool);

            IF_DEBUG(DLC_ALLOC) {
                DPUT1("FREE: freed block @ %x\n", Adapters[adapter].BufferPool);
            }

            //
            // Delete all DOS buffer pools
            //

            for (i = 0; i <= 0xfe00; i += 0x0200) {
                DeleteBufferPool(GET_POOL_INDEX(adapter, i));
            }

            //
            // closing the adapter also closed the direct station
            //

            Adapters[adapter].DirectStationOpen = FALSE;

            //
            // clear the stored ADAPTER_PARMS and DLC_PARMS
            //

            RtlZeroMemory(&Adapters[adapter].AdapterParms, sizeof(ADAPTER_PARMS));
            RtlZeroMemory(&Adapters[adapter].DlcParms, sizeof(DLC_PARMS));

            if (pDosCcb->uchDlcCommand == LLC_DIR_INITIALIZE) {
                Status = LLC_STATUS_SUCCESS;
            }
        }
        break;

    case LLC_DIR_OPEN_ADAPTER:
        if (Status != LLC_STATUS_SUCCESS) {
            break;
        }

        //
        // Initialize the adapter support software
        //

        Status = InitializeAdapterSupport(adapter, pDirectParms);

        //
        // if we allocated the direct station buffer ok then perform the
        // rest of the open request - open the direct station, add any
        // group or functional addresses specified and set the ADAPTER_PARMS
        // and DLC_PARMS default values in the DOS_ADAPTER structure
        //

        if (Status == LLC_STATUS_SUCCESS) {

            //
            // open the direct station
            //

            Status = OpenDirectStation(adapter);
            if (Status == LLC_STATUS_SUCCESS) {

                //
                // add the group address
                //

                if (groupAddress) {
                    Status = LlcCommand(adapter,
                                        LLC_DIR_SET_GROUP_ADDRESS,
                                        groupAddress
                                        );
                } else IF_DEBUG(DLC) {
                    DPUT1("Error: couldn't set group address: %02x\n", Status);
                }

                if (Status == LLC_STATUS_SUCCESS) {

                    //
                    // add the functional address
                    //

                    if (functionalAddress) {
                        Status = LlcCommand(adapter,
                                            LLC_DIR_SET_FUNCTIONAL_ADDRESS,
                                            functionalAddress
                                            );
                    }
                } else IF_DEBUG(DLC) {
                    DPUT1("Error: couldn't set functional address: %02x\n", Status);
                }

            } else IF_DEBUG(DLC) {
                DPUT1("Error: could open Direct Station: %02x\n", Status);
            }
        }

        //
        // copy the returned default information to the adapter structure if
        // we successfully managed to open the direct station and add the
        // group and functional addresses (if specified)
        //

        if (Status == LLC_STATUS_SUCCESS) {
            RtlCopyMemory(&Adapters[adapter].AdapterParms,
                          pParms->DirOpenAdapter.pAdapterParms,
                          sizeof(ADAPTER_PARMS)
                          );
            if (pParms->DirOpenAdapter.pDlcParms) {
                RtlCopyMemory(&Adapters[adapter].DlcParms,
                              pParms->DirOpenAdapter.pDlcParms,
                              sizeof(DLC_PARMS)
                              );
            }
        } else {

            //
            // yoiks! something failed - close the direct station (if its
            // open, close the adapter and fail the request)
            //

            if (Adapters[adapter].DirectStationOpen) {
                CloseDirectStation(adapter);
            }
            CloseAdapter(adapter);
        }
        break;

    case LLC_DLC_CLOSE_SAP:
    case LLC_DLC_CLOSE_STATION:

        //
        // Delete the buffer pools of the closed or closing station.
        // It does not matter, if the close operation is still pending,
        // because the pending operations should always succeed
        //

        if (Status == LLC_STATUS_SUCCESS || Status == LLC_STATUS_PENDING) {

            DeleteBufferPool(GET_POOL_INDEX(adapter, pDosCcb->u.dlc.usStationId));

            //
            // DLC.SYS returns a pointer to the NT RECEIVE CCB for this SAP.
            // Change the pointer to the DOS RECEIVE CCB
            //

            if (Status == LLC_STATUS_SUCCESS || !pDosCcb->ulCompletionFlag) {

                PLLC_CCB pNtReceive;
                PLLC_DOS_RECEIVE_PARMS_EX pNtReceiveParms;

                pNtReceive = (PLLC_CCB)READ_DWORD(&pOutputCcb->pNext);
                if (pNtReceive) {
                    pNtReceiveParms = (PLLC_DOS_RECEIVE_PARMS_EX)(pNtReceive->u.pParameterTable);
                    WRITE_FAR_POINTER(&pOutputCcb->pNext, pNtReceiveParms->dpOriginalCcbAddress);

                    //
                    // free the NT RECEIVE CCB we allocated (see LLC_RECEIVE above)
                    //

                    ASSERT(pNtReceive->ulCompletionFlag == LLC_DOS_SPECIAL_COMMAND);
                    LocalFree((HLOCAL)pNtReceive);

                    IF_DEBUG(DLC) {
                        DPUT1("VrDlc5cHandler: freed Extended RECEIVE+parms @ %08x\n", pNtReceive);
                    }

                }
            }
        }
        break;

    case LLC_DLC_OPEN_SAP:

        //
        // delete the buffer pool, if the open SAP command failed
        //

        if (Status != LLC_STATUS_SUCCESS) {
            DeleteBufferPool(GET_POOL_INDEX(adapter, pParms->DlcOpenSap.usStationId));
        } else {

            //
            // record the DLC status change appendage for this SAP
            //

            Adapters[ adapter ].DlcStatusChangeAppendage

                [ SAP_ID(pParms->DlcOpenSap.usStationId) ]

                    = pParms->DlcOpenSap.DlcStatusFlags;

            //
            // and user value
            //

            Adapters[ adapter ].UserStatusValue

                [ SAP_ID(pParms->DlcOpenSap.usStationId) ]

                    = pParms->DlcOpenSap.usUserStatValue;
        }
        break;

    case LLC_DLC_RESET:

        //
        // Delete the reset sap buffer pool,
        // or all sap buffer pools.  We don't need to care about
        // the possible error codes, because this can fail only
        // if the given sap station does not exist any more =>
        // it does not matter, if we reset it again.
        //

        if (pDosCcb->u.dlc.usStationId != 0) {
            DeleteBufferPool(GET_POOL_INDEX(adapter, pDosCcb->u.dlc.usStationId));
        } else {

            int sapNumber;

            //
            // Close all SAP stations (0x0200 - 0xfe00). SAP number goes up in
            // increments of 2 since bit 0 is ignored (ie SAP 2 == SAP 3 etc)
            //

            for (sapNumber = 2; sapNumber <= 0xfe; sapNumber += 2) {
                DeleteBufferPool(POOL_INDEX_FROM_SAP(sapNumber, adapter));
            }
        }
        break;
    }
    return Status;
}


VOID
CompleteCcbProcessing(
    IN LLC_STATUS Status,
    IN LLC_DOS_CCB UNALIGNED * pCcb,
    IN PLLC_PARMS pNtParms
    )

/*++

Routine Description:

    Performs any CCB completion processing. Processing can be called either
    when the CCB completes synchronously, or asynchronously. Processing is
    typically to fill in parts of the DOS CCB or parameter table

Arguments:

    Status  - of the request
    pCcb    - pointer to DOS CCB to complete (flat 32-bit pointer to DOS memory)
    pNtParms- pointer to NT parameter table

Return Value:

    None.

--*/

{
    LLC_DOS_PARMS UNALIGNED * pDosParms = READ_FAR_POINTER(&pCcb->u.pParms);
    BYTE adapter = pCcb->uchAdapterNumber;

    IF_DEBUG(DLC) {
        DPUT("CompleteCcbProcessing\n");
    }

    switch (pCcb->uchDlcCommand) {
    case LLC_DIR_OPEN_ADAPTER:

        //
        // this command is unique in that it has a parameter table which points
        // to up to 4 other parameter tables. The following values are output:
        //
        //  ADAPTER_PARMS
        //      OPEN_ERROR_CODE
        //      NODE_ADDRESS
        //
        //  DIRECT_PARMS
        //      WORK_LEN_ACT
        //
        //  DLC_PARMS
        //      None for CCB1
        //
        //  NCB_PARMS
        //      Not accessed
        //

        //
        // we only copy the info if the command succeeded (we may have garbage
        // table pointers otherwise). It is also OK to copy the information if
        // the adapter is already open and the caller requested that we pass
        // the default information back
        //

        if (Status == LLC_STATUS_SUCCESS || Status == LLC_STATUS_ADAPTER_OPEN) {

            PLLC_DOS_DIR_OPEN_ADAPTER_PARMS pOpenAdapterParms = (PLLC_DOS_DIR_OPEN_ADAPTER_PARMS)pDosParms;
            PADAPTER_PARMS pAdapterParms = READ_FAR_POINTER(&pOpenAdapterParms->pAdapterParms);
            PDIRECT_PARMS pDirectParms = READ_FAR_POINTER(&pOpenAdapterParms->pDirectParms);
            PDLC_PARMS pDlcParms = READ_FAR_POINTER(&pOpenAdapterParms->pDlcParms);

            //
            // if we got an error and the caller didn't request the original
            // open parameters, then skip out
            //

            if (Status == LLC_STATUS_ADAPTER_OPEN && !(pAdapterParms->OpenOptions & 0x200)) {
                break;
            }

            WRITE_WORD(&pAdapterParms->OpenErrorCode, pNtParms->DirOpenAdapter.pAdapterParms->usOpenErrorCode);
            RtlCopyMemory(&pAdapterParms->NodeAddress,
                          pNtParms->DirOpenAdapter.pAdapterParms->auchNodeAddress,
                          sizeof(pAdapterParms->NodeAddress)
                          );

            //
            // direct parms are not returned from NT DLC, so we just copy the
            // requested work area size to the actual
            //

            WRITE_WORD(&pDirectParms->AdapterWorkAreaActual,
                        READ_WORD(&pDirectParms->AdapterWorkAreaRequested)
                        );

            //
            // copy the entire DLC_PARMS structure from the DOS_ADAPTER structure
            //

            if (pDlcParms) {
                RtlCopyMemory(pDlcParms, &Adapters[adapter].DlcParms, sizeof(*pDlcParms));
            }
        }
        break;

    case LLC_DIR_STATUS:

        //
        // copy the common areas from the 32-bit parameter table to 16-bit table
        // This copies up to the adapter parameters address
        //

        RtlCopyMemory(pDosParms, pNtParms, (DWORD)&((PDOS_DIR_STATUS_PARMS)0)->dpAdapterParmsAddr);

        //
        // fill in the other fields as best we can
        //

        RtlZeroMemory(pDosParms->DosDirStatus.auchMicroCodeLevel,
                      sizeof(pDosParms->DosDirStatus.auchMicroCodeLevel)
                      );
        WRITE_DWORD(&pDosParms->DosDirStatus.dpAdapterMacAddr, 0);
        WRITE_DWORD(&pDosParms->DosDirStatus.dpTimerTick, 0);
        WRITE_WORD(&pDosParms->DosDirStatus.usLastNetworkStatus,
                    Adapters[adapter].LastNetworkStatusChange
                    );

        //
        // If the app has requested we return the extended parameter table, then
        // fill it in with reasonable values if we can. There is one table per
        // adapter, statically allocated in the real-mode redir TSR
        //

        if (pDosParms->DosDirStatus.uchAdapterConfig & 0x20) {

            //
            // Ethernet type uses different bit in DOS and Nt (or OS/2)
            //

            lpVdmWindow->aExtendedStatus[adapter].cbSize = sizeof(EXTENDED_STATUS_PARMS);

            //
            // if adapter type as reported by NtAcsLan is Ethernet (0x100), set
            // adapter type in extended status table to Ethernet (0x10), else
            // record whatever NtAcsLan gave us
            //

            if (pNtParms->DirStatus.usAdapterType & 0x100) {
                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wAdapterType,
                           0x0010
                           );
                lpVdmWindow->aExtendedStatus[adapter].cbPageFrameSize = 0;
                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wCurrentFrameSize,
                           0
                           );
                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wMaxFrameSize,
                           0
                           );
            } else {
                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wAdapterType,
                           pNtParms->DirStatus.usAdapterType
                           );

                //
                // set the TR page frame size (KBytes)
                //

                lpVdmWindow->aExtendedStatus[adapter].cbPageFrameSize = 16;

                //
                // set the current and maximum DHB sizes for TR cards
                //

                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wCurrentFrameSize,
                           (WORD)pNtParms->DirStatus.ulMaxFrameLength
                           );
                WRITE_WORD(&lpVdmWindow->aExtendedStatus[adapter].wMaxFrameSize,
                           (WORD)pNtParms->DirStatus.ulMaxFrameLength
                           );
            }

            //
            // record the address of the extended parameter table in the
            // DIR.STATUS parameter table
            //

            WRITE_DWORD(&pDosParms->DosDirStatus.dpExtendedParms,
                        NEW_DOS_ADDRESS(dpVdmWindow, &lpVdmWindow->aExtendedStatus[adapter])
                        );
        } else {

            //
            // no extended parameters requested
            //

            WRITE_DWORD(&pDosParms->DosDirStatus.dpExtendedParms, 0);
        }

        //
        // return the tick counter. We don't currently update the tick counter
        //

        WRITE_DWORD(&pDosParms->DosDirStatus.dpTimerTick,
                    NEW_DOS_ADDRESS(dpVdmWindow, &lpVdmWindow->dwDlcTimerTick)
                    );

        //
        // always return a pointer to the extended adapter parameter table we
        // now keep in DOS memory. We currently always zero this table. It
        // would normally be maintained by the adapter (MAC) software
        //

        WRITE_DWORD(&pDosParms->DosDirStatus.dpAdapterParmsAddr,
                    NEW_DOS_ADDRESS(dpVdmWindow, &lpVdmWindow->AdapterStatusParms[adapter])
                    );
        RtlZeroMemory(&lpVdmWindow->AdapterStatusParms[adapter],
                      sizeof(lpVdmWindow->AdapterStatusParms[adapter])
                      );
        break;

    case LLC_DLC_OPEN_SAP:

        //
        // STATION_ID is only output value
        //

        WRITE_WORD(&pDosParms->DlcOpenSap.usStationId, pNtParms->DlcOpenSap.usStationId);
        break;

    case LLC_DLC_OPEN_STATION:

        //
        // LINK_STATION_ID is only output value
        //

        WRITE_WORD(&pDosParms->DlcOpenStation.usLinkStationId, pNtParms->DlcOpenStation.usLinkStationId);
        break;

    case LLC_DLC_STATISTICS:
        break;
    }
}


LLC_STATUS
InitializeAdapterSupport(
    IN UCHAR AdapterNumber,
    IN DOS_DLC_DIRECT_PARMS UNALIGNED * pDirectParms OPTIONAL
    )

/*++

Routine Description:

    The function initializes the buffer pool for the new adapter opened by
    DOS DLC

Arguments:

    AdapterNumber   - which adapter to initialize the buffer pool for
    pDirectParms    - Direct station parameter table, not used in NT, but
                      optional in DOS

Return Value:

    LLC_STATUS
        LLC_NO_RESOURCES

--*/

{
    LLC_STATUS Status;
    HANDLE hBufferPool;

    IF_DEBUG(DLC) {
        DPUT("InitializeAdapterSupport\n");
    }

    //
    // Check if the global DLL initialization has already been done. This is not
    // done in global DLL init because there is no reason to start an extra
    // thread if DLC is not used. If this succeeds then the asynchronous event
    // handler thread will be waiting on a list of 2 events - one for each
    // adapter. We need to submit a READ CCB for this adapter
    //

    Status = VrDlcInit();
    if (Status != LLC_STATUS_SUCCESS) {
        return Status;
    } else if (InitiateRead(AdapterNumber, &Status) == NULL) {
        return Status;
    }

    OpenedAdapters++;

    //
    // mark the adapter as being opened and get the media type/class
    //

    Adapters[AdapterNumber].IsOpen = TRUE;
    Adapters[AdapterNumber].AdapterType = GetAdapterType(AdapterNumber);

    //
    // Create the DLC buffer pool for the new adapter. DLC driver will
    // deallocate the buffer pool in the DIR.CLOSE.ADAPTER or when
    // the MVDM process makes a process exit
    //

    Adapters[AdapterNumber].BufferPool = (PVOID)LocalAlloc(LMEM_FIXED, DOS_DLC_BUFFER_POOL_SIZE);
    if (Adapters[AdapterNumber].BufferPool == NULL) {
        Status = LLC_STATUS_NO_MEMORY;
        goto ErrorHandler;
    }

    Status = BufferCreate(AdapterNumber,
                          Adapters[AdapterNumber].BufferPool,
                          DOS_DLC_BUFFER_POOL_SIZE,
                          DOS_DLC_MIN_FREE_THRESHOLD,
                          &hBufferPool
                          );
    if (Status != LLC_STATUS_SUCCESS) {
        goto ErrorHandler;
    }

    if (ARGUMENT_PRESENT(pDirectParms)) {

        //
        // create a buffer pool for the direct station (SAP 0). This allows
        // us to receive MAC and non-MAC frames sent to the direct station
        // without having to purposefully allocate a buffer
        //

        Status = CreateBufferPool(GET_POOL_INDEX(AdapterNumber, 0),
                                  pDirectParms->dpPoolAddress,
                                  pDirectParms->cPoolBlocks,
                                  pDirectParms->usBufferSize
                                  );
        if (Status != LLC_STATUS_SUCCESS) {
            goto ErrorHandler;
        }

        SaveExceptions(AdapterNumber,
                       (LPDWORD)&pDirectParms->dpAdapterCheckExit
                       );
        Status = SetExceptionFlags(AdapterNumber,
                                   (DWORD)pDirectParms->dpAdapterCheckExit,
                                   (DWORD)pDirectParms->dpNetworkStatusExit,
                                   (DWORD)pDirectParms->dpPcErrorExit,
                                   0
                                   );
        if (Status != LLC_STATUS_SUCCESS) {
            goto ErrorHandler;
        }
    }

    IF_DEBUG(DLC) {
        DPUT("InitializeAdapterSupport: returning success\n");
    }

    return LLC_STATUS_SUCCESS;

ErrorHandler:

    //
    // The open failed. We must close the adapter, but we don't care about the
    // result. This must succeed
    //

    if (Adapters[AdapterNumber].BufferPool != NULL) {
        LocalFree(Adapters[AdapterNumber].BufferPool);

        IF_DEBUG(DLC_ALLOC) {
            DPUT1("FREE: freed block @ %x\n", Adapters[AdapterNumber].BufferPool);
        }

    }

    CloseAdapter(AdapterNumber);
    Adapters[AdapterNumber].IsOpen = FALSE;

    //
    // this is probably not the right error code to return under these
    // circumstances, but we'll keep it until something better comes along
    //

    IF_DEBUG(DLC) {
        DPUT("InitializeAdapterSupport: returning FAILURE\n");
    }

    return LLC_STATUS_ADAPTER_NOT_INITIALIZED;
}


VOID
SaveExceptions(
    IN UCHAR AdapterNumber,
    IN LPDWORD pulExceptionFlags
    )

/*++

Routine Description:

    Procedure saves the current exception handlers
    and copies new current values on the old ones.

Arguments:

    IN UCHAR AdapterNumber - current adapter
    IN LPDWORD pulExceptionFlags - 3 dos exception handlers in the arrays

Return Value:

    None

--*/

{
    IF_DEBUG(DLC) {
        DPUT("SaveExceptions\n");
    }

    RtlCopyMemory(Adapters[AdapterNumber].PreviousExceptionHandlers,
                  Adapters[AdapterNumber].CurrentExceptionHandlers,
                  sizeof(Adapters[AdapterNumber].PreviousExceptionHandlers)
                  );
    RtlCopyMemory(Adapters[AdapterNumber].CurrentExceptionHandlers,
                  pulExceptionFlags,
                  sizeof(Adapters[AdapterNumber].CurrentExceptionHandlers)
                  );
}


LPDWORD
RestoreExceptions(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Procedure restores the previous exception handlers
    and returns the their address.

Arguments:

    IN UCHAR AdapterNumber - current adapter

Return Value:

    None

--*/

{
    IF_DEBUG(DLC) {
        DPUT("RestoreExceptions\n");
    }

    RtlCopyMemory(Adapters[AdapterNumber].CurrentExceptionHandlers,
                  Adapters[AdapterNumber].PreviousExceptionHandlers,
                  sizeof(Adapters[AdapterNumber].CurrentExceptionHandlers)
                  );
    return Adapters[AdapterNumber].CurrentExceptionHandlers;
}


LLC_STATUS
CopyDosBuffersToDescriptorArray(
    IN OUT PLLC_TRANSMIT_DESCRIPTOR pDescriptors,
    IN PLLC_XMIT_BUFFER pDlcBufferQueue,
    IN OUT LPDWORD pIndex
    )

/*++

Routine Description:

    The routine copies DOS transmit buffers to a Nt Transmit
    descriptor array.  All DOS pointers must be mapped to the flat
    32-bit address space.  Any data in the parameter table may be
    unaligned.

Arguments:

    pDescriptors    - current descriptor array
    pDlcBufferQueue - DOS transmit buffer queue
    pIndex          - current index in the descriptor array

Return Value:

    LLC_STATUS

--*/

{
    PLLC_XMIT_BUFFER pBuffer;
    DWORD Index = *pIndex;
    DWORD i = 0;
    DWORD DlcStatus = LLC_STATUS_SUCCESS;
    WORD cbBuffer;

    IF_DEBUG(DLC) {
        DPUT("CopyDosBuffersToDescriptorArray\n");
    }

    while (pDlcBufferQueue) {
        pBuffer = (PLLC_XMIT_BUFFER)DOS_PTR_TO_FLAT(pDlcBufferQueue);

        //
        // Check the overflow of the internal xmit buffer in stack and
        // the loop counter, that prevents the forever loop of zero length
        // transmit buffer (the buffer chain might be circular)
        //

        if (Index >= MAX_TRANSMIT_SEGMENTS || i > 60000) {
            DlcStatus = LLC_STATUS_TRANSMIT_ERROR;
            break;
        }

        if ((cbBuffer = READ_WORD(&pBuffer->cbBuffer)) != 0) {
            pDescriptors[Index].pBuffer = (PUCHAR)(pBuffer->auchData)
                                        + READ_WORD(&pBuffer->cbUserData);
            pDescriptors[Index].cbBuffer = cbBuffer;
            pDescriptors[Index].eSegmentType = LLC_NEXT_DATA_SEGMENT;
            pDescriptors[Index].boolFreeBuffer = FALSE;

            Index++;
        }
        i++;
        pDlcBufferQueue = (PLLC_XMIT_BUFFER)READ_DWORD(&pBuffer->pNext);
    }
    *pIndex = Index;
    return DlcStatus;
}


LLC_STATUS
BufferCreate(
    IN UCHAR AdapterNumber,
    IN PVOID pVirtualMemoryBuffer,
    IN DWORD ulVirtualMemorySize,
    IN DWORD ulMinFreeSizeThreshold,
    OUT HANDLE* phBufferPoolHandle
    )

/*++

Routine Description:

    Function creates a Windows/Nt DLC buffer pool.

    THIS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber           -
    pVirtualMemoryBuffer    - pointer to a virtual memory
    ulVirtualMemorySize     - size of all available buffer pool space
    ulMinFreeSizeThreshold  - locks more pages when this is exceeded
    phBufferPoolHandle      -

Return Value:

    LLC_STATUS

--*/

{
    LLC_CCB ccb;
    LLC_BUFFER_CREATE_PARMS BufferCreate;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT("BufferCreate\n");
    }

    InitializeCcb(&ccb, AdapterNumber, LLC_BUFFER_CREATE, &BufferCreate);

    BufferCreate.pBuffer = pVirtualMemoryBuffer;
    BufferCreate.cbBufferSize = ulVirtualMemorySize;
    BufferCreate.cbMinimumSizeThreshold = ulMinFreeSizeThreshold;

    status = lpAcsLan(&ccb, NULL);
    *phBufferPoolHandle = BufferCreate.hBufferPool;

    IF_DEBUG(DLC) {
        DPUT2("BufferCreate: returning %#x (%d)\n", status, status);
    }

    return DLC_ERROR_STATUS(status, ccb.uchDlcStatus);
}


LLC_STATUS
SetExceptionFlags(
    IN UCHAR AdapterNumber,
    IN DWORD ulAdapterCheckFlag,
    IN DWORD ulNetworkStatusFlag,
    IN DWORD ulPcErrorFlag,
    IN DWORD ulSystemActionFlag
    )

/*++

Routine Description:

    Sets the new appendage addresses

    THIS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber       -
    ulAdapterCheckFlag  -
    ulNetworkStatusFlag -
    ulPcErrorFlag       -
    ulSystemActionFlag  -

Return Value:

    LLC_STATUS

--*/

{
    LLC_CCB ccb;
    LLC_STATUS status;
    LLC_DIR_SET_EFLAG_PARMS DirSetFlags;

    IF_DEBUG(DLC) {
        DPUT("SetExceptionFlags\n");
    }

    InitializeCcb(&ccb, AdapterNumber, LLC_DIR_SET_EXCEPTION_FLAGS, &DirSetFlags);

    DirSetFlags.ulAdapterCheckFlag = ulAdapterCheckFlag;
    DirSetFlags.ulNetworkStatusFlag = ulNetworkStatusFlag;
    DirSetFlags.ulPcErrorFlag = ulPcErrorFlag;
    DirSetFlags.ulSystemActionFlag = ulSystemActionFlag;

    status = lpAcsLan(&ccb, NULL);
    return DLC_ERROR_STATUS(status, ccb.uchDlcStatus);
}


LLC_STATUS
LlcCommand(
    IN UCHAR AdapterNumber,
    IN UCHAR Command,
    IN DWORD Parameter
    )

/*++

Routine Description:

    Calls the ACSLAN DLL to perform a DLC request which takes no parameter
    table, but which takes parameters in byte, word or dword form in the CCB

    COMMANDS USING THIS ROUTINE MUST COMPLETE SYNCHRONOUSLY

Arguments:

    AdapterNumber   - which adapter to perform command for
    Command         - which DLC command to perform. Currently, commands are:
                        DIR.SET.GROUP.ADDRESS
                        DIR.SET.FUNCTIONAL.ADDRESS
                        DLC.FLOW.CONTROL
                        RECEIVE.CANCEL
    Parameter       - the associated command

Return Value:

    DWORD

--*/

{
    LLC_CCB ccb;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT3("LlcCommand(%d, %02x, %08x)\n", AdapterNumber, Command, Parameter);
    }

    InitializeCcb2(&ccb, AdapterNumber, Command);
    ccb.u.ulParameter = Parameter;

    status = lpAcsLan(&ccb, NULL);
    return DLC_ERROR_STATUS(status, ccb.uchDlcStatus);
}


LLC_STATUS
OpenAdapter(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Opens a DLC adapter context for a Windows/Nt VDM

    THIS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber   - which adapter to open

Return Value:

    LLC_STATUS

--*/

{
    LLC_CCB Ccb;
    LLC_DIR_OPEN_ADAPTER_PARMS DirOpenAdapter;
    LLC_ADAPTER_OPEN_PARMS AdapterParms;
    LLC_EXTENDED_ADAPTER_PARMS ExtendedParms;
    LLC_DLC_PARMS DlcParms;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT1("OpenAdapter(AdapterNumber=%d)\n", AdapterNumber);
    }

    InitializeCcb(&Ccb, AdapterNumber, LLC_DIR_OPEN_ADAPTER, &DirOpenAdapter);

    DirOpenAdapter.pAdapterParms = &AdapterParms;
    DirOpenAdapter.pExtendedParms = &ExtendedParms;
    DirOpenAdapter.pDlcParms = &DlcParms;

    ExtendedParms.hBufferPool = NULL;
    ExtendedParms.pSecurityDescriptor = NULL;
    ExtendedParms.LlcEthernetType = LLC_ETHERNET_TYPE_DEFAULT;

    RtlZeroMemory(&AdapterParms, sizeof(AdapterParms));
    RtlZeroMemory(&DlcParms, sizeof(DlcParms));

    status = lpAcsLan(&Ccb, NULL);

    if (status == LLC_STATUS_SUCCESS) {

        //
        // get the adapter media type/class
        //

        Adapters[AdapterNumber].AdapterType = GetAdapterType(AdapterNumber);

        //
        // mark the adapter structure as open
        //

        Adapters[AdapterNumber].IsOpen = TRUE;

        //
        // fill in the DOS ADAPTER_PARMS and DLC_PARMS structures with any
        // returned values
        //

        RtlCopyMemory(&Adapters[AdapterNumber].AdapterParms,
                      &AdapterParms,
                      sizeof(ADAPTER_PARMS)
                      );
        RtlCopyMemory(&Adapters[AdapterNumber].DlcParms,
                      &DlcParms,
                      sizeof(DLC_PARMS)
                      );
        Adapters[AdapterNumber].DlcSpecified = TRUE;
    }

    IF_DEBUG(DLC) {
        DPUT2("OpenAdapter: returning %d (%x)\n", status, status);
    }

    return DLC_ERROR_STATUS(status, Ccb.uchDlcStatus);
}


VOID
CloseAdapter(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Closes this adapter. Uses a CCB in the DOS_ADAPTER structure specifically
    for this purpose

    THIS COMMAND COMPLETES ** ASYNCHRONOUSLY **

Arguments:

    AdapterNumber   - adapter to close

Return Value:

    None.

--*/

{
    InitializeCcb2(&Adapters[AdapterNumber].AdapterCloseCcb, AdapterNumber, LLC_DIR_CLOSE_ADAPTER);
    Adapters[AdapterNumber].AdapterCloseCcb.ulCompletionFlag = VRDLC_COMMAND_COMPLETION;

#if DBG

    ASSERT(lpAcsLan(&Adapters[AdapterNumber].AdapterCloseCcb, NULL) == LLC_STATUS_SUCCESS);

#else

    lpAcsLan(&Adapters[AdapterNumber].AdapterCloseCcb, NULL);

#endif

    //
    // mark the adapter structure as being closed
    //

    Adapters[AdapterNumber].IsOpen = FALSE;
}


LLC_STATUS
OpenDirectStation(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Opens the direct station for this adapter

    THIS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber   - which adapter to open direct station for

Return Value:

    LLC_STATUS

--*/

{
    LLC_CCB ccb;
    LLC_DIR_OPEN_DIRECT_PARMS DirOpenDirect;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT1("OpenDirectStation(%d)\n", AdapterNumber);
    }

    InitializeCcb(&ccb, AdapterNumber, LLC_DIR_OPEN_DIRECT, &DirOpenDirect);

    DirOpenDirect.usOpenOptions = 0;
    DirOpenDirect.usEthernetType = 0;

    status = lpAcsLan(&ccb, NULL);
    if (status == LLC_STATUS_SUCCESS) {

        //
        // mark this DOS_ADAPTER as having the direct station open
        //

        Adapters[AdapterNumber].DirectStationOpen = TRUE;
    }

    status = DLC_ERROR_STATUS(status, ccb.uchDlcStatus);

    IF_DEBUG(DLC) {
        DPUT2("OpenDirectStation: returning %d (%x)\n", status, status);
    }

    return status;
}


VOID
CloseDirectStation(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Closes the direct station for this adapter. Uses a CCB in the DOS_ADAPTER
    structure specifically for this purpose

    THIS COMMAND COMPLETES ** ASYNCHRONOUSLY **

Arguments:

    AdapterNumber   - adapter to close the direct station for

Return Value:

    None.

--*/

{
    InitializeCcb2(&Adapters[AdapterNumber].DirectCloseCcb, AdapterNumber, LLC_DIR_CLOSE_DIRECT);
    Adapters[AdapterNumber].DirectCloseCcb.ulCompletionFlag = VRDLC_COMMAND_COMPLETION;

#if DBG

    ASSERT(lpAcsLan(&Adapters[AdapterNumber].DirectCloseCcb, NULL) == LLC_STATUS_SUCCESS);

#else

    lpAcsLan(&Adapters[AdapterNumber].DirectCloseCcb, NULL);

#endif

    //
    // mark the adapter structure as no longer having the direct station open
    //

    Adapters[AdapterNumber].DirectStationOpen = FALSE;
}


LLC_STATUS
BufferFree(
    IN UCHAR AdapterNumber,
    IN PVOID pFirstBuffer,
    OUT LPWORD pusBuffersLeft
    )

/*++

Routine Description:

    Frees a SAP buffer pool in the NT DLC driver

    THIS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber   -
    pFirstBuffer    -
    pusBuffersLeft  -

Return Value:

    LLC_STATUS

--*/

{
    LLC_CCB ccb;
    LLC_BUFFER_FREE_PARMS parms;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT1("BufferFree(%x)\n", pFirstBuffer);
    }

    InitializeCcb(&ccb, AdapterNumber, LLC_BUFFER_FREE, &parms);

    parms.pFirstBuffer = pFirstBuffer;

    status = lpAcsLan(&ccb, NULL);
    *pusBuffersLeft = parms.cBuffersLeft;

    return DLC_ERROR_STATUS(status, ccb.uchDlcStatus);
}


LLC_STATUS
VrDlcInit(
    VOID
    )

/*++

Routine Description:

    perform one-shot initialization:

        * clear Adapters structures

        * initialize array of buffer pool structures and initialize the buffer
          pool critical section (InitializeBufferPools in vrdlcbuf.c)

        * create all events and threads for asynchronous command completion
          processing (InitializeEventHandler in vrdlcpst.c)

        * initialize critical sections for each adapter's local-busy(buffer)
          state information

        * set the DLC initialized flag

Arguments:

    None.

Return Value:

    LLC_STATUS
        Success - LLC_STATUS_SUCCESS
                    DLC support already initialized or initialization completed
                    successfully

        Failure - LLC_STATUS_NO_MEMORY
                    failed to create the asynchronous event thread or an event
                    object

--*/

{
    static BOOLEAN VrDlcInitialized = FALSE;
    LLC_STATUS Status = LLC_STATUS_SUCCESS;

    if (!VrDlcInitialized) {

        //
        // ensure that the DOS_ADAPTER structures begin life in a known state
        //

        RtlZeroMemory(Adapters, sizeof(Adapters));

        //
        // clear out the buffer pool structures and initialize the buffer
        // pool critical section
        //

        InitializeBufferPools();

        //
        // crreate the event handler thread and the worker thread
        //

        if (!(InitializeEventHandler() && InitializeDlcWorkerThread())) {
            Status = LLC_STATUS_NO_MEMORY;
        } else {

            //
            // initialize each adapter's local-busy state critical section
            // and set the first & last indicies to -1, meaning no index
            //

            int i;

            for (i = 0; i < ARRAY_ELEMENTS(Adapters); ++i) {
                InitializeCriticalSection(&Adapters[i].EventQueueCritSec);
                InitializeCriticalSection(&Adapters[i].LocalBusyCritSec);
                Adapters[i].FirstIndex = Adapters[i].LastIndex = NO_LINKS_BUSY;
            }
            VrDlcInitialized = TRUE;
        }
    }
    return Status;
}


VOID
VrVdmWindowInit(
    VOID
    )

/*++

Routine Description:

    This routine saves the address of a VDM memory window, that is used
    in the communication betwen VDM TSR and its virtual device driver.
    This is called from a DOS TSR module.

Arguments:

    ES:BX in the VDM context are set to point to a memory window in TSR.

Return Value:

    None

--*/

{
    IF_DEBUG(DLC) {
        DPUT("VrVdmWindowInit\n");
    }

    //
    // Initialize the VDM memory window addresses
    //

    dpVdmWindow = MAKE_DWORD(getES(), getBX());
    lpVdmWindow = (LPVDM_REDIR_DOS_WINDOW)DOS_PTR_TO_FLAT(dpVdmWindow);

    IF_DEBUG(DLC) {
        DPUT2("VrVdmWindowsInit: dpVdmWindow=%08x lpVdmWindow=%08x\n", dpVdmWindow, lpVdmWindow);
    }

    //
    // have to return success to VDM redir TSR
    //

    setCF(0);
}


ADAPTER_TYPE
GetAdapterType(
    IN UCHAR AdapterNumber
    )

/*++

Routine Description:

    Determines what type of adapter AdapterNumber designates

    THE DIR.STATUS COMMAND COMPLETES SYNCHRONOUSLY

Arguments:

    AdapterNumber   - number of adapter to get type of

Return Value:

    ADAPTER_TYPE
        TokenRing, Ethernet, PcNetwork, or UnknownAdapter
--*/

{
    LLC_CCB ccb;
    LLC_DIR_STATUS_PARMS parms;
    LLC_STATUS status;

    IF_DEBUG(DLC) {
        DPUT("GetAdapterType\n");
    }

    InitializeCcb(&ccb, AdapterNumber, LLC_DIR_STATUS, &parms);

    status = lpAcsLan(&ccb, NULL);

    if (status == LLC_STATUS_SUCCESS) {
        switch (parms.usAdapterType) {
        case 0x0001:    // Token Ring Network PC Adapter
        case 0x0002:    // Token Ring Network PC Adapter II
        case 0x0004:    // Token Ring Network Adapter/A
        case 0x0008:    // Token Ring Network PC Adapter II
        case 0x0020:    // Token Ring Network 16/4 Adapter
        case 0x0040:    // Token Ring Network 16/4 Adapter/A
        case 0x0080:    // Token Ring Network Adapter/A
            return TokenRing;

        case 0x0100:    //Ethernet Adapter
            return Ethernet;

        case 0x4000:    // PC Network Adapter
        case 0x8000:    // PC Network Adapter/A
            return PcNetwork;
        }
    }
    return UnknownAdapter;
}


BOOLEAN
LoadDlcDll(
    VOID
    )

/*++

Routine Description:

    Dynamically loads DLCAPI.DLL & fixes-up entry points

Arguments:

    None.

Return Value:

    BOOLEAN
        TRUE if success else FALSE

--*/

{
    HANDLE hLibrary;
    LPWORD lpVdmPointer;

    if ((hLibrary = LoadLibrary("DLCAPI")) == NULL) {

        IF_DEBUG(DLC) {
            DPUT1("LoadDlcDll: Error: cannot load DLCAPI.DLL: %d\n", GetLastError());
        }

        return FALSE;
    }
    if ((lpAcsLan = (ACSLAN_FUNC_PTR)GetProcAddress(hLibrary, "AcsLan")) == NULL) {

        IF_DEBUG(DLC) {
            DPUT1("LoadDlcDll: Error: cannot GetProcAddress(AcsLan): %d\n", GetLastError());
        }

        return FALSE;
    }
    if ((lpDlcCallDriver = (DLC_CALL_DRIVER_FUNC_PTR)GetProcAddress(hLibrary, "DlcCallDriver")) == NULL) {

        IF_DEBUG(DLC) {
            DPUT1("LoadDlcDll: Error: cannot GetProcAddress(DlcCallDriver): %d\n", GetLastError());
        }

        return FALSE;
    }
    if ((lpNtAcsLan = (NTACSLAN_FUNC_PTR)GetProcAddress(hLibrary, "NtAcsLan")) == NULL) {

        IF_DEBUG(DLC) {
            DPUT1("LoadDlcDll: Error: cannot GetProcAddress(NtAcsLan): %d\n", GetLastError());
        }

        return FALSE;
    }

    IF_DEBUG(DLC) {
        DPUT("LoadDlcDll: DLCAPI.DLL loaded Ok\n");
    }

    //
    // Initialize the VDM memory window addresses from our well-known address
    // in the VDM Redir. Do this here because we no longer initialize 32-bit
    // support at the point where we load the 16-bit REDIR
    //

    lpVdmPointer = POINTER_FROM_WORDS(getCS(), (DWORD)&((VDM_LOAD_INFO*)0)->DlcWindowAddr);
    dpVdmWindow = MAKE_DWORD(GET_SEGMENT(lpVdmPointer), GET_OFFSET(lpVdmPointer));
    lpVdmWindow = (LPVDM_REDIR_DOS_WINDOW)DOS_PTR_TO_FLAT(dpVdmWindow);

    IF_DEBUG(DLC) {
        DPUT4("LoadDlcDll: lpVdmPointer=%x dpVdmWindow = %04x:%04x lpVdmWindow=%x\n",
              lpVdmPointer,
              HIWORD(dpVdmWindow),
              LOWORD(dpVdmWindow),
              lpVdmWindow
              );
    }

    return TRUE;
}


VOID
TerminateDlcEmulation(
    VOID
    )

/*++

Routine Description:

    Closes any open adapters. Any pending commands are terminated

Arguments:

    None.

Return Value:

    None.

--*/

{
    DWORD i;

    IF_DEBUG(DLC) {
        DPUT("TerminateDlcEmulation\n");
    }

    IF_DEBUG(CRITICAL) {
        DPUT("TerminateDlcEmulation\n");
    }

    for (i = 0; i < ARRAY_ELEMENTS(Adapters); ++i) {
        if (Adapters[i].IsOpen) {
            CloseAdapter((BYTE)i);
        }
    }
}

HANDLE DlcWorkerEvent;
HANDLE DlcWorkerCompletionEvent;
HANDLE DlcWorkerThreadHandle;

struct {
    PLLC_CCB Input;
    PLLC_CCB Original;
    PLLC_CCB Output;
    LLC_STATUS Status;
} DlcWorkerThreadParms;


BOOLEAN
InitializeDlcWorkerThread(
    VOID
    )

/*++

Routine Description:

    Creates events which control VrDlcWorkerThread and starts the worker thread

Arguments:

    None.

Return Value:

    BOOLEAN
        TRUE    - worker thread was successfully created
        FALSE   - couldn't start worker thread for some reason

--*/

{
    DWORD threadId;

    //
    // create 2 auto-reset events
    //

    DlcWorkerEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (DlcWorkerEvent == NULL) {
        return FALSE;
    }
    DlcWorkerCompletionEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (DlcWorkerCompletionEvent == NULL) {
        CloseHandle(DlcWorkerEvent);
        return FALSE;
    }

    //
    // kick off the one-and-only worker thread
    //

    DlcWorkerThreadHandle = CreateThread(NULL,
                                         0,
                                         (LPTHREAD_START_ROUTINE)VrDlcWorkerThread,
                                         NULL,
                                         0,
                                         &threadId
                                         );
    if (DlcWorkerThreadHandle == NULL) {
        CloseHandle(DlcWorkerEvent);
        CloseHandle(DlcWorkerCompletionEvent);
        return FALSE;
    }
    return TRUE;
}


VOID
VrDlcWorkerThread(
    IN LPVOID Parameters
    )

/*++

Routine Description:

    Submits requests to NtAcsLan on behalf of DOS thread. This exists because of
    a problem with 16-bit Windows apps that use DLC (like Extra!). Eg:

        1. start Extra! session. Extra submits RECEIVE command
        2. connect to mainframe
        3. start second Extra! session
        4. connect second instance to mainframe
        5. kill first Extra! session

    On a DOS machine, the RECEIVE is submitted for the entire process, so when
    the first Extra! session is killed, the RECEIVE is still active.

    However, on NT, each session is represented by a separate thread in NTVDM.
    So when the first session is killed, any outstanding IRPs are cancelled,
    including the RECEIVE. The second instance of Extra! doesn't know that the
    RECEIVE has been cancelled, and never receives any more data

Arguments:

    Parameters  - unused pointer to parameter block

Return Value:

    None.

--*/

{
    DWORD object;

    UNREFERENCED_PARAMETER(Parameters);

    while (TRUE) {
        object = WaitForSingleObject(DlcWorkerEvent, INFINITE);
        if (object == WAIT_OBJECT_0) {
            DlcWorkerThreadParms.Status = lpNtAcsLan(DlcWorkerThreadParms.Input,
                                                     DlcWorkerThreadParms.Original,
                                                     DlcWorkerThreadParms.Output,
                                                     NULL
                                                     );
            SetEvent(DlcWorkerCompletionEvent);
        }
    }
}


LLC_STATUS
DlcCallWorker(
    PLLC_CCB pInputCcb,
    PLLC_CCB pOriginalCcb,
    PLLC_CCB pOutputCcb
    )

/*++

Routine Description:

    Queues (depth is one) a request to the DLC worker thread and waits for the
    worker thread to complete the request

Arguments:

    pInputCcb       - pointer to input CCB. Mapped to 32-bit aligned memory
    pOriginalCcb    - address of original CCB. Can be non-aligned DOS address
    pOutputCcb      - pointer to output CCB. Can be non-aligned DOS address

Return Value:

    LLC_STATUS

--*/

{
    DlcWorkerThreadParms.Input = pInputCcb;
    DlcWorkerThreadParms.Original = pOriginalCcb;
    DlcWorkerThreadParms.Output = pOutputCcb;
    SetEvent(DlcWorkerEvent);
    WaitForSingleObject(DlcWorkerCompletionEvent, INFINITE);
    return DlcWorkerThreadParms.Status;
}