tcpdump源码分析
linux环境下libpcap 源代码分析
韩大卫@吉林师范大学
libpcap 源代码官方下载地址：
git clonehttps://github.com/the-tcpdump-group/libpcap.git
tcpdumpm源代码官方下载地址：
git clone git://bpf.tcpdump.org/tcpdump
tcpdump.c使用libpcap里的pcap_open_live和pcap_loop 完成两个最关键的动作：获取捕获报文的接口，和捕获报文并将报文交给callback。 (关于tcpdump源代码的构架，请参考作者的tcpdump源代码分析)
现结合libpcap源代码分析pcap_open_live和pcap_loop的实现机制，并进入linux内核，展示linux内核对这两个API的响应动作。
tcpdump.c对pcap_open_live的使用是：
pd = pcap_open_live(device, snaplen, !pflag, 1000, ebuf);
pcap_open_live定义如下：
pcap_t *pcap_open_live(const char *source, int snaplen,int promisc, int to_ms, char *errbuf)
source 为指定的网络接口。
snaplen 为最大报文长度。
Promisc 是否将设备设置为混杂模式。
to_ms 超时时间。
errbuf 为错误信息描述字符。
返回值为cap_t类型的指针，pcap_t 定义是：
typedef struct pcap pcap_t;
struct pcap {
/*typedef int (*read_op_t)(pcap_t *, int cnt,pcap_handler, u_char *);
read_op为从网络接口读取报文的函数指针，待其得到赋值后，调用实现函数*/
read_op_tread_op;
//从文件里读取报文的函数指针
int(*next_packet_op)(pcap_t *, struct pcap_pkthdr *, u_char **);
//文件描述符,即socket
int fd;
intselectable_fd;
intbufsize; //read缓冲区大小
u_char *buffer;//read缓冲区指针
u_char *bp;
int cc;
...
int snapshot;
intlinktype; /* Network linktype */
intlinktype_ext;
int tzoff; /* timezone offset */
intoffset; /* offset forproper alignment */
intactivated; /* true if the capture isreally started */
intoldstyle; /* if we're opening withpcap_open_live() */
struct pcap_optopt;
u_char *pkt;
...
//激活函数，激活函数在得到调用后，会建立起与底层IPC的socket
activate_op_tactivate_op;
...
};
pcap_t *
pcap_open_live(const char *source, int snaplen, intpromisc, int to_ms, char *errbuf){
pcap_t *p;
int status;
//创建捕获报文的接口句柄
p =pcap_create(source, errbuf);
if (p == NULL)
return(NULL);
//设置最大报文长度
status =pcap_set_snaplen(p, snaplen);
if (status <0)
goto fail;
//将设备设为混杂模式
status =pcap_set_promisc(p, promisc);
if (status <0)
goto fail;
//设置超时时间
status =pcap_set_timeout(p, to_ms);
if (status <0)
goto fail;
p->oldstyle= 1;
//pcap_avtivate调用pcap_t的activate_op, 建立起与底层IPC通道
status =pcap_activate(p);
if (status <0)
goto fail;
return (p);
...
}
pcap_t *pcap_create(const char *source, char*errbuf){
size_t i;
int is_theirs;
pcap_t *p;
if (source ==NULL)
source ="any";
//在capture_source_types数组里寻找是否有特定API集合的接口对应source
for (i = 0;capture_source_types[i].create_op != NULL; i++) {
is_theirs =0;
p =capture_source_types[i].create_op(source, errbuf, &is_theirs);
if(is_theirs) {
return (p);
}
}
//如果没有，那么就将source作为普通网络接口
return(pcap_create_interface(source, errbuf));
}
pcap_create_interface() 函数在libpcap下有多个实现，可由编译宏来指定特定的pcap_create_interface来初始化read_op等函数指针。linux环境里默认是libpcap/pcap-linux.c中的 pcap_create_interface():
pcap_t *
pcap_create_interface(const char *device, char *ebuf)
{
pcap_t *handle;
/*可将 pcap_create_common看做pcap_t结构的构造函数，初始化一个pcap_t*/
handle =pcap_create_common(device, ebuf, sizeof (struct pcap_linux));
if (handle ==NULL)
returnNULL;
//为pcap_t 的激活函数指针填充具体实现函数
handle->activate_op = pcap_activate_linux;
handle->can_set_rfmon_op = pcap_can_set_rfmon_linux;
return handle;
}
完成后回到pcap_open_live，设置snaplen,promisc,to_ms后，调用status = pcap_activate(p),该函数执行status = p->activate_op(p) ，
进而调用 pcap_activate_linux(), 完成read_op等重要函数指针的具体赋值。
static int
pcap_activate_linux(pcap_t *handle)
{
structpcap_linux *handlep = handle->priv;
const char *device;
int status = 0;
device =handle->opt.source;
handle->inject_op = pcap_inject_linux;
handle->setfilter_op = pcap_setfilter_linux;
handle->setdirection_op = pcap_setdirection_linux;
handle->set_datalink_op = pcap_set_datalink_linux;
handle->getnonblock_op = pcap_getnonblock_fd;
handle->setnonblock_op = pcap_setnonblock_fd;
handle->cleanup_op = pcap_cleanup_linux;
//最重要的函数指针read_op
handle->read_op = pcap_read_linux;
handle->stats_op = pcap_stats_linux;
if(strcmp(device, "any") == 0) {
if(handle->opt.promisc) {
handle->opt.promisc = 0;
/* Justa warning. */
snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
"Promiscuous mode not supported>先使用activete_new()
status =activate_new(handle);
if (status < 0) {
goto fail;
}
//根据错误值具体处理
if (status ==1) {
switch(activate_mmap(handle, &status)) {
case 1:
returnstatus;
case 0:
break;
case -1:
gotofail;
}
}
//如果status为0，再尝试使用activete_old()函数
else if (status== 0) {
/*Non-fatal error; try old way */
if ((status= activate_old(handle)) != 1) {
gotofail;
}
}
status = 0;
if(handle->opt.buffer_size != 0) {
//设置socket的缓冲区和缓冲区长度
if(setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
&handle->opt.buffer_size,
sizeof(handle->opt.buffer_size)) == -1) {
snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
"SO_RCVBUF: %s",pcap_strerror(errno));
status= PCAP_ERROR;
gotofail;
}
}
handle->selectable_fd = handle->fd;
return status;
...
}
static int
activate_new(pcap_t *handle)
{
struct pcap_linux*handlep = handle->priv;
const char *device = handle->opt.source;
int is_any_device = (strcmp(device,"any") == 0);
int sock_fd = -1, arptype;
int err = 0;
structpacket_mreq mr;
/*指定网口情况下用PF_PACKET协议通信得到原始以太网数据帧数据
关于socket()函数，我个人认为可以将其理解为open()：
open()打开不同的文件，这样在返回的句柄里就可使用这个文件设备模块提供的ops，
socket()打开不同的协议，返回句柄里也包括了该协议的底层模块提供的ops. 只不过linux下面没法将网络协议当作普通文件（如/dev/xx）处理，所以才有了另一套socket特定的APIs*/
sock_fd =is_any_device ?
socket(PF_PACKET,SOCK_DGRAM, htons(ETH_P_ALL)) :
socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
...
handlep->sock_packet = 0;
/*iface_get_id()使用ioctl(fd, SIOCGIFINDEX, &ifr)获取lo还回设备的索引值*/
handlep->lo_ifindex = iface_get_id(sock_fd, "lo",handle->errbuf);
handle->offset = 0;
if(!is_any_device) {
handlep->cooked = 0;
if(handle->opt.rfmon) {
err =enter_rfmon_mode(handle, sock_fd, device);
if (err< 0) {
close(sock_fd);
return err;
}
if (err== 0) {
close(sock_fd);
return PCAP_ERROR_RFMON_NOTSUP;
}
if(handlep->mondevice != NULL)
device= handlep->mondevice;
}
/*iface_get_arptype()调用ioctl(fd, SIOCGIFHWADDR, &ifr)获取硬件类型 */
arptype =iface_get_arptype(sock_fd, device, handle->errbuf);
if (arptype< 0) {
close(sock_fd);
returnarptype;
}
map_arphrd_to_dlt(handle, arptype, 1);
...
//获取指定设备的索引值
handlep->ifindex = iface_get_id(sock_fd, device,
handle->errbuf);
if(handlep->ifindex == -1) {
close(sock_fd);
returnPCAP_ERROR;
/*iface_bind()将设备的索引值作为struct socketadd_ll的索引值与socket绑定
structsockaddr_ll sll;
sll.sll_family =AF_PACKET;
sll.sll_ifindex = ifindex;
sll.sll_protocol =htons(ETH_P_ALL);
bind(fd, (struct sockaddr *) &sll,sizeof(sll)) == -1 */
if ((err =iface_bind(sock_fd, handlep->ifindex,
handle->errbuf)) != 1) {
close(sock_fd);
if (err< 0)
return err;
else
return 0; /* try old mechanism*/
}
...
}
if(!is_any_device && handle->opt.promisc) {
memset(&mr, 0, sizeof(mr));
mr.mr_ifindex = handlep->ifindex;
mr.mr_type = PACKET_MR_PROMISC;
if(setsockopt(sock_fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
&mr, sizeof(mr)) == -1) {
snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
"setsockopt: %s", pcap_strerror(errno));
close(sock_fd);
returnPCAP_ERROR;
}
}
if(handlep->cooked) {
if(handle->snapshot < SLL_HDR_LEN + 1)
handle->snapshot = SLL_HDR_LEN + 1;
}
handle->bufsize = handle->snapshot;
//根据以太网链路层类型决定VLAN Tag在报文中的偏移值
switch(handle->linktype) {
caseDLT_EN10MB:
handlep->vlan_offset = 2 * ETH_ALEN;
break;
case DLT_LINUX_SLL:
handlep->vlan_offset = 14;
break;
default:
handlep->vlan_offset = -1; /* unknown */
break;
}
//将sock_fd作为pcap_t的fd
handle->fd =sock_fd;
...
}
至此，通过pcap_open_live完成全部准备阶段的内容，之后就可以使用pcap_loop()来获取来自底层的数据并提交给callback函数进行应用处理， tcpdump.c 对pcap_loop的使用是：
status = pcap_loop(pd, cnt, callback, pcap_userdata);
//cnt 为指定捕获报文的个数
在libpcap/pcap.c里有pcap_loop的定义：
int
pcap_loop(pcap_t *p, int cnt, pcap_handler callback,u_char *user)
{
register int n;
for (;;) {
if(p->rfile != NULL) {
//从文件里读取报文
n =pcap_offline_read(p, cnt, callback, user);
} else {
//从指定网口读取报文
do {
//read_op即为pcap_read_packet
n =p->read_op(p, cnt, callback, user);
} while(n == 0);
}
//当n<0时退出循环，退出pcap_loop
if (n <=0)
return(n);
//如果达到捕获报文个数，退出pcap_loop
if (cnt> 0) {
cnt -=n;
if (cnt<= 0)
return (0);
}
}
函数指针read_op指向的就是pcap_read_linux_mmap
pcap_get_ring_frame(handle, TP_STATUS_USER)进行取数据， 这里的数据是是通过应用程序进行mmap一块内核的内存，内核取得的数据保存在mmap所映射的区域，进行取。具体可以搜索下pcap_get_ring_frame这接口，网络上有说明的
bp = (unsigned char*)h.raw + tp_mac;获取之后的数据给bp
callback(user, &pcaphdr, bp);调用这个进行打印
static void print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp) 接着调用这个
hdrlen = (*print_info->p.printer)(h, sp);调用这个进行打印
经过初始化，调用u_int prism_if_print(const struct pcap_pkthdr *h, const u_char *p)
return PRISM_HDR_LEN + ieee802_11_print(p + PRISM_HDR_LEN, length - PRISM_HDR_LEN, caplen - PRISM_HDR_LEN, 0, 0);这里把源数据去掉PRISM_HDR_LEN的长度。
fc = EXTRACT_LE_16BITS(p);
hdrlen = extract_header_length(fc);进行去掉额外的头信息
p += hdrlen;源数据偏移26字节
p+=8再进行偏移八个字节
ip4 = (const struct ip *)p;
up = (struct udphdr *)((const u_char *)ip4 + IP_HL(ip4) * 4);
dport = EXTRACT_16BITS(&up->uh_dport);
最后就能得到相应的源地址的ip的端口号了，上述跟踪的是udp的广播包的形式打印的
}