Драйвер LLDP для Windows XP

typedef struct _IP_ADAPTER_INFO
 { 
               struct _IP_ADAPTER_INFO *Next; 
               DWORD ComboIndex; 
               char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4]; 
               char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];  
               UINT AddressLength;  
               BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH];  
               DWORD Index;  
               UINT Type;  
               UINT DhcpEnabled;  
               PIP_ADDR_STRING CurrentIpAddress;  
               IP_ADDR_STRING IpAddressList;  
               IP_ADDR_STRING GatewayList;  
               IP_ADDR_STRING DhcpServer;  
               BOOL HaveWins;  
               IP_ADDR_STRING PrimaryWinsServer; 
               IP_ADDR_STRING SecondaryWinsServer;  
               time_t LeaseObtained;  
               time_t LeaseExpires; 
 
} IP_ADAPTER_INFO, *PIP_ADAPTER_INFO;

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include "pcap.h"
#include "conio.h"
#pragma comment (lib, "wpcap.lib")
#pragma comment (lib, "Packet.lib")
void main(int argc, char **argv)
{
pcap_t *fp;
char errbuf[PCAP_ERRBUF_SIZE];
u_char packet[100];
int i;
 
    /* Check the validity of the command line */
    if (argc != 2)
    {
        printf("usage: %s interface (e.g. 'rpcap://eth0')", argv[0]);
        return;
    }
 
    /* Open the output device */
    if ( (fp= pcap_open_live(argv[1],100,1000,NULL,errbuf) ) == NULL)
    {
        fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", argv[1]);
        return;
    }
 
    /* Supposing to be on ethernet, set mac destination to 1:1:1:1:1:1 */
    packet[0]=1;
    packet[1]=1;
    packet[2]=1;
    packet[3]=1;
    packet[4]=1;
    packet[5]=1;
 
    /* set mac source to 2:2:2:2:2:2 */
    packet[6]=2;
    packet[7]=2;
    packet[8]=2;
    packet[9]=2;
    packet[10]=2;
    packet[11]=2;
 
    /* Fill the rest of the packet */
    for(i=12;i<100;i++)
    {
        packet[i]=(u_char)i;
    }
 
    /* Send down the packet */
    if (pcap_sendpacket(fp, packet, 100 /* size */) != 0)
    {
        fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(fp));
        return;
    }
 
    return;
getch();
}

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#define HAVE_REMOTE
#include <pcap.h>
#include <windows.h>
#include "TChar.h" 
#include <winsock2.h>
#include <winsock.h>
#include <iphlpapi.h>
#include <wsipx.h>
#include <WSNwLink.h>
#include <conio.h>
#include <cstdlib>
#include <NB30.h>
#include <string.h> 
#include <iostream>
#include <comdef.h>
#include <Wbemidl.h>
#include <strsafe.h>
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "Netapi32.lib")
#pragma comment(lib, "wbemuuid.lib")
 
using namespace std;
 
//------------------------------------------
typedef struct _ASTAT_
{
ADAPTER_STATUS adapt;
NAME_BUFFER NameBuff [30];
}ASTAT, * PASTAT;
ASTAT Adapter;
//------------------------------------------
 
//--------------- Описание переменных и констант -----------------
 
#define MAX_KEY_LENGTH 255
#define MAX_VALUE_NAME 16383
 
int LogOff=0;
 
char SystemName[512]={NULL};
char *CompNameRet;
char *CompIP;
int *mcad;
int t=0;
int j=0;
char *MBID;
int indexpack, numpack;
char romaname[255];
const int WSVer = 0x101;
u_char packet[1024]={NULL};
int qqq[6];
char Buf[128];
char *mb_sn;
char zzz[256], eee;
TCHAR arrMBSN[1024];
int AdapterNumber;
typedef int (__cdecl *MYPROC)(LPWSTR); 
int counter=0;
char HostIP[12]={NULL};
//----------------------------------------------------------------
 
//------------- Определяем имя компьютера --------------------------
char* CompName() {
    WSADATA wsaData;
    WORD wVerReq;
    wVerReq = MAKEWORD(1, 1);
    int err = WSAStartup(wVerReq, &wsaData);
        if (err) exit(1);
            if (gethostname((char *)&romaname, 255)) exit(1);
    WSACleanup();
    char* pName=new char(127);
    pName=&romaname[0];
return pName;
}
//------------------------------------------------------------------OK
 
//-------------- Определяем IP компьютера --------------------------
char* ComputerIP(){
    WSADATA wsaData;
    hostent *h;
char *IPBufPointer;
if (WSAStartup(WSVer, &wsaData) == 0)
{
if (gethostname(&Buf[0], 128) == 0)
    {
    h = gethostbyname(&Buf[0]);
        if (h != NULL)
            IPBufPointer=inet_ntoa (*(reinterpret_cast<in_addr *>(*(h->h_addr_list)))),0,0;
            h->h_addr_list;
    }
    WSACleanup();
    }
return IPBufPointer;
}
//------------------------------------------------------------------OK
 
//------------- Определяем MAC-адрес компьютера --------------------
int *GetMacAddr(int NA){
    NCB Ncb;
    UCHAR uRetCode;
    int *www;
    memset( &Ncb, 0, sizeof(Ncb) );
    Ncb.ncb_command = NCBRESET;
    Ncb.ncb_lana_num = NA;
    
    uRetCode = Netbios( &Ncb );
    if  (!uRetCode==0)
    {
        printf( "The NCBRESET return code is: 0x%x \n", uRetCode );
    }
 
    memset( &Ncb, 0, sizeof (Ncb) );
    Ncb.ncb_command = NCBASTAT;
    Ncb.ncb_lana_num = NA;
    strcpy( (char *)Ncb.ncb_callname, "* " );
    Ncb.ncb_buffer = (UCHAR *) &Adapter;
    Ncb.ncb_length = sizeof(Adapter);
    uRetCode = Netbios( &Ncb );
    if (!uRetCode==0) {
        printf( "The NCBASTAT return code is: 0x%x \n", uRetCode );
    }
    if ( uRetCode == 0 ){
 
        int addr_adapt;
        for (addr_adapt=0;addr_adapt<6;addr_adapt++){
            qqq[addr_adapt]=Adapter.adapt.adapter_address[addr_adapt];
        }
    }
    www=qqq;
return www;
}
//-------------------------------------------------------------------OK
 
//--------------------- Серийник материнки --------------------------
char *GetMotherBoardID(){
    BSTR rrr;
    char result;
    HRESULT hres;
    hres =  CoInitializeEx(0, COINIT_MULTITHREADED);                                                                                // Инициализация COM
    hres =  CoInitializeSecurity(NULL, -1,NULL,NULL,RPC_C_AUTHN_LEVEL_DEFAULT,RPC_C_IMP_LEVEL_IMPERSONATE,NULL,EOAC_NONE,NULL);     // Установка уровня безопасности COM
    hres =  CoInitializeSecurity(
    NULL, 
    -1,                          // Аутентификация COM 
    NULL,                        // Аутентификация сервисов
    NULL,                        // Резерв
    RPC_C_AUTHN_LEVEL_DEFAULT,   // Текущая аутентификация
    RPC_C_IMP_LEVEL_IMPERSONATE, // Текущее соотношение  
    NULL,                        // Информация аутентификации
    EOAC_NONE,                   // Дополнительные соглашения 
    NULL                         // Резерв
    );
    //Начальный локатор к WMI
    IWbemLocator *pLoc = NULL;
    hres = CoCreateInstance(CLSID_WbemLocator,0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pLoc);
    // Соединение с WMI используем IWbemLocator::ConnectServer метод
    IWbemServices *pSvc = NULL;
    // Соединение с областью имен root\cimv2 
    // используем текщего пользователя и получаем указатель pSvc
    // чтобы делать вызовы IWbemServices.
    hres = pLoc->ConnectServer(
         _bstr_t(L"ROOT\\CIMV2"), // Путь к объекту в области имен WMI
         NULL,                    // Имя пользователя. NULL = текущий пользователь
         NULL,                    // Пароль пользователя. NULL = текущий
         0,                       // Локаль. NULL текукщая
         NULL,                    // Флаги безопасности.
         0,                       // Авторизация (например Kerberos)
         0,                       // Объект контекста
         &pSvc                    // Указатель прокси для IWbemServices
         );
    // Установка уровней безопасности для прокси
        hres = CoSetProxyBlanket(
       pSvc,                        // Указатель на прокси
       RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
       RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
       NULL,                        // Имя сервера
       RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx 
       RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
       NULL,                        // идентификация клиента
       EOAC_NONE                    // соглашения прокси
    );
        // Используем указательIWbemServices, чтобы сделать запрос к WMI 
        IEnumWbemClassObject* pEnumerator = NULL;
        hres = pSvc->ExecQuery(bstr_t("WQL"), bstr_t( "SELECT SerialNumber FROM Win32_BIOS"),WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL,&pEnumerator);
        // Выборка данных из запроса
        IWbemClassObject *pclsObj;
        ULONG uReturn = 0;
                
        while (pEnumerator)
            {
                HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,&pclsObj, &uReturn);
                    if(0 == uReturn)
                        {
                            break;
                        }
        VARIANT vtProp;
        // Получим значение серийника 
        hr = pclsObj->Get(L"SerialNumber", 0, &vtProp, 0, 0);
        mb_sn=(char *)vtProp.bstrVal;
        rrr=vtProp.bstrVal;
        result=(WideCharToMultiByte(CP_ACP,0,rrr,-1,zzz,128,NULL,NULL));
        mb_sn=&zzz[0];
        VariantClear(&vtProp);
    }
    // Освободим память
    pSvc->Release();
    pLoc->Release();
    pEnumerator->Release();
    pclsObj->Release();
    CoUninitialize();
return mb_sn;
}
//-------------------------------------------------------------------OK
 
 
// -------------------------------------- Определяем номер адаптера ---------------------------------------------
int GetNumAdapt(char DevName[], char StrSource[]){
 
char tmpStr[512]={NULL};
int NumSym=0;int num=0;int pr=0;
int ind[sizeof(NumSym)]={0};
int g=0;int aNum=0;int cxz=0;int cnt=0;int j;int ii;
 
for (num=0; num<strlen(StrSource); num++)
{
    if(StrSource[num]== '{'){ind[NumSym]=num;NumSym++;}
}
 
for (j=0;j<NumSym;j++)
{
    for (ii=ind[j];ii<ind[j]+38;ii++){tmpStr[g]=StrSource[ii];g++;}
    tmpStr[g]=NULL;
 
for (cxz=0;cxz<38;cxz++)
    {
        if (tmpStr[cxz]==DevName[cxz]){cnt++;}
        
    }
        if (cnt=38){aNum=j;}
        g=0;cnt=0;
        memset(tmpStr,NULL, sizeof(tmpStr));
}
return aNum;
}
//----------------------------------------------------------------------------------------------------------------OK
 
//------------------------ Передача пакета --------------------------
int SendPaket() {
 
    HKEY hKey;
    TCHAR    achKey[MAX_KEY_LENGTH];   // buffer for subkey name
    DWORD    cbName;                   // size of name string 
    TCHAR    achClass[MAX_PATH] = TEXT("");  // buffer for class name 
    DWORD    cchClassName = MAX_PATH;  // size of class string 
    DWORD    cSubKeys=0;               // number of subkeys 
    DWORD    cbMaxSubKey;              // longest subkey size 
    DWORD    cchMaxClass;              // longest class string 
    DWORD    cValues;              // number of values for key 
    DWORD    cchMaxValue;          // longest value name 
    DWORD    cbMaxValueData;       // longest value data 
    DWORD    cbSecurityDescriptor; // size of security descriptor 
    FILETIME ftLastWriteTime;      // last write time 
 
    DWORD i, retCode; 
 
    pcap_t *fp;
    char *PrePath="rpcap://\\device\\NPF_";
    char DeviceName[512];
    char tmpDM[512];
    char errbuf[PCAP_ERRBUF_SIZE];
    AdapterNumber=0;
    i=0;
    char qwe[512]={NULL};
    char *MyIP;
 
// ------------------------------------- Выборка зарегистрированных адаптеров -------------------------------------------------------------------
    if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\DNSRegisteredAdapters",0,KEY_ALL_ACCESS,&hKey) == ERROR_SUCCESS )
    {
        retCode = RegQueryInfoKey(
        hKey,                    // key handle 
        achClass,                // buffer for class name 
        &cchClassName,           // size of class string 
        NULL,                    // reserved 
        &cSubKeys,               // number of subkeys 
        &cbMaxSubKey,            // longest subkey size 
        &cchMaxClass,            // longest class string 
        &cValues,                // number of values for this key 
        &cchMaxValue,            // longest value name 
        &cbMaxValueData,         // longest value data 
        &cbSecurityDescriptor,   // security descriptor 
        &ftLastWriteTime);       // last write time 
            if (cSubKeys)
            {
                for (i=0; i<cSubKeys; i++) 
                    { 
                    cbName = MAX_KEY_LENGTH;
                    retCode = RegEnumKeyEx(hKey, i,achKey, &cbName, NULL, NULL, NULL, &ftLastWriteTime); 
                    if (retCode == ERROR_SUCCESS) 
                        {
                            strcpy(tmpDM, PrePath);
                            int itmpstr=0;
                            int t=0;
                            for (t=0; t<sizeof(achKey); t++)
                            {
                                DeviceName[t]=(char)achKey[t];
                                qwe[t]=(char)achKey[t];
                            }
                            strcat(tmpDM,DeviceName);
 
HKEY rKey;
BYTE Reget[512]={NULL};
DWORD RegetPath = sizeof(Reget);
char lstDev[512]={NULL};
//char * ptrStr;
 
 
RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Linkage", 0, KEY_QUERY_VALUE, &rKey);
RegQueryValueEx(rKey, L"Route", NULL, NULL, Reget, &RegetPath);
RegCloseKey(rKey);
 
int u=0;
int s=0;
for (u=0; u<sizeof(Reget); u++)
    {
    if (!Reget[u]==0)
        {
            lstDev[s]=Reget[u];
            s++;
        }
    }
    
    lstDev[s+1]=NULL;
 
    fp= pcap_open(tmpDM,1024,PCAP_OPENFLAG_PROMISCUOUS,1000,NULL,errbuf);
        if (!fp==NULL)
            {
                AdapterNumber=GetNumAdapt(DeviceName, lstDev);
                mcad=GetMacAddr(AdapterNumber);
                CompNameRet=CompName();
                CompIP=ComputerIP();
                MBID=GetMotherBoardID();
                MyIP=ComputerIP();
                for (i=0;i<12;i++)
                {
                HostIP[i]=(char)MyIP[i];
                }
                counter=0;
                for (counter=0;counter<strlen(CompNameRet);counter++)
                {
                    SystemName[counter]=CompNameRet[counter];
                }
                SystemName[counter+1]=NULL;
 
    // Формируем пакет 
                // Вставка в пакет destination MAC он постоянный
                packet[0]=0x01;
                packet[1]=0x80;
                packet[2]=0xc2;
                packet[3]=0x00;
                packet[4]=0x00;
                packet[5]=0x0E;
                numpack=1;
                indexpack=5;
 
                // Вставка в пакет source MAC
                int i;
                for (i=0;i<6;i++)
                    {
                        indexpack+=1;packet[indexpack]=mcad[i];
                    }
                    numpack=2;
 
                                // Вставка идентификатора LLDP Ethertype
                                indexpack+=1;packet[indexpack]=0x88;
                                indexpack+=1;packet[indexpack]=0xcc;
                                
                                // =============== Обязательные TLV ====================
                                // Вставка в пакет Chassis ID
                                indexpack+=1;packet[indexpack]=0x02; // Тип
                                indexpack+=1;packet[indexpack]=0x07; // Длина
                                indexpack+=1;packet[indexpack]=0x04; // subtype - MAC
                                indexpack+=1;packet[indexpack]=mcad[0];
                                indexpack+=1;packet[indexpack]=mcad[1];
                                indexpack+=1;packet[indexpack]=mcad[2];
                                indexpack+=1;packet[indexpack]=mcad[3];
                                indexpack+=1;packet[indexpack]=mcad[4];
                                indexpack+=1;packet[indexpack]=mcad[5];
                                numpack=3;
                                
                                // Port ID
                                indexpack+=1;packet[indexpack]=0x04;
                                indexpack+=1;packet[indexpack]=0x07; // Тип и длина
                                indexpack+=1;packet[indexpack]=0x03; // sybtype Port ID
                                indexpack+=1;packet[indexpack]=mcad[0];
                                indexpack+=1;packet[indexpack]=mcad[1];
                                indexpack+=1;packet[indexpack]=mcad[2];
                                indexpack+=1;packet[indexpack]=mcad[3];
                                indexpack+=1;packet[indexpack]=mcad[4];
                                indexpack+=1;packet[indexpack]=mcad[5];
                                numpack=4;
                                
                                // TTL
                                switch (LogOff)
                                {
                                case 0:
                                    indexpack+=1;packet[indexpack]=0x06;// Тип и длина
                                    indexpack+=1;packet[indexpack]=0x02;
                                    indexpack+=1;packet[indexpack]=0xff;// Значение
                                    indexpack+=1;packet[indexpack]=0xff;
                                break;
 
                                case 1:
                                    indexpack+=1;packet[indexpack]=0x06;// Тип и длина
                                    indexpack+=1;packet[indexpack]=0x02;
                                    indexpack+=1;packet[indexpack]=0x00;// Значение
                                    indexpack+=1;packet[indexpack]=0x00;
                                break;
                                }
                                numpack=5;
                                // =====================================================
 
                                // Вставка в пакет имени компьютера
                                indexpack+=1;packet[indexpack]=0x0a; // Тип
                                indexpack+=1;packet[indexpack]=strlen(SystemName);    // Длина
                                int ind;
                                for (ind=0;ind<strlen(SystemName);ind++)
                                    {   
                                    indexpack+=1;
                                    packet[indexpack]=(WCHAR )romaname[ind];
                                    }
                                numpack=6; 
 
                                // Вставка серийника материнки
                                indexpack++;packet[indexpack]=0x0c;
                                indexpack++;packet[indexpack]=strlen(MBID);
                                counter=0;
                                for (counter=0;counter<strlen(MBID);counter++)
                                {
                                    indexpack++;
                                    packet[indexpack]=MBID[counter];
                                }
                                numpack=7;
 
                                // Вставка в пакет IP компьютера
                                indexpack++;packet[indexpack]=0x0d;
                                indexpack++;packet[indexpack]=strlen(HostIP);
                                counter=0;
                                for (counter=0;counter<strlen(HostIP);counter++)
                                {
                                    indexpack++;
                                    packet[indexpack]=HostIP[counter];
                                }
                                numpack=8;
 
 
 
                                //****************************
                                //  ***  The End of Frame  ***
                                //****************************
                                indexpack+=1;packet[indexpack]=0x00;
                                indexpack+=1;packet[indexpack]=0x00;
                                //**************************** 
 
    // Отправка пакета 
                                
                            if (pcap_sendpacket(fp, packet, 1024 ) != 0)
                                {
                                    fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(fp));
                                    return 0;
                                }
                            }
                        }
                }
        }
}
return 0;
}
//-------------------------------------------------------------------OK
 
 
//---------------- Отлов завершения работы/сессии ------------------
BOOL __stdcall Ctrl_Handler(DWORD Msg)
{
switch (Msg)
{
case CTRL_LOGOFF_EVENT: // Использую логофф, ибо все равно срабатывает при выключении компа, а проверять удобнее
    LogOff=1;
    SendPaket();
    exit(0);  
break;
}
return true;
}
//------------------------------------------------------------------OK
 
 
//---------------- ВХОД -------------------------------
int main(int argc, CHAR* argv[]){
 
    SetConsoleCtrlHandler(&Ctrl_Handler, true ); // Инициализация ловушки завершения работы/сессии
 
    int time=0;
 
do
    {
        SendPaket();
        Sleep(300000);
    } while ( time=1 );
 
 
    
return 0;
}
//-----------------------------------------------------OK