搜索工具-客户端篇

最近在整视频平台，整的头大，就来更新更新博客吧！劳逸结合，??

要知道，市面上的摄像机啊，录像机啊，都有自己的搜索工具，主要防止ip人为修改之后被忘记的情况，这时候搜索工具一搜，ip地址就能获取到了！类似的原理网上也很多。

贴出部分代码：

//获取所有网卡设备信息,但这个函数感觉获取的信息不全，没有GetAdaptersInfo好
pcap_if_t* GetAllNetDevice()
{
	devCount = 0;
	if(pcap_findalldevs(&alldev, errbuf) ==-1)
	{
		return NULL;
	}
	for(dev=alldev;dev;dev=dev->next)
	{
		devCount++;	
	}
	return alldev;
}

int startCap(int if_index)
{
	int i;
	int ret;
	u_int netmask;
	struct bpf_program fcode;
    u_char frame[1024];
	char mac[ETHER_LEN+1];
	char error_content[PCAP_ERRBUF_SIZE];
	struct bpf_program bpf_filter;
	char bpf_filter_string[] = "ether proto 0x8043";
    struct pcap_pkthdr *pkthdr;
	const unsigned char *packet = NULL;
	ethhdr e_header;
	SCANIP_COMMAND_HEADER cmd_header;


	//获取本机mac地址
	CString sMACAddress;
    if(FALSE == GetMACAddress(sMACAddress))
	{
		return -1;
	}

    //填充发送的帧    
    //eth_header
	memcpy(e_header.dest, MAC_BCAST_ADDR, ETH_ALEN);
	memcpy(e_header.src, sMACAddress, ETH_ALEN);
	e_header.type = htons(0x8043);//乱定义的 
    memcpy(frame, &e_header, ETHER_LEN);

	//cmd
    cmd_header.length = htonl(sizeof(SCANIP_COMMAND_HEADER));
    cmd_header.cmd = htonl(SCANIP_CMD);
    memcpy(&frame[ETHER_LEN], &cmd_header, CMDHEADER_LEN);


	//获得选中的网卡接口
    dev=alldev;
	for(count=0;count<if_index-1;count++)
	{
		dev=dev->next;
	}

	if ((adhandle= pcap_open_live(dev->name,	// 设备名
							 65536,											//捕获数据包长度																					
							 1,													// 混杂模式 (非0意味着是混杂模式)
							 1000,												// 读超时设置
							 errbuf											// 错误信息
							 )) == NULL)
	{
		pcap_freealldevs(alldev);
		return -1;
	}

	pcap_setnonblock(adhandle, 1, errbuf);

	pcap_compile(adhandle,&bpf_filter,bpf_filter_string,0,0);
	pcap_setfilter(adhandle, &bpf_filter);
	if (pcap_datalink(adhandle) != DLT_EN10MB)//表示为以太网
    {
        printf("pcap_datalink error...\n");
        return -1;
    }

	//send packet
    ret = pcap_sendpacket(adhandle, (u_char *)&frame, ETHER_LEN+CMDHEADER_LEN);//ChengliWang
    if(ret != 0)
    {
        perror("pcap_sendpacket");
        return -1;
    }

	//receive packet    
    ethhdr *pEth_header = NULL;
    SCANIP_COMMAND_HEADER *pCmd_header = NULL;
    SCANIP_NET_CFG *pNet_cfg = NULL;    
    struct in_addr ipAddr; 
	struct in6_addr ipv6;
	char ip[256];

    count = 0;
    for(i=0; i<255; i++)
	{
		ret = pcap_next_ex(adhandle, &pkthdr, &packet);
        if(0 == ret)
        {
            printf("time out...\n");
            //Sleep(10);
            continue;
        }

		pEth_header = (ethhdr *)packet;        
        pCmd_header = (SCANIP_COMMAND_HEADER *)(packet+ETHER_LEN);
        if((pEth_header->type == ntohs(0x8043)) && (pCmd_header->cmd == ntohl(SCANIP_RETCMD)))
        {
			pNet_cfg = (SCANIP_NET_CFG *)(packet + ETHER_LEN + CMDHEADER_LEN);
            ipAddr.s_addr = ntohl(pNet_cfg->ip);
            printf("ip:%s\n",(char *)inet_ntoa(ipAddr));
			ipv6=pNet_cfg->ipv6;
			if(NULL == inet_ntop(AF_INET6, ipv6.s6_addr, ip, INET6_ADDRSTRLEN))
			{
				perror("inet_ntop");
			}
			printf("ipv6 = %s\n",ip);

            //save netcfg to vector
            memcpy(&net_cfg_vector[count++], pNet_cfg, NETCFG_LEN);
		}
	}
	printf("");

}


int GetMACAddress(CString &sMACAddress)
{
	PIP_ADAPTER_INFO pAdapterInfo;
	DWORD AdapterInfoSize;   
	TCHAR szMac[32]  =  {0};
	DWORD Err;
	AdapterInfoSize  =  0;

    Err  =  GetAdaptersInfo(NULL,  &AdapterInfoSize);
    if((Err  !=  0)  &&  (Err  !=  ERROR_BUFFER_OVERFLOW))
    {   
 	    TRACE("获得网卡信息失败！");
		return  FALSE;
    }

    //  分配网卡信息内存
    pAdapterInfo  =  (PIP_ADAPTER_INFO)  GlobalAlloc(GPTR,  AdapterInfoSize);

    if(pAdapterInfo  ==  NULL)
	{ 
         TRACE("分配网卡信息内存失败"); 
         return  FALSE;
    } 
    if(GetAdaptersInfo(pAdapterInfo,  &AdapterInfoSize)  !=  0)
	{ 
	     TRACE(_T("获得网卡信息失败！\n"));
		 GlobalFree(pAdapterInfo);
		 return  FALSE; 
    }

    sMACAddress.Format(_T("%02X%02X%02X%02X%02X%02X"),
		 pAdapterInfo->Address[0],
		 pAdapterInfo->Address[1],
         pAdapterInfo->Address[2],
		 pAdapterInfo->Address[3],
		 pAdapterInfo->Address[4],
		 pAdapterInfo->Address[5]);
    GlobalFree(pAdapterInfo);
      return  TRUE;
}

/*分析链路层*/
int analyze_frame(const u_char * pkt,struct datapkt * data,struct pktcount *npacket)
{
		int i;
		struct ethhdr *ethh = (struct ethhdr*)pkt;
		data->ethh = (struct ethhdr*)malloc(sizeof(struct ethhdr));
		if(NULL == data->ethh)
			return -1;
	
		for(i=0;i<6;i++)
		{
			data->ethh->dest[i] = ethh->dest[i];
			data->ethh->src[i] = ethh->src[i];
		}
	
		npacket->n_sum++;

		/*由于网络字节顺序原因，需要对*/
		data->ethh->type = ntohs(ethh->type);

		//处理ARP还是IP包？
		switch(data->ethh->type)
		{
			case 0x0806:
				return analyze_arp((u_char*)pkt+14,data,npacket);      //mac 头大小为14
				break;
			case 0x0800:				
				return analyze_ip((u_char*)pkt+14,data,npacket);
				break;
			case 0x86dd:		
				return analyze_ip6((u_char*)pkt+14,data,npacket);			
				return -1;
				break;
			default:
				npacket->n_other++;
				return -1;
				break;
		}
		return 1;
}

/*分析网络层：ARP*/
int analyze_arp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct arphdr *arph = (struct arphdr*)pkt;
	data->arph = (struct arphdr*)malloc(sizeof(struct arphdr));
	
	if(NULL == data->arph )
		return -1;
	
	//复制IP及MAC
	for(i=0;i<6;i++)
	{
		if(i<4)
		{
			data->arph->ar_destip[i] = arph->ar_destip[i];
			data->arph->ar_srcip[i] = arph->ar_srcip[i];
		}
		data->arph->ar_destmac[i] = arph->ar_destmac[i];
		data->arph->ar_srcmac[i]= arph->ar_srcmac[i];
	}

	data->arph->ar_hln = arph->ar_hln;
	data->arph->ar_hrd = ntohs(arph->ar_hrd);
	data->arph->ar_op = ntohs(arph->ar_op);
	data->arph->ar_pln = arph->ar_pln;
	data->arph->ar_pro = ntohs(arph->ar_pro);

	strcpy(data->pktType,"ARP");
	npacket->n_arp++;
	return 1;
}

/*分析网络层：IP*/
int analyze_ip(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct iphdr *iph = (struct iphdr*)pkt;
	data->iph = (struct iphdr*)malloc(sizeof(struct iphdr));
	
	if(NULL == data->iph)
		return -1;
	data->iph->check = iph->check;
	npacket->n_ip++;
	
	/*for(i = 0;i<4;i++)
	{
		data->iph->daddr[i] = iph->daddr[i];
		data->iph->saddr[i] = iph->saddr[i];
	}*/
	data->iph->saddr = iph->saddr;
	data->iph->daddr = iph->daddr;

	data->iph->frag_off = iph->frag_off;
	data->iph->id = iph->id;
	data->iph->proto = iph->proto;
	data->iph->tlen = ntohs(iph->tlen);
	data->iph->tos = iph->tos;
	data->iph->ttl = iph->ttl;
	data->iph->ihl = iph->ihl;
	data->iph->version = iph->version;
	//data->iph->ver_ihl= iph->ver_ihl;
	data->iph->op_pad = iph->op_pad;

	int iplen = iph->ihl*4;							//ip头长度
	switch(iph->proto)
	{
		case PROTO_ICMP:
			return analyze_icmp((u_char*)iph+iplen,data,npacket);
			break;
		case PROTO_TCP:
			return analyze_tcp((u_char*)iph+iplen,data,npacket);
			break;
		case PROTO_UDP:
			return analyze_udp((u_char*)iph+iplen,data,npacket);
			break;
		default :
			return-1;
			break;
	}
	return 1;
}

/*分析网络层：IPV6*/
int analyze_ip6(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct iphdr6 *iph6 = (struct iphdr6*)pkt;
	data->iph6 = (struct iphdr6*)malloc(sizeof(struct iphdr6));
	
	if(NULL == data->iph6)
		return -1;

	npacket->n_ip6++;
	
	data->iph6->version = iph6->version;
	data->iph6->flowtype = iph6->flowtype;
	data->iph6->flowid = iph6->flowid;
	data->iph6->plen = ntohs(iph6->plen);
	data->iph6->nh = iph6->nh;
	data->iph6->hlim =iph6->hlim;

	for(i=0;i<16;i++)
	{
		data->iph6->saddr[i] = iph6->saddr[i];
		data->iph6->daddr[i] = iph6->daddr[i];
	}
	
	switch(iph6->nh)
	{
		case 0x3a:					
			return analyze_icmp6((u_char*)iph6+40,data,npacket);
			break;
		case 0x06:
			return analyze_tcp((u_char*)iph6+40,data,npacket);
			break;
		case 0x11:
			return analyze_udp((u_char*)iph6+40,data,npacket);
			break;
		default :
			return-1;
			break;
	}
	//npacket->n_ip6++;
	//strcpy(data->pktType,"IPV6");
	return 1;
}
	
/*分析传输层：ICMP*/
int analyze_icmp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct icmphdr* icmph = (struct icmphdr*)pkt;
	data->icmph = (struct icmphdr*)malloc(sizeof(struct icmphdr));
	
	if(NULL == data->icmph)
		return -1;

	data->icmph->chksum = icmph->chksum;
	data->icmph->code = icmph->code;
	data->icmph->seq =icmph->seq;
	data->icmph->type = icmph->type;
	strcpy(data->pktType,"ICMP");
	npacket->n_icmp++;
	return 1;
}

/*分析传输层：ICMPv6*/
int analyze_icmp6(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct icmphdr6* icmph6 = (struct icmphdr6*)pkt;
	data->icmph6 = (struct icmphdr6*)malloc(sizeof(struct icmphdr6));
	
	if(NULL == data->icmph6)
		return -1;

	data->icmph6->chksum = icmph6->chksum;
	data->icmph6->code = icmph6->code;
	data->icmph6->seq =icmph6->seq;
	data->icmph6->type = icmph6->type;
	data->icmph6->op_len = icmph6->op_len;
	data->icmph6->op_type = icmph6->op_type;
	for(i=0;i<6;i++)
	{
		data->icmph6->op_ethaddr[i] = icmph6->op_ethaddr[i];
	}
	strcpy(data->pktType,"ICMPv6");
	npacket->n_icmp6++;
	return 1;
}

/*分析传输层：TCP*/
int analyze_tcp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct tcphdr *tcph = (struct tcphdr*)pkt;
	data->tcph = (struct tcphdr*)malloc(sizeof(struct tcphdr));
	if(NULL == data->tcph)
		return -1;
	
	data->tcph->ack_seq = tcph->ack_seq;
	data->tcph->check = tcph->check;
	
	data->tcph->doff = tcph->doff;
	data->tcph->res1 = tcph->res1;
	data->tcph->cwr = tcph->cwr;
	data->tcph->ece = tcph->ece;
	data->tcph->urg = tcph->urg;
	data->tcph->ack = tcph->ack;
	data->tcph->psh = tcph->psh;
	data->tcph->rst = tcph->rst;
	data->tcph->syn = tcph->syn;
	data->tcph->fin = tcph->fin;
	//data->tcph->doff_flag = tcph->doff_flag;

	data->tcph->dport = ntohs(tcph->dport);
	data->tcph->seq = tcph->seq;
	data->tcph->sport = ntohs(tcph->sport);
	data->tcph->urg_ptr = tcph->urg_ptr;
	data->tcph->window= tcph->window;
	data->tcph->opt = tcph->opt;
	
	/*不要忘记http分支*/
	if(ntohs(tcph->dport) == 80 || ntohs(tcph->sport)==80)
	{
		npacket->n_http++;
		strcpy(data->pktType,"HTTP");
	}
	else{
		npacket->n_tcp++;
		strcpy(data->pktType,"TCP");	
	}
	return 1;
}

/*分析传输层：UDP*/
int analyze_udp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct udphdr* udph = (struct udphdr*)pkt;
	data->udph = (struct udphdr*)malloc(sizeof(struct udphdr));
	if(NULL == data->udph )
		return -1;

	data->udph->check = udph->check;
	data->udph->dport = ntohs(udph->dport);
	data->udph->len = ntohs(udph->len);
	data->udph->sport = ntohs(udph->sport);

	strcpy(data->pktType,"UDP");
	npacket->n_udp++;
	return 1;
}

//将数据包以十六进制方式打印出来
void print_packet_hex(const u_char* pkt,int size_pkt,CString *buf)
{
	int i=0,j = 0,rowcount;
	 u_char ch;

	 char tempbuf[256];
	 memset(tempbuf,0,256);

	for(i = 0;i<size_pkt;i+=16)
	{
		buf->AppendFormat(_T("%04x:  "),(u_int)i);
		rowcount = (size_pkt-i) > 16 ? 16 : (size_pkt-i);			

		for (j = 0; j < rowcount; j++)		
			buf->AppendFormat(_T("%02x  "),(u_int)pkt[i+j]);	

		//不足16，用空格补足
		if(rowcount <16)
			for(j=rowcount;j<16;j++)
					buf->AppendFormat(_T("    "));	


		for (j = 0; j < rowcount; j++) 
		{
             ch = pkt[i+j];
             ch = isprint(ch) ? ch : '.';
			 buf->AppendFormat(_T("%c"),ch);
		}

		buf->Append(_T("\r\n"));

		if(rowcount<16)
			return;
	}
}