开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 文章/文档 > 通讯编程文档 > 查看源码
TDIClient.c
资源名称：虚拟串口驱动程序.rar　[点击查看]
上传用户：zanmei2
上传日期：2010-03-06
资源大小：775k
文件大小：32k
源码类别：

通讯编程文档

开发平台：

C/C++

TDIClient.c：源码内容
  1. /*++
  3. Copyright (c) 2005  Changzhi Zhou All Rights Reserved
  5. Module Name:
  7.     TDIClient.c
  9. Abstract:
  11.     This module contains the routines relevant to TDI client calls.
  13. Environment:
  15.     Kernel mode
  17. Revision History:
  19. Changzhi Zhou Feb 5, 2005
  21. --*/
  22. #include "TDIClient.h"
  23. #include "main.h"
  25. NTSTATUS InitializeConnection( PDEVICE_EXTENSION deviceExtension )
  26. /*++
  28. Routine Description:
  30. 1. Open a transport address and get the highest deviceobject of the transport stack.
  31. 2. Build RecvContext in the DeviceExtension
  32. 3. SetTdiEventHandle, includes TDI_EVENT_RECEIVE_DATAGRAM and TDI_EVENT_ERROR
  34. Arguments:
  36.     deviceExtension - pointer to a device object extension.
  38. Return Value:
  40.     NT status code.
  42. --*/
  43. {
  44. NTSTATUS status;
  45. static USHORT Port = LOCAL_PORT;
  47. if ( ( deviceExtension->hTransAddr ) || ( deviceExtension->lpTransAddrFileObject ) )
  48. return STATUS_INVALID_DEVICE_STATE;
  49. status = TDIOpenTransportAddress( wcharNetDevName,
  50. &deviceExtension->hTransAddr,
  51. &deviceExtension->lpTransAddrFileObject,
  52. Port
  53. );
  54. DebugPrint(("OpenTransAddr: handle = %x, lpFileObj = %x, status = %xn",
  55. deviceExtension->hTransAddr, deviceExtension->lpTransAddrFileObject, status ));
  56. if ( status != STATUS_SUCCESS )
  57. {
  58. deviceExtension->lpTransAddrFileObject = NULL;
  59. deviceExtension->hTransAddr = NULL;
  60. return status;
  61. }
  62. Port += 0x100;
  63. deviceExtension->TDILowerDeviceObject = IoGetRelatedDeviceObject( deviceExtension->lpTransAddrFileObject );
  64. DebugPrint(("TDI Provider: 0x%xn", deviceExtension->TDILowerDeviceObject ));
  65. if ( deviceExtension->TDILowerDeviceObject == NULL )
  66. {
  67. ObDereferenceObject ( deviceExtension->lpTransAddrFileObject );
  68. ZwClose ( deviceExtension->hTransAddr );
  69. deviceExtension->lpTransAddrFileObject = NULL;
  70. deviceExtension->hTransAddr = NULL;
  71. return STATUS_UNSUCCESSFUL;
  72. }
  74. TDIBuildRecvContext( &deviceExtension->recvContext );
  76. TDIClnSetEventHandler( deviceExtension->lpTransAddrFileObject,
  77. deviceExtension->TDILowerDeviceObject, TDI_EVENT_RECEIVE_DATAGRAM,
  78. TDIEventRecvDatagram, deviceExtension );
  79. TDIClnSetEventHandler( deviceExtension->lpTransAddrFileObject,
  80. deviceExtension->TDILowerDeviceObject, TDI_EVENT_ERROR,
  81. TDIEventError, NULL );
  82. return status;
  83. }
  84. NTSTATUS Disconnection ( PDEVICE_EXTENSION deviceExtension )
  85. /*++
  87. Routine Description:
  89. 1. SetTdiEventhandle TDI_EVENT_RECEIVE_DATAGRAM to NULL
  90. 2. Free RecvContext in the DeviceExtension
  91. 3. Close an opened transport address.
  92. 3. SetTdiEventHandle, includes TDI_EVENT_RECEIVE_DATAGRAM and TDI_EVENT_ERROR
  94. Arguments:
  96.     deviceExtension - pointer to a device object extension.
  98. Return Value:
  100.     NT status code.
  102. --*/
  103. {
  104. NTSTATUS status;
  105. if ( ( deviceExtension->hTransAddr == NULL ) || ( deviceExtension->lpTransAddrFileObject == NULL ) )
  106. return STATUS_INVALID_DEVICE_STATE;
  107. TDIClnSetEventHandler( deviceExtension->lpTransAddrFileObject,
  108. deviceExtension->TDILowerDeviceObject, TDI_EVENT_RECEIVE_DATAGRAM,
  109. NULL, deviceExtension );
  110. TDIFreeRecvContext( &deviceExtension->recvContext );
  112. ObDereferenceObject ( deviceExtension->lpTransAddrFileObject );
  113. deviceExtension->lpTransAddrFileObject = NULL;
  114. status = ZwClose ( deviceExtension->hTransAddr );
  115. if ( status == STATUS_SUCCESS )
  116. deviceExtension->hTransAddr = NULL;
  117. else
  118. {
  119. DebugPrint(("ZwClose hTransAddr failed with status %x !n", status ));
  120. }
  121. return status;
  122. }
  123. NTSTATUS TDISendDatagram(
  124.     IN PDEVICE_OBJECT DeviceObject,
  125.     IN PIRP Irp
  126. )
  127. /*++
  129. Routine Description:
  131.   This function is called in SampleWrite. It builds a internel irp and send down 
  132.   to the underlying transport. Until the irp completes or timeout, it will return.
  133.   The remote peer's IP address and port are indicated by RemoteAddress and 
  134.   RemotePort in deviceExtension.
  136. 1. TdiBuildInternalDeviceControlIrp for TDI_SEND_DATAGRAM
  137. 2. Allocate and lockpage a MDL based on Irp->MdlAddress
  138. 3. TdiBuildSendDatagram and pass down to the underlying transport device.
  139. 4. Wait 3 seconds for the completion. If timeout, cancel the irp
  140. 5. Set the Irp according with the completed irp.
  142. Note:
  143. This routine is synchronous.
  144. It must be running at IRQL = PASSIVE_LEVEL
  146. Arguments:
  148.    DeviceObject - pointer to a device object.
  150.    Irp - pointer to an I/O Request Packet for IRP_MJ_WRITE.
  152. Return Value:
  154.     NT status code.
  156. --*/
  157. {
  158. NTSTATUS status;
  159. PIRP pIrp;
  160. PDEVICE_EXTENSION deviceExtension;
  161. KEVENT Event;
  162. IO_STATUS_BLOCK IoStatus;
  163. PMDL pMdl;
  164. PVOID VirtualAddress;
  165. ULONG Length;
  166. EXCEPTION_POINTERS        * pExceptionInfo;
  167. ULONG                       lclExceptionCode;
  168. PVOID                       lclExceptionAddr;
  169. PVOID SystemAddress;
  171. TA_IP_ADDRESS RmtAddress = {1, {TDI_ADDRESS_LENGTH_IP, TDI_ADDRESS_TYPE_IP, { REMOTE_PORT, REMOTE_ADDRESS}}};
  172. TDI_CONNECTION_INFORMATION RmtInfo = {0, 0, 0, 0, sizeof(RmtAddress), &RmtAddress};
  174. deviceExtension = ( PDEVICE_EXTENSION )DeviceObject->DeviceExtension;
  175. RmtAddress.Address->Address->sin_port = deviceExtension->RemotePort;
  176. RmtAddress.Address->Address->in_addr = deviceExtension->RemoteAddress;
  177. status = STATUS_SUCCESS;
  178. KeInitializeEvent( &Event, NotificationEvent, FALSE);
  179. pIrp = TdiBuildInternalDeviceControlIrp(
  180. TDI_SEND_DATAGRAM,
  181. deviceExtension->TDILowerDeviceObject,
  182. deviceExtension->lpTransAddrFileObject,
  183. &Event,
  184. &IoStatus );
  185. if ( NULL == pIrp )
  186. {
  187. DebugPrint(("TDISendDatagram: Allocate Irp failedn"));
  188. return STATUS_INSUFFICIENT_RESOURCES;
  189. }
  190. VirtualAddress = MmGetMdlVirtualAddress ( Irp->MdlAddress );
  191. Length = MmGetMdlByteCount( Irp->MdlAddress );
  192. ASSERT ( VirtualAddress && Length );
  194. pMdl = IoAllocateMdl ( VirtualAddress, Length, FALSE, FALSE, pIrp );
  195. if ( NULL == pMdl )
  196. {
  197. DebugPrint(("TDISendDatagram: Allocate Mdl failedn"));
  198. return STATUS_INSUFFICIENT_RESOURCES;
  199. }
  200. _try
  201. {
  202. MmProbeAndLockPages(pMdl,                     // (Try to) fix buffer.
  203. KernelMode,
  204. IoModifyAccess
  205. );
  206. }
  207. _except(
  208. pExceptionInfo = GetExceptionInformation(),                                                                                                                                                                                                    
  209. lclExceptionCode = pExceptionInfo->ExceptionRecord->ExceptionCode,                                                                                                                                                                             
  210. lclExceptionAddr = pExceptionInfo->ExceptionRecord->ExceptionAddress,                                                                                                                                                                          
  211. EXCEPTION_EXECUTE_HANDLER                                                                                                                                                                                                                      
  212. )                                                                                                                                                                                                                                               
  213. {                                                                                                                                                                                                                                                    
  214. DebugPrint((".TDISendDatagram:  MmProbeAndLockPages() failed.  Error = 0x%08x at 0x%08xn",
  215. lclExceptionCode, lclExceptionAddr));
  216. status = STATUS_UNSUCCESSFUL;
  217. IoFreeMdl ( pMdl );
  218. CompleteRequest ( pIrp, status, 0 );
  219. Irp->IoStatus.Information = 0;
  220. return status;
  221. }
  222. TdiBuildSendDatagram(
  223. pIrp,
  224. deviceExtension->TDILowerDeviceObject,
  225. deviceExtension->lpTransAddrFileObject,
  226. NULL,
  227. NULL,
  228. pMdl,
  229. Length,
  230. &RmtInfo
  231. );
  232. status = IoCallDriver ( deviceExtension->TDILowerDeviceObject, pIrp );
  233. if( ( status != STATUS_SUCCESS ) || ( STATUS_PENDING != status ) )
  234. {
  235. DebugPrint(("TDISendDatagram: Problem in IoCallDriver with status %xn", status ));
  236. }
  237. if ( status == STATUS_PENDING )
  238. {
  239.         LARGE_INTEGER TimeOut;
  240. NTSTATUS waitStatus;
  241. DebugPrint(("Send data pending... wait for 3 secondsn"));
  242.         TimeOut.QuadPart = -30000 * 1000;         // Calculate timeout value (5 seconds from now).
  243. waitStatus = KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, &TimeOut);
  244. if ( STATUS_TIMEOUT == waitStatus )
  245. {
  246. DebugPrint(("TDISendDatagram: Send data time out...n"));
  247. IoCancelIrp ( pIrp );
  248. KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, 0);
  249. }
  250. }
  251. Irp->IoStatus.Information = IoStatus.Information;
  252. DebugPrint(("TDISendDatagram: Send %d bytesn", Irp->IoStatus.Information ));
  253. status = ((STATUS_SUCCESS==status) || (STATUS_PENDING== status)) ? IoStatus.Status : status;
  254. return status;
  255. }
  256. NTSTATUS TDIEventError(
  257.    IN PVOID TdiEventContext,  // The endpoint's file object.
  258.    IN NTSTATUS Status         // Status code indicating error type.
  259.    )
  260. /*++
  261. Tdi error handle.
  262. --*/
  263. {
  264.    DebugPrint(("Sample ErrorEventHandler: Status: 0x%8.8Xn", Status) );
  266.    return( STATUS_SUCCESS );
  267. }
  269. NTSTATUS TDIEventRecvDatagram(
  270.     IN PVOID  TdiEventContext,
  271.     IN LONG  SourceAddressLength,
  272.     IN PVOID  SourceAddress,
  273.     IN LONG  OptionsLength,
  274.     IN PVOID  Options,
  275.     IN ULONG  ReceiveDatagramFlags,
  276.     IN ULONG  BytesIndicated,
  277.     IN ULONG  BytesAvailable,
  278.     OUT ULONG  *BytesTaken,
  279.     IN PVOID  Tsdu,
  280.     OUT PIRP  *IoRequestPacket
  281.     )
  282. /*++
  284. Routine Description:
  286.   TDI_EVENT_RECEIVE_DATAGRAM handle.
  287.   When a UDP packet from particular address and port arrive, this callback function will be called.
  288.   Usually BytesIndicated is less than or equal to BytesAvailable. If less, a Irp should be buildt
  289.   for the remainder data. This irp has be pre-allocated by TDIBuildRecvContext.
  291. Note:
  292. Don't forget to call IoSetNextIrpStackLocation to handle the IoRequestPacket.
  293. Because the stack locations of this irp between this function and underlying transport are identical.
  295.   Pls refer to Windows DDK documentation chapter relevant to this handle.
  297. --*/
  298. {
  299. LONG i;
  300. PUCHAR p;
  301. PIRP pIrp;
  303. NTSTATUS status;
  304. ULONG BytesToCopy;
  305. ULONG stageSize;
  306. PDEVICE_EXTENSION deviceExtension;
  308. deviceExtension = (PDEVICE_EXTENSION)TdiEventContext;
  309. DebugPrint(("SourceAddress: "));
  310. p = (PUCHAR)SourceAddress;
  311. for( i = 0; i < SourceAddressLength; i++)
  312. {
  313. DbgPrint("%2x ", p[ i ] );
  314. }
  315. DbgPrint(("n"));
  316. DebugPrint(("ReceiveDatagramFlags: %xn", ReceiveDatagramFlags ));
  317. DebugPrint(("BytesIndicated: %dn", BytesIndicated ));
  318. DebugPrint(("BytesAvailable: %dn", BytesAvailable ));
  319. *BytesTaken = BytesIndicated;
  320. CopyToRingBuffer( deviceExtension, (PUCHAR)Tsdu, BytesIndicated );
  322. *IoRequestPacket = NULL;
  323. status = STATUS_SUCCESS;
  324. if ( BytesIndicated < BytesAvailable )
  325. {
  326. if ( deviceExtension->recvContext.pIrp )
  327. {
  328. pIrp = deviceExtension->recvContext.pIrp;
  329. DebugPrint(("EventRecvDatagram: pIrp = %xn", deviceExtension->recvContext.pIrp ));
  330. TdiBuildReceiveDatagram( pIrp,
  331. deviceExtension->TDILowerDeviceObject,
  332. deviceExtension->lpTransAddrFileObject,
  333. TDIRecvRemainderCompRoutine,
  334. deviceExtension,
  335. deviceExtension->recvContext.pMdl,
  336. 0,
  337. &(deviceExtension->recvContext.ReceiveDatagramInfo),
  338. &(deviceExtension->recvContext.ReturnInfo),
  339. TDI_RECEIVE_NORMAL);
  340. IoSetNextIrpStackLocation ( pIrp );
  341. *IoRequestPacket = pIrp;
  342. status = STATUS_MORE_PROCESSING_REQUIRED;
  343. }
  344. }
  345. return status;
  346. }
  347. VOID CopyToRingBuffer(
  348. PDEVICE_EXTENSION deviceExtension,
  349. PUCHAR LinearBuffer,
  350. ULONG BytesIndicated )
  351. /*++
  353. Routine Description:
  355.   This function is called by TDIEventRecvDatagram and TDIRecvRemainderCompRoutine.
  357.   It copies linear buffer containing network packet to ring buffer. If source buffer length
  358.   is more than the length of ReceiveBuffer, the last part of LinearBuffer will be copied
  359.   to destination buffer.
  361.   If there is WaitOnMaskIrp in deviceExtension and the WaitMask meets SERIAL_EV_RXCHAR || SERIAL_EV_RLSD,
  362.   it will complete the WaitOnMaskIrp to indicate the application that there are some data arrive.
  364.   The destination ringbuffer, deviceExtension->RxBuffer, is shared with IRP_MJ_READ.
  365.   So the access to the ringbuffer must be synchronous.
  367. Arguments:
  369.   deviceExtension - pointer to device object extension
  370.   LinearBuffer - Tsdu containing network packets.
  371.   BytesIndicated - the length of LinearBuffer
  373. Return Value:
  375.     NT status code.
  377. --*/
  378. {
  379. ULONG stageSize;
  380. KIRQL oldIrql;
  381. ULONG BytesToCopy;
  382. PUCHAR lpSrc;
  384. BytesToCopy = BytesIndicated;
  385. lpSrc = LinearBuffer;
  386. if ( BytesIndicated > RINGBUFFER_SIZE )
  387. {
  388. lpSrc = (PUCHAR)LinearBuffer + BytesIndicated - RINGBUFFER_SIZE;
  389. BytesToCopy = RINGBUFFER_SIZE;
  390. }
  391. KeAcquireSpinLock(&deviceExtension->ThreadSpinLock, &oldIrql);
  392. stageSize = deviceExtension->RxBuffer + RINGBUFFER_SIZE - deviceExtension->lpRx;
  393. if( BytesToCopy <= stageSize )
  394. RtlCopyMemory ( deviceExtension->lpRx, lpSrc, BytesToCopy );
  395. else
  396. {
  397. RtlCopyMemory ( deviceExtension->lpRx, lpSrc, stageSize );
  398. RtlCopyMemory ( deviceExtension->RxBuffer, lpSrc + stageSize, ( BytesToCopy - stageSize ) );
  399. }
  400. deviceExtension->lpRx = deviceExtension->RxBuffer + ( ( RINGBUFFER_SIZE - stageSize + BytesToCopy ) % RINGBUFFER_SIZE );
  401. deviceExtension->SerialStatus.AmountInInQueue += BytesToCopy;
  402. if ( deviceExtension->SerialStatus.AmountInInQueue > RINGBUFFER_SIZE )
  403. {
  404. deviceExtension->lpRead = deviceExtension->lpRx;
  405. deviceExtension->SerialStatus.AmountInInQueue = RINGBUFFER_SIZE;
  406. }
  407. if( ( deviceExtension->WaitOnMaskIrp ) &&
  408. ( ( deviceExtension->WaitMask & SERIAL_EV_RXCHAR ) || ( deviceExtension->WaitMask & SERIAL_EV_RLSD ) ) )
  409. {
  410. DebugPrint(("ClientEventRecv: Complete WaitOnMaskIrpn"));
  411. deviceExtension->SerialStatus.EofReceived = TRUE;
  412. *(PULONG)deviceExtension->WaitOnMaskIrp->AssociatedIrp.SystemBuffer = ( SERIAL_EV_RXCHAR | SERIAL_EV_RLSD );
  413. CompleteRequest( deviceExtension->WaitOnMaskIrp, STATUS_SUCCESS, sizeof( ULONG ) );
  414. deviceExtension->WaitOnMaskIrp = NULL;
  415. SampleIoDecrement( deviceExtension );
  416. }
  417. KeReleaseSpinLock( &deviceExtension->ThreadSpinLock, oldIrql );
  418. }
  419. NTSTATUS TDIBuildRecvContext( PRECV_CONTEXT lpContext)
  420. /*++
  422. Routine Description:
  424.   This function is called by InitializeConnection.
  425.   It builds RecvContext, including pIrp, pMdl, and locks the Mdl.
  427. Arguments:
  429.   lpContext - pointer to deviceExtension->recvContext
  431. Return Value:
  433.     NT status code.
  435. --*/
  436. {
  437. PIRP pIrp;
  438. PMDL pMdl;
  439. PDEVICE_EXTENSION deviceExtension;
  440. EXCEPTION_POINTERS        * pExceptionInfo;
  441. ULONG                       lclExceptionCode;
  442. PVOID                       lclExceptionAddr;
  443. PIO_STACK_LOCATION ioStack;
  445. if( lpContext->pIrp || lpContext->pMdl || ( lpContext->RemainderBuffer == NULL ) )
  446. return STATUS_UNSUCCESSFUL;
  447. deviceExtension = CONTAINING_RECORD( lpContext, DEVICE_EXTENSION, recvContext );
  448. pIrp = IoAllocateIrp ( deviceExtension->TDILowerDeviceObject->StackSize + 2, FALSE );
  449. /*
  450. Because the irp will be used for many times, TdiBuildInternalDeviceControlIrp is not best.
  451. */
  452. /* pIrp = TdiBuildInternalDeviceControlIrp(
  453. TDI_RECEIVE_DATAGRAM,
  454. deviceExtension->TDILowerDeviceObject,
  455. deviceExtension->lpTransAddrFileObject,
  456. &lpContext->Event,
  457. &lpContext->IoStatus
  458. );
  459. */
  460. if (NULL == pIrp)
  461. {
  462. DebugPrint(("TdiBuildInternalIrp failedn"));
  463. return STATUS_INSUFFICIENT_RESOURCES;
  464. }else
  465. {
  466. DebugPrint(("TDIBuildRecvContext: pIrp = %xn", pIrp ));
  467. }
  468. pMdl = IoAllocateMdl ( lpContext->RemainderBuffer,
  469. RECVREMAINDER_BUFFER_SIZE, FALSE, FALSE, NULL );
  470. if (NULL==pMdl)
  471. {
  472. goto Error_Exit;
  473. }
  474. _try
  475. {
  476. // lockpage the Mdl, even though it is allocated based on NonPagesPool
  477. MmProbeAndLockPages(pMdl,                     // (Try to) fix buffer.
  478. KernelMode,
  479. IoModifyAccess
  480. );
  481. lpContext->bLocked = TRUE;
  482. DebugPrint(("RemainderBuffer: 0x%x,  pMdl: 0x%xn", lpContext->RemainderBuffer, pMdl ));
  483. }
  484. _except(
  485. pExceptionInfo = GetExceptionInformation(),                                                                                                                                                                                                    
  486. lclExceptionCode = pExceptionInfo->ExceptionRecord->ExceptionCode,                                                                                                                                                                             
  487. lclExceptionAddr = pExceptionInfo->ExceptionRecord->ExceptionAddress,                                                                                                                                                                          
  488. EXCEPTION_EXECUTE_HANDLER                                                                                                                                                                                                                      
  489. )                                                                                                                                                                                                                                               
  490. {                                                                                                                                                                                                                                                    
  491. DebugPrint((".TDIClnRecv:  MmProbeAndLockPages() failed.  Error = 0x%08x at 0x%08xn",
  492. lclExceptionCode, lclExceptionAddr));
  493. goto Error_Exit;
  494. }
  495. lpContext->pIrp = pIrp;
  496. lpContext->pMdl = pMdl;
  497. return STATUS_SUCCESS;
  498. Error_Exit:
  499. if ( pMdl )
  500. IoFreeMdl ( pMdl );
  501. if ( pIrp )
  502. IoFreeIrp ( pIrp );
  503. return STATUS_UNSUCCESSFUL;
  504. }
  505. NTSTATUS                                          
  506. TDIRecvRemainderCompRoutine(
  507. PDEVICE_OBJECT      DeviceObject, // TDI driver's device object.
  508. PIRP                pIrp,    // Address of completed Irp.
  509. PVOID               pCtx     // Pointer to context.
  510. )
  511. /*++
  513. Routine Description:
  515.   Completion routine of IoRequestPacket in TDIEventRecvDatagram.
  516.   It copies receiving data in recvContext.RemainderBuffer to RxBuffer.
  517.   The length of receining data is indicated by pIrp->IoStatus.Information.
  519. Arguments:
  521.     DeviceObject - pointer to the device object
  522. pIrp - pointer to completed Irp, which is recvContext->pIrp
  523. pCtx - pointer to context, which is deviceExtension
  525. Return Value:
  527.     NT status code.
  529. --*/
  530. {
  531. PDEVICE_EXTENSION deviceExtension;
  532. PRECV_CONTEXT lpContext;
  533. ULONG RecvDataLength;
  534. PUCHAR lpSrc;
  536. DebugPrint(("TDIRecvRemainderCompRoutine...n"));
  537. RecvDataLength = pIrp->IoStatus.Information;
  538. deviceExtension = (PDEVICE_EXTENSION)pCtx;
  539. DebugPrint(("Remainder length: %dn", RecvDataLength ));
  540. CopyToRingBuffer ( deviceExtension,
  541. (PUCHAR)deviceExtension->recvContext.RemainderBuffer,
  542. RecvDataLength );
  543. return STATUS_MORE_PROCESSING_REQUIRED;
  544. }
  545. NTSTATUS TDIFreeRecvContext( PRECV_CONTEXT lpContext )
  546. /*++
  548. Routine Description:
  550. Free recvContext.
  552. Arguments:
  554. lpContext - pointer to recvContext.
  556. Return Value:
  558.     NT status code.
  560. --*/
  561. {
  562. if ( lpContext->pIrp )
  563. {
  564. IoFreeIrp ( lpContext->pIrp );
  565. lpContext->pIrp = NULL;
  566. }
  567. if ( lpContext->bLocked )
  568. {
  569. MmUnlockPages ( lpContext->pMdl );
  570. lpContext->bLocked = FALSE;
  571. }
  572. if ( lpContext->pMdl )
  573. {
  574. IoFreeMdl ( lpContext->pMdl );
  575. lpContext->pMdl = NULL;
  576. }
  577. return STATUS_SUCCESS;
  578. }
  579. /**************************************************************************************************/
  580. /*                                                                                                */
  581. /* Build and send down an Irp for Receive.                                                        */
  582. /*                                                                                                */
  583. /* Notes:                                                                                         */
  584. /*        1) This routine is NOT synchronous (no particular reason it's not, other than to show   */
  585. /*           off asynchronous operation of an Irp).                                               */
  586. /*                                                                                                */
  587. /*        2) There are indications that an MDL and probe-and-lock are needed even if the buffer   */
  588. /*           is from the non-paged pool.  Eg, microsoft.public.win32.programmer.kernel,           */
  589. /*           "MmProbeAndLockPages bug checks," dave porter, 2001-03-02.  But see the further      */
  590. /*           discussion in comp.os.ms-windows.programmer.nt.kernel-mode, "Free MDL in completion  */
  591. /*           routine," 1999/05/09.                                                                */
  592. /*                                                                                                */
  593. /*        3) Although not documented, it appears that the Irp, the Mdl and the locking are undone */
  594. /*           by the transport.  There are claims to that effect in several places in newsgroups,  */
  595. /*           and freeing the MDL always caused errors in a test (eg, bad pool caller or touching  */
  596. /*           paged storage at wrong IRQL).  Further, testing showed that IoFreeMdl() was being    */
  597. /*           called by somebody (presumably, the transport) for a given MDL.                      */
  598. /*                                                                                                */
  599. /*        4) The supplied context (pCtx) is an event, which the I/O completion routine for the    */
  600. /*           Receive Irp will signal.                                                             */
  601. /*                                                                                                */
  602. /**************************************************************************************************/
  603. NTSTATUS TDIQueryNetworkInformation( PDEVICE_OBJECT DeviceObject, PIRP Irp )
  604. {
  605. PDEVICE_EXTENSION deviceExtension;
  606. PIO_STACK_LOCATION IrpStack;
  607. IO_STATUS_BLOCK IoStatus;
  608. NTSTATUS status;
  609. ULONG InputLength, OutputLength;
  610. ULONG QType;
  611. PIRP pIrp;
  612. KEVENT Event;
  613. PMDL pMdl;
  614. ULONG_PTR virtualAddress;
  616. EXCEPTION_POINTERS        * pExceptionInfo;
  617. ULONG                       lclExceptionCode;
  618. PVOID                       lclExceptionAddr;
  619. BOOLEAN pageLocked;
  621. deviceExtension = DeviceObject->DeviceExtension;
  622. IrpStack = IoGetCurrentIrpStackLocation(Irp);
  623. QType = *((ULONG *)Irp->AssociatedIrp.SystemBuffer);
  624. DebugPrint(("QueryNetworkInformation: QType = %xn", QType ));
  625. KeInitializeEvent(&Event, NotificationEvent, FALSE);
  626. pIrp = TdiBuildInternalDeviceControlIrp(TDI_QUERY_INFORMATION ,
  627. deviceExtension->TDILowerDeviceObject,   // TDI driver's device object.
  628. deviceExtension->lpTransAddrFileObject, // Address file object.
  629. &Event,       // Event to be signalled when Irp completes.
  630. &IoStatus     // I/O status block.
  631. );
  632. if (NULL==pIrp)
  633.         return STATUS_INSUFFICIENT_RESOURCES;
  634. virtualAddress = (ULONG_PTR) MmGetMdlVirtualAddress(Irp->MdlAddress);
  635. OutputLength = MmGetMdlByteCount(Irp->MdlAddress);
  636. pMdl = IoAllocateMdl( (PVOID)virtualAddress, OutputLength, FALSE, FALSE, NULL);
  637. pageLocked = FALSE;
  638. _try{
  639. MmProbeAndLockPages(pMdl, KernelMode, IoModifyAccess );
  640. pageLocked = TRUE;
  641. }
  642. _except(
  643. pExceptionInfo = GetExceptionInformation(),                                                                                                                                                                                                    
  644. lclExceptionCode = pExceptionInfo->ExceptionRecord->ExceptionCode,                                                                                                                                                                             
  645. lclExceptionAddr = pExceptionInfo->ExceptionRecord->ExceptionAddress,                                                                                                                                                                          
  646. EXCEPTION_EXECUTE_HANDLER                                                                                                                                                                                                                      
  647. )                                                                                                                                                                                                                                               
  648. {                                                                                                                                                                                                                                                    
  649. DebugPrint((".TDIClnRecv:  MmProbeAndLockPages() failed.  Error = 0x%08x at 0x%08xn",
  650. lclExceptionCode, lclExceptionAddr));
  651. status = lclExceptionCode;                                                                                                                                                                                                                          
  652. goto done;
  653. }         
  654. TdiBuildQueryInformation ( pIrp, deviceExtension->TDILowerDeviceObject,
  655. deviceExtension->lpTransAddrFileObject,
  656. NULL, NULL, QType, pMdl );
  657. status = IoCallDriver ( deviceExtension->TDILowerDeviceObject, pIrp );
  658. if (STATUS_PENDING==status)
  659. KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, 0);
  660. done:
  661. status = ((STATUS_SUCCESS==status) || (STATUS_PENDING==status)) ? IoStatus.Status : status;
  662. Irp->IoStatus.Information = IoStatus.Information;
  663. DebugPrint(("QueryInfo: status %x, Info %dn", status, Irp->IoStatus.Information ));
  665. return status;
  666. }
  668. NTSTATUS
  669. TDIClnSetEventHandler(
  670.                       PFILE_OBJECT   pAddrFileObj,    // Address file object.
  671.                       PDEVICE_OBJECT pTcpDevObj,      // TDI driver's device object.
  672.                       LONG           EventType,       // Type of event.
  673.                       PVOID          pEventHandler,   // Event handler routine.
  674.                       PVOID          pEventContext    // Context for event handler.
  675.   )
  676. /**************************************************************************************************/
  677. /*                                                                                                */
  678. /* Set up an event handler.                                                                       */
  679. /*                                                                                                */
  680. /* Note:  This routine is synchronous.                                                            */
  681. /*                                                                                                */
  682. /**************************************************************************************************/
  683. {
  684. NTSTATUS            status;
  685. KEVENT              Event;
  686. IO_STATUS_BLOCK     IoStatus;
  687. PIRP pIrp;
  688. do {                                                 // Single-iteration loop, to make possible escape via break.
  689. KeInitializeEvent(&Event, NotificationEvent, FALSE);
  690. // Get an Irp for internal device ioctl.
  691. pIrp = TdiBuildInternalDeviceControlIrp(TDI_SET_EVENT_HANDLER,
  692. pTcpDevObj,   // TDI driver's device object.
  693. pAddrFileObj, // Address file object.
  694. &Event,       // Event to be signalled when Irp completes.
  695. &IoStatus     // I/O status block.
  696. );
  697. if (NULL==pIrp)
  698. {
  699. status = STATUS_INSUFFICIENT_RESOURCES;
  700. break;
  701. }
  702. TdiBuildSetEventHandler(pIrp,
  703. pTcpDevObj,
  704. pAddrFileObj,
  705. NULL,                    // I/O completion routine.
  706. NULL,                    // Context for I/O completion routine.
  707. EventType,
  708. pEventHandler,           // Event handler routine.
  709. pEventContext            // Context for event handler routine.
  710. );
  712. status = IoCallDriver(pTcpDevObj, pIrp);
  714. if (STATUS_PENDING==status)                      // Have to wait on this Irp?
  715. KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, 0);
  716. // Problem from IoCallDriver() or Problem discovered in completion?
  717. if ( ( STATUS_SUCCESS!=status && STATUS_PENDING!=status )
  718. || ( STATUS_PENDING==status && 0!=IoStatus.Status ) )
  719. {
  720. // Note:  If problem was in IoCallDriver(), IoStatus.Status probably won't be meaningful.
  721. DebugPrint(("TDIClnSetEventHandler:  Problem in IoCallDriver().  status = 0x%08x, IoStatus.Status = 0x%08xn",
  722. STATUS_PENDING==status ? 0 : status , IoStatus.Status));
  723. }
  724.     } while(0);                                       // End 'do-while' single-iteration loop.
  726. status = ((STATUS_SUCCESS==status) || (STATUS_PENDING==status)) ? IoStatus.Status : status;
  728. return status;
  729. }                                                     // End TDIClnSetEventHandler().
  732. NTSTATUS
  733. TDIOpenTransportAddress(
  734.                     PWSTR          pTransDevName,     // Transport device name.
  735.                     PHANDLE        pHandle,           // Output handle address.
  736.                     PFILE_OBJECT * ppAddrFileObj,     // Output address file object.
  737.                     USHORT         Port               // Port to open.
  738. )
  739. /**************************************************************************************************/
  740. /*                                                                                                */
  741. /* Open transport address.                                                                        */
  742. /*                                                                                                */
  743. /**************************************************************************************************/
  744. {
  745. NTSTATUS                    status;
  746. UNICODE_STRING              TransDeviceName;
  747. OBJECT_ATTRIBUTES           Attr;
  748. IO_STATUS_BLOCK             IoStatus;
  749. PTA_IP_ADDRESS pSin;
  750. PFILE_FULL_EA_INFORMATION pEa;
  751. char Buffer[sizeof(FILE_FULL_EA_INFORMATION) + TDI_TRANSPORT_ADDRESS_LENGTH + sizeof(TA_IP_ADDRESS)];
  753. ASSERT ( *pHandle == NULL );
  754. ASSERT ( *ppAddrFileObj == NULL );
  755. RtlInitUnicodeString(&TransDeviceName,               // Build Unicode transport device name.
  756. pTransDevName
  757. );
  759. InitializeObjectAttributes(&Attr,                    // Attributes (to be initialized);
  760. &TransDeviceName,
  761. OBJ_CASE_INSENSITIVE
  762. |
  763. OBJ_KERNEL_HANDLE,        // Only in kernel mode but in any process.
  764. 0,
  765. 0
  766. );
  767. pEa = (PFILE_FULL_EA_INFORMATION)Buffer;
  768. pEa->NextEntryOffset= 0;
  769. pEa->Flags = 0;
  770. pEa->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;    // Length of TdiTransportAddress, namely of "TransportAddress" string less 1 (ie, without terminator).
  771. RtlCopyMemory ( pEa->EaName, TdiTransportAddress, pEa->EaNameLength + 1 );
  772. pEa->EaValueLength = sizeof(TA_IP_ADDRESS);          // Length of structure.
  774.     // Point to Buffer just after what's been used (ie, after terminator).
  775. pSin =(PTA_IP_ADDRESS) ( pEa->EaName + pEa->EaNameLength + 1);
  776. pSin->TAAddressCount= 1;                                                                                                                                                                                                                                     
  777. pSin->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
  778. pSin->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
  779. pSin->Address[0].Address[0].sin_port = Port;
  780. pSin->Address[0].Address[0].in_addr = 0;//0x601a8c0; // 192.168.1.6
  781. RtlZeroMemory ( pSin->Address[ 0 ].Address[ 0 ].sin_zero, sizeof ( pSin->Address[ 0 ].Address[ 0 ].sin_zero ) );
  783. status = ZwCreateFile(pHandle,                       // Actual open of transport address.
  784. GENERIC_READ | GENERIC_WRITE,
  785. &Attr,
  786. &IoStatus,
  787. 0,
  788. FILE_ATTRIBUTE_NORMAL,
  789. FILE_SHARE_READ,
  790. FILE_OPEN_IF,
  791. 0,
  792. pEa, //NULL,
  793. sizeof ( Buffer )
  794. );
  796. if (!NT_SUCCESS(status))
  797. {
  798. DebugPrint(("ZwCreateFile failed with status %xn", status ));
  799. return status;
  800. }
  802. status = ObReferenceObjectByHandle(*pHandle,         // Get the object pointer for the address file object's handle.
  803. GENERIC_READ | GENERIC_WRITE,
  804. 0,
  805. KernelMode,
  806. (PVOID *)ppAddrFileObj,
  807. NULL
  808. );
  810. if (!NT_SUCCESS(status))
  811. {
  812. DebugPrint(("ObReferenceObject failed with status %xn", status ));
  813. ZwClose ( *pHandle );
  814. *pHandle = NULL;
  815. }
  816. return status;
  817. }