packet32.c

3 网卡驱动相关实例 这是和网卡NT KMD驱动程序有关的一些资料和例子。

/*++

Copyright (c) 1990  Microsoft Corporation

Module Name:

    packet32.c

Abstract:


Author:

    BrianL

Environment:

    User mode only.

Notes:


Future:



Revision History:

--*/

#define UNICODE 1

#include <windows.h>
#include <windowsx.h>

#include <ntddndis.h>
#include <ntddpack.h>

#include "packet32.h"

TCHAR   szWindowTitle[] = TEXT("PACKET32.DLL");






#if DBG

#define ODS(_x) OutputDebugString(TEXT(_x))

#else

#define ODS(_x)

#endif




BOOLEAN StartPacketDriver( LPTSTR ServiceName );


BOOL PacketInit( IN PVOID DllHandle, IN ULONG Reason, IN PCONTEXT Context OPTIONAL )

/*++

Routine Description:


Arguments:

    DllHandle - Not Used

    Reason - Attach or Detach

    Context - Not Used

Return Value:

    SUCCESS - TRUE
    FAILURE - FALSE

--*/

{
    BOOLEAN     Status;

    ODS("Packet32: DllEntry\n");


    switch ( Reason ) 
	{
        case DLL_PROCESS_ATTACH:
            Status=StartPacketDriver(TEXT("PACKET"));
            break;

        case DLL_PROCESS_DETACH:
            break;

        default:
            break;
    }

    return Status;
}






LPADAPTER PacketOpenAdapter( LPTSTR   AdapterName )
/*++

Routine Description:

    This rotine opens an instance of the adapter

Arguments:

    AdapterName - unicode name of the adapter to open

Return Value:

    SUCCESS - returns a pointer to an adapter object
    FAILURE - NULL

--*/
{
    LPADAPTER  lpAdapter;
    BOOLEAN    Result;

    ODS("Packet32: PacketOpenAdapter\n");

    lpAdapter=(LPADAPTER)GlobalAllocPtr( GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(ADAPTER));

    if (lpAdapter==NULL) 
	{
        ODS("Packet32: PacketOpenAdapter GlobalAlloc Failed\n");
        return NULL;
    }

    wsprintf(lpAdapter->SymbolicLink, TEXT("\\\\.\\%s%s"), DOSNAMEPREFIX, &AdapterName[8]);

    Result=DefineDosDevice(DDD_RAW_TARGET_PATH, &lpAdapter->SymbolicLink[4], AdapterName);

    if (Result) 
	{
        lpAdapter->hFile=CreateFile(lpAdapter->SymbolicLink,
                             GENERIC_WRITE | GENERIC_READ,
                             0,
                             NULL,
                             CREATE_ALWAYS,
                             FILE_FLAG_OVERLAPPED,
                             0
                             );

        if (lpAdapter->hFile != INVALID_HANDLE_VALUE) 
		{
            return lpAdapter;
        }
    }

    ODS("Packet32: PacketOpenAdapter Could not open adapter\n");

    GlobalFreePtr(lpAdapter);

    return NULL;
}


VOID PacketCloseAdapter(LPADAPTER lpAdapter)
/*++

Routine Description:

    This rotine closes a previouly opened adapter

Arguments:

    Adapter object returned from PacketOpenAdapter

Return Value:


--*/
{
    ODS("Packet32: PacketCloseAdapter\n");
    CloseHandle(lpAdapter->hFile);
    GlobalFreePtr(lpAdapter);
}




LPPACKET PacketAllocatePacket(/*LPADAPTER AdapterObject*/)
/*++

Routine Description:

    This rotine this routine allocates a packet object for use
    in sending a receiveing packets

Arguments:

    Adapter object returned from PacketOpenAdapter

Return Value:

    SUCCESS - returns packet object
    FAILURE - NULL

--*/
{
    LPPACKET    lpPacket;

    lpPacket=(LPPACKET)GlobalAllocPtr( GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(PACKET));

    if (lpPacket==NULL) 
	{
        ODS("Packet32: PacketAllocateSendPacket: GlobalAlloc Failed\n");
        return NULL;
    }

    lpPacket->OverLapped.hEvent=CreateEvent(NULL, FALSE, FALSE, NULL);

    if (lpPacket->OverLapped.hEvent==NULL) 
	{
        ODS("Packet32: PacketAllocateSendPacket: CreateEvent Failed\n");
        GlobalFreePtr(lpPacket);
        return NULL;
    }

    return lpPacket;
}


VOID PacketFreePacket(LPPACKET lpPacket)
{
    CloseHandle(lpPacket->OverLapped.hEvent);
    GlobalFreePtr(lpPacket);
}


VOID PacketInitPacket(LPPACKET lpPacket, PVOID Buffer, UINT Length )
/*++

Routine Description:

    This rotine initializes a packet object to point to
    a memory buffer described by Start address and length

Arguments:

    lpPacket   -  Packet object returned by PacketAllocatePacket

    Buffer     -  Begining address of a memory buffer

    Length     -  Length of memory buffer

Return Value:

--*/
{
    lpPacket->Buffer=Buffer;
    lpPacket->Length=Length;
}


BOOLEAN PacketSendPacket(LPADAPTER   AdapterObject, LPPACKET lpPacket, BOOLEAN Sync)
/*++

Routine Description:

    This rotine sends a packet to the adapter

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

    lpPacket       - Packet object returned by PacketAllocatePacket and initialized
                     by PacketInitPacket

    Sync           - TRUE if service should wait for packet to transmit


Return Value:

    SUCCESS - TRUE if succeeded and SYNC==TRUE
    FAILURE -

--*/
{
    BOOLEAN      Result;
    DWORD      BytesTransfered;

    lpPacket->OverLapped.Offset=0;
    lpPacket->OverLapped.OffsetHigh=0;

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) 
	{
        return FALSE;
    }

    Result=WriteFile(
              AdapterObject->hFile,
              lpPacket->Buffer,
              lpPacket->Length,
              &BytesTransfered,
              &lpPacket->OverLapped );

    if (Sync) 
	{			//  They want to wait
        Result=GetOverlappedResult(
                   AdapterObject->hFile,
                   &lpPacket->OverLapped,
                   &BytesTransfered,
                   TRUE);
    } 
	else 
	{   //  They don't want to wait, they will call PacketWaitPacket to get the real result
        Result=TRUE;
    }

    return Result;
}



BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject, LPPACKET lpPacket, BOOLEAN Sync, PULONG BytesReceived)
/*++

Routine Description:

    This rotine issues a receive request from the adapter

Arguments:

    AdapterObject  - AdapterObject return by PacketOpenAdapter

    lpPacket       - Packet object returned by PacketAllocatePacket and initialized
                     by PacketInitPacket

    Sync           - TRUE if service should wait for packet to transmit


Return Value:

    SUCCESS - TRUE if succeeded and SYNC==TRUE
    FAILURE -

--*/
{
    BOOLEAN      Result;

    lpPacket->OverLapped.Offset=0;
    lpPacket->OverLapped.OffsetHigh=0;

    if (!ResetEvent(lpPacket->OverLapped.hEvent)) 
	{
        return FALSE;
    }

    Result=ReadFile(
              AdapterObject->hFile,
              lpPacket->Buffer,
              lpPacket->Length,
              BytesReceived,
              &lpPacket->OverLapped);

    if (Sync) 
	{   //  They want to wait
        Result=GetOverlappedResult(
                   AdapterObject->hFile,
                   &lpPacket->OverLapped,
                   BytesReceived,
                   TRUE);
    } 
	else 
	{   //  They don't want to wait, they will call PacketWaitPacket to get the real result
        Result=TRUE;
    }

    return Result;
}