基于libpcap的嵌入式linux 抓包工具，运用telnet 解决嵌入式设备抓包实时显示问题方便测试

主要是为了测试时能实时捕捉和显示嵌入式设备上的数据包：
这样操作设备同时可以实时查看数据包。当然我做有配套日客户端接收程序；
编写环境:ubuntu 14      arm-linux-gcc4.4.3       libpcap库   libpcap-1.7.4.tar.gz

实现原理为登入设备telnet 然后运行抓包代码如下图是不用客户端直接登入设备：(抓包器会自动屏蔽23号telnet端口数据包防止抓包数据无限增长)

下面贴出了程序源码，欢迎大家讨论和一起学习：
XX1.c

/*########################################################
###### 日期：2016-5-1                                #######
###### 作者：zhj                                          #######
###### 作用：通过telnet进行远程网络数据包捕捉      #######
###### 版本：v1.4                                                #######
###### 特征：支持端口,IP,MAC,tcp,tcp长度,udp过滤           #######
########################################################*/

//过滤规则指令如下：
//tcp.len.123  tcp.len=123  
//#    tcp.tcp   tcp 过滤
//#   udp.udp  udp过滤
//# tcp.len.123   表示tcp.数据区长度大于123的包
//# tcp.len=123    表示tcp.数据区长度等于123的包                        
//#    adr.port=123    表示过滤端口为123的数据包
//#    dst.port=123   表示过滤目标端口为123的数据包
//#     src.port=123  表示过滤源端口为123的数据包
//#    adr.ip=192.168.1.1  表示过IP口为192.168.1.1的数据包
//#    dsr.ip=192.168.1.1   表示过滤目标IP为192.168.1.1的数据包 
//#    src.ip=192.168.1.1   表示过滤源IP为192.168.1.1的数据包
//#    adr.mac=112233445566   表示过滤MAC地址为112233445566的数据包
//#     dst.mac=112233445566   表示过滤目标MAC地址为112233445566的数据包 
//#     src.mac=112233445566   表示过滤源MAC地址为112233445566的数据包

#include <time.h>
#include <pcap.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>

#include<string.h>
int dst_port[2]={0,0};
int src_port[2]={0,0};
int adr_port[2]={0,0};
short dst_mac[6]={0,0,0,0,0,0};
short src_mac[6]={0,0,0,0,0,0};
short adr_mac[6]={0,0,0,0,0,0};
int dst_ip[4]={0,0,0,0};
int src_ip[4]={0,0,0,0};
int adr_ip[4]={0,0,0,0};
int tcp_len[6]={0,0,0,0,0,0};

struct tm *p;
int dst_portb[2]={0,0};
int src_portb[2]={0,0};
short dst_macb[6]={0,0,0,0,0,0};
short src_macb[6]={0,0,0,0,0,0};
int dst_ipb[4]={0,0,0,0};
int src_ipb[4]={0,0,0,0};
int io;
time_t timep;

unsigned char jjbuf[65535],jjbufer[65535];
int jjbuflen,jjbuflock=0,forx=0;

char bb=0,tcp=0,tcplenx=0,tcplen=0,udp=0,srcport=0,dstport=0,adrport=0,srcmac=0,dstmac=0,adrmac=0,srcip=0,dstip=0,adrip=0,dec_gl=1;

/*########################################################
#################  捕捉数据包回调函数 ####################
########################################################*/
void my_callback(u_char *useless,const struct pcap_pkthdr* pkthdr,const u_char* packet)//抓包回调函数——处理抓包数据
{
 if(((packet[34]==0x00)&(packet[35]==0x17))|((packet[36]==0x00)&(packet[37]==0x17)))//过滤23号端口网络包(即telnet协议)防止网络数据泛滥
 {
  
 }
 else
 {
  int Iplen=0,Tcplen=0,packetlen=0;
  Iplen=((packet[14])&0x0f)<<2;//计算IP头度
  if(0x06==packet[23])//TCP
  {
   Tcplen=((packet[26+Iplen]&0xf0)>>2);//计算TCP头长度
   packetlen=(((int)packet[16])<<8)+packet[17];//计算IP包长度
  }
  
 /*#########################################################################
###################       tcp长度过滤是否开启      ########################
#########################################################################*/
  for(forx=0;forx<1;forx++)
  {
   if(tcplenx==1)//判断是否开启___tcp___长度过滤
   {
    if(tcplen==1){
     if(0x06==packet[23]){
      if((packetlen-Iplen-Tcplen)==tcp_len[0]){}//计算数据区长度
      else{break;}}
     else{break;}}
    else{
     if(0x06==packet[23]){
      if((packetlen-Iplen-Tcplen)>tcp_len[0]){}//计算数据区长度
      else{break;}}
     else{break;}}
   }

 /*#########################################################################
 ###################      判断协议过滤是否开启      ########################
 #########################################################################*/
   if(tcp==1)//判断是否开启___tcp___过滤
   {
    if(0x06==packet[23]){}
    else{break;}
   }
   
   if(udp==1)//判断是否开启___udp___过滤
   {
    if(0x11==packet[23]){}
    else{break;}
   }

 /*#########################################################################
 ###################      判断端口过滤是否开启      ########################
 #########################################################################*/
   if(srcport==1)//判断是否开启___源端口___过滤
   {
    if((src_port[0]==packet[Iplen+14])&(src_port[1]==packet[Iplen+15])){}
    else{break;}
   }
   
   if(dstport==1)//判断是否开启___目标端口___过滤
   {
    if((dst_port[0]==packet[Iplen+16])&(dst_port[1]==packet[Iplen+17])){}
    else{break;}
   }
   
   if(adrport==1)//判断是否开启___全部端口___过滤
   {
    if(((adr_port[0]==packet[Iplen+16])&(adr_port[1]==packet[Iplen+17]))|((adr_port[0]==packet[Iplen+14])&(adr_port[1]==packet[Iplen+15]))){}
    else{break;}
   }
   
 /*#########################################################################
 ####################      判断MAC过滤是否开启      ########################
 #########################################################################*/
   if(srcmac==1)//判断是否开启___源MAC___过滤
   {
    if((src_mac[0]==packet[6])&(src_mac[1]==packet[7])&(src_mac[2]==packet[8])&(src_mac[3]==packet[9])&(src_mac[4]==packet[10])&(src_mac[5]==packet[11])){}
    else{break;}
   }
   
   if(dstmac==1)//判断是否开启___目标MAC___过滤
   {
    if((dst_mac[0]==packet[0])&(dst_mac[1]==packet[1])&(dst_mac[2]==packet[2])&(dst_mac[3]==packet[3])&(dst_mac[4]==packet[4])&(dst_mac[5]==packet[5])){}
    else{break;}
   }
   
   if(adrmac==1)//判断是否开启___全部MAC___过滤
   {
    if(((adr_mac[0]==packet[0])&(adr_mac[1]==packet[1])&(adr_mac[2]==packet[2])&(adr_mac[3]==packet[3])&(adr_mac[4]==packet[4])&(adr_mac[5]==packet[5]))|
    ((adr_mac[0]==packet[6])&(adr_mac[1]==packet[7])&(adr_mac[2]==packet[8])&(adr_mac[3]==packet[9])&(adr_mac[4]==packet[10])&(adr_mac[5]==packet[11]))){}
    else{break;}
   }
   
 /*#########################################################################
 #####################      判断IP过滤是否开启      ########################
 #########################################################################*/
   if(srcip==1)//判断是否开启___源IP___过滤
   {
    if((src_ip[0]==packet[26])&(src_ip[1]==packet[27])&(src_ip[2]==packet[28])&(src_ip[3]==packet[29])){}
    else{break;}
   }
   
   if(dstip==1)//判断是否开启___目标IP___过滤
   {
    if((dst_ip[0]==packet[30])&(dst_ip[1]==packet[31])&(dst_ip[2]==packet[32])&(dst_ip[3]==packet[33])){}
    else{break;}
   }
   
   if(adrip==1)//判断是否开启___全部IP___过滤
   {
    if(((adr_ip[0]==packet[30])&(adr_ip[1]==packet[31])&(adr_ip[2]==packet[32])&(adr_ip[3]==packet[33]))|
       ((adr_ip[0]==packet[26])&(adr_ip[1]==packet[27])&(adr_ip[2]==packet[28])&(adr_ip[3]==packet[29]))){}
    else{break;}
   }

  /*#########################################################################
  #######################      输出捕捉的数据包     #########################
  #########################################################################*/
   if(jjbuflock==0)
   {
    time(&timep);
    jjbuflock=1;
    jjbuflen=pkthdr->len;
    memcpy(jjbuf,packet,jjbuflen);
    p=localtime(&timep); /*取得当地时间*/
    printf ("%d-%d-%d-", (1900+p->tm_year),( 1+p->tm_mon), p->tm_mday);
    //时间矫正8小时
    int timehour=p->tm_hour+8;
    if(timehour>24){timehour-=24;}
    printf("%d:%d:%d----", timehour, p->tm_min, p->tm_sec);
    for(io=0;io<jjbuflen;io++)//输出捕捉的数据包
    {
     if (jjbuf[io]<16){printf("0");}
     printf("%x",jjbuf[io]);
    }
    printf("_");
    if (bb==1){printf("\n");}
    fflush(stdout);
    jjbuflock=0;
   }
  }
 }
}

 

/*########################################################
#################  字符转数字函数 ########################
########################################################*/ 
int ascii_int(char argc)
{
 if(58>(argc))
 {
  argc=argc-48;
 }
 if(argc>96)
 {
  argc=argc-87;
 }
 return argc;
}

 

/*########################################################
##################### 主main函数 ##########################
########################################################*/ 
int main(int argc,char **argv)
{
    int i;
    char *dev;
    char errbuf[PCAP_ERRBUF_SIZE];
 int vile=-1;
    pcap_t* devfd;
    const u_char *packet;
    struct pcap_pkthdr hdr;   
    struct ether_header *eptr;
 char c,c1,c2=0,c3,c4,c5,c6=0,c7,c8,c9;
 int bufdata[40]={};
 int ipbuff[4]={0,0,0,0};
 
/*########################################################
#################  过滤数据整理  #########################
############  所有数据转换成16进制数据   #################
########################################################*/ 
 for(c=0;c<argc;c++)
 {
  for(c1=0;c1<30;c1++)
  {
   if(argv[c][c1]=='\0')//得到指令的长度____c1
   {
    //printf("size=%d\n",c1);指令的长度____c1
/*########################################################
#################  开启本地过滤  #########################
########################################################*/
    if(argv[c][0]==98)//tcp协议开启
    {
     bb=1;
     printf("enable newline");
    }
/*########################################################
#################  协议和长度过滤数据  #########################
########################################################*/
    if(argv[c][0]==116)//tcp协议和tcp长度过滤开启
    {
     if(argv[c][4]==108)
     {
      for(c4=8;c4<c1;c4++)
      {
                            bufdata[c4]=ascii_int(argv[c][c4]);
      }
      
      int oo=8;
      for(c4=8;c4<c1;c4++)//
      {
       for(c7=0;c7<c1-c4-1;c7++)//
       {
        bufdata[oo]*=10;
       }
       oo++;
      }
      for(c8=8;c8<c1;c8++)
      {
       tcp_len[0]+=bufdata[c8];
      }
      if(argv[c][7]==61)
      {
       tcplen=1;//开启tcp长度相等过滤
       tcplenx=1;
       printf("enable tcp_data_long=%d",tcp_len[0]);
      }
      else
      {
       tcplen=2;//开启tcp长度大于过滤
       tcplenx=1;
       printf("enable tcp_data_long>%d",tcp_len[0]);
      }
     }
     if(argv[c][4]==116)
     {
      tcp=1;
      printf("enable tcp");
     }
    }
    if(argv[c][0]==117)//udp协议开启
    {
     udp=1;
     printf("enable  udp");
    }
/*########################################################
#################  端口过滤数据  #########################
########################################################*/
    if(argv[c][4]==112)//
    {
     if(argv[c][0]==115)//源端口过滤数据整理
     {
      for(c4=9;c4<c1;c4++)
      {
                            bufdata[c4]=ascii_int(argv[c][c4]);
      }
      
      int oo=9;
      for(c4=9;c4<c1;c4++)//
      {
       for(c7=0;c7<c1-c4-1;c7++)//
       {
        bufdata[oo]*=10;
       }
       oo++;
      }
      for(c8=9;c8<c1;c8++)
      {
       src_port[0]+=bufdata[c8];
      }
      src_port[1]=src_port[0]%256;
      src_port[0]=(src_port[0]/16)/16;
      printf("enable srcport=%d",adr_port[0]*256+adr_port[1]);
      srcport=1;//开启端口过滤
     }
     if(argv[c][0]==100)//目标端口过滤数据整理
     {
      for(c4=9;c4<c1;c4++)
      {
                            bufdata[c4]=ascii_int(argv[c][c4]);
      }
      
      int oo=9;
      for(c4=9;c4<c1;c4++)//
      {
       for(c7=0;c7<c1-c4-1;c7++)//
       {
        bufdata[oo]*=10;
       }
       oo++;
      }
      for(c8=9;c8<c1;c8++)
      {
       dst_port[0]+=bufdata[c8];
      }
      dst_port[1]=dst_port[0]%256;
      dst_port[0]=(dst_port[0]/16)/16;
      printf("enable dstport=%d",adr_port[0]*256+adr_port[1]);
      dstport=1;//开=启端口过滤
     }
     if(argv[c][0]==97)//全部端口过滤数据整理
     {
      for(c4=9;c4<c1;c4++)
      {
                            bufdata[c4]=ascii_int(argv[c][c4]);
      }
      
      int oo=9;
      for(c4=9;c4<c1;c4++)//
      {
       for(c7=0;c7<c1-c4-1;c7++)//
       {
        bufdata[oo]*=10;
       }
       oo++;
      }
      for(c8=9;c8<c1;c8++)
      {
       adr_port[0]+=bufdata[c8];
      }
      adr_port[1]=adr_port[0]%256;
      adr_port[0]=(adr_port[0]/16)/16;
      printf("enabe port=%d",adr_port[0]*256+adr_port[1]);
      adrport=1;//开启端口过滤
     }
    }
/*########################################################
#################  ip过滤数据  ###########################
########################################################*/
    if(argv[c][4]==105)//
    {
     char i1[4]={0,0,0,0},i2=0,i3;
     for(c9=7;c9<c1;c9++)
     {
      if(argv[c][c9]=='.')
      {
       i1[i2]=c9;
       i2++;
      }
      else
      {
       bufdata[c9]=ascii_int(argv[c][c9]);
      }
     }
     i1[3]=c1;
     for(c9=7;c9<i1[0];c9++)//ip1
     {
      for(i3=0;i3<i1[0]-c9-1;i3++)
      {
             bufdata[c9]*=10;
      }
      ipbuff[0]+=bufdata[c9];
     }
     for(c9=i1[0]+1;c9<i1[1];c9++)//ip2
     {
      for(i3=0;i3<i1[1]-c9-1;i3++)
      {
             bufdata[c9]*=10;
      }
      ipbuff[1]+=bufdata[c9];
     }
     for(c9=i1[1]+1;c9<i1[2];c9++)//ip3
     {
      for(i3=0;i3<i1[2]-c9-1;i3++)
      {
             bufdata[c9]*=10;
      }
      ipbuff[2]+=bufdata[c9];
     }
     for(c9=i1[2]+1;c9<i1[3];c9++)//ip9
     {
      for(i3=0;i3<i1[3]-c9-1;i3++)
      {
             bufdata[c9]*=10;
      }
      ipbuff[3]+=bufdata[c9];
     }
     //for(c9=7;c9<c1;c9++)
     //{
                    //    printf("%x--",bufdata[c9]);
     //}
     //printf("\n%d--%d--%d--%d\n",i1[0],i1[1],i1[2],i1[3]);
     //printf("%d--%d--%d--%d\n",ipbuff[0],ipbuff[1],ipbuff[2],ipbuff[3]);
     //printf("%x--%x--%x--%x\n",ipbuff[0],ipbuff[1],ipbuff[2],ipbuff[3]);
     if(argv[c][0]==115)//源IP过滤数据整理
     {
      src_ip[0]=ipbuff[0];
      src_ip[1]=ipbuff[1];
      src_ip[2]=ipbuff[2];
      src_ip[3]=ipbuff[3];
      printf("eanbel srcip=%d.%d.%d.%d",src_ip[0],src_ip[1],src_ip[2],src_ip[3]);
      srcip=1;//开启IP过滤
     }
     if(argv[c][0]==100)//目标IP过滤数据整理
     {
      dst_ip[0]=ipbuff[0];
      dst_ip[1]=ipbuff[1];
      dst_ip[2]=ipbuff[2];
      dst_ip[3]=ipbuff[3];
      printf("enable dstip=%d.%d.%d.%d",dst_ip[0],dst_ip[1],dst_ip[2],dst_ip[3]);
      dstip=1;//开启IP过滤
     }
     if(argv[c][0]==97)//全部IP过滤数据整理
     {
      adr_ip[0]=ipbuff[0];
      adr_ip[1]=ipbuff[1];
      adr_ip[2]=ipbuff[2];
      adr_ip[3]=ipbuff[3];
      printf("enable ip=%d.%d.%d.%d",adr_ip[0],adr_ip[1],adr_ip[2],adr_ip[3]);
      adrip=1;//开启IP过滤
     }
     ipbuff[0]=0;ipbuff[1]=0;ipbuff[2]=0;ipbuff[3]=0;
    }
/*########################################################
#################  mac过滤数据  ##########################
########################################################*/
    if(argv[c][4]==109)
    {
     if(argv[c][0]==115)//源MAC过滤数据整理
     {
      for(c4=8;c4<c1;c4++)
      {
                            argv[c][c4]=ascii_int(argv[c][c4]);
      }
      c6=0;
      for (c5=0;c5<12;c5+=2)
      {
       src_mac[c6]=(argv[c][c5+8]*16+argv[c][c5+9]);
       c6++;
      }
      printf("enable srcmac=%x-%x-%x-%x-%x-%x",src_mac[0],src_mac[1],src_mac[2],src_mac[3],src_mac[4],src_mac[5]);
      srcmac=1;//开启MAC过滤
     }
     if(argv[c][0]==100)//目标MAC过滤数据整理
     {
      for(c4=8;c4<c1;c4++)
      {
                            argv[c][c4]=ascii_int(argv[c][c4]);
      }
      c6=0;
      for (c5=0;c5<12;c5+=2)
      {
       dst_mac[c6]=(argv[c][c5+8]*16+argv[c][c5+9]);
       c6++;
      }
      printf("enable dstmac%x-%x-%x-%x-%x-%x",dst_mac[0],dst_mac[1],dst_mac[2],dst_mac[3],dst_mac[4],dst_mac[5]);
      dstmac=1;//开启MAC过滤
     }
     if(argv[c][0]==97)//全部MAC过滤数据整理
     {
      for(c4=8;c4<c1;c4++)
      {
                            argv[c][c4]=ascii_int(argv[c][c4]);
      }
      c6=0;
      for (c5=0;c5<12;c5+=2)
      {
       adr_mac[c6]=(argv[c][c5+8]*16+argv[c][c5+9]);
       c6++;
      }
      printf("enable mac=%x-%x-%x-%x-%x-%x",adr_mac[0],adr_mac[1],adr_mac[2],adr_mac[3],adr_mac[4],adr_mac[5]);
      adrmac=1;//开启MAC过滤
     }
    }
    printf("\n");
    break;
   }
  }
 }
/*########################################################
#################  获取网络设备名 ########################
########################################################*/
    dev = pcap_lookupdev(errbuf);//
    //if(dev!= NULL)
    { printf("%s\n",dev);}

/*########################################################
#################  设备描述符devfd #######################
########################################################*/
 devfd = pcap_open_live(dev,65535,0,1000,errbuf);//

 //if(devfd!= NULL)
   // { printf("devfd\n");}
    //{ printf("%d\n",devfd);}
 
/*########################################################
#################  开始循环抓包 #######################
########################################################*/
    printf("starting.....\n");
    pcap_loop(devfd,vile,my_callback,NULL);//
    //printf("\nDone processing packets... wheew!\n");
    return 0;
}