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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
passthru.c
资源名称：passthru.rar　[点击查看]
上传用户：sabrinaco
上传日期：2016-01-19
资源大小：3177k
文件大小：22k
源码类别：

防火墙与安全工具

开发平台：

Visual C++

passthru.c：源码内容
  1. /*++
  3. Copyright (c) 1992-2000  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     passthru.c
  9. Abstract:
  11.     Ndis Intermediate Miniport driver sample. This is a passthru driver.
  13. Author:
  15. Environment:
  18. Revision History:
  21. --*/
  24. #include "precomp.h"
  26. #pragma hdrstop
  28. #pragma NDIS_INIT_FUNCTION(DriverEntry)
  29. #define START CTL_CODE(FILE_DEVICE_UNKNOWN, 0x901, METHOD_BUFFERED, FILE_ANY_ACCESS )
  30. #define RUN CTL_CODE(FILE_DEVICE_UNKNOWN, 0x902, METHOD_BUFFERED, FILE_ANY_ACCESS )
  31. #define USERNUM CTL_CODE(FILE_DEVICE_UNKNOWN, 0x903, METHOD_BUFFERED, FILE_ANY_ACCESS )
  32. #define CUT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x904, METHOD_BUFFERED, FILE_ANY_ACCESS )
  33. #define CONNECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x905, METHOD_BUFFERED, FILE_ANY_ACCESS )
  34. #define IP CTL_CODE(FILE_DEVICE_UNKNOWN, 0x906, METHOD_BUFFERED, FILE_ANY_ACCESS )
  35. #define LOOKADAPT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x907, METHOD_BUFFERED, FILE_ANY_ACCESS )
  36. #define SETADAPT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x908, METHOD_BUFFERED, FILE_ANY_ACCESS )
  37. #define OPENADAPT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x909, METHOD_BUFFERED, FILE_ANY_ACCESS )
  38. #define QUERYOID CTL_CODE(FILE_DEVICE_UNKNOWN, 0x90a, METHOD_BUFFERED, FILE_ANY_ACCESS )
  39. #define SETOID CTL_CODE(FILE_DEVICE_UNKNOWN, 0x90b, METHOD_BUFFERED, FILE_ANY_ACCESS )
  40. NDIS_HANDLE                     ProtHandle = NULL;
  41. NDIS_HANDLE                     DriverHandle = NULL;
  42. NDIS_MEDIUM                     MediumArray[4] =
  43.                                     {
  44.                                         NdisMedium802_3,    // Ethernet
  45.                                         NdisMedium802_5,    // Token-ring
  46.                                         NdisMediumFddi,     // Fddi
  47.                                         NdisMediumWan       // NDISWAN
  48.                                     };
  50. NDIS_SPIN_LOCK  GlobalLock;
  52. PADAPT          pAdaptList = NULL;
  53. LONG            MiniportCount = 0;
  55. NDIS_HANDLE     NdisWrapperHandle;
  57. //
  58. // To support ioctls from user-mode:
  59. //
  61. #define LINKNAME_STRING     L"\DosDevices\Passthru"
  62. #define NTDEVICE_STRING     L"\Device\Passthru"
  64. NDIS_HANDLE     NdisDeviceHandle = NULL;
  65. PDEVICE_OBJECT  ControlDeviceObject = NULL;
  67. enum _DEVICE_STATE
  68. {
  69.     PS_DEVICE_STATE_READY = 0,  // ready for create/delete
  70.     PS_DEVICE_STATE_CREATING,   // create operation in progress
  71.     PS_DEVICE_STATE_DELETING    // delete operation in progress
  72. }               ControlDeviceState = PS_DEVICE_STATE_READY;
  76. NTSTATUS
  77. DriverEntry(
  78.     IN  PDRIVER_OBJECT      DriverObject,
  79.     IN  PUNICODE_STRING     RegistryPath
  80.     )
  81. /*++
  83. Routine Description:
  85.     First entry point to be called, when this driver is loaded.
  86.     Register with NDIS as an intermediate driver.
  88. Arguments:
  90.     DriverObject - pointer to the system's driver object structure
  91.         for this driver
  92.     
  93.     RegistryPath - system's registry path for this driver
  94.     
  95. Return Value:
  97.     STATUS_SUCCESS if all initialization is successful, STATUS_XXX
  98.     error code if not.
  100. --*/
  101. {
  102.     NDIS_STATUS                     Status;
  103.     NDIS_PROTOCOL_CHARACTERISTICS   PChars;
  104.     NDIS_MINIPORT_CHARACTERISTICS   MChars;
  105.     PNDIS_CONFIGURATION_PARAMETER   Param;
  106.     NDIS_STRING                     Name;
  107.     int i,j;
  108.     usernum=0;
  109.     for(i=0;i<60;i++)
  110.     {
  111.         for(j=0;j<4;j++)
  112.             ip[i][j]=0;
  113.         packetnum[i]=0;
  114.         num[i]=1;
  115.     }
  116.     NdisAllocateMemoryWithTag(&selectpAdapt, sizeof(ADAPT), TAG);
  117.     NdisInitializeString(&selectpAdapt->DeviceName,"a");
  118.     Status = NDIS_STATUS_SUCCESS;
  119.     NdisAllocateSpinLock(&GlobalLock);
  120.     DbgPrint("hi,stating");
  121.     NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject, RegistryPath, NULL);
  123.     do
  124.     {
  125.         //
  126.         // Register the miniport with NDIS. Note that it is the miniport
  127.         // which was started as a driver and not the protocol. Also the miniport
  128.         // must be registered prior to the protocol since the protocol's BindAdapter
  129.         // handler can be initiated anytime and when it is, it must be ready to
  130.         // start driver instances.
  131.         //
  133.         NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_CHARACTERISTICS));
  135.         MChars.MajorNdisVersion = PASSTHRU_MAJOR_NDIS_VERSION;
  136.         MChars.MinorNdisVersion = PASSTHRU_MINOR_NDIS_VERSION;
  138.         MChars.InitializeHandler = MPInitialize;
  139.         MChars.QueryInformationHandler = MPQueryInformation;
  140.         MChars.SetInformationHandler = MPSetInformation;
  141.         MChars.ResetHandler = MPReset;
  142.         MChars.TransferDataHandler = MPTransferData;
  143.         MChars.HaltHandler = MPHalt;
  144. #ifdef NDIS51_MINIPORT
  145.         MChars.CancelSendPacketsHandler = MPCancelSendPackets;
  146.         MChars.PnPEventNotifyHandler = MPDevicePnPEvent;
  147.         MChars.AdapterShutdownHandler = MPAdapterShutdown;
  148. #endif // NDIS51_MINIPORT
  150.         //
  151.         // We will disable the check for hang timeout so we do not
  152.         // need a check for hang handler!
  153.         //
  154.         MChars.CheckForHangHandler = NULL;
  155.         MChars.ReturnPacketHandler = MPReturnPacket;
  157.         //
  158.         // Either the Send or the SendPackets handler should be specified.
  159.         // If SendPackets handler is specified, SendHandler is ignored
  160.         //
  161.         MChars.SendHandler = NULL;  // MPSend;
  162.         MChars.SendPacketsHandler = MPSendPackets;
  164.         Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
  165.                                                &MChars,
  166.                                                sizeof(MChars),
  167.                                                &DriverHandle);
  168.         if (Status != NDIS_STATUS_SUCCESS)
  169.         {
  170.             break;
  171.         }
  173. #ifndef WIN9X
  174.         NdisMRegisterUnloadHandler(NdisWrapperHandle, PtUnload);
  175. #endif
  177.         //
  178.         // Now register the protocol.
  179.         //
  180.         NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
  181.         PChars.MajorNdisVersion = PASSTHRU_PROT_MAJOR_NDIS_VERSION;
  182.         PChars.MinorNdisVersion = PASSTHRU_PROT_MINOR_NDIS_VERSION;
  184.         //
  185.         // Make sure the protocol-name matches the service-name
  186.         // (from the INF) under which this protocol is installed.
  187.         // This is needed to ensure that NDIS can correctly determine
  188.         // the binding and call us to bind to miniports below.
  189.         //
  190.         NdisInitUnicodeString(&Name, L"Passthru");  // Protocol name
  191.         PChars.Name = Name;
  192.         PChars.OpenAdapterCompleteHandler = PtOpenAdapterComplete;
  193.         PChars.CloseAdapterCompleteHandler = PtCloseAdapterComplete;
  194.         PChars.SendCompleteHandler = PtSendComplete;
  195.         PChars.TransferDataCompleteHandler = PtTransferDataComplete;
  196.     
  197.         PChars.ResetCompleteHandler = PtResetComplete;
  198.         PChars.RequestCompleteHandler = PtRequestComplete;
  199.         PChars.ReceiveHandler = PtReceive;
  200.         PChars.ReceiveCompleteHandler = PtReceiveComplete;
  201.         PChars.StatusHandler = PtStatus;
  202.         PChars.StatusCompleteHandler = PtStatusComplete;
  203.         PChars.BindAdapterHandler = PtBindAdapter;
  204.         PChars.UnbindAdapterHandler = PtUnbindAdapter;
  205.         PChars.UnloadHandler = PtUnloadProtocol;
  207.         PChars.ReceivePacketHandler = PtReceivePacket;
  208.         PChars.PnPEventHandler= PtPNPHandler;
  210.         NdisRegisterProtocol(&Status,
  211.                             &ProtHandle,
  212.                             &PChars,
  213.                             sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
  215.         if (Status != NDIS_STATUS_SUCCESS)
  216.         {
  217.             NdisIMDeregisterLayeredMiniport(DriverHandle);
  218.             break;
  219.         }
  221.         NdisIMAssociateMiniport(DriverHandle, ProtHandle);
  222.     }
  223.     while (FALSE);
  225.     if (Status != NDIS_STATUS_SUCCESS)
  226.     {
  227.         NdisTerminateWrapper(NdisWrapperHandle, NULL);
  228.     }
  230.     return(Status);
  231. }
  234. NDIS_STATUS
  235. PtRegisterDevice(
  236.     VOID
  237.     )
  238. /*++
  240. Routine Description:
  242.     Register an ioctl interface - a device object to be used for this
  243.     purpose is created by NDIS when we call NdisMRegisterDevice.
  245.     This routine is called whenever a new miniport instance is
  246.     initialized. However, we only create one global device object,
  247.     when the first miniport instance is initialized. This routine
  248.     handles potential race conditions with PtDeregisterDevice via
  249.     the ControlDeviceState and MiniportCount variables.
  251.     NOTE: do not call this from DriverEntry; it will prevent the driver
  252.     from being unloaded (e.g. on uninstall).
  254. Arguments:
  256.     None
  258. Return Value:
  260.     NDIS_STATUS_SUCCESS if we successfully register a device object.
  262. --*/
  263. {
  264.     NDIS_STATUS         Status = NDIS_STATUS_SUCCESS;
  265.     UNICODE_STRING      DeviceName;
  266.     UNICODE_STRING      DeviceLinkUnicodeString;
  267.     PDRIVER_DISPATCH    DispatchTable[IRP_MJ_MAXIMUM_FUNCTION];
  268.     UINT                i;
  270.     DBGPRINT(("==>PtRegisterDevicen"));
  272.     NdisAcquireSpinLock(&GlobalLock);
  274.     ++MiniportCount;
  275.     
  276.     if (1 == MiniportCount)
  277.     {
  278.         ASSERT(ControlDeviceState != PS_DEVICE_STATE_CREATING);
  280.         //
  281.         // Another thread could be running PtDeregisterDevice on
  282.         // behalf of another miniport instance. If so, wait for
  283.         // it to exit.
  284.         //
  285.         while (ControlDeviceState != PS_DEVICE_STATE_READY)
  286.         {
  287.             NdisReleaseSpinLock(&GlobalLock);
  288.             NdisMSleep(1);
  289.             NdisAcquireSpinLock(&GlobalLock);
  290.         }
  292.         ControlDeviceState = PS_DEVICE_STATE_CREATING;
  294.         NdisReleaseSpinLock(&GlobalLock);
  296.         for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
  297.         {
  298.             DispatchTable[i] = PtDispatch;
  299.         }
  301.         NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
  302.         NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);
  304.         //
  305.         // Create a device object and register our dispatch handlers
  306.         //
  307.         
  308.         Status = NdisMRegisterDevice(
  309.                     NdisWrapperHandle, 
  310.                     &DeviceName,
  311.                     &DeviceLinkUnicodeString,
  312.                     &DispatchTable[0],
  313.                     &ControlDeviceObject,
  314.                     &NdisDeviceHandle
  315.                     );
  317.         NdisAcquireSpinLock(&GlobalLock);
  319.         ControlDeviceState = PS_DEVICE_STATE_READY;
  320.     }
  322.     NdisReleaseSpinLock(&GlobalLock);
  324.     DBGPRINT(("<==PtRegisterDevice: %xn", Status));
  326.     return (Status);
  327. }
  330. NTSTATUS
  331. PtDispatch(
  332.     IN PDEVICE_OBJECT   DeviceObject,
  333.     IN PIRP             Irp
  334.     )
  335. /*++
  336. Routine Description:
  338.     Process IRPs sent to this device.
  340. Arguments:
  342.     DeviceObject - pointer to a device object
  343.     Irp   - pointer to an I/O Request Packet
  345. Return Value:
  347.     NTSTATUS - STATUS_SUCCESS always - change this when adding
  348.     real code to handle ioctls.
  350. --*/
  351. {
  352.     NTSTATUS            status = STATUS_SUCCESS;
  353.     int i;
  354.     PVOID pNext;
  355.     ULONG id;
  356.     ULONG tran=0;
  357.     PADAPT pAdapt;
  358.     POPEN_CONTEXT pOpenContext;
  359.     PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
  360.     PPTUSERIO_OID_DATA pOidData = (PPTUSERIO_OID_DATA)Irp->AssociatedIrp.SystemBuffer;
  361.     // 取得I/O控制代码
  362.     ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
  363.     // 取得I/O缓冲区指针和它的长度
  364.     PVOID pIoBuffer = Irp->AssociatedIrp.SystemBuffer;
  365.     ULONG uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  366.     ULONG uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
  368.     pNext=pIoBuffer;
  369.     DBGPRINT(("==>Pt Dispatchn"));
  370.     switch (pIrpStack->MajorFunction)
  371.     {
  372.         case IRP_MJ_CREATE:
  373.             pIrpStack->FileObject->FsContext = NULL;
  374.             pIrpStack->FileObject->FsContext2 = NULL;
  375.             tran=0;
  376.             break;
  377.         case IRP_MJ_CLOSE:
  378.             pOpenContext = (POPEN_CONTEXT)pIrpStack->FileObject->FsContext;
  381.             pIrpStack->FileObject->FsContext = NULL;
  382.             pIrpStack->FileObject->FsContext2 = NULL;
  384.             if(pOpenContext != NULL) // 关闭的是一个适配器句柄
  385.             {
  386.                 if(pOpenContext->pAdapt != NULL)
  387.                 {
  388.                     NdisAcquireSpinLock(&(pOpenContext->pAdapt)->Lock);
  389.                     (pOpenContext->pAdapt)->pOpenContext = NULL;
  390.                     NdisReleaseSpinLock(&(pOpenContext->pAdapt)->Lock);
  391.                  }
  392.                 DevDerefOpenContext(pOpenContext);
  393.             }
  394.             tran=0;
  395.             break;        
  396.         case IRP_MJ_DEVICE_CONTROL:
  397.         switch(uIoControlCode)
  398.         {
  399.             case START:
  400.                 NdisMoveMemory(mac[usernum],(unsigned char*)pIoBuffer,6);
  401.                 usernum++;
  402.                 tran=0;
  403.                 break;
  404.             case RUN:
  405.                 NdisMoveMemory((ULONG *)pIoBuffer,packetnum,240);
  406.                 tran=240;
  407.                 for(i=0;i<60;i++)
  408.                 packetnum[i]=0;
  409.                 break;
  410.             case USERNUM:
  411.                 NdisMoveMemory(&usernum,(ULONG *)pIoBuffer,4);
  412.                 tran=0;
  413.                 break;
  414.             case CUT:
  415.                 NdisMoveMemory(&id,(ULONG *)pIoBuffer,4);
  416.                 num[id]=0;
  417.                 tran=0;
  418.                 break;
  419.             case CONNECT:
  420.                 NdisMoveMemory(&id,(ULONG *)pIoBuffer,4);
  421.                 num[id]=1;
  422.                 tran=0;
  423.                 break;
  424.             case IP:
  425.                 for(i=0;i<60;i++)
  426.                 NdisMoveMemory((UCHAR *)pNext+i*4,ip[i],4);
  427.                 tran=240;
  428.                 break;
  429.             case LOOKADAPT:
  430.                 GetBindingList(pIoBuffer,uOutSize,&tran);
  431.                 break;
  432.             case SETADAPT:
  434.                 break;
  435.             case OPENADAPT:
  436.                 pAdapt=LookupAdaptByName((PUCHAR)pIoBuffer,uInSize);
  437.                 if(pAdapt==NULL)
  438.                 {
  439.                     status= STATUS_OBJECT_NAME_NOT_FOUND;
  440.                     break;
  441.                 }
  442.                  // 如果正在Unbind，则失败
  443.                 NdisAcquireSpinLock(&pAdapt->Lock);
  444.                 if(pAdapt->UnbindingInProcess)
  445.                 {
  446.                     NdisReleaseSpinLock(&pAdapt->Lock);
  447.                     PtDerefAdapter(pAdapt);
  448.                     status = STATUS_INVALID_DEVICE_STATE;
  449.                     break;
  450.                 }
  451.                 NdisReleaseSpinLock(&pAdapt->Lock);
  452.                  // 如果适配器已经打开，则失败
  453.                 if(pAdapt->pOpenContext != NULL)
  454.                 {
  455.                     PtDerefAdapter(pAdapt);
  456.                     status = STATUS_DEVICE_BUSY;
  457.                     break;
  458.                 }
  459.                 pOpenContext = DevAllocateOpenContext(pAdapt);
  460.                 if(pOpenContext == NULL)
  461.                 {
  462.                     PtDerefAdapter(pAdapt);
  463.                     status = STATUS_INSUFFICIENT_RESOURCES;
  464.                     break;
  465.                 }
  466.                 if(InterlockedCompareExchangePointer(&(pAdapt->pOpenContext),
  467.                                                     pOpenContext, NULL) != NULL)
  468.                 {
  469.                     PtDerefAdapter(pAdapt);
  470.                     status = STATUS_DEVICE_BUSY;
  471.                     break;
  472.                 }
  473.                 selectpAdapt=pAdapt;
  474.             // 将打开环境与句柄关联
  475.                 pIrpStack->FileObject->FsContext = pOpenContext;
  476.                 status = STATUS_SUCCESS;
  477.                 tran=0;
  478.                 break;
  479.             case SETOID:
  480.             case QUERYOID:
  481.                 status = STATUS_INVALID_DEVICE_REQUEST;
  482.                 do
  483.                 {
  484.                     // 取得与此句柄关联的OPEN_CONTEXT结构的指针 // 首先检查此句柄是否打开适配器
  485.                     pOpenContext = (POPEN_CONTEXT)pIrpStack->FileObject->FsContext;
  486.                     if(pOpenContext == NULL)
  487.                     {
  488.                         status = STATUS_INVALID_HANDLE;
  489.                         break;
  490.                     }
  491.                     pAdapt = pOpenContext->pAdapt;
  492.                     if(pAdapt == NULL)
  493.                     {
  494.                         status = STATUS_INVALID_HANDLE;
  495.                         break;
  496.                     }
  497.         
  498.                      // 检查缓冲区
  499.                     if(uOutSize != uInSize || uOutSize < sizeof(PTUSERIO_OID_DATA) ||
  500.                     uOutSize < sizeof(PTUSERIO_OID_DATA) - 1 + pOidData->Length)
  501.                     {
  502.                         status = STATUS_INVALID_PARAMETER;
  503.                         break;
  504.                     }
  505.                      // 如果Unbind正在进行，则失败
  506.                     NdisAcquireSpinLock(&pAdapt->Lock);
  507.                     if( pAdapt->UnbindingInProcess )
  508.                     {
  509.                          NdisReleaseSpinLock(&pAdapt->Lock);
  510.                          DBGPRINT(( "      Unbind In Processn" ));
  511.                          status = STATUS_INVALID_DEVICE_STATE;
  512.                          break;
  513.                     }
  514.                     // All other queries are failed, if the miniport is not at D0,
  515.                     if (pAdapt->MPDeviceState > NdisDeviceStateD0)
  516.                     {
  517.                         NdisReleaseSpinLock(&pAdapt->Lock);
  518.                         DBGPRINT(( "      Invalid Miniport Device Staten" ));
  519.                         status = STATUS_INVALID_DEVICE_STATE;
  520.                         break;
  521.                     }
  522.                     // This is in the process of powering down the system, always fail the request
  523.                    if (pAdapt->StandingBy == TRUE)
  524.                    {
  525.                         NdisReleaseSpinLock(&pAdapt->Lock);
  526.                         DBGPRINT(( "      Miniport Powering Downn" ));
  527.                         status = STATUS_INVALID_DEVICE_STATE;
  528.                         break;
  529.                     }
  530.                     NdisReleaseSpinLock(&pAdapt->Lock);
  531.                     // 检查完毕，最后，进行这个请求
  532.                     DevRefOpenContext(pOpenContext);
  533.                     // 初始化NDIS_REQUEST结构
  534.                     NdisZeroMemory(&pOpenContext->Request, sizeof(pOpenContext->Request));
  535.                     if(uIoControlCode == SETOID)
  536.                     { 
  537.                          pOpenContext->Request.RequestType = NdisRequestSetInformation;
  538.                          pOpenContext->Request.DATA.SET_INFORMATION.Oid = pOidData->Oid;
  539.                          pOpenContext->Request.DATA.SET_INFORMATION.InformationBuffer = pOidData->Data;
  540.                          pOpenContext->Request.DATA.SET_INFORMATION.InformationBufferLength = pOidData->Length;
  541.                     }
  542.                     else
  543.                     {
  544.                          pOpenContext->Request.RequestType = NdisRequestQueryInformation;
  545.                          pOpenContext->Request.DATA.QUERY_INFORMATION.Oid = pOidData->Oid;
  546.                          pOpenContext->Request.DATA.QUERY_INFORMATION.InformationBuffer = pOidData->Data;
  547.                          pOpenContext->Request.DATA.QUERY_INFORMATION.InformationBufferLength = pOidData->Length;
  548.                     }
  549.                     NdisResetEvent( &pOpenContext->RequestEvent);
  550.                     NdisRequest(&status, pAdapt->BindingHandle, &pOpenContext->Request);
  551.                     if(status != NDIS_STATUS_PENDING)
  552.                     {
  553.                          DevRequestComplete(pAdapt, &pOpenContext->Request, status);
  554.                     }
  555.                     // 等待请求的完成，即等待Ndis调用DevRequestComplete例程
  556.                     NdisWaitEvent(&pOpenContext->RequestEvent, 0);
  557.                     if(pOpenContext->RequestStatus == NDIS_STATUS_SUCCESS)
  558.                     {
  559.                          if(uIoControlCode == SETOID)
  560.                          {
  561.                              pOidData->Length = pOpenContext->Request.DATA.SET_INFORMATION.BytesRead;
  562.                          }
  563.                         else if(uIoControlCode == QUERYOID)
  564.                          {
  565.                              pOidData->Length = pOpenContext->Request.DATA.QUERY_INFORMATION.BytesWritten;
  566.                          }
  567.                         // 设置返回给I/O管理器的信息
  568.                         tran = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  569.                         status = STATUS_SUCCESS;
  570.                     }
  571.                     else
  572.                     {
  573.                         status = STATUS_UNSUCCESSFUL;
  574.                     }
  575.                     DevDerefOpenContext(pOpenContext);
  576.                 }while(FALSE);
  577.                 break;
  578.         default:
  579.             break;
  580.         }
  581.     }
  582.     Irp->IoStatus.Information = tran;
  583.     Irp->IoStatus.Status = status;
  584.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  585.     DBGPRINT(("<== Pt Dispatchn"));
  587.     return status;
  589. } 
  592. NDIS_STATUS
  593. PtDeregisterDevice(
  594.     VOID
  595.     )
  596. /*++
  598. Routine Description:
  600.     Deregister the ioctl interface. This is called whenever a miniport
  601.     instance is halted. When the last miniport instance is halted, we
  602.     request NDIS to delete the device object
  604. Arguments:
  606.     NdisDeviceHandle - Handle returned by NdisMRegisterDevice
  608. Return Value:
  610.     NDIS_STATUS_SUCCESS if everything worked ok
  612. --*/
  613. {
  614.     NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
  616.     DBGPRINT(("==>PassthruDeregisterDevicen"));
  618.     NdisAcquireSpinLock(&GlobalLock);
  620.     ASSERT(MiniportCount > 0);
  622.     --MiniportCount;
  623.     
  624.     if (0 == MiniportCount)
  625.     {
  626.         //
  627.         // All miniport instances have been halted. Deregister
  628.         // the control device.
  629.         //
  631.         ASSERT(ControlDeviceState == PS_DEVICE_STATE_READY);
  633.         //
  634.         // Block PtRegisterDevice() while we release the control
  635.         // device lock and deregister the device.
  636.         // 
  637.         ControlDeviceState = PS_DEVICE_STATE_DELETING;
  639.         NdisReleaseSpinLock(&GlobalLock);
  641.         if (NdisDeviceHandle != NULL)
  642.         {
  643.             Status = NdisMDeregisterDevice(NdisDeviceHandle);
  644.             NdisDeviceHandle = NULL;
  645.         }
  647.         NdisAcquireSpinLock(&GlobalLock);
  648.         ControlDeviceState = PS_DEVICE_STATE_READY;
  649.     }
  651.     NdisReleaseSpinLock(&GlobalLock);
  653.     DBGPRINT(("<== PassthruDeregisterDevice: %xn", Status));
  654.     return Status;
  655.     
  656. }
  659. VOID
  660. PtUnloadProtocol(
  661.     VOID
  662. )
  663. {
  664.     NDIS_STATUS Status;
  666.     if (ProtHandle != NULL)
  667.     {
  668.         NdisDeregisterProtocol(&Status, ProtHandle);
  669.         ProtHandle = NULL;
  670.     }
  672.     DBGPRINT(("PtUnloadProtocol: done!n"));
  673. }