ndisprot.cpp

有关WDM驱动程序编程的几个源码

            pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest(pIrp, IO_NO_INCREMENT);
            IoDecrement(pOpen);
            return STATUS_PENDING;
        }         
        pInterRequest->pIrp = pIrp;

		if(uOutSize == uInSize && uOutSize >= sizeof(PROTOCOL_OID_DATA) &&
					uOutSize >= sizeof(PROTOCOL_OID_DATA) - 1 + pOidData->Length)	// 缓冲区可用？
		{
			// 初始化NDIS_REQUEST结构
			if(uIoControlCode == IOCTL_PROTOCOL_SET_OID)
			{
				pInterRequest->Request.RequestType = NdisRequestSetInformation;
				pInterRequest->Request.DATA.SET_INFORMATION.Oid = pOidData->Oid;
				pInterRequest->Request.DATA.SET_INFORMATION.InformationBuffer = pOidData->Data;
				pInterRequest->Request.DATA.SET_INFORMATION.InformationBufferLength = pOidData->Length;
			}
			else
			{
				pInterRequest->Request.RequestType = NdisRequestQueryInformation;
				pInterRequest->Request.DATA.QUERY_INFORMATION.Oid = pOidData->Oid;
				pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer = pOidData->Data;
				pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength = pOidData->Length;
			}

			// 提交这个请求
			NdisRequest(&status, pOpen->hAdapter, &pInterRequest->Request);
		}
		else
		{
			status = NDIS_STATUS_FAILURE;
            pInterRequest->Request.DATA.SET_INFORMATION.BytesRead = 0;
            pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten = 0;
		}
		
		if(status != NDIS_STATUS_PENDING)
		{
			ProtocolRequestComplete(pOpen, &pInterRequest->Request, status);
		}
	}

	return STATUS_PENDING;
}

VOID
ProtocolResetComplete(
    IN NDIS_HANDLE  ProtocolBindingContext,
    IN NDIS_STATUS  Status
    )

{
	OPEN_INSTANCE *pOpen;
    pOpen = (OPEN_INSTANCE*)ProtocolBindingContext;

	// 取出IRP指针
	PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(
                       &pOpen->ResetIrpList,
                       &pOpen->ResetQueueLock
                       );
    PIRP pIrp = CONTAINING_RECORD(pListEntry,IRP,Tail.Overlay.ListEntry);

	// 完成此IRP
    if(Status == NDIS_STATUS_SUCCESS) 
	{
        pIrp->IoStatus.Status = STATUS_SUCCESS;
    } 
	else 
	{
        pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
    }
    pIrp->IoStatus.Information = 0;    
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    IoDecrement(pOpen);
}


VOID
ProtocolRequestComplete(
    IN NDIS_HANDLE   ProtocolBindingContext,
    IN PNDIS_REQUEST NdisRequest,
    IN NDIS_STATUS   Status
    )
{
	POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
	PINTERNAL_REQUEST pInterRequest = CONTAINING_RECORD(NdisRequest, INTERNAL_REQUEST, Request);
	PIRP pIrp = pInterRequest->pIrp;

	if(Status == NDIS_STATUS_SUCCESS)
	{
		PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
		UINT nIoControlCode = pIrpSp->Parameters.DeviceIoControl.IoControlCode;
		PPROTOCOL_OID_DATA pOidData = (PPROTOCOL_OID_DATA)pIrp->AssociatedIrp.SystemBuffer;

		//  将大小返回到用户缓冲区
        if(nIoControlCode == IOCTL_PROTOCOL_SET_OID) 
		{
            pOidData->Length = pInterRequest->Request.DATA.SET_INFORMATION.BytesRead;
        } 
		else if(nIoControlCode == IOCTL_PROTOCOL_QUERY_OID) 
		{
			pOidData->Length = pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
		}	

		// 设置返回给I/O管理器的信息
		pIrp->IoStatus.Information = pIrpSp->Parameters.DeviceIoControl.InputBufferLength;
		pIrp->IoStatus.Status = STATUS_SUCCESS;
	}
	else
	{
		pIrp->IoStatus.Information = 0;
		pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
	}
	ExFreePool(pInterRequest);
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	IoDecrement(pOpen);
}

NTSTATUS
GetAdapterList(
    IN  PVOID              Buffer,		// 缓冲区
    IN  ULONG              Length,		// 缓冲区大小
    IN  OUT PULONG         DataLength	// 返回实际需要的长度
    )
{
	KIRQL oldIrql;
	KeAcquireSpinLock(&g_data.GlobalLock, &oldIrql);

	OPEN_INSTANCE *pOpen ;

		// 遍历列表，计算所需的缓冲区大小
	ULONG nRequiredLength = 0;
	ULONG nAdapters = 0;

	PLIST_ENTRY pThisEntry;
	PLIST_ENTRY pHeader = &g_data.AdapterList;
	for(pThisEntry = pHeader->Flink ; pThisEntry != pHeader; pThisEntry = pThisEntry->Flink)
	{
		pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
		nRequiredLength += pOpen->ustrAdapterName.Length + sizeof(UNICODE_NULL);
		nRequiredLength += pOpen->ustrLinkName.Length + sizeof(UNICODE_NULL);
		nAdapters++;
	}

	// 我们将要以下面的格式返回数据：
	// nAdapters + 一个或者多个（"AdapterName\0" + "SymbolicLink\0"） + UNICODE_NULL
	// 所以，下面要包含上nAapters和UNICODE_NULL的大小
	nRequiredLength += sizeof(nAdapters) + sizeof(UNICODE_NULL); 

	*DataLength = nRequiredLength;
	if(nRequiredLength > Length) 
	{
        KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
        return STATUS_BUFFER_TOO_SMALL;
    }

		// 填充缓冲区
	// 首先是适配器数量
	*(PULONG)Buffer = nAdapters;
	Buffer = (PCHAR)Buffer + sizeof(ULONG);

	// 然后复制适配器和符号连接名称
	for(pThisEntry = pHeader->Flink; 
			pThisEntry != pHeader;
			pThisEntry = pThisEntry->Flink)
    {
        pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
        
        RtlCopyMemory(Buffer, pOpen->ustrAdapterName.Buffer,
                            pOpen->ustrAdapterName.Length + sizeof(WCHAR));

		Buffer = (PCHAR)Buffer + pOpen->ustrAdapterName.Length + sizeof(WCHAR);

        
        RtlCopyMemory(Buffer, pOpen->ustrLinkName.Buffer,
                            pOpen->ustrLinkName.Length + sizeof(WCHAR));

		Buffer = (PCHAR)Buffer + pOpen->ustrLinkName.Length + sizeof(WCHAR);                       
    }
	
	// 最后的结束标志
    *(PWCHAR)Buffer = UNICODE_NULL;
    
    KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);

	return STATUS_SUCCESS;
}



void IoIncrement(OPEN_INSTANCE *pOpen)
{
	if(InterlockedIncrement((PLONG)&pOpen->nIrpCount) == 1)
		NdisResetEvent(&pOpen->CleanupEvent);
}

void IoDecrement(OPEN_INSTANCE *pOpen)
{
	if(InterlockedDecrement((PLONG)&pOpen->nIrpCount) == 0)
		NdisSetEvent(&pOpen->CleanupEvent);
}




NTSTATUS
DispatchCleanup(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
    POPEN_INSTANCE      pOpen = (POPEN_INSTANCE)DeviceObject->DeviceExtension;
    NTSTATUS            status = STATUS_SUCCESS;


    if(DeviceObject == g_data.pControlDevice) 
	{
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }

    IoIncrement(pOpen);
 
    CancelReadIrp(DeviceObject);

    IoDecrement(pOpen);

    NdisWaitEvent(&pOpen->CleanupEvent, 0);

    Irp->IoStatus.Information = 0;    
    Irp->IoStatus.Status = status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
    return status;

}


VOID
ProtocolStatus(
    IN NDIS_HANDLE   ProtocolBindingContext,
    IN NDIS_STATUS   Status,
    IN PVOID         StatusBuffer,
    IN UINT          StatusBufferSize
    )
{
}

VOID
ProtocolStatusComplete(
    IN NDIS_HANDLE  ProtocolBindingContext
    )
{
}



NDIS_STATUS
ProtocolPNPHandler(
    IN    NDIS_HANDLE        ProtocolBindingContext,
    IN    PNET_PNP_EVENT     NetPnPEvent
    )
{
    NDIS_STATUS                 Status  = NDIS_STATUS_SUCCESS;
    PNET_DEVICE_POWER_STATE     powerState;
    
    powerState = (PNET_DEVICE_POWER_STATE)NetPnPEvent->Buffer;
    switch(NetPnPEvent->NetEvent)
    {
         case  NetEventSetPower :
            switch (*powerState) 
			{
            
                case NetDeviceStateD0:
                    Status = NDIS_STATUS_SUCCESS;
                    break;

                default:
                    //
                    // We can't suspend, so we ask NDIS to Unbind us by
                    // returning this status:
                    //
                    Status = NDIS_STATUS_NOT_SUPPORTED;
                    break;
            }
    }
    return Status;
}