1045 lines
30 KiB
C++
1045 lines
30 KiB
C++
/////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2001 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// connect.cpp
|
|
//
|
|
// Abstract:
|
|
// This module contains code which deals with making and breaking
|
|
// connections
|
|
//
|
|
//////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "sysvars.h"
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// private constants, types, and prototypes
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
const PCHAR strFunc1 = "TSConnect";
|
|
const PCHAR strFunc2 = "TSDisconnect";
|
|
// const PCHAR strFunc3 = "TSIsConnected";
|
|
const PCHAR strFunc4 = "TSConnectHandler";
|
|
const PCHAR strFunc5 = "TSDisconnectHandler";
|
|
const PCHAR strFunc6 = "TSListen";
|
|
// const PCHAR strFuncP1 = "TSGenAcceptComplete";
|
|
const PCHAR strFuncP2 = "TSGenConnectComplete";
|
|
|
|
//
|
|
// this context structure stores information needed to complete
|
|
// the request in the completion handler
|
|
//
|
|
struct CONNECT_CONTEXT
|
|
{
|
|
PIRP pUpperIrp; // irp from dll to complete
|
|
ULONG ulWhichCommand; // command that is being completed
|
|
ULONG ulListenFlag; // 0 or TDI_QUERY_ACCEPT
|
|
PENDPOINT_OBJECT pEndpoint; // connection endpoint
|
|
PIRP_POOL pIrpPool;
|
|
PTDI_CONNECTION_INFORMATION
|
|
pTdiConnectInfo;
|
|
};
|
|
typedef CONNECT_CONTEXT *PCONNECT_CONTEXT;
|
|
|
|
|
|
//
|
|
// completion functions
|
|
//
|
|
TDI_STATUS
|
|
TSGenConnectComplete(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
);
|
|
|
|
TDI_STATUS
|
|
TSGenAcceptComplete(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
);
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// public functions
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------
|
|
//
|
|
// Function: TSConnect
|
|
//
|
|
// Arguments: pEndpoint -- connection endpoint structure
|
|
// pSendBuffer -- arguments from user dll
|
|
// pIrp -- completion information
|
|
//
|
|
// Returns: NTSTATUS (normally pending)
|
|
//
|
|
// Descript: This function attempts to connect the local endpoint object
|
|
// with a remote endpoint
|
|
//
|
|
// -----------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
TSConnect(PENDPOINT_OBJECT pEndpoint,
|
|
PSEND_BUFFER pSendBuffer,
|
|
PIRP pUpperIrp)
|
|
{
|
|
PTRANSPORT_ADDRESS pTransportAddress
|
|
= (PTRANSPORT_ADDRESS)&pSendBuffer->COMMAND_ARGS.ConnectArgs.TransAddr;
|
|
ULONG ulTimeout
|
|
= pSendBuffer->COMMAND_ARGS.ConnectArgs.ulTimeout;
|
|
//
|
|
// show debug, if it is turned on
|
|
//
|
|
if (ulDebugLevel & ulDebugShowCommand)
|
|
{
|
|
DebugPrint2("\nCommand = ulCONNECT\n"
|
|
"FileObject = %p\n"
|
|
"Timeout = %u\n",
|
|
pEndpoint,
|
|
ulTimeout);
|
|
TSPrintTaAddress(pTransportAddress->Address);
|
|
}
|
|
|
|
//
|
|
// make sure all is kosher
|
|
//
|
|
if (pEndpoint->fIsConnected)
|
|
{
|
|
DebugPrint1("%s: endpoint already connected\n", strFunc1);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
if (!pEndpoint->pAddressObject)
|
|
{
|
|
DebugPrint1("%s: endpoint not associated with transport address\n",
|
|
strFunc1);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// allocate all the necessary structures
|
|
//
|
|
PCONNECT_CONTEXT pConnectContext;
|
|
PTDI_CONNECTION_INFORMATION pTdiConnectInfo = NULL;
|
|
|
|
//
|
|
// our context
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pConnectContext,
|
|
sizeof(CONNECT_CONTEXT),
|
|
strFunc1,
|
|
"ConnectContext")) != STATUS_SUCCESS)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// the connection information structure
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pTdiConnectInfo,
|
|
sizeof(TDI_CONNECTION_INFORMATION)
|
|
+ sizeof(TRANSADDR),
|
|
strFunc1,
|
|
"TdiConnectionInformation")) == STATUS_SUCCESS)
|
|
//
|
|
// set up the TdiConnectionInformation
|
|
//
|
|
{
|
|
PUCHAR pucTemp = (PUCHAR)pTdiConnectInfo;
|
|
ULONG ulAddrLength
|
|
= FIELD_OFFSET(TRANSPORT_ADDRESS, Address)
|
|
+ FIELD_OFFSET(TA_ADDRESS, Address)
|
|
+ pTransportAddress->Address[0].AddressLength;
|
|
|
|
pucTemp += sizeof(TDI_CONNECTION_INFORMATION);
|
|
|
|
pTdiConnectInfo->RemoteAddress = pucTemp;
|
|
pTdiConnectInfo->RemoteAddressLength = ulAddrLength;
|
|
RtlCopyMemory(pucTemp,
|
|
pTransportAddress,
|
|
ulAddrLength);
|
|
|
|
}
|
|
else
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// set up the completion context
|
|
//
|
|
pConnectContext->pUpperIrp = pUpperIrp;
|
|
pConnectContext->pTdiConnectInfo = pTdiConnectInfo;
|
|
pConnectContext->pEndpoint = pEndpoint;
|
|
pConnectContext->ulWhichCommand = TDI_CONNECT;
|
|
|
|
|
|
//
|
|
// finally, the irp itself
|
|
//
|
|
PIRP pLowerIrp = TSAllocateIrp(pEndpoint->GenHead.pDeviceObject,
|
|
NULL);
|
|
|
|
if (pLowerIrp)
|
|
{
|
|
LONGLONG llTimeout;
|
|
PLONGLONG pllTimeout = NULL;
|
|
|
|
if (ulTimeout)
|
|
{
|
|
llTimeout = Int32x32To64(ulTimeout, -10000);
|
|
pllTimeout = &llTimeout;
|
|
}
|
|
|
|
//
|
|
// if made it to here, everything is correctly allocated
|
|
// set up irp and and call the tdi provider
|
|
//
|
|
#pragma warning(disable: CONSTANT_CONDITIONAL)
|
|
|
|
TdiBuildConnect(pLowerIrp,
|
|
pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->GenHead.pFileObject,
|
|
TSGenConnectComplete,
|
|
pConnectContext,
|
|
pllTimeout,
|
|
pTdiConnectInfo,
|
|
NULL); // ReturnConnectionInfo
|
|
|
|
#pragma warning(default: CONSTANT_CONDITIONAL)
|
|
|
|
//
|
|
// make the call to the tdi provider
|
|
//
|
|
pSendBuffer->pvLowerIrp = pLowerIrp; // so command can be cancelled
|
|
|
|
NTSTATUS lStatus = IoCallDriver(pEndpoint->GenHead.pDeviceObject,
|
|
pLowerIrp);
|
|
|
|
if ((!NT_SUCCESS(lStatus)) && (ulDebugLevel & ulDebugShowCommand))
|
|
{
|
|
DebugPrint2("%s: unexpected status for IoCallDriver [0x%08x]\n",
|
|
strFunc1,
|
|
lStatus);
|
|
}
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
//
|
|
// get here if there was an allocation failure
|
|
// need to clean up everything else...
|
|
//
|
|
cleanup:
|
|
if (pConnectContext)
|
|
{
|
|
TSFreeMemory(pConnectContext);
|
|
}
|
|
if (pTdiConnectInfo)
|
|
{
|
|
TSFreeMemory(pTdiConnectInfo);
|
|
}
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------
|
|
//
|
|
// Function: TSDisconnect
|
|
//
|
|
// Arguments: pEndpoint -- connection endpoint structure
|
|
// pIrp -- completion information
|
|
//
|
|
// Returns: NTSTATUS (normally pending)
|
|
//
|
|
// Descript: This function attempts to disconnect a local endpoint from
|
|
// a remote endpoint
|
|
//
|
|
// -----------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
TSDisconnect(PENDPOINT_OBJECT pEndpoint,
|
|
PSEND_BUFFER pSendBuffer,
|
|
PIRP pUpperIrp)
|
|
{
|
|
ULONG ulFlags = pSendBuffer->COMMAND_ARGS.ulFlags;
|
|
|
|
if (ulFlags != TDI_DISCONNECT_RELEASE)
|
|
{
|
|
ulFlags = TDI_DISCONNECT_ABORT;
|
|
}
|
|
|
|
//
|
|
// show debug, if it is turned on
|
|
//
|
|
if (ulDebugLevel & ulDebugShowCommand)
|
|
{
|
|
DebugPrint2("\nCommand = ulDISCONNECT\n"
|
|
"EndpointObject = %p\n"
|
|
"Flags = 0x%x\n",
|
|
pEndpoint,
|
|
ulFlags);
|
|
}
|
|
|
|
//
|
|
// make sure all is kosher
|
|
//
|
|
if (!pEndpoint->fIsConnected)
|
|
{
|
|
DebugPrint1("%s: endpoint not currently connected\n", strFunc2);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// allocate all the necessary structures
|
|
//
|
|
PCONNECT_CONTEXT pConnectContext;
|
|
|
|
//
|
|
// first, our context
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pConnectContext,
|
|
sizeof(CONNECT_CONTEXT),
|
|
strFunc2,
|
|
"ConnectContext")) == STATUS_SUCCESS)
|
|
{
|
|
pConnectContext->pUpperIrp = pUpperIrp;
|
|
pConnectContext->ulWhichCommand = TDI_DISCONNECT;
|
|
pConnectContext->pEndpoint = pEndpoint;
|
|
|
|
//
|
|
// then the irp itself
|
|
//
|
|
PIRP pLowerIrp = TSAllocateIrp(pEndpoint->GenHead.pDeviceObject,
|
|
NULL);
|
|
|
|
if (pLowerIrp)
|
|
{
|
|
//
|
|
// if made it to here, everything is correctly allocated
|
|
// set up everything and call the tdi provider
|
|
//
|
|
|
|
#pragma warning(disable: CONSTANT_CONDITIONAL)
|
|
|
|
TdiBuildDisconnect(pLowerIrp,
|
|
pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->GenHead.pFileObject,
|
|
TSGenConnectComplete,
|
|
pConnectContext,
|
|
NULL, // pLargeInteger Time
|
|
ulFlags, // TDI_DISCONNECT _ABORT or _RELEASE
|
|
NULL, // RequestConnectionInfo
|
|
NULL); // ReturnConnectionInfo
|
|
|
|
#pragma warning(default: CONSTANT_CONDITIONAL)
|
|
|
|
//
|
|
// make the call to the tdi provider
|
|
//
|
|
pSendBuffer->pvLowerIrp = pLowerIrp; // so command can be cancelled
|
|
pEndpoint->fStartedDisconnect = TRUE;
|
|
|
|
NTSTATUS lStatus = IoCallDriver(pEndpoint->GenHead.pDeviceObject,
|
|
pLowerIrp);
|
|
|
|
if ((!NT_SUCCESS(lStatus)) && (ulDebugLevel & ulDebugShowCommand))
|
|
{
|
|
DebugPrint2("%s: unexpected status for IoCallDriver [0x%08x]\n",
|
|
strFunc2,
|
|
lStatus);
|
|
}
|
|
return STATUS_PENDING;
|
|
}
|
|
TSFreeMemory(pConnectContext);
|
|
}
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
|
|
|
|
// --------------------------------------------------
|
|
//
|
|
// Function: TSListen
|
|
//
|
|
// Arguments: pEndpoint -- connection endpoint structure
|
|
//
|
|
// Returns: status of operation (usually success)
|
|
//
|
|
// Descript: Wait for an incoming call request
|
|
//
|
|
// --------------------------------------------------
|
|
|
|
NTSTATUS
|
|
TSListen(PENDPOINT_OBJECT pEndpoint)
|
|
{
|
|
ULONG ulListenFlag = 0;
|
|
|
|
//
|
|
// show debug, if it is turned on
|
|
//
|
|
if (ulDebugLevel & ulDebugShowCommand)
|
|
{
|
|
DebugPrint1("\nCommand = ulLISTEN\n"
|
|
"FileObject = %p\n",
|
|
pEndpoint);
|
|
}
|
|
|
|
//
|
|
// make sure all is kosher
|
|
//
|
|
if (pEndpoint->fIsConnected)
|
|
{
|
|
DebugPrint1("%s: endpoint already connected\n", strFunc6);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
if (!pEndpoint->pAddressObject)
|
|
{
|
|
DebugPrint1("%s: endpoint not associated with transport address\n",
|
|
strFunc6);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// allocate all the necessary structures
|
|
//
|
|
PCONNECT_CONTEXT pConnectContext;
|
|
PTDI_CONNECTION_INFORMATION pTdiConnectInfo = NULL;
|
|
|
|
//
|
|
// our context
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pConnectContext,
|
|
sizeof(CONNECT_CONTEXT),
|
|
strFunc6,
|
|
"ConnectContext")) != STATUS_SUCCESS)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// the connection information structure
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pTdiConnectInfo,
|
|
sizeof(TDI_CONNECTION_INFORMATION),
|
|
strFunc6,
|
|
"TdiConnectionInformation")) == STATUS_SUCCESS)
|
|
//
|
|
// set up the TdiConnectionInformation
|
|
//
|
|
{
|
|
pTdiConnectInfo->UserData = NULL;
|
|
pTdiConnectInfo->UserDataLength = 0;
|
|
pTdiConnectInfo->RemoteAddress = NULL;
|
|
pTdiConnectInfo->RemoteAddressLength = 0;
|
|
pTdiConnectInfo->Options = &pConnectContext->ulListenFlag;
|
|
pTdiConnectInfo->OptionsLength = sizeof(ULONG);
|
|
|
|
|
|
//
|
|
// set up the completion context
|
|
// note that the upper irp is NOT passed!
|
|
//
|
|
pConnectContext->pUpperIrp = NULL;
|
|
pConnectContext->pTdiConnectInfo = pTdiConnectInfo;
|
|
pConnectContext->pEndpoint = pEndpoint;
|
|
pConnectContext->ulWhichCommand = TDI_LISTEN;
|
|
pConnectContext->ulListenFlag = ulListenFlag;
|
|
|
|
if (!pEndpoint->pAddressObject->pIrpPool)
|
|
{
|
|
pEndpoint->pAddressObject->pIrpPool
|
|
= TSAllocateIrpPool(pEndpoint->pAddressObject->GenHead.pDeviceObject,
|
|
ulIrpPoolSize);
|
|
pConnectContext->pIrpPool = pEndpoint->pAddressObject->pIrpPool;
|
|
}
|
|
|
|
//
|
|
// finally, the irp itself
|
|
//
|
|
PIRP pLowerIrp = TSAllocateIrp(pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->pAddressObject->pIrpPool);
|
|
|
|
if (pLowerIrp)
|
|
{
|
|
//
|
|
// if made it to here, everything is correctly allocated
|
|
// set up irp and call the tdi provider
|
|
//
|
|
#pragma warning(disable: CONSTANT_CONDITIONAL)
|
|
|
|
TdiBuildListen(pLowerIrp,
|
|
pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->GenHead.pFileObject,
|
|
TSGenAcceptComplete,
|
|
pConnectContext,
|
|
ulListenFlag,
|
|
pTdiConnectInfo,
|
|
NULL); // ReturnConnectionInfo
|
|
|
|
#pragma warning(default: CONSTANT_CONDITIONAL)
|
|
|
|
NTSTATUS lStatus = IoCallDriver(pEndpoint->GenHead.pDeviceObject,
|
|
pLowerIrp);
|
|
|
|
if ((!NT_SUCCESS(lStatus)) && (ulDebugLevel & ulDebugShowCommand))
|
|
{
|
|
DebugPrint2("%s: unexpected status for IoCallDriver [0x%08x]\n",
|
|
strFunc6,
|
|
lStatus);
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
//
|
|
// get here if there was an allocation failure
|
|
// need to clean up everything else...
|
|
//
|
|
cleanup:
|
|
if (pConnectContext)
|
|
{
|
|
TSFreeMemory(pConnectContext);
|
|
}
|
|
if (pTdiConnectInfo)
|
|
{
|
|
TSFreeMemory(pTdiConnectInfo);
|
|
}
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------
|
|
//
|
|
// Function: TSIsConnected
|
|
//
|
|
// Arguments: pEndpoint -- connection endpoint structure
|
|
// pReceiveBuffer -- put results in here
|
|
//
|
|
// Returns: STATUS_SUCCESS
|
|
//
|
|
// Descript: Checks to see if endpoint is currently connected
|
|
//
|
|
// --------------------------------------------------
|
|
|
|
NTSTATUS
|
|
TSIsConnected(PENDPOINT_OBJECT pEndpoint,
|
|
PRECEIVE_BUFFER pReceiveBuffer)
|
|
{
|
|
pReceiveBuffer->RESULTS.ulReturnValue = pEndpoint->fIsConnected;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------
|
|
//
|
|
// Function: TSConnectHandler
|
|
//
|
|
// Arguments: pvTdiEventContext -- here, ptr to address object
|
|
// lRemoteAddressLength -- # bytes in remote address
|
|
// pvRemoteAddress -- pTransportAddress of remote
|
|
// lUserDataLength -- length of data at pvUserData
|
|
// pvUserData -- connect data from remote
|
|
// lOptionsLength -- length of data in pvOptions
|
|
// pvOptions -- transport-specific connect options
|
|
// pConnectionContext -- return ptr to connection context
|
|
// ppAcceptIrp -- return ptr to TdiBuildAccept irp
|
|
//
|
|
// Returns: STATUS_CONNECTION_REFUSED if are rejecting connection
|
|
// STATUS_MORE_PROCESSING_REQUIRED is accepting and have supplied
|
|
// a ppAcceptIrp
|
|
//
|
|
// Descript: listens for an offerred connection, then
|
|
// accepts it or rejects it
|
|
//
|
|
// --------------------------------------------------
|
|
|
|
TDI_STATUS
|
|
TSConnectHandler(PVOID pvTdiEventContext,
|
|
LONG lRemoteAddressLength,
|
|
PVOID pvRemoteAddress,
|
|
LONG lUserDataLength,
|
|
PVOID pvUserData,
|
|
LONG lOptionsLength,
|
|
PVOID pvOptions,
|
|
CONNECTION_CONTEXT *pConnectionContext,
|
|
PIRP *ppAcceptIrp)
|
|
{
|
|
PADDRESS_OBJECT pAddressObject = (PADDRESS_OBJECT)pvTdiEventContext;
|
|
PENDPOINT_OBJECT pEndpoint = pAddressObject->pEndpoint;
|
|
|
|
//
|
|
// show the information passed in.
|
|
// Note that we actually use very little of it..
|
|
//
|
|
if (ulDebugLevel & ulDebugShowHandlers)
|
|
{
|
|
DebugPrint1("\n >>>> %s\n", strFunc4);
|
|
DebugPrint2("pAddressObject = %p\n"
|
|
"RemoteAddressLength = %d\n",
|
|
pAddressObject,
|
|
lRemoteAddressLength);
|
|
|
|
if (lRemoteAddressLength)
|
|
{
|
|
PTRANSPORT_ADDRESS pTransportAddress = (PTRANSPORT_ADDRESS)pvRemoteAddress;
|
|
|
|
DebugPrint0("RemoteAddress: ");
|
|
TSPrintTaAddress(&pTransportAddress->Address[0]);
|
|
}
|
|
|
|
DebugPrint1("UserDataLength = %d\n", lUserDataLength);
|
|
if (lUserDataLength)
|
|
{
|
|
PUCHAR pucTemp = (PUCHAR)pvUserData;
|
|
|
|
DebugPrint0("UserData: ");
|
|
for (LONG lCount = 0; lCount < lUserDataLength; lCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
|
|
DebugPrint1("OptionsLength = %d\n", lOptionsLength);
|
|
|
|
if (lOptionsLength)
|
|
{
|
|
PUCHAR pucTemp = (PUCHAR)pvOptions;
|
|
|
|
DebugPrint0("Options: ");
|
|
for (LONG lCount = 0; lCount < (LONG)lOptionsLength; lCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
}
|
|
|
|
//
|
|
// now do the work
|
|
//
|
|
if (pEndpoint->fIsConnected || pEndpoint->fAcceptInProgress)
|
|
{
|
|
return TDI_CONN_REFUSED;
|
|
}
|
|
pEndpoint->fAcceptInProgress = TRUE;
|
|
|
|
|
|
//
|
|
// allocate all the necessary structures
|
|
//
|
|
PCONNECT_CONTEXT pConnectContext;
|
|
|
|
|
|
//
|
|
// first, our context
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pConnectContext,
|
|
sizeof(CONNECT_CONTEXT),
|
|
strFunc4,
|
|
"ConnectContext")) == STATUS_SUCCESS)
|
|
{
|
|
pConnectContext->pUpperIrp = NULL;
|
|
pConnectContext->ulWhichCommand = TDI_ACCEPT;
|
|
pConnectContext->pEndpoint = pEndpoint;
|
|
|
|
//
|
|
// then the irp itself
|
|
//
|
|
PIRP pLowerIrp = TSAllocateIrp(pEndpoint->GenHead.pDeviceObject,
|
|
pAddressObject->pIrpPool);
|
|
|
|
pConnectContext->pIrpPool = pAddressObject->pIrpPool;
|
|
if (pLowerIrp)
|
|
{
|
|
//
|
|
// if made it to here, everything is correctly allocated
|
|
// set up irp and call the tdi provider
|
|
//
|
|
|
|
#pragma warning(disable: CONSTANT_CONDITIONAL)
|
|
|
|
TdiBuildAccept(pLowerIrp,
|
|
pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->GenHead.pFileObject,
|
|
TSGenAcceptComplete,
|
|
pConnectContext,
|
|
NULL, // RequestConnectionInfo
|
|
NULL); // ReturnConnectionInfo
|
|
|
|
#pragma warning(default: CONSTANT_CONDITIONAL)
|
|
|
|
|
|
//
|
|
// need to do this since we are not calling IoCallDriver
|
|
//
|
|
IoSetNextIrpStackLocation(pLowerIrp);
|
|
|
|
*pConnectionContext = pEndpoint;
|
|
*ppAcceptIrp = pLowerIrp;
|
|
|
|
return TDI_MORE_PROCESSING;
|
|
}
|
|
TSFreeMemory(pConnectContext);
|
|
}
|
|
pEndpoint->fAcceptInProgress = FALSE;
|
|
return TDI_CONN_REFUSED;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------
|
|
//
|
|
// Function: TdiDisconnectHandler
|
|
//
|
|
// Arguments: pvTdiEventContext -- here, our address object
|
|
// ConnectionContext -- here, our connection object
|
|
// lDisconnectDataLength -- length of data in pvDisconnectData
|
|
// pvDisconnectData -- data sent by remote as part of disconnect
|
|
// lDisconnectInformationLength -- length of pvDisconnectInformation
|
|
// pvDisconnectInformation -- transport-specific sidconnect info
|
|
// ulDisconnectFlags -- nature of disconnect
|
|
//
|
|
// Returns: STATUS_SUCCESS
|
|
//
|
|
// Descript: deals with an incoming disconnect. Note that the disconnect
|
|
// is really complete at this point, as far as the protocol
|
|
// is concerned. We just need to clean up our stuff
|
|
//
|
|
// --------------------------------------------------
|
|
|
|
TDI_STATUS
|
|
TSDisconnectHandler(PVOID pvTdiEventContext,
|
|
CONNECTION_CONTEXT ConnectionContext,
|
|
LONG lDisconnectDataLength,
|
|
PVOID pvDisconnectData,
|
|
LONG lDisconnectInformationLength,
|
|
PVOID pvDisconnectInformation,
|
|
ULONG ulDisconnectFlags)
|
|
|
|
{
|
|
PENDPOINT_OBJECT pEndpoint = (PENDPOINT_OBJECT)ConnectionContext;
|
|
|
|
//
|
|
// show info in arguments
|
|
//
|
|
if (ulDebugLevel & ulDebugShowHandlers)
|
|
{
|
|
DebugPrint1("\n >>>> %s\n", strFunc5);
|
|
DebugPrint3("pAddressObject = %p\n"
|
|
"pEndpoint = %p\n"
|
|
"DisconnectDataLength = %d\n",
|
|
pvTdiEventContext,
|
|
pEndpoint,
|
|
lDisconnectDataLength);
|
|
|
|
if (lDisconnectDataLength)
|
|
{
|
|
PUCHAR pucTemp = (PUCHAR)pvDisconnectData;
|
|
|
|
DebugPrint0("DisconnectData: ");
|
|
for (LONG lCount = 0; lCount < (LONG)lDisconnectDataLength; lCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
|
|
DebugPrint1("DisconnectInformationLength = %d\n",
|
|
lDisconnectInformationLength);
|
|
|
|
if (lDisconnectInformationLength)
|
|
{
|
|
PUCHAR pucTemp = (PUCHAR)pvDisconnectInformation;
|
|
|
|
DebugPrint0("DisconnectInformation: ");
|
|
for (LONG lCount = 0; lCount < (LONG)lDisconnectInformationLength; lCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
DebugPrint1("DisconnectFlags = 0x%08x\n", ulDisconnectFlags);
|
|
if (ulDisconnectFlags & TDI_DISCONNECT_ABORT)
|
|
{
|
|
DebugPrint0(" TDI_DISCONNECT_ABORT\n");
|
|
}
|
|
if (ulDisconnectFlags & TDI_DISCONNECT_RELEASE)
|
|
{
|
|
DebugPrint0(" TDI_DISCONNECT_RELEASE\n");
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// do our cleanup..
|
|
//
|
|
pEndpoint->fIsConnected = FALSE;
|
|
|
|
if ((ulDisconnectFlags & TDI_DISCONNECT_RELEASE) &&
|
|
(!pEndpoint->fStartedDisconnect))
|
|
{
|
|
//
|
|
// allocate all the necessary structures
|
|
//
|
|
PCONNECT_CONTEXT pConnectContext;
|
|
|
|
//
|
|
// first, our context
|
|
//
|
|
if ((TSAllocateMemory((PVOID *)&pConnectContext,
|
|
sizeof(CONNECT_CONTEXT),
|
|
strFunc5,
|
|
"ConnectContext")) == STATUS_SUCCESS)
|
|
{
|
|
pConnectContext->pUpperIrp = NULL;
|
|
pConnectContext->ulWhichCommand = TDI_DISCONNECT;
|
|
pConnectContext->pEndpoint = pEndpoint;
|
|
|
|
//
|
|
// then the irp itself
|
|
//
|
|
PIRP pLowerIrp = TSAllocateIrp(pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->pAddressObject->pIrpPool);
|
|
|
|
pConnectContext->pIrpPool = pEndpoint->pAddressObject->pIrpPool;
|
|
if (pLowerIrp)
|
|
{
|
|
//
|
|
// if made it to here, everything is correctly allocated
|
|
// set up irp and call the tdi provider
|
|
//
|
|
|
|
#pragma warning(disable: CONSTANT_CONDITIONAL)
|
|
|
|
TdiBuildDisconnect(pLowerIrp,
|
|
pEndpoint->GenHead.pDeviceObject,
|
|
pEndpoint->GenHead.pFileObject,
|
|
TSGenAcceptComplete,
|
|
pConnectContext,
|
|
NULL, // pLargeInteger Time
|
|
TDI_DISCONNECT_RELEASE,
|
|
NULL, // RequestConnectionInfo
|
|
NULL); // ReturnConnectionInfo
|
|
|
|
#pragma warning(default: CONSTANT_CONDITIONAL)
|
|
|
|
//
|
|
// make the call to the tdi provider
|
|
//
|
|
NTSTATUS lStatus = IoCallDriver(pEndpoint->GenHead.pDeviceObject,
|
|
pLowerIrp);
|
|
|
|
if ((!NT_SUCCESS(lStatus)) && (ulDebugLevel & ulDebugShowCommand))
|
|
{
|
|
DebugPrint2("%s: unexpected status for IoCallDriver [0x%08x]\n",
|
|
strFunc5,
|
|
lStatus);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TSFreeMemory(pConnectContext);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// get here if do NOT need to send TDI_DISCONNECT_RELEASE message back
|
|
// to other end of connection
|
|
//
|
|
else
|
|
{
|
|
pEndpoint->fAcceptInProgress = FALSE;
|
|
pEndpoint->fIsConnected = FALSE;
|
|
}
|
|
|
|
return TDI_SUCCESS;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// private functions
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
// ---------------------------------------------------------
|
|
//
|
|
// Function: TSGenAcceptComplete
|
|
//
|
|
// Arguments: pDeviceObject -- device object on which call was made
|
|
// pIrp -- IRP used in the call
|
|
// pContext -- context used for the call
|
|
//
|
|
// Returns: status of operation (STATUS_MORE_PROCESSING_REQUIRED)
|
|
//
|
|
// Descript: Gets the result of the command, stuffs results into
|
|
// receive buffer, cleans up the Irp and associated data
|
|
// structures, etc
|
|
// This is used to complete cases where this no IRP from the
|
|
// dll to complete (ie, connect handler, listen, listen-accept,
|
|
// listen-disconnect)
|
|
//
|
|
// ---------------------------------------------------------
|
|
|
|
#pragma warning(disable: UNREFERENCED_PARAM)
|
|
|
|
TDI_STATUS
|
|
TSGenAcceptComplete(PDEVICE_OBJECT pDeviceObject,
|
|
PIRP pLowerIrp,
|
|
PVOID pvContext)
|
|
{
|
|
PCONNECT_CONTEXT pConnectContext = (PCONNECT_CONTEXT)pvContext;
|
|
NTSTATUS lStatus = pLowerIrp->IoStatus.Status;
|
|
|
|
//
|
|
// dealing with completions where there is no DLL irp associated
|
|
//
|
|
switch (pConnectContext->ulWhichCommand)
|
|
{
|
|
case TDI_ACCEPT:
|
|
if (NT_SUCCESS(lStatus))
|
|
{
|
|
pConnectContext->pEndpoint->fIsConnected = TRUE;
|
|
}
|
|
pConnectContext->pEndpoint->fAcceptInProgress = FALSE;
|
|
break;
|
|
|
|
case TDI_LISTEN:
|
|
if (NT_SUCCESS(lStatus))
|
|
{
|
|
pConnectContext->pEndpoint->fIsConnected = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DebugPrint1("Failure in TSListen: status = 0x%08x\n", lStatus);
|
|
}
|
|
break;
|
|
|
|
case TDI_DISCONNECT:
|
|
pConnectContext->pEndpoint->fAcceptInProgress = FALSE;
|
|
pConnectContext->pEndpoint->fIsConnected = FALSE;
|
|
pConnectContext->pEndpoint->fStartedDisconnect = FALSE;
|
|
break;
|
|
}
|
|
|
|
TSFreeIrp(pLowerIrp, pConnectContext->pIrpPool);
|
|
|
|
//
|
|
// generic cleanup
|
|
//
|
|
if (pConnectContext->pTdiConnectInfo)
|
|
{
|
|
TSFreeMemory(pConnectContext->pTdiConnectInfo);
|
|
}
|
|
TSFreeMemory(pConnectContext);
|
|
|
|
return TDI_MORE_PROCESSING;
|
|
}
|
|
|
|
#pragma warning(default: UNREFERENCED_PARAM)
|
|
|
|
|
|
// ---------------------------------------------------------
|
|
//
|
|
// Function: TSGenConnectComplete
|
|
//
|
|
// Arguments: pDeviceObject -- device object on which call was made
|
|
// pIrp -- IRP used in the call
|
|
// pContext -- context used for the call
|
|
//
|
|
// Returns: status of operation (STATUS_MORE_PROCESSING_REQUIRED)
|
|
//
|
|
// Descript: Gets the result of the command, stuffs results into
|
|
// receive buffer, completes the IRP from the dll,
|
|
// cleans up the Irp and associated data structures, etc
|
|
// Deals only with commands that carry an IRP from the dll
|
|
//
|
|
// ---------------------------------------------------------
|
|
|
|
#pragma warning(disable: UNREFERENCED_PARAM)
|
|
|
|
TDI_STATUS
|
|
TSGenConnectComplete(PDEVICE_OBJECT pDeviceObject,
|
|
PIRP pLowerIrp,
|
|
PVOID pvContext)
|
|
{
|
|
PCONNECT_CONTEXT pConnectContext = (PCONNECT_CONTEXT)pvContext;
|
|
NTSTATUS lStatus = pLowerIrp->IoStatus.Status;
|
|
|
|
//
|
|
// this is completing a command from the dll
|
|
//
|
|
PRECEIVE_BUFFER pReceiveBuffer = TSGetReceiveBuffer(pConnectContext->pUpperIrp);
|
|
|
|
pReceiveBuffer->lStatus = lStatus;
|
|
|
|
if (NT_SUCCESS(lStatus))
|
|
{
|
|
if (ulDebugLevel & ulDebugShowCommand)
|
|
{
|
|
if (pLowerIrp->IoStatus.Information)
|
|
{
|
|
DebugPrint2("%s: Information = 0x%08x\n",
|
|
strFuncP2,
|
|
pLowerIrp->IoStatus.Information);
|
|
}
|
|
}
|
|
|
|
switch (pConnectContext->ulWhichCommand)
|
|
{
|
|
case TDI_CONNECT:
|
|
pConnectContext->pEndpoint->fIsConnected = TRUE;
|
|
break;
|
|
|
|
case TDI_DISCONNECT:
|
|
pConnectContext->pEndpoint->fIsConnected = FALSE;
|
|
break;
|
|
|
|
default:
|
|
DebugPrint2("%s: invalid command value [0x%08x]\n",
|
|
strFuncP2,
|
|
pConnectContext->ulWhichCommand);
|
|
DbgBreakPoint();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ulDebugLevel & ulDebugShowCommand)
|
|
{
|
|
DebugPrint2("%s: Completed with status 0x%08x\n",
|
|
strFuncP2,
|
|
lStatus);
|
|
}
|
|
}
|
|
TSCompleteIrp(pConnectContext->pUpperIrp);
|
|
TSFreeIrp(pLowerIrp, NULL);
|
|
|
|
//
|
|
// generic cleanup
|
|
//
|
|
if (pConnectContext->pTdiConnectInfo)
|
|
{
|
|
TSFreeMemory(pConnectContext->pTdiConnectInfo);
|
|
}
|
|
TSFreeMemory(pConnectContext);
|
|
|
|
return TDI_MORE_PROCESSING;
|
|
}
|
|
|
|
#pragma warning(default: UNREFERENCED_PARAM)
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// end of file connect.cpp
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|