arp.txt

Arp的一些编程

#include "StdAfx.h"
#include "SendARP.h"
#include "resource.h"

CSendARP::CSendARP(const HWND hDlg) : m_hDlg(hDlg)
{
    m_fp=NULL;
    m_fp2=NULL;
}

CSendARP::~CSendARP(void)
{

}

bool CSendARP::OpenAdapter()
{
    bpf_u_int32 netmask = 0;              
    char pcap_filter[100];              //filter space
    struct bpf_program pcap_fp;         //hold the compiled filter.
    char errbuf[PCAP_ERRBUF_SIZE] = "";
    //打开网卡
    char* str=new char[sizeof(m_pData->nic)+sizeof("\\Device\\NPF_")];
    strcpy(str,"\\Device\\NPF_");
    strcat(str,m_pData->nic);
    
    if(!(m_fp = pcap_open_live(str,// name of the device
                                256,        // portion of the packet to capture, max 65536
                                0,            // promiscuous mode closed
                                10,            // read timeout
                                errbuf)))    // error buffer
    {
        ::SendMessage(m_hDlg, IDC_LIST_MSG, -1, (long)errbuf);
        delete[] str;
        return false;
    }
    //设置过滤器
    delete[] str;
    sprintf_s(pcap_filter, "ether dst %x:%x:%x:%x:%x:%x and ether proto 0x0806",
                      m_pData->mac[0],m_pData->mac[1],m_pData->mac[2],
                      m_pData->mac[3],m_pData->mac[4],m_pData->mac[5]);

    if (pcap_compile(m_fp, &pcap_fp, pcap_filter, 0, netmask) == -1)
        return false;

    if (pcap_setfilter(m_fp, &pcap_fp) == -1)
        return false;
    
    return true;
}

bool CSendARP::SendARP_Multiple(ARPPACKET & packet,int ip3)
{
    packet.Targ_Prot_Addr[3]=ip3;
    if(!pcap_sendpacket(m_fp, (UCHAR*)&packet, 60))
    {
        return false;
    }
    return true;
}

UINT WorkProc_Send(LPVOID lpParam)
{
    CSendARP* pTalk=(CSendARP*)lpParam;
    ARPPACKET packet;

    memset(&packet.DestMAC,0xff,6);
    memcpy(&packet.SourMAC,pTalk->m_pData->mac,6);
    packet.EthType[0]=0x08;
    packet.EthType[1]=0x06;
    packet.HW_Type=htons(1);
    packet.Prot_Type=htons(0x0800);
    packet.HW_Addr_Len=0x06;
    packet.Prot_Addr_Len=0x04;
    packet.Opcode=htons(1);
    memcpy(&packet.Send_HW_Addr,pTalk->m_pData->mac,6);
    memcpy(&packet.Send_Prot_Addr,pTalk->m_pData->ip,4);
    memset(&packet.Targ_HW_Addr,0,6);
    memcpy(&packet.Targ_Prot_Addr,pTalk->m_pData->ip,4);
    
    memset(&packet.padding,0,18);

    for(pTalk->__i=1;pTalk->__i<255;pTalk->__i++)
    {
        if(pTalk->__i != pTalk->m_pData->ip[3] && 
            ((pTalk->m_pData->ip[3] & pTalk->m_pData->Mask[3]) 
            == (pTalk->__i & pTalk->m_pData->Mask[3])))

            pTalk->SendARP_Multiple(packet,pTalk->__i);
        Sleep(20);
    }
    return 0;
}

UINT WorkProc_Recv(LPVOID lpParam)
{
    
    CSendARP* pTalk=(CSendARP*)lpParam;
    pTalk->nCount=1;
    pTalk->Continue=1;
    struct pcap_pkthdr *header;
    const u_char *pkt_data;
    int res;
    DWORD dwTick, dwOldTick;
    dwTick = dwOldTick = ::GetTickCount();
    while(((res = pcap_next_ex( pTalk->m_fp, &header, &pkt_data)) >= 0) && pTalk->Continue)
    {
        if(res==0)
        {
            dwTick = ::GetTickCount();
            if( pTalk->__i==255 && dwTick - dwOldTick > 3000)
                break;   //超时了，说明没有回应了
        }

        
        if(res>0)
        {
            dwTick = dwOldTick = ::GetTickCount();
            PARPPACKET pbuf = (PARPPACKET)pkt_data;
            CString str;
            pTalk->nCount++;
            ::PostMessage(pTalk->m_hDlg,WM_MY_MSG1,2,(LPARAM)pbuf);
        }
    }
    ::SendMessage(pTalk->m_hDlg,WM_MY_MSG1,3,NULL);
    return 0;
}

void CSendARP::Init(const USERDATA* pUserData)
{
    m_pData=pUserData;
}

BOOL CSendARP::Start()    
{
    if(OpenAdapter())
    {

        Thread_Recv=AfxBeginThread(WorkProc_Recv,this);
        Thread_Send=AfxBeginThread(WorkProc_Send,this);
        return TRUE;
    }
    return FALSE;
}
    
void CSendARP::Close()
{
    Continue=0;

    
    if(m_fp != NULL) 
        pcap_close(m_fp); //关闭网卡
    CString str;
    str.Format("网段内当前共有活动主机%d台！",nCount);
    ::SendDlgItemMessage(m_hDlg,IDC_MSG_HOST,WM_SETTEXT,0,(LPARAM)(LPCTSTR)str);
}




#include <afxwin.h>
#include "global.h"
#include"include/pcap.h"

#pragma pack(push)
#pragma pack(1)

typedef struct tagARPFrame                      
{
    u_char8    DestMAC[6];
    u_char8    SourMAC[6];
    u_char8 EthType[2];
    unsigned short         HW_Type;           /* hardware address */
    unsigned short         Prot_Type;             /* protocol address */
    unsigned char      HW_Addr_Len;       /* length of hardware address */
    unsigned char      Prot_Addr_Len;         /* length of protocol address */
    unsigned short         Opcode;                /* ARP/RARP */
 
    unsigned char      Send_HW_Addr[6];     /* sender hardware address */
    unsigned char      Send_Prot_Addr[4];      /* sender protocol address */
    unsigned char      Targ_HW_Addr[6];     /* target hardware address */
    unsigned char      Targ_Prot_Addr[4];      /* target protocol address */
    unsigned char      padding[18];
} ARPPACKET, *PARPPACKET;
#pragma pack(pop)

class CSendARP
{
public:
    CSendARP(const HWND hDlg);
    ~CSendARP(void);
    BOOL Start();
    void Init(const USERDATA* pUserData);
    void Close();


private:
    const USERDATA* m_pData;
    pcap_t* m_fp;
    pcap_t* m_fp2;
    
    bool SendARP_Multiple(ARPPACKET & packet,int ip3);
    bool OpenAdapter();
    friend UINT WorkProc_Send(LPVOID lpParam);
    friend UINT WorkProc_Recv(LPVOID lpParam);
    
protected:
    HWND m_hDlg;
    CWinThread* Thread_Send;
    CWinThread* Thread_Recv;
    int Continue;
    int nCount;
    UCHAR mac[6];
    int d_ip3;
    int __i;
    
};

//////////////////////////////////////////////

#include "StdAfx.h"
#include "SendARP.h"
#include "resource.h"

CSendARP::CSendARP(const HWND hDlg) : m_hDlg(hDlg)
{
    m_fp=NULL;
    m_fp2=NULL;
}

CSendARP::~CSendARP(void)
{

}

bool CSendARP::OpenAdapter()
{
    bpf_u_int32 netmask = 0;              
    char pcap_filter[100];              //filter space
    struct bpf_program pcap_fp;         //hold the compiled filter.
    char errbuf[PCAP_ERRBUF_SIZE] = "";
    //打开网卡
    char* str=new char[sizeof(m_pData->nic)+sizeof("\\Device\\NPF_")];
    strcpy(str,"\\Device\\NPF_");
    strcat(str,m_pData->nic);
    
    if(!(m_fp = pcap_open_live(str,// name of the device
                                256,        // portion of the packet to capture, max 65536
                                0,            // promiscuous mode closed
                                10,            // read timeout
                                errbuf)))    // error buffer
    {
        ::SendMessage(m_hDlg, IDC_LIST_MSG, -1, (long)errbuf);
        delete[] str;
        return false;
    }
    //设置过滤器
    delete[] str;
    sprintf_s(pcap_filter, "ether dst %x:%x:%x:%x:%x:%x and ether proto 0x0806",
                      m_pData->mac[0],m_pData->mac[1],m_pData->mac[2],
                      m_pData->mac[3],m_pData->mac[4],m_pData->mac[5]);

    if (pcap_compile(m_fp, &pcap_fp, pcap_filter, 0, netmask) == -1)
        return false;

    if (pcap_setfilter(m_fp, &pcap_fp) == -1)
        return false;
    
    return true;
}