libpcap使用初探

原贴:http://blog.sina.com.cn/s/blog_8164269e0101hfkc.html


头文件在 /usr/local/include/pcap/pcap.h中,具体函数可以参见头文件,

  • char *pcap_lookupdev(char *);
  • int pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
  • pcap_t *pcap_create(const char *, char *);
  • int pcap_set_snaplen(pcap_t *, int);
  • int pcap_set_promisc(pcap_t *, int);
  • int pcap_can_set_rfmon(pcap_t *);
  • int pcap_set_rfmon(pcap_t *, int);
  • int pcap_set_timeout(pcap_t *, int);
  • int pcap_set_tstamp_type(pcap_t *, int);
  • int pcap_set_immediate_mode(pcap_t *, int);
  • int pcap_set_buffer_size(pcap_t *, int);
  • int pcap_set_tstamp_precision(pcap_t *, int);
  • int pcap_get_tstamp_precision(pcap_t *);
  • int pcap_activate(pcap_t *);
  • int pcap_list_tstamp_types(pcap_t *, int **);
  • void pcap_free_tstamp_types(int *);
  • int pcap_tstamp_type_name_to_val(const char *);
  • const char *pcap_tstamp_type_val_to_name(int);
  • const char *pcap_tstamp_type_val_to_description(int);
下面开始介绍一下这些函数的用法:
1.获取网络接口:可以手动或者指定
使用 char  *pcap_lookupdev(char *buf); 该函数返回第一个合适的网络接口的,若出错则返回错我信息的字符串,buf至少为PCAP_ERRBUF_SIZE的长度.
  • #include
  • #include

  • int main()
  • {
  •   char errBuf[PCAP_ERRBUF_SIZE], * device;
  •   
  •   device = pcap_lookupdev(errBuf);
  •   
  •   if(device)
  •   {
  •     printf("success: device: %s\n", device);
  •   }
  •   else
  •   {
  •     printf("error: %s\n", errBuf);
  •   }
  •   
  •   return 0;
  • }
2.释放网络接口
void pcap_close(pcap_t * p),用与关闭 pcap_open_live()获取的pcap_t的网络接口对象并释放相关资源。

3.打开网络接口
pcap_t * pcap_open_live(const char * device, int snaplen, int promisc, int to_ms, char * errbuf)
这个函数会返回指定接口的pcap_t类型指针,后面的所有操作都要使用这个指针。
第一个参数是第一步获取的网络接口字符串,可以直接使用硬编码。
第二个参数是对于每个数据包,从开头要抓多少个字节,我们可以设置这个值来只抓每个数据包的头部,而不关心具体的内容。典型的以太网帧长度是1518字节,但其他的某些协议的数据包会更长一点,但任何一个协议的一个数据包长度都必然小于65535个字节。
第三个参数指定是否打开混杂模式(Promiscuous Mode),0表示非混杂模式,任何其他值表示混合模式。如果要打开混杂模式,那么网卡必须也要打开混杂模式,可以使用如下的命令打开eth0混杂模式:
ifconfig eth0 promisc
第四个参数指定需要等待的毫秒数,超过这个数值后,第3步获取数据包的这几个函数就会立即返回。0表示一直等待直到有数据包到来。
第五个参数是存放出错信息的数组。

4.获取数据包
打开网络接口后就已经开始监听了,那如何知道收到了数据包呢?有下面3种方法:
a)
u_char * pcap_next(pcap_t * p, struct pcap_pkthdr * h)
如果返回值为NULL,表示没有抓到包
第一个参数是第2步返回的pcap_t类型的指针
第二个参数是保存收到的第一个数据包的pcap_pkthdr类型的指针
pcap_pkthdr类型的定义如下:
  • struct pcap_pkthdr
  • {
  •   struct timeval ts;    
  •   bpf_u_int32 caplen;  
  •   bpf_u_int32 len;      
  • };
b)
int pcap_loop(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
第一个参数是第2步返回的pcap_t类型的指针
第二个参数是需要抓的数据包的个数,一旦抓到了cnt个数据包,pcap_loop立即返回。负数的cnt表示pcap_loop永远循环抓包,直到出现错误。
第三个参数是一个回调函数指针,它必须是如下的形式:
void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
第一个参数是pcap_loop的最后一个参数,当收到足够数量的包后pcap_loop会调用callback回调函数,同时将pcap_loop()的user参数传递给它
第二个参数是收到的数据包的pcap_pkthdr类型的指针
第三个参数是收到的数据包数据


c)
int pcap_dispatch(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
这个函数和pcap_loop()非常类似,只是在超过to_ms毫秒后就会返回(to_ms是pcap_open_live()的第4个参数)
下面试试看第二个例子
  • #include
  • #include
  • #include
  • #include

  • int main()
  • {
  •   char errBuf[PCAP_ERRBUF_SIZE], * devStr;
  •   
  •  
  •   devStr = pcap_lookupdev(errBuf);
  •   
  •   if(devStr)
  •   {
  •     printf("success: device: %s\n", devStr);
  •   }
  •   else
  •   {
  •     printf("error: %s\n", errBuf);
  •     exit(1);
  •   }
  •   
  •  
  •   pcap_t * device = pcap_open_live(devStr, 65535, 1, 0, errBuf);
  •   
  •   if(!device)
  •   {
  •     printf("error: pcap_open_live(): %s\n", errBuf);
  •     exit(1);
  •   }

  •  
  •   struct pcap_pkthdr packet;
  •   const u_char * pktStr = pcap_next(device, &packet);

  •   if(!pktStr)
  •   {
  •     printf("did not capture a packet!\n");
  •     exit(1);
  •   }
  •   
  •   printf("Packet length: %d\n", packet.len);
  •   printf("Number of bytes: %d\n", packet.caplen);
  •   printf("Recieved time: %s\n", ctime((const time_t *)&packet.ts.tv_sec)); 
  •   
  •   pcap_close(device);
  •   
  •   return 0;
  • }
注意使用GCC编译需要加上-lpcap,比如我们这个C文件叫做test.c,使用如下命令:
gcc -o test test.c -lpcap否则会报错

例3,下面这个程序会把收到的数据包打印出来
  • #include
  • #include
  • #include
  • #include

  • void getPacket(u_char * arg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
  • {
  •   int * id = (int *)arg;
  •   
  •   printf("id: %d\n", ++(*id));
  •   printf("Packet length: %d\n", pkthdr->len);
  •   printf("Number of bytes: %d\n", pkthdr->caplen);
  •   printf("Recieved time: %s", ctime((const time_t *)&pkthdr->ts.tv_sec)); 
  •   
  •   int i;
  •   for(i=0; ilen; ++i)
  •   {
  •     printf(" x", packet[i]);
  •     if( (i + 1) % 16 == 0 )
  •     {
  •       printf("\n");
  •     }
  •   }
  •   
  •   printf("\n\n");
  • }

  • int main()
  • {
  •   char errBuf[PCAP_ERRBUF_SIZE], * devStr;
  •   
  •  
  •   devStr = pcap_lookupdev(errBuf);
  •   
  •   if(devStr)
  •   {
  •     printf("success: device: %s\n", devStr);
  •   }
  •   else
  •   {
  •     printf("error: %s\n", errBuf);
  •     exit(1);
  •   }
  •   
  •  
  •   pcap_t * device = pcap_open_live(devStr, 65535, 1, 0, errBuf);
  •   
  •   if(!device)
  •   {
  •     printf("error: pcap_open_live(): %s\n", errBuf);
  •     exit(1);
  •   }
  •   
  •  
  •   int id = 0;
  •   pcap_loop(device, -1, getPacket, (u_char*)&id);
  •   
  •   pcap_close(device);

  •   return 0;
  • }
5.下面讲一下数据包的过滤,就像wireshark的filter一样
几乎所有的操作系统(BSD, AIX, Mac OS, Linux等)都会在内核中提供过滤数据包的方法,主要都是基于BSD Packet Filter(BPF)结构的。libpcap利用BPF来过滤数据包。
过滤数据包需要完成3件事:
a) 构造一个过滤表达式
b) 编译这个表达式
c) 应用这个过滤器

a)
BPF使用一种类似于汇编语言的语法书写过滤表达式,不过libpcap和tcpdump都把它封装成更高级且更容易的语法了,具体可以man tcpdump,以下是一些例子:
src host 192.168.1.177
只接收源ip地址是192.168.1.177的数据包

dst port 80
只接收tcp/udp的目的端口是80的数据包

not tcp
只接收不使用tcp协议的数据包

tcp[13] == 0x02 and (dst port 22 or dst port 23)
只接收SYN标志位置位且目标端口是22或23的数据包(tcp首部开始的第13个字节)

icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo
只接收icmp的ping请求和ping响应的数据包

ehter dst 00:e0:09:c1:0e:82
只接收以太网mac地址是00:e0:09:c1:0e:82的数据包

ip[8] == 5
只接收ip的ttl=5的数据包(ip首部开始的第8个字节)

b)
构造完过滤表达式后,我们需要编译它,使用如下函数:
int pcap_compile(pcap_t * p, struct bpf_program * fp, char * str, int optimize, bpf_u_int32 netmask)
fp:这是一个传出参数,存放编译后的bpf
str:过滤表达式
optimize:是否需要优化过滤表达式
metmask:简单设置为0即可

c)
最后我们需要应用这个过滤表达式:
int pcap_setfilter(pcap_t * p,  struct bpf_program * fp)
第二个参数fp就是前一步pcap_compile()的第二个参数

应用完过滤表达式之后我们便可以使用pcap_loop()或pcap_next()等抓包函数来抓包了。
下面的程序演示了如何过滤数据包,我们只接收目的端口是80的数据包:
  • #include
  • #include
  • #include
  • #include

  • void getPacket(u_char * arg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
  • {
  •   int * id = (int *)arg;
  •   
  •   printf("id: %d\n", ++(*id));
  •   printf("Packet length: %d\n", pkthdr->len);
  •   printf("Number of bytes: %d\n", pkthdr->caplen);
  •   printf("Recieved time: %s", ctime((const time_t *)&pkthdr->ts.tv_sec)); 
  •   
  •   int i;
  •   for(i=0; ilen; ++i)
  •   {
  •     printf(" x", packet[i]);
  •     if( (i + 1) % 16 == 0 )
  •     {
  •       printf("\n");
  •     }
  •   }
  •   
  •   printf("\n\n");
  • }

  • int main()
  • {
  •   char errBuf[PCAP_ERRBUF_SIZE], * devStr;
  •   
  •  
  •   devStr = pcap_lookupdev(errBuf);
  •   
  •   if(devStr)
  •   {
  •     printf("success: device: %s\n", devStr);
  •   }
  •   else
  •   {
  •     printf("error: %s\n", errBuf);
  •     exit(1);
  •   }
  •   
  •  
  •   pcap_t * device = pcap_open_live(devStr, 65535, 1, 0, errBuf);
  •   
  •   if(!device)
  •   {
  •     printf("error: pcap_open_live(): %s\n", errBuf);
  •     exit(1);
  •   }
  •   
  •  
  •   struct bpf_program filter;
  •   pcap_compile(device, &filter, "dst port 80", 1, 0);
  •   pcap_setfilter(device, &filter);
  •   
  •  
  •   int id = 0;
  •   pcap_loop(device, -1, getPacket, (u_char*)&id);
  •   
  •   pcap_close(device);

  •   return 0;
  • }

你可能感兴趣的:(网络)