packet32.c

网卡驱动相关实例 这是和网卡NT KMD驱动程序有关的一些资料和例子。主要是以下三方面内容: 3.1 article 一些有用的文档 3.2 Canberra 网络诊听工具Ethern

//
//   Returns:   result of asynchronous operation
// 
//------------------------------------------------------------------------

BOOLEAN PacketWaitPacket(LPADAPTER lpAdapter,
                         LPPACKET  lpPacket,
                         PULONG    BytesReceived)
{
    return GetOverlappedResult(lpAdapter->hFile,
                               &lpPacket->OverLapped,
                               BytesReceived,
                               TRUE);
}

//------------------------------------------------------------------------
//
//  PacketResetAdapter - reset adapter, completing all pending operations
//
//      Args:   lpAdapter - pointer to an Adapter
//
//   Returns:   TRUE
// 
//------------------------------------------------------------------------

BOOLEAN PacketResetAdapter(LPADAPTER lpAdapter)
{
    UINT    BytesReturned;

    DeviceIoControl(lpAdapter,
                    (DWORD)IOCTL_PROTOCOL_RESET,
                    NULL,
                    0,
                    NULL,
                    0,
                    &BytesReturned,
                    NULL);

    return TRUE;
}

//------------------------------------------------------------------------
//
//  PacketRequest - issue a request to an adapter
//
//      Args:   lpAdapter - pointer to an Adapter
//              Set       - set OID if TRUE else get OID
//              OidData - pointer to OID data
//
//   Returns:   Number of bytes returned   
// 
//------------------------------------------------------------------------

ULONG PacketRequest(LPADAPTER lpAdapter,
                    BOOLEAN   Set,
                    PPACKET_OID_DATA OidData)
{
    UINT       BytesReturned = 0;
    UINT       Result;

    Result = DeviceIoControl(lpAdapter->hFile,
    (DWORD) Set ? IOCTL_PROTOCOL_SET_OID : IOCTL_PROTOCOL_QUERY_OID, OidData,
                             sizeof(PACKET_OID_DATA)-1+OidData->Length,
                             OidData,
                             sizeof(PACKET_OID_DATA)-1+OidData->Length,
                             &BytesReturned,
                             NULL);
    return BytesReturned;
}

//------------------------------------------------------------------------
//
//  PacketSetFilter - issue a set filter request to an adapter
//
//      Args:   lpAdapter  - pointer to an Adapter
//              Filter     - filter to set
//
//   Returns:   
// 
//------------------------------------------------------------------------

BOOLEAN PacketSetFilter(LPADAPTER lpAdapter, ULONG Filter)

{

    BOOLEAN Status;

    ULONG   IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+sizeof(ULONG)-1);

    PPACKET_OID_DATA OidData;

    OidData = GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT, IoCtlBufferLength);

    if (OidData == NULL) return FALSE;

    OidData->Oid = OID_GEN_CURRENT_PACKET_FILTER;
    OidData->Length = sizeof(ULONG);
    *((PULONG)OidData->Data) = Filter;

    Status = PacketRequest(lpAdapter, TRUE, OidData);

    GlobalFreePtr(OidData);

    return Status;
}

//------------------------------------------------------------------------
//
//  PacketGetAddress - issue a get address request to an adapter
//
//      Args:   lpAdapter     - pointer to an Adapter
//              AddressBuffer - buffer to hold the address
//
//   Returns:   number of bytes copied to address buffer   
// 
//------------------------------------------------------------------------

ULONG PacketGetAddress(LPADAPTER lpAdapter, PUCHAR AddressBuffer)
                             
{

    ULONG   Result;
    
    BYTE iBuf[sizeof(PACKET_OID_DATA) + 128];

    PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA) iBuf;

    pOidData->Oid = OID_802_3_CURRENT_ADDRESS;
    pOidData->Length = 6;
    pOidData->Data[0] = 0;

    Result = PacketRequest(lpAdapter, 0, pOidData);

    if (Result > 0) {
        memcpy(AddressBuffer, &iBuf[8], 6);
        Result = 6;
    }
    else
        Result = 0;
        
    return Result;
}

//------------------------------------------------------------------------
//
//  StartPacketDriver - starts the kernel mode packet driver
//
//      Args:   ServiceName - name of service to start
//
//   Returns:   
// 
//------------------------------------------------------------------------

BOOLEAN StartPacketDriver(LPTSTR ServiceName)

{
    BOOLEAN  Status;

    SC_HANDLE  SCManagerHandle;
    SC_HANDLE  SCServiceHandle;

    // Open a handle to the SC Manager database.

    SCManagerHandle = OpenSCManager(NULL,       // local machine
                                    NULL,       // ServicesActive database
                                    SC_MANAGER_ALL_ACCESS);

    if (SCManagerHandle==NULL) {

        MessageBox(NULL,TEXT("Could not open SC"), szWindowTitle, MB_OK);

        return FALSE;

    } else {

        SCServiceHandle = OpenService(SCManagerHandle,
                                      ServiceName,
                                      SERVICE_START);

        if (SCServiceHandle == NULL)

            MessageBox(NULL,TEXT("Could not open service"),szWindowTitle,MB_OK);

        Status = StartService(SCServiceHandle, 0, NULL);

        if (!Status) {

            if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING) {

                ODS("Packet32: Packet service already started\n");

                return TRUE;
            }
        }
        return Status;
    }
}

//------------------------------------------------------------------------
//
//  PacketGetAdapterNames - returns the names of all available adapters
//
//      Args:   pStr   - pointer to buffer for UNICODE names
//              pSize  - address of ulong containing string length
//
//   Returns:   
// 
//------------------------------------------------------------------------

ULONG PacketGetAdapterNames(PTSTR pStr, PULONG pSize)

{

    HKEY    SystemKey;
    HKEY    ControlSetKey;
    HKEY    ServicesKey;
    HKEY    NdisPerfKey;
    HKEY    LinkageKey;
    LONG    Status;

    DWORD   RegType;

    Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                          TEXT("SYSTEM"),
                          0,
                          KEY_READ,
                          &SystemKey);

    if (Status == ERROR_SUCCESS) {

        Status = RegOpenKeyEx(SystemKey,
                              TEXT("CurrentControlSet"),
                              0,
                              KEY_READ,
                              &ControlSetKey);

        if (Status == ERROR_SUCCESS) {

            Status = RegOpenKeyEx(ControlSetKey,
                                  TEXT("Services"),
                                  0,
                                  KEY_READ,
                                  &ServicesKey);

            if (Status == ERROR_SUCCESS) {

                Status = RegOpenKeyEx(ServicesKey,
                                      TEXT("Packet"),
                                      0,
                                      KEY_READ,
                                      &NdisPerfKey);

                if (Status == ERROR_SUCCESS) {

                    Status = RegOpenKeyEx(NdisPerfKey,
                                          TEXT("Linkage"),
                                          0,
                                          KEY_READ,
                                          &LinkageKey);

                    if (Status == ERROR_SUCCESS) {

                        Status = RegQueryValueEx(LinkageKey,
                                                 TEXT("Export"),
                                                 NULL,
                                                 &RegType,
                                                 (LPBYTE)pStr,
                                                 pSize);

                        RegCloseKey(LinkageKey);
                    }

                    RegCloseKey(NdisPerfKey);
                }

                RegCloseKey(ServicesKey);
            }

            RegCloseKey(ControlSetKey);
        }

        RegCloseKey(SystemKey);
    }
    return Status;
}

//------------------------------------------------------------------------
//
//  PacketGetName - returns the name of a specified adapter
//
//      Args:   pStr - pointer to buffer for a UNICODE name
//              n    - which name to return
//
//   Returns:   TRUE  if the n'th name was found
//              FALSE if the n'th name does not exist   
// 
//------------------------------------------------------------------------

ULONG PacketGetName(PTSTR pStr, ULONG n)
{
    TCHAR   buf[256];
    TCHAR   *Name;
    ULONG   NameLength = 256;

    Name = buf;
        
    PacketGetAdapterNames(Name, &NameLength);

    switch (n) {
        case 3: Name = &Name[strlen(Name)+1];
                if (!strlen(Name))
                    break;
        case 2: Name = (char *) &Name[strlen(Name)+1];
                if (!strlen(Name))
                    break;
        case 1: Name = (char *) &Name[strlen(Name)+1];
                if (!strlen(Name))
                    break;
        case 0: break;
    }
    
    if (strlen(Name) != 0) {
        strcpy(pStr, Name);
        return TRUE;
        }
    else
        return FALSE;
}