mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
813 lines
22 KiB
813 lines
22 KiB
|
|
/*************************************************************************
|
|
*
|
|
* 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;
|
|
|
|
}
|