windows-server-2003/termsrv/drivers/td/tdicom/tdilib.c

/*************************************************************************
* tdlib.c
*
* TDI library functions.
*
* Copyright 1998 Microsoft
*************************************************************************/

/*
 *  Includes
 */
#include <ntddk.h>
#include <tdi.h>
#include <tdikrnl.h>

#include "tdtdi.h"

#include <winstaw.h>
#define _DEFCHARINFO_
#include <icadd.h>
#include <ctxdd.h>
#include <sdapi.h>

#include <td.h>


#define _TDI_POLL_TIMEOUT       (30 * 1000) // 30 seconds
#define _TDI_CONNECT_TIMEOUT    45
#define _TDI_DISCONNECT_TIMEOUT 60

#if DBG
ULONG
DbgPrint(
    PCH Format,
    ...
    );
#define DBGPRINT(x) DbgPrint x
#if DBGTRACE
#define TRACE0(x)   DbgPrint x
#define TRACE1(x)   DbgPrint x
#else
#define TRACE0(x)
#define TRACE1(x)
#endif
#else
#define DBGPRINT(x)
#define TRACE0(x)
#define TRACE1(x)
#endif

/*
 * To use TDI:
 *
 * To connect to a remote server:
 *
 *    Create Address EndPoint
 *
 *    Create Connection Object
 *
 *    Associate the Address EndPoint with the Connection Object
 *
 *    Do a Connect
 *
 * To receive connections:
 *
 *    Create Address EndPoint
 *
 *    Create Connection Object
 *
 *    Associate the Address EndPoint with the Connection Object
 *
 *    Listen for a connection.
 *
 *    Return connection
 */



/*
 * Global data
 */

//
//  Wait for xx seconds before polling on thread deletion.
//

ULONG
_TdiPollTimeout = _TDI_POLL_TIMEOUT;

/*
 * Forward references
 */

PIRP
_TdiAllocateIrp(
    IN PFILE_OBJECT FileObject,
    IN PDEVICE_OBJECT DeviceObject OPTIONAL
    );

NTSTATUS
_TdiRequestComplete (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Ctx
    );

NTSTATUS
_TdiSetEventHandler (
    IN PTD pTd,
    IN PDEVICE_OBJECT DeviceObject,
    IN PFILE_OBJECT FileObject,
    IN ULONG EventType,
    IN PVOID EventHandler,
    IN PVOID EventContext
    );

NTSTATUS
_TdiSubmitRequest (
    IN PTD pTd,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN BOOLEAN bKeepLock
    );

/*
 * External references
 */
NTSTATUS MemoryAllocate( ULONG, PVOID * );
VOID     MemoryFree( PVOID );

BOOLEAN
PsIsThreadTerminating(
    IN PETHREAD Thread
    );


/*
 * Functions
 */

NTSTATUS
_TdiCreateAddress (
    IN PUNICODE_STRING pTransportName,
    IN PVOID           TdiAddress,
    IN ULONG           TdiAddressLength,
    OUT PHANDLE        pHandle,
    OUT PFILE_OBJECT   *ppFileObject,
    OUT PDEVICE_OBJECT *ppDeviceObject
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES AddressAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    PFILE_FULL_EA_INFORMATION EABuffer;
    PDEVICE_OBJECT DeviceObject;
    HANDLE         TdiHandle  = NULL;
    PFILE_OBJECT   FileObject = NULL;

    /*
     * The TDI interfaces uses an EA of name "TdiTransportName"
     * to specify the structure TA_ADDRESS.
     */
    Status = MemoryAllocate( (sizeof(FILE_FULL_EA_INFORMATION)-1 +
                                    TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
                                    TdiAddressLength), &EABuffer);

    if ( !NT_SUCCESS(Status) ) {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }

    EABuffer->NextEntryOffset = 0;
    EABuffer->Flags = 0;
    EABuffer->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
    EABuffer->EaValueLength = (USHORT)TdiAddressLength;

    // Copy in the EA name
    RtlCopyMemory(EABuffer->EaName, TdiTransportAddress, EABuffer->EaNameLength+1);

    // Copy the TA_ADDRESS parameter
    RtlCopyMemory(&EABuffer->EaName[TDI_TRANSPORT_ADDRESS_LENGTH+1], TdiAddress,
                                    EABuffer->EaValueLength);

    TRACE0(("TdiCreateAddress Create endpoint of %wZ\n",pTransportName));

    InitializeObjectAttributes (
        &AddressAttributes,
        pTransportName,
        OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE ,
        NULL,           // RootDirectory
        NULL            // SecurityDescriptor
        );

    Status = ZwCreateFile(
                 &TdiHandle, // Handle
                 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                 &AddressAttributes, // Object Attributes
                 &IoStatusBlock, // Final I/O status block
                 NULL,           // Allocation Size
                 FILE_ATTRIBUTE_NORMAL, // Normal attributes
                 0,             // Sharing attributes
                 FILE_OPEN_IF,  // Create disposition
                 0,             // CreateOptions
                 EABuffer,      // EA Buffer
                 FIELD_OFFSET(FILE_FULL_EA_INFORMATION, EaName) +
                 TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
                 TdiAddressLength // EA length
                 );

    MemoryFree(EABuffer);

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("TdiCreateAddress: Error Status 0x%x from function\n",Status));
        return( Status );
    }

    if (!NT_SUCCESS(Status = IoStatusBlock.Status)) {
        DBGPRINT(("TdiCreateAddress: Error Status 0x%x from Iosb\n",Status));
        return( Status );
    }

    //
    //  Obtain a referenced pointer to the file object.
    //
    Status = ObReferenceObjectByHandle (
                                TdiHandle,
                                0,
                                *IoFileObjectType,
                                KernelMode,
                                (PVOID *)&FileObject,
                                NULL
                                );

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("TdiCreateAddress: Error Status 0x%x Referencing FileObject\n",Status));
        goto error_cleanup;

    }


    //
    //  Get the address of the device object for the endpoint.
    //

    DeviceObject = IoGetRelatedDeviceObject(FileObject);

    // Copy the out parameters
    *pHandle = TdiHandle;
    *ppFileObject = FileObject;
    *ppDeviceObject = DeviceObject;

    return STATUS_SUCCESS;

error_cleanup:

    if ( FileObject != NULL ) {
        ObDereferenceObject( FileObject );
    }

    if ( TdiHandle != NULL ) {
        ZwClose( TdiHandle );
    }

    return Status;
}

NTSTATUS
_TdiOpenConnection (
    IN PUNICODE_STRING pTransportName,
    IN PVOID           ConnectionContext,
    OUT PHANDLE        pHandle,
    OUT PFILE_OBJECT   *ppFileObject,
    OUT PDEVICE_OBJECT *ppDeviceObject
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES AddressAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    PFILE_FULL_EA_INFORMATION EABuffer;
    CONNECTION_CONTEXT UNALIGNED *ContextPointer;
    PDEVICE_OBJECT DeviceObject;
    HANDLE ConnHandle = NULL;
    PFILE_OBJECT FileObject = NULL;

    Status = MemoryAllocate( (sizeof(FILE_FULL_EA_INFORMATION)-1 +
                              TDI_CONNECTION_CONTEXT_LENGTH+1 +
                              sizeof(CONNECTION_CONTEXT)), &EABuffer);

    if( !NT_SUCCESS(Status) ) {
        return( Status );
    }

    EABuffer->NextEntryOffset = 0;
    EABuffer->Flags = 0;
    EABuffer->EaNameLength = TDI_CONNECTION_CONTEXT_LENGTH;
    EABuffer->EaValueLength = sizeof(CONNECTION_CONTEXT);

    // Copy in the EA name
    RtlCopyMemory(EABuffer->EaName, TdiConnectionContext, TDI_CONNECTION_CONTEXT_LENGTH+1);

    // Copy in the EA data
    ContextPointer =
        (CONNECTION_CONTEXT UNALIGNED *)&EABuffer->EaName[TDI_CONNECTION_CONTEXT_LENGTH+1];
    *ContextPointer = ConnectionContext;

    TRACE0(("_TdiOpenConnection: Create connection object on transport %wZ\n",pTransportName));

    InitializeObjectAttributes (&AddressAttributes,
                                    pTransportName, // Name
                                    OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE ,   // Attributes
                                    NULL,                   // RootDirectory
                                    NULL);                  // SecurityDescriptor

    Status = ZwCreateFile(&ConnHandle,               // Handle
                          GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                          &AddressAttributes, // Object Attributes
                          &IoStatusBlock, // Final I/O status block
                          NULL,           // Allocation Size
                          FILE_ATTRIBUTE_NORMAL, // Normal attributes
                          FILE_SHARE_READ | FILE_SHARE_WRITE, // Sharing attributes
                          FILE_OPEN_IF,   // Create disposition
                          0,              // CreateOptions
                          EABuffer,       // EA Buffer
                          sizeof(FILE_FULL_EA_INFORMATION) +
                            TDI_CONNECTION_CONTEXT_LENGTH + 1 +
                            sizeof(CONNECTION_CONTEXT));


    MemoryFree(EABuffer);

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("_TdiOpenConnection: Error 0x%x Creating Connection object\n",Status));
        return(Status);
    }

    Status = IoStatusBlock.Status;
    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("_TdiOpenConnection: Error 0x%x Creating Connection object in Iosb\n",Status));
        return(Status);
    }

    TRACE0(("_TdiOpenConnection: Returning connection handle %lx\n", ConnHandle));


    //
    //  Obtain a referenced pointer to the file object.
    //
    Status = ObReferenceObjectByHandle (
                                ConnHandle,
                                0,
                                *IoFileObjectType,
                                KernelMode,
                                (PVOID *)&FileObject,
                                NULL
                                );

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("_TdiOpenConnection: Error Status 0x%x Referencing FileObject\n",Status));
        ZwClose( ConnHandle );
        return(Status);
    }



    //
    //  Get the address of the device object for the endpoint.
    //

    DeviceObject = IoGetRelatedDeviceObject(FileObject);

    // Copy the out parameters
    *pHandle        = ConnHandle;
    *ppFileObject   = FileObject;
    *ppDeviceObject = DeviceObject;

    return(Status);
}

NTSTATUS
_TdiListen(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   ConnectionFileObject,
    IN PDEVICE_OBJECT ConnectionDeviceObject
    )
{
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;
    TDI_CONNECTION_INFORMATION RequestInfo;
    TDI_CONNECTION_INFORMATION ReturnInfo;

    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( ConnectionFileObject, ConnectionDeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    RtlZeroMemory( &RequestInfo, sizeof(RequestInfo) );
    RtlZeroMemory( &ReturnInfo,  sizeof(ReturnInfo) );

    TdiBuildListen(
        Irp,
        ConnectionDeviceObject,
        ConnectionFileObject,
        NULL,        // Completion routine
        NULL,        // Context
        0,           // Flags
        &RequestInfo,
        &ReturnInfo
        );

    Status = _TdiSubmitRequest(pTd, ConnectionDeviceObject, Irp, FALSE);

    TRACE0(("_TdiListen: Status 0x%x\n",Status));

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}

NTSTATUS
_TdiAccept(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   ConnectionFileObject,
    IN PDEVICE_OBJECT ConnectionDeviceObject
    )
{
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;
    TDI_CONNECTION_INFORMATION RequestInfo;
    TDI_CONNECTION_INFORMATION ReturnInfo;

    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( ConnectionFileObject, ConnectionDeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    RtlZeroMemory( &RequestInfo, sizeof(RequestInfo) );
    RtlZeroMemory( &ReturnInfo,  sizeof(ReturnInfo) );

    TdiBuildAccept(
        Irp,
        ConnectionDeviceObject,
        ConnectionFileObject,
        NULL,        // Completion routine
        NULL,        // Context
        &RequestInfo,
        &ReturnInfo
        );

    Status = _TdiSubmitRequest(pTd, ConnectionDeviceObject, Irp, FALSE);

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}


NTSTATUS
_TdiConnect(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PLARGE_INTEGER pTimeout OPTIONAL,
    IN PFILE_OBJECT   ConnectionFileObject,
    IN PDEVICE_OBJECT ConnectionDeviceObject,
    IN ULONG              RemoteTransportAddressLength,
    IN PTRANSPORT_ADDRESS pRemoteTransportAddress
    )
{
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;
    TDI_CONNECTION_INFORMATION RequestInfo;
    TDI_CONNECTION_INFORMATION ReturnInfo;


    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( ConnectionFileObject, ConnectionDeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    RtlZeroMemory( &RequestInfo, sizeof(RequestInfo) );
    RtlZeroMemory( &ReturnInfo,  sizeof(ReturnInfo) );

    RequestInfo.RemoteAddressLength = RemoteTransportAddressLength;
    RequestInfo.RemoteAddress = pRemoteTransportAddress;


    TdiBuildConnect(
        Irp,
        ConnectionDeviceObject,
        ConnectionFileObject,
        NULL,        // Completion routine
        NULL,        // Context
        pTimeout,
        &RequestInfo,
        &ReturnInfo
        );

    Status = _TdiSubmitRequest(pTd, ConnectionDeviceObject, Irp, TRUE);

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}


NTSTATUS
_TdiAssociateAddress(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   ConnectionFileObject,
    IN HANDLE         AddressHandle,
    IN PDEVICE_OBJECT AddressDeviceObject
    )
{
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;

    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( ConnectionFileObject, AddressDeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    TdiBuildAssociateAddress(
        Irp,
        AddressDeviceObject,
        ConnectionFileObject,
        NULL,        // Completion routine
        NULL,        // Context
        AddressHandle
        );

    Status = _TdiSubmitRequest(pTd, AddressDeviceObject, Irp, FALSE);

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}

NTSTATUS
_TdiDisconnect(
    IN PTD pTd,
    IN PFILE_OBJECT   ConnectionFileObject,
    IN PDEVICE_OBJECT ConnectionDeviceObject
    )
{
    PIRP Irp;
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;

    Irp = _TdiAllocateIrp( ConnectionFileObject, ConnectionDeviceObject );
    if (Irp == NULL) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        return Status;
    }

    TdiBuildDisconnect(
        Irp,
        ConnectionDeviceObject,
        ConnectionFileObject,
        NULL,        // Completion routine
        NULL,        // Context
        0,
        TDI_DISCONNECT_ABORT,
        NULL,
        NULL
        );

    Status = _TdiSubmitRequest(pTd, ConnectionDeviceObject, Irp, TRUE);

    IoFreeIrp( Irp );

    return(Status);
}

NTSTATUS
_TdiSetEventHandler (
    IN PTD pTd,
    IN PDEVICE_OBJECT DeviceObject,
    IN PFILE_OBJECT FileObject,
    IN ULONG EventType,
    IN PVOID EventHandler,
    IN PVOID EventContext
    )
/*++

Routine Description:

    This routine registers an event handler with a TDI transport provider.

Arguments:

    IN PDEVICE_OBJECT DeviceObject - Supplies the device object of the transport provider.
    IN PFILE_OBJECT FileObject - Supplies the address object's file object.
    IN ULONG EventType, - Supplies the type of event.
    IN PVOID EventHandler - Supplies the event handler.
    IN PVOID EventContext - Supplies the context for the event handler.

Return Value:

    NTSTATUS - Final status of the set event operation

--*/

{
    NTSTATUS Status;
    PIRP Irp;

    Irp = _TdiAllocateIrp( FileObject, NULL );

    if (Irp == NULL) {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }

    TdiBuildSetEventHandler(Irp, DeviceObject, FileObject,
                            NULL, NULL,
                            EventType, EventHandler, EventContext);

    Status = _TdiSubmitRequest(pTd, DeviceObject, Irp, FALSE);

    IoFreeIrp( Irp );

    return Status;
}

NTSTATUS
_TdiSubmitRequest (
    IN PTD pTd,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN BOOLEAN bKeepLock
    )

/*++

Routine Description:

    This routine submits a request to TDI and waits for it to complete.

Arguments:

    IN PFILE_OBJECT FileObject - Connection or Address handle for TDI request
    IN PIRP Irp - TDI request to submit.

Return Value:

    NTSTATUS - Final status of request.

--*/

{
    NTSTATUS Status;
    PKEVENT  Event;

    Status = MemoryAllocate( sizeof(KEVENT), &Event );
    if( !NT_SUCCESS(Status) ) {
        return( Status );
    }

    KeInitializeEvent (Event, NotificationEvent, FALSE);

    IoSetCompletionRoutine(Irp, _TdiRequestComplete, Event, TRUE, TRUE, TRUE);

    //
    //  Submit the request
    //

    Status = IoCallDriver(DeviceObject, Irp);

    //
    //  If it failed immediately, return now, otherwise wait.
    //

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("_TdiSubmitRequest: submit request.  Status = %X", Status));
        MemoryFree( Event );
        return Status;
    }

    if (Status == STATUS_PENDING) {

        TRACE0(("TDI request issued, waiting..."));

        do {

            //
            //  Wait for a couple of seconds for the request to complete
            //
            //  If it times out, and the thread is terminating, cancel the
            //  request and unwind that way.
            //

            if ( !bKeepLock ) {
                Status = IcaWaitForSingleObject(
                             pTd->pContext,
                             Event,
                             _TdiPollTimeout
                             );
            } else {
                LARGE_INTEGER WaitTimeout;
                PLARGE_INTEGER pWaitTimeout = NULL;

                WaitTimeout = RtlEnlargedIntegerMultiply( _TdiPollTimeout, -10000 );
                pWaitTimeout = &WaitTimeout;
                
                Status = KeWaitForSingleObject(
                             Event,
                             UserRequest,
                             UserMode,
                             FALSE,
                             pWaitTimeout 
                             );
            }

            TRACE0(("_TdiSubmitRequest: Status 0x%x from IcaWaitForSingleObject\n",Status));

            //
            //  If we timed out the wait, and the thread is terminating,
            //  give up and cancel the IRP.
            //

            if ( (Status == STATUS_TIMEOUT)

                   &&

                 ARGUMENT_PRESENT(Irp)

                   &&

                 PsIsThreadTerminating( Irp->Tail.Overlay.Thread ) ) {

                //
                //  Ask the I/O system to cancel this IRP.  This will cause
                //  everything to unwind properly.
                //
                DBGPRINT(("_TdiSubmitRequest: Irp being canceled\n"));

                IoCancelIrp(Irp);
            }

        } while (  Status == STATUS_TIMEOUT );

        if (!NT_SUCCESS(Status)) {
            DBGPRINT(("Could not wait for connection to complete\n"));
            MemoryFree( Event );
            return Status;
        }

        Status = Irp->IoStatus.Status;
    }

    TRACE0(("TDI request complete Status 0x%x\n",Status));

    MemoryFree( Event );

    return(Status);
}

NTSTATUS
_TdiRequestComplete (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Ctx
    )

/*++

Routine Description:

    Completion routine for _TdiRequestSubmit operation.

Arguments:

    IN PDEVICE_OBJECT DeviceObject, - Supplies a pointer to the device object
    IN PIRP Irp, - Supplies the IRP submitted
    IN PVOID Context - Supplies a pointer to the kernel event to release

Return Value:

    NTSTATUS - Status of KeSetEvent


    We return STATUS_MORE_PROCESSING_REQUIRED to prevent the IRP completion
    code from processing this puppy any more.

--*/

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(DeviceObject);

    TRACE0(("_TdiRequestComplete: Context %lx\n", Ctx));

    //
    //  Set the event to the Signalled state with 0 priority increment and
    //  indicate that we will not be blocking soon.
    //

    KeSetEvent((PKEVENT) Ctx, 0, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;

}

PIRP
_TdiAllocateIrp(
    IN PFILE_OBJECT FileObject,
    IN PDEVICE_OBJECT DeviceObject OPTIONAL
    )
/*++

Routine Description:

    This function allocates and builds an I/O request packet.

Arguments:

    FileObject - Supplies a pointer to the file object for which this
        request is directed.  This pointer is copied into the IRP, so
        that the called driver can find its file-based context.  NOTE
        THAT THIS IS NOT A REFERENCED POINTER.  The caller must ensure
        that the file object is not deleted while the I/O operation is
        in progress.  The redir accomplishes this by incrementing a
        reference count in a local block to account for the I/O; the
        local block in turn references the file object.

    DeviceObject - Supplies a pointer to a device object to direct this
        request to.  If this is not supplied, it uses the file object to
        determine the device object.

Return Value:

    PIRP - Returns a pointer to the constructed IRP.

--*/

{
    PIRP Irp;

    if (ARGUMENT_PRESENT(DeviceObject)) {
        Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    } else {
        Irp = IoAllocateIrp(IoGetRelatedDeviceObject(FileObject)->StackSize, FALSE);
    }

    if (Irp == NULL) {
        return(NULL);
    }

    Irp->Tail.Overlay.OriginalFileObject = FileObject;

    Irp->Tail.Overlay.Thread = PsGetCurrentThread();

    Irp->RequestorMode = KernelMode;

    return Irp;
}

NTSTATUS
_TdiReceiveDatagram(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   FileObject,
    IN PDEVICE_OBJECT DeviceObject,
    IN PTRANSPORT_ADDRESS pRemoteAddress,
    IN ULONG RemoteAddressLength,
    IN ULONG RecvFlags,
    IN PVOID pBuffer,
    IN ULONG BufferLength,
    OUT PULONG pReturnLength
    )
{
    PMDL     pMdl;
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;
    PTDI_CONNECTION_INFORMATION pRequestInfo = NULL;
    PTDI_CONNECTION_INFORMATION pReturnInfo = NULL;

	MemoryAllocate( sizeof( *pRequestInfo), &pRequestInfo);
    MemoryAllocate( sizeof( *pReturnInfo), &pReturnInfo);
 
	if ((!pRequestInfo) || (!pReturnInfo)) {
		if (pRequestInfo) MemoryFree( pRequestInfo);
        if (pReturnInfo) MemoryFree( pReturnInfo);
        return( STATUS_INSUFFICIENT_RESOURCES);
    }
 
    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( FileObject, DeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    RtlZeroMemory( pRequestInfo, sizeof( *pRequestInfo) );
    RtlZeroMemory( pReturnInfo,  sizeof( *pReturnInfo) );

    // Copy in info to return remote address
    pReturnInfo->RemoteAddress = pRemoteAddress;
    pReturnInfo->RemoteAddressLength = RemoteAddressLength;

    // Build MDL for buffer
    pMdl = IoAllocateMdl(
               pBuffer,
               BufferLength,
               FALSE,
               FALSE,
               (PIRP)NULL
               );

    if( pMdl == NULL ) {
        MemoryFree( pRequestInfo);
        MemoryFree( pReturnInfo);

        if (IrpAllocated) {
            IoFreeIrp( Irp );
        }

        return( STATUS_INSUFFICIENT_RESOURCES );
    }

    MmBuildMdlForNonPagedPool ( pMdl );

    TdiBuildReceiveDatagram(
        Irp,
        DeviceObject,
        FileObject,
        NULL,        // Completion routine
        NULL,        // Context
        pMdl,        // Mdl address
        BufferLength,
        pRequestInfo,
        pReturnInfo,
        RecvFlags    // InFlags
        );

    Status = _TdiSubmitRequest(pTd, DeviceObject, Irp, FALSE);

    IoFreeMdl( pMdl );

    if ( NT_SUCCESS(Status) ) {
        // Packet length returned is in the Iosb
        *pReturnLength = (ULONG)Irp->IoStatus.Information;
        TRACE0(("_TdiReceiveDatagram: Irp DataLength 0x%x UserDataLength 0x%x, "
        "OptionsLength 0x%x, RemoteAddressLength 0x%x\n", *pReturnLength,
        ReturnInfo.UserDataLength, ReturnInfo.OptionsLength,
        ReturnInfo.RemoteAddressLength));
    }

	MemoryFree( pRequestInfo);
    MemoryFree( pReturnInfo);

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}


NTSTATUS
_TdiSendDatagram(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   FileObject,
    IN PDEVICE_OBJECT DeviceObject,
    IN PTRANSPORT_ADDRESS pRemoteAddress,
    IN ULONG RemoteAddressLength,
    IN PVOID pBuffer,
    IN ULONG BufferLength
    )
{
    PMDL     pMdl;
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;
    TDI_CONNECTION_INFORMATION SendInfo;

    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( FileObject, DeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    RtlZeroMemory( &SendInfo, sizeof(SendInfo) );

    // We must fill in our destination address
    SendInfo.RemoteAddress = pRemoteAddress;
    SendInfo.RemoteAddressLength = RemoteAddressLength;

    // Build MDL for buffer
    pMdl = IoAllocateMdl(
               pBuffer,
               BufferLength,
               FALSE,
               FALSE,
               (PIRP)NULL
               );

    if( pMdl == NULL ) {
        if (IrpAllocated) {
            IoFreeIrp( Irp );
        }
        return( STATUS_INSUFFICIENT_RESOURCES );
    }

    MmBuildMdlForNonPagedPool ( pMdl );

    TdiBuildSendDatagram(
        Irp,
        DeviceObject,
        FileObject,
        NULL,        // Completion routine
        NULL,        // Context
        pMdl,        // Mdl address
        BufferLength,
        &SendInfo
        );

    Status = _TdiSubmitRequest(pTd, DeviceObject, Irp, FALSE);

    IoFreeMdl( pMdl );

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}

NTSTATUS
_TdiQueryAddressInfo(
    IN PTD pTd,
    IN PIRP Irp OPTIONAL,
    IN PFILE_OBJECT   FileObject,
    IN PDEVICE_OBJECT DeviceObject,
    IN PTDI_ADDRESS_INFO pAddressInfo,
    IN ULONG AddressInfoLength
    )
{
    PMDL     pMdl;
    NTSTATUS Status;
    BOOLEAN  IrpAllocated = FALSE;

    if (!ARGUMENT_PRESENT(Irp)) {

        Irp = _TdiAllocateIrp( FileObject, DeviceObject );
        if (Irp == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            return Status;
        }

        IrpAllocated = TRUE;
    }

    // Build MDL for buffer
    pMdl = IoAllocateMdl(
               pAddressInfo,
               AddressInfoLength,
               FALSE,
               FALSE,
               (PIRP)NULL
               );

    if( pMdl == NULL ) {
        if (IrpAllocated) {
            IoFreeIrp( Irp );
        }
        return( STATUS_INSUFFICIENT_RESOURCES );
    }

    MmBuildMdlForNonPagedPool ( pMdl );

    TdiBuildQueryInformation(
        Irp,
        DeviceObject,
        FileObject,
        NULL,        // Completion routine
        NULL,        // Context
        TDI_QUERY_ADDRESS_INFO,
        pMdl
        );

    Status = _TdiSubmitRequest(pTd, DeviceObject, Irp, FALSE);

    IoFreeMdl( pMdl );

    if (IrpAllocated) {
        IoFreeIrp( Irp );
    }

    return(Status);
}