windows-nt/Source/XPSP1/NT/termsrv/drivers/td/tdspx/tdspx.c

/*************************************************************************
*
* tdspx.c
*
* Copyright 1998, Microsoft
*  
*************************************************************************/

#include <ntddk.h>
#include <tdi.h>

#include <isnkrnl.h>
#include <ndis.h>
#include <wsnwlink.h>

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

#include "tdtdi.h"
#include "tdspx.h"

#ifdef _HYDRA_
// This becomes the device name
PWCHAR ModuleName = L"tdspx";
#endif

#define REG_IPX_Linkage \
    L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\NwlnkIpx\\Linkage"

#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


/*=============================================================================
==   External Functions Defined
=============================================================================*/

NTSTATUS TdiDeviceOpen( PTD, PSD_OPEN );
NTSTATUS TdiDeviceClose( PTD, PSD_CLOSE );
NTSTATUS TdiDeviceOpenEndpoint( PTD, PVOID, ULONG );
NTSTATUS TdiDeviceBuildTransportNameAndAddress( PTD, PICA_STACK_ADDRESS,
                                                PUNICODE_STRING,
                                                PTRANSPORT_ADDRESS *, PULONG );
NTSTATUS TdiDeviceBuildWildcardAddress( PTD, PTRANSPORT_ADDRESS *, PULONG );
NTSTATUS TdiDeviceWaitForDatagramConnection( PTD, PFILE_OBJECT, PDEVICE_OBJECT,
                                             PTRANSPORT_ADDRESS *, PULONG );
NTSTATUS TdiDeviceCompleteDatagramConnection( PTD, PFILE_OBJECT, PDEVICE_OBJECT, PTRANSPORT_ADDRESS, ULONG );
NTSTATUS TdiDeviceConnectionSend( PTD );
NTSTATUS TdiDeviceReadComplete( PTD, PUCHAR, PULONG );
NTSTATUS _OpenRegKey(PHANDLE, PWCHAR);
NTSTATUS _GetRegMultiSZValue(HANDLE ,PWCHAR,PUNICODE_STRING );
VOID     GetGUID(OUT PUNICODE_STRING, IN  int);


/*=============================================================================
==   External Functions Referenced
=============================================================================*/

NTSTATUS MemoryAllocate( ULONG, PVOID * );
VOID     MemoryFree( PVOID );


/*=============================================================================
==   Internal Functions Defined
=============================================================================*/

NTSTATUS _IpxGetTransportAddress( PTD, int, PULONG, PUCHAR );
NTSTATUS _IPXGetAdapterNumber( int Lana, int * AdpNum );

#if DBG
VOID
DumpIpxAddress(
    PTRANSPORT_ADDRESS p,
    ULONG Len
    );
#endif

/*=============================================================================
==   Global variables
=============================================================================*/

/*
 * Define variables used by afdcommon code
 */
USHORT TdiDeviceEndpointType = TdiConnectionStream;
USHORT TdiDeviceAddressType = TDI_ADDRESS_TYPE_IPX;
USHORT TdiDeviceInBufHeader = 0;
// ULONG TdiDeviceMaxTransportAddressLength = sizeof(TA_IPX_ADDRESS);


/*******************************************************************************
 *
 * TdiDeviceOpen
 *
 *  Allocate and initialize private data structures
 *
 * ENTRY:
 *    pTd (input)
 *       Pointer to TD data structure
 *    pSdOpen (input/output)
 *       Points to the parameter structure SD_OPEN.
 *
 * EXIT:
 *    STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS
TdiDeviceOpen( PTD pTd, PSD_OPEN pSdOpen )
{
    return( STATUS_SUCCESS );
}


/*******************************************************************************
 *
 * TdiDeviceClose
 *
 *  Close transport driver
 *
 *  NOTE: this must not close the current connection endpoint
 *
 * ENTRY:
 *    pTd (input)
 *       Pointer to TD data structure
 *    pSdClose (input/output)
 *       Points to the parameter structure SD_CLOSE.
 *
 * EXIT:
 *    STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS 
TdiDeviceClose( PTD pTd, PSD_CLOSE pSdClose )
{
    return( STATUS_SUCCESS );
}


/*******************************************************************************
 *
 * TdiDeviceOpenEndpoint
 *
 *  Open an existing endpoint
 *
 * ENTRY:
 *    pTd (input)
 *       Pointer to TD data structure
 *    pIcaEndpoint (input)
 *       Pointer to ICA endpoint structure
 *    IcaEndpointLength (input)
 *       length of endpoint data
 *
 * EXIT:
 *    STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS
TdiDeviceOpenEndpoint(
    PTD pTd,
    PVOID pIcaEndpoint,
    ULONG IcaEndpointLength
    )
{
    return( STATUS_SUCCESS );
}


/*****************************************************************************
 *
 *  TdiDeviceBuildTransportNameAndAddress
 *
 *  Build the Transport Name and Address given an optional ICA_STACK_ADDRESS,
 *  or the Lana value from the pTd->Params structure.
 *
 * ENTRY:
 *
 *   pTd (input)
 *     pointer to TD data structure
 *   pLocalAddress (input)
 *     pointer to local address to use (OPTIONAL)
 *   pTransportName (output)
 *     pointer to UNICODE_STRING to return transport name
 *     NOTE: the buffer pointed to be pTransportName.Buffer must
 *           be free'd by the caller
 *   ppTransportAddress (output)
 *     pointer to location to return TRANSPORT_ADDRESS structure
 *     NOTE: the transport address buffer must be free'd by the caller
 *   pTransportAddressLength (output)
 *     pointer to location to return TransportAddress length
 *
 * EXIT:
 *  STATUS_SUCCESS - Success
 *
 ****************************************************************************/

NTSTATUS
TdiDeviceBuildTransportNameAndAddress(
    PTD pTd,
    PICA_STACK_ADDRESS pLocalAddress,
    PUNICODE_STRING pTransportName,
    PTRANSPORT_ADDRESS *ppTransportAddress,
    PULONG pTransportAddressLength
    )
{
    PTDI_ADDRESS_IPX pIpxAddress;
    int Lana;
    NTSTATUS Status;

    /*
     * For SPX, the transport device name is fixed,
     * so just allocate and initialize the transport name string here.
     */
    Status = MemoryAllocate( sizeof(DD_SPX_DEVICE_NAME), &pTransportName->Buffer );
    if ( !NT_SUCCESS( Status ) ) {
        DBGPRINT(("TdiDeviceBuildTransportNameAndAddress: SPX Could not allocate memory\n"));
	goto badmalloc1;
    }
    wcscpy( pTransportName->Buffer, DD_SPX_DEVICE_NAME );
    pTransportName->Length = sizeof(DD_SPX_DEVICE_NAME) - sizeof(UNICODE_NULL);
    pTransportName->MaximumLength = pTransportName->Length + sizeof(UNICODE_NULL);

    /*
     * Allocate a transport address structure
     */
    *pTransportAddressLength = sizeof(TRANSPORT_ADDRESS) +
                               sizeof(TDI_ADDRESS_IPX);
    Status = MemoryAllocate( *pTransportAddressLength, ppTransportAddress );
    if ( !NT_SUCCESS( Status ) ) {
        DBGPRINT(("TdiDeviceBuildTransportNameAndAddress: SPX Could not allocate memory\n"));
        goto badmalloc2;
    }

    /*
     * Initialize the static part of the transport address
     */
    (*ppTransportAddress)->TAAddressCount = 1;
    (*ppTransportAddress)->Address[0].AddressLength = sizeof(TDI_ADDRESS_IPX);
    (*ppTransportAddress)->Address[0].AddressType = TDI_ADDRESS_TYPE_IPX;
    pIpxAddress = (PTDI_ADDRESS_IPX)(*ppTransportAddress)->Address[0].Address;
    pIpxAddress->Socket = htons( CITRIX_SPX_SOCKET );

    /*
     * If a local address is specified, then use it.
     */
    if ( pLocalAddress ) {

        /*
         * Skip over the address family(type) data (bytes 0&1) of the
         * local address struct, and copy the remainder of the address
         * directly to the Address field of the TransportAddress struct.
         */
        ASSERT( *(PUSHORT)pLocalAddress == TDI_ADDRESS_TYPE_IPX );
        RtlCopyMemory( pIpxAddress, &((PCHAR)pLocalAddress)[2], sizeof(TDI_ADDRESS_IPX) );

	TRACE1(("TDSPX: TdiDeviceBuildTransportAddress: Local address:\n"));

    /*
     * There was no local address specified.
     * In this case, we use the LanAdapter value from the PDPARAMS
     * structure to lookup the corresponding IPX address.
     */
    } else if ( (Lana = pTd->Params.Network.LanAdapter) ) {

        /*
         * Get Local Address Information
         */
        Status = _IpxGetTransportAddress( pTd, Lana,
                                          &pIpxAddress->NetworkAddress,
                                          pIpxAddress->NodeAddress );
        if ( !NT_SUCCESS( Status ) ) {
	    DBGPRINT(("TDSPX: TdiDeviceBuildTransportAddress: Bad Lana 0x%x\n",Lana));
	    goto badadapterdata;
        }

	TRACE1(("TDSPX: TdiDeviceBuildTransportAddress: Found address for Lana 0x%x\n",Lana));

    /*
     * No LanAdapter value was specified, so use the wildcard address (zero)
     */
    } else {
	DBGPRINT(("TDSPX: TdiDeviceBuildTransportAddress: Wildcard address"));
        pIpxAddress->NetworkAddress = 0;
        RtlZeroMemory( pIpxAddress->NodeAddress,
                       sizeof(pIpxAddress->NodeAddress) );
    }

#if DBGTRACE
    DumpIpxAddress( *ppTransportAddress, *pTransportAddressLength );
#endif

    return( STATUS_SUCCESS );

/*=============================================================================
==   Error returns
=============================================================================*/

badadapterdata:
    MemoryFree( *ppTransportAddress );

badmalloc2:
    MemoryFree( pTransportName->Buffer );

badmalloc1:
    return( Status );
}


/*****************************************************************************
 *
 *  TdiDeviceBuildWildcardAddress
 *
 *  Build a wildcard Address for this protocol.
 *
 * ENTRY:
 *
 *   pTd (input)
 *     pointer to TD data structure
 *   ppWildcardAddress (output)
 *     pointer to location to return TRANSPORT_ADDRESS structure
 *     NOTE: the transport address buffer must be free'd by the caller
 *   pWildcardAddressLength (output)
 *     pointer to location to return TransportAddress length
 *
 * EXIT:
 *  STATUS_SUCCESS - Success
 *
 ****************************************************************************/

NTSTATUS
TdiDeviceBuildWildcardAddress(
    PTD pTd,
    PTRANSPORT_ADDRESS *ppWildcardAddress,
    PULONG pWildcardAddressLength
    )
{
    PTDI_ADDRESS_IPX pIpxAddress;
    NTSTATUS Status;

    /*
     * Allocate a transport address structure
     */
    *pWildcardAddressLength = sizeof(TRANSPORT_ADDRESS) +
                               sizeof(TDI_ADDRESS_IPX);
    Status = MemoryAllocate( *pWildcardAddressLength, ppWildcardAddress );
    if ( !NT_SUCCESS( Status ) )
        return( Status );

    /*
     * Initialize the static part of the transport address
     */
    (*ppWildcardAddress)->TAAddressCount = 1;
    (*ppWildcardAddress)->Address[0].AddressLength = sizeof(TDI_ADDRESS_IPX);
    (*ppWildcardAddress)->Address[0].AddressType = TDI_ADDRESS_TYPE_IPX;
    pIpxAddress = (PTDI_ADDRESS_IPX)(*ppWildcardAddress)->Address[0].Address;
    pIpxAddress->NetworkAddress = 0;
    RtlZeroMemory( pIpxAddress->NodeAddress,
                   sizeof(pIpxAddress->NodeAddress) );
    pIpxAddress->Socket = 0;

    return( STATUS_SUCCESS );
}


/*****************************************************************************
 *
 *  TdiDeviceWaitForDatagramConnection
 *
 *  Wait for a datagram connection request, validate it,
 *  and return the remote transport address of the connection.
 *
 * ENTRY:
 *
 *   pTd (input)
 *     pointer to TD data structure
 *   pFileObject (input)
 *     pointer to file object to wait for a connection on
 *   ppRemoteAddress (output)
 *     pointer to location to return TRANSPORT_ADDRESS structure
 *     NOTE: the transport address buffer must be free'd by the caller
 *   pRemoteAddressLength (output)
 *     pointer to location to return RemoteAddress length
 *
 * EXIT:
 *  STATUS_SUCCESS - Success
 *
 ****************************************************************************/

NTSTATUS
TdiDeviceWaitForDatagramConnection(
    PTD pTd,
    PFILE_OBJECT pFileObject,
    PDEVICE_OBJECT pDeviceObject,
    PTRANSPORT_ADDRESS *ppRemoteAddress,
    PULONG pRemoteAddressLength
    )
{
    return( STATUS_NOT_SUPPORTED );
}


/*****************************************************************************
 *
 *  TdiDeviceCompleteDatagramConnection
 *
 *  Do any final work to complete a datagram connection.
 *
 * ENTRY:
 *
 *   pTd (input)
 *     pointer to TD data structure
 *   pFileObject (input)
 *     pointer to file object for this connection
 *
 * EXIT:
 *  STATUS_SUCCESS - Success
 *
 ****************************************************************************/

NTSTATUS
TdiDeviceCompleteDatagramConnection(
    PTD pTd, 
    PFILE_OBJECT pFileObject,
    PDEVICE_OBJECT pDeviceObject,
    PTRANSPORT_ADDRESS pTransportAddress,
    ULONG TransportAddressLength
    )
{
    return( STATUS_NOT_SUPPORTED );
}


/*******************************************************************************
 *
 *  TdiDeviceConnectionSend
 *
 *  Initialize host module data structure
 *  -- this structure gets sent to the client
 *
 *
 * ENTRY:
 *    pTd (input)
 *       Pointer to td data structure
 *
 * EXIT:
 *    STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS 
TdiDeviceConnectionSend( PTD pTd )
{
    PCLIENTMODULES pClient;

    /*
     *  Get pointer to client structure
     */
    pClient = pTd->pClient;

    /*
     *  Initialize Td host module structure
     */
    pClient->TdVersionL = VERSION_HOSTL_TDSPX;
    pClient->TdVersionH = VERSION_HOSTH_TDSPX;
    pClient->TdVersion  = VERSION_HOSTH_TDSPX;

    return( STATUS_SUCCESS );
}


/*******************************************************************************
 *
 *  TdiDeviceReadComplete
 *
 *  Do any read complete processing
 *
 *
 * ENTRY:
 *    pTd (input)
 *       Pointer to td data structure
 *    pBuffer (input)
 *       Pointer to input buffer
 *    pByteCount (input/output)
 *       Pointer to location containing byte count read
 *
 * EXIT:
 *    STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS 
TdiDeviceReadComplete( PTD pTd, PUCHAR pBuffer, PULONG pByteCount )
{
    return( STATUS_SUCCESS );
}


/*******************************************************************************
 *
 *  _IpxGetTransportAddress
 *
 *  Get IPX transport address for a given LanAdapter number
 *
 *
 *  ENTRY:
 *     pTd (input)
 *        pointer to TD data structure
 *     Lana (input)
 *        Lan Adapter number
 *     pNetworkAddress (output)
 *        pointer to location to return NetworkAddress
 *     pNodeAddress (output)
 *        pointer to location to return NodeAddress
 *
 *
 *  EXIT:
 *     STATUS_SUCCESS - no error
 *
 ******************************************************************************/

NTSTATUS
_IpxGetTransportAddress(
    PTD pTd,
    int Lana,
    PULONG pNetworkAddress,
    PUCHAR pNodeAddress
    )
{
    OBJECT_ATTRIBUTES objectAttributes;
    IO_STATUS_BLOCK ioStatusBlock;
    UNICODE_STRING nameString;
    HANDLE IPXHandle;
    ULONG tdiBufferLength;
    PSTREAMS_TDI_ACTION tdiBuffer;
    ULONG cmd;
    PIPX_ADDRESS_DATA pIpxAddressData;
    PFILE_OBJECT pFileObject;
    NTSTATUS Status;
    int IpxAdapterNum = 0;
    /*
     * Open a Handle to the IPX driver.
     */
    RtlInitUnicodeString( &nameString, DD_IPX_DEVICE_NAME );

    InitializeObjectAttributes(
        &objectAttributes,
        &nameString,
        OBJ_CASE_INSENSITIVE,
        (HANDLE) NULL,
        (PSECURITY_DESCRIPTOR) NULL
        );

    Status = ZwCreateFile( &IPXHandle,
                           SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
                           &objectAttributes,
                           &ioStatusBlock,
                           NULL,
                           FILE_ATTRIBUTE_NORMAL,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           FILE_OPEN_IF,
                           0,
                           NULL,
                           0
                           );
    if ( !NT_SUCCESS( Status ) )
        return( Status );

    /*
     * Allocate a TDI buffer to do the IOCTL.
     */
    tdiBufferLength = sizeof(STREAMS_TDI_ACTION) + sizeof(ULONG) +
                      sizeof(IPX_ADDRESS_DATA);
    Status = MemoryAllocate( tdiBufferLength, &tdiBuffer );
    if ( !NT_SUCCESS( Status ) ) {
        ZwClose( IPXHandle );
        return( Status );
    }

    // Get IPX Adapter Num from winstation Lana ID

    
    Status = _IPXGetAdapterNumber( Lana, &IpxAdapterNum);
    if ( !NT_SUCCESS( Status ) ) {
        ZwClose( IPXHandle );
        return( Status );
    } 

    /*
     * Fill in the tdiBuffer header
     */
    RtlMoveMemory( &tdiBuffer->Header.TransportId, "MISN", 4 );
    // use the following since we opened a control channel above
    tdiBuffer->DatagramOption = NWLINK_OPTION_CONTROL;

    /**
       Fill out the buffer, the buffer looks like this:

       ULONG cmd
       data passed.
    **/

    cmd = MIPX_GETCARDINFO;
    memcpy( tdiBuffer->Buffer, &cmd, sizeof(ULONG));


    tdiBuffer->BufferLength = sizeof(ULONG) + sizeof(IPX_ADDRESS_DATA);

    pIpxAddressData = (PIPX_ADDRESS_DATA)(tdiBuffer->Buffer + sizeof(ULONG));
    pIpxAddressData->adapternum = IpxAdapterNum;

    Status = ObReferenceObjectByHandle( IPXHandle,
                                        0,
                                        NULL,
                                        KernelMode,
                                        (PVOID *)&pFileObject,
                                        NULL
                                        );
    ASSERT( Status == STATUS_SUCCESS );

    Status = CtxDeviceIoControlFile( pFileObject,
                                     IOCTL_TDI_ACTION,
                                     NULL,
                                     0,
                                     tdiBuffer,
                                     tdiBufferLength,
                                     FALSE,
                                     NULL,
                                     &ioStatusBlock,
                                     NULL
                                     );
    ObDereferenceObject( pFileObject );

    ZwClose( IPXHandle );

    if ( Status == STATUS_SUCCESS ) {
        RtlCopyMemory( pNetworkAddress, pIpxAddressData->netnum, 
                       sizeof(pIpxAddressData->netnum) );
        RtlCopyMemory( pNodeAddress, pIpxAddressData->nodenum, 
                       sizeof(pIpxAddressData->nodenum) );
    }
    
    return( Status );
}

#if DBG
VOID
DumpIpxAddress(
    PTRANSPORT_ADDRESS p,
    ULONG Len
    )
{
    ULONG j;
    LONG i;
    PTDI_ADDRESS_IPX Ipx;

    DbgPrint("TAAddressCount %d, TotalLen %d\n",p->TAAddressCount,Len);

    for( i=0; i < p->TAAddressCount; i++ ) {

        DbgPrint("AddressLength %d, AddressType %d\n",p->Address[i].AddressLength,p->Address[i].AddressType);

        Ipx = (PTDI_ADDRESS_IPX)&p->Address[i].Address[0];

	DbgPrint("Network 0x%x Socket 0x%x\n",Ipx->NetworkAddress,Ipx->Socket);

	for( j=0; j < 6; j++ ) {
            DbgPrint("%x:",Ipx->NodeAddress[j]);
        }
        DbgPrint("\n\n");
    }
}
#endif



NTSTATUS
_IPXGetAdapterNumber(
    int Lana,
    int * AdpNum 
    )
/*++
Routine Description:

    Get the IPX Lan Adapter number using the instation Lana ID index
    
Arguments:
    
    Lana   - IN the winstation Lana ID index
    AdpNum - OUT the IPX Lana Adapter num

Return Value:

    return nt status

--*/
{

    NTSTATUS Status;
    int  AdapterNum;
    UNICODE_STRING RouteString;
    UNICODE_STRING NameString;
    
    HANDLE KeyHandle = NULL;        
    PWSTR  RouteStr, Str;
    unsigned RouteLen, Len;
    


    /* 
     * Convert winstation Lana_ID to Network Adapter number
     */    

    
    RtlInitUnicodeString( &RouteString , NULL );
    GetGUID( &RouteString , Lana );
    RouteLen = RouteString.Length;    
    RouteStr = RouteString.Buffer;
    AdapterNum =0;
    
#if DBG
    KdPrint( ( "TDIPX: _TcpGetTransportAddress Length = %d GUID = %ws\n" , RouteLen, RouteStr ) );
#endif

    if (RouteLen < (2 * sizeof(UNICODE_NULL))) {        
        return( STATUS_DEVICE_DOES_NOT_EXIST );
    }


    RtlInitUnicodeString( &NameString, NULL );

    Status = _OpenRegKey( &KeyHandle, REG_IPX_Linkage );
    if ( !NT_SUCCESS( Status ) )
        return Status;

    
    NameString.Length = 0;
    NameString.MaximumLength = 0;
    NameString.Buffer = NULL;
    Status = _GetRegMultiSZValue( KeyHandle, L"Route", &NameString );
    ZwClose( KeyHandle );

    if ( !NT_SUCCESS( Status ) )
        return Status;

    if (NameString.Length < (2 * sizeof(WCHAR))) {
        return(STATUS_DEVICE_DOES_NOT_EXIST);       
    }

    Len = NameString.Length;
    Str = NameString.Buffer;
    Status = STATUS_DEVICE_DOES_NOT_EXIST;
    AdapterNum = 0;

    for (;;) {
        // Check current string to see if it's a GUID (it must start with an
        // open brace after initial double-quote).
        if (Str[1] == L'{') {
            if ( wcsncmp( (PWSTR) &Str[1],RouteStr, wcslen(RouteStr)-1) == 0) {
#if DBG
            KdPrint( ( "TDIPX: _TcpGetTransportAddress: Get Lan Adapter Number = %i\n",AdapterNum ) );
#endif
                Status = STATUS_SUCCESS;
                break;
            }
            else {
//      KdPrint( ( "TDIPX: _TcpGetTransportAddress, No this lana Adapter = %i\n",AdapterNum ) );
                AdapterNum ++;
            }

        }
        // Skip through current string past NULL.
        while (Len >= sizeof(WCHAR)) {
            Len -= sizeof(WCHAR);
            if (*Str++ == UNICODE_NULL)
                break;
        }
        // Check for index out of range.
        if (Len < (2 * sizeof(UNICODE_NULL))) {
            break;                    
            }
    }

    if ( !NT_SUCCESS( Status ) )
         return Status;

    *AdpNum = AdapterNum;
    return STATUS_SUCCESS;    
  
}