Linux内核角度分析tcpdump原理（一）
一、tcpdump的用途
tcpdump是Linux系统抓包工具，tcpdump基于libpcap库，根据使用者的定义对网络上的数据包进行截获，tcpdump可以将网络中传送的数据包中的"头"完全截获下来提供分析，支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助去掉无用的信息。通过tcpdump可以分析很多网络行为，比如丢包重传、详细报文、tcp分组等，总之通过tcpdunp可以为各种网络问题进行排查,可以在服务器上将捕获的数据包信息以pcap文件保存下来，通过wireshark打开，更直观地分析。
tcpdump是基于libpcap库的，数据包的过滤是基于BPF(tcpdump依附标准的bpf机器来运行，tcpdump过滤规则会被转化为一段bpf指令并加载到内核中的bpf虚拟机器上执行)，使用bpf虚拟机的tcpdump完美解决了包过滤问题。总之tcpdump使用libpcap这种链路层旁路处理的形式进行包捕获，使用bpf机制实现对包的完美过滤。
更多介绍和使用可以从官网：
http://www.tcpdump.org/index.html#documentation查阅到。
tips
下面将先介绍libpcap(第二章），对libpcap有一个了解，然后再从Linux内核角度分析tcpdunp的抓包原理(第三章)。
二、libpcap简单介绍
libpcap(Packet Capture Library)，即数据包捕获函数库，是Unix/Linux平台下的网络数据包捕获函数库，独立于系统的用户层包捕获的API接口，为底层网络监测提供了一个可移植的框架。
利用libpcap函数库开发应用程序的基本步骤：
-
捕获各种数据包，例如：网络流量统计。
-
过滤网络数据包，例如：过滤掉本地上的一些数据，类似防火墙。
-
分析网络数据包，例如：分析网络协议，数据的采集。
-
存储网络数据包，例如：保存捕获的数据以为将来进行分析。
libpcap库在linux上的安装过程
sudo apt-get insatll flex
sudo apt-get install bison
wget -c http://www.tcpdump.org/release/libpcap-1.7.4.tar.gz
cd libpcap-1.7.4
./congigure
sudo make
sudo make install
测试：
//demo:查找当前系统的可用网络设备
#include
#include
int main(int argc, char *argv[])
{
char *dev,errbuf[1024];
dev=pcap_lookupdev(errbuf);//函数用来查找网络设备
if(dev==NULL){
printf("%s\n",errbuf);
return 0;
}
printf("Device: %s\n", dev);
return 0;
}
编译：
#注意编译时加上：-lpcap
gcc test.c -o test -lpcap
报错提醒：
error while loading shared libraries: libpcap.so.1: cannot open shared object file: No such file or directory
解决：
执行 locate libpcap.so.1 , 查看libpcap.so.1在系统中的路径 , 显示为 ： /usr/local/lib/libpcap.so.1.2.1
以管理员权限打开编辑 /etc/ld.so.conf 文件, 末尾新一行追加 /usr/local/lib , /usr/local/lib 为 libpcap.so.1.7.4 所在目录, 保存退出
以管理员权限执行 ldconfig(如果不支持改命令用whereis ldconfig查看并设置环境变量)命令,
成功
几个重要的API
-
pcap_lookupdev()：函数用于查找网络设备，返回可被 pcap_open_live() 函数调用的网络设备名指针。
/*errbuf:存放出错信息字符串，宏定义PCAP_ERRBUF_SIZE为错误缓冲区大小
返回值为设备名(第一个合适的网络接口的字符串指针)
*/
char *pcap_lookupdev(char *errbuf)
-
pcap_lookupnet()：函数获得指定网络设备的网络号和掩码。
/*获取指定网卡的ip地址，子网掩码
device:网络设备名
netp:存放ip地址的指针
maskp:存放子网掩码的指针
errbuf:存放出错信息*/
int pcap_lookupnet(char *device,bpf_u_int32 *netp,bpf_u_int32 *maskp,char *errbuf );
-
pcap_open_live()： 函数用于打开网络设备，并且返回用于捕获网络数据包的数据包捕获描述字。对于此网络设备的操作都要基于此网络设备描述字。
/*
device:网络接口名字
snaplen:数据包大小，最大为65535字节
promise：“1” 代表混杂模式，其它非混杂模式。什么为混杂模式
to_ms：指定需要等待的毫秒数，超过这个数值后，获取数据包的函数就会立即返回（这个函数不会阻塞，后面的抓包函数才会阻塞）。0 表示一直等待直到有数据包到来。
ebuf：存储错误信息。
返回值：pcap_t类型指针，后面的所有操作都要用这个指针
*/
pcap_t *pcap_open_live(const char *device,int snaplen,int promisc,int to_ms,char *ebuf );
-
pcap_compile()： 函数用于将用户制定的过滤策略编译到过滤程序中。
/*
p是嗅探器回话句柄
fp是一个bpf_program结构的指针，在pcap_compile()函数中被赋值。
str:指定的过滤条件
optimize参数控制结果代码的优化。
netmask参数指定本地网络的网络掩码
*/
int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask)
-
pcap_setfilter()：函数用于设置过滤器。
/*
p：pcap_open_live() 返回的 pcap_t 类型的指针
fp：pcap_compile() 的第二个参数
*/
int pcap_setfilter( pcap_t * p, struct bpf_program * fp );
-
pcap_loop()：函数 pcap_dispatch() 函数用于捕获数据包，捕获后还可以进行处理，此外 pcap_next() 和 pcap_next_ex() 两个函数也可以用来捕获数据包。
-
pcap_close()：函数用于关闭网络设备，释放资源。
三、tcpdump实现抓包原理剖析
使用strace追踪
strace tcpdump tcp port 80
可以看到tcpdump抓包创建的的套接字类型AF_PACKET
在libpcap库源码中也可以看到有调用socket系统调用：
tatic int
pcap_can_set_rfmon_linux(pcap_t *handle)
{
...
sock_fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (sock_fd == -1) {
(void)snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
"socket: %s", pcap_strerror(errno));
return PCAP_ERROR;
}
...
}
AF_PACKET和socket应用结合一般都是用于抓包分析,packet套接字提供的是L2的抓包能力。
socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))
系统调用：
SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
......
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
return retval;
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}
socket创建函数：
int sock_create(int family, int type, int protocol, struct socket **res)
{
return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}
调用：__sock_create
sock_create 函数主要就是创建了socket . 同时根据之前PF_PACKET 模块注册到全局变量net_families 。 找到af_packet.c 中初始化的 static const struct net_proto_family packet_family_ops。而sock_create 函数中 err = pf->create(net, sock, protocol, kern); 最终就会调用 packet_family_ops 里的packet_create
int __sock_create(struct net *net, int family, int type, int protocol,
struct socket **res, int kern)
{
int err;
struct socket *sock;
const struct net_proto_family *pf;
......
sock = sock_alloc();//分配socket结构空间
if (!sock) {
net_warn_ratelimited("socket: no more sockets\n");
return -ENFILE; /* Not exactly a match, but its the
closest posix thing */
}
sock->type = type;//记录socket类型
#ifdef CONFIG_MODULES
if (rcu_access_pointer(net_families[family]) == NULL)
request_module("net-pf-%d", family);
#endif
rcu_read_lock();
pf = rcu_dereference(net_families[family]);//根据family协议簇找到注册的(PF_PACKET)协议族操作表
err = -EAFNOSUPPORT;
if (!pf)
goto out_release;
if (!try_module_get(pf->owner))
goto out_release;
rcu_read_unlock();
err = pf->create(net, sock, protocol, kern);//执行该协议族(PF_PACKET)的创建函数
......
}
Linux内核中定义了net_proto_family结构体，用来指明不同的协议族对应的socket创建函数，family字段是协议族的类型，create是创建socket的函数，如下是PF_PACKET对应结构体。
static const struct net_proto_family packet_family_ops = {
.family = PF_PACKET,
.create = packet_create,
.owner = THIS_MODULE,
};
找到AF_PACKET协议族对应的create函数：可以看到po->prot_hook.func = packet_rcv;po->prot_hook其实packet_type，packet_type结构体： packet_type 结构体第一个type 很重要，对应链路层中2个字节的以太网类型。而dev.c 链路层抓取的包上报给对应模块，就是根据抓取的链路层类型，然后给对应的模块处理，例如socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)); ETH_P_ALL表示所有的底层包都会给到PF_PACKET 模块的处理函数，这里处理函数就是packet_rcv 函数。
设置了回调函数:packet_rcv,并通过register_prot_hook(sk)完成了注册，其中注册过程将再下面分析
static int packet_create(struct net *net, struct socket *sock, int protocol,
int kern)
{
struct sock *sk;
struct packet_sock *po;
__be16 proto = (__force __be16)protocol; /* weird, but documented */
int err;
......
po = pkt_sk(sk);
sk->sk_family = PF_PACKET;//设置sk协议族为PF_PACKET
po->num = proto; //数据包的类型ETH_P_ALL
po->xmit = dev_queue_xmit;
err = packet_alloc_pending(po);
if (err)
goto out2;
packet_cached_dev_reset(po);
sk->sk_destruct = packet_sock_destruct;
sk_refcnt_debug_inc(sk);
/*
* Attach a protocol block
*/
spin_lock_init(&po->bind_lock);
mutex_init(&po->pg_vec_lock);
.....
po->rollover = NULL;
po->prot_hook.func = packet_rcv;//设置回调函数
if (sock->type == SOCK_PACKET)
po->prot_hook.func = packet_rcv_spkt;
po->prot_hook.af_packet_priv = sk;
if (proto) {
po->prot_hook.type = proto;
register_prot_hook(sk);//将这个socket挂载到ptype_all连接串列上
}
......
}
//packet_sock结构体
struct packet_sock {
/* struct sock has to be the first member of packet_sock */
struct sock sk;
......
struct net_device __rcu *cached_dev;
int (*xmit)(struct sk_buff *skb);
struct packet_type prot_hook ____cacheline_aligned_in_smp;//packet_create函数中通过该字段进行下一步的设置：po->prot_hook
};
/*po->prot_hook其实packet_type，packet_type结构体：
数据包完成链路层的处理后，需要提交给协议栈上层继续处理，每个packet_type结构就是数据包的一个可能去向
packet_type 结构体第一个type 很重要，对应链路层中2个字节的以太网类型。而dev.c 链路层抓取的包上报给对应模块，就是根据抓取的链路层类型，然后给对应的模块处理，例如socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)); ETH_P_ALL表示所有的底层包都会给到PF_PACKET 模块的处理函数，这里处理函数就是packet_rcv 函数。
*/
struct packet_type {
__be16 type; /* type指定了协议的标识符，标记了packet_type收取什么类型的数据包，处理程序func会使用该标识符 ，保存了三层协议类型，ETH_P_IP、ETH_P_ARP等等*/
struct net_device *dev; /* NULL指针表示该处理程序对系统中所有网络设备都有效 */
/* func:packet_create函数通过该字段设置的回调函数：po->prot_hook.func = packet_rcv;
func是该结构的主要成员，它是一个指向网络层函数的指针，ip层处理时挂载的是ip_rcv
*/
int (*func) (struct sk_buff *,
struct net_device *,
struct packet_type *,
struct net_device *);
bool (*id_match)(struct packet_type *ptype,
struct sock *sk);
void *af_packet_priv;
struct list_head list;
};
展开注册函数register_prot_hook(sk)
static void register_prot_hook(struct sock *sk)
{
struct packet_sock *po = pkt_sk(sk);
if (!po->running) {
if (po->fanout)
__fanout_link(sk, po);
else
dev_add_pack(&po->prot_hook);//将pacekt_type放到ptype_all链表上。
sock_hold(sk);
po->running = 1;
}
}
//ptype_all链表：
struct list_head ptype_all __read_mostly;//全局变量
展开dev_add_pack
//将pacekt_type放到ptype_all链表上。
void dev_add_pack(struct packet_type *pt)
{
struct list_head *head = ptype_head(pt);//获取ptype_all链表
spin_lock(&ptype_lock);
list_add_rcu(&pt->list, head);//将po->prot_hook挂载到ptype_all链表
spin_unlock(&ptype_lock);
}
//获取ptype_all链表
static inline struct list_head *ptype_head(const struct packet_type *pt)
{
if (pt->type == htons(ETH_P_ALL))//type为ETH_P_ALL时，则挂在ptype_all上面
return pt->dev ? &pt->dev->ptype_all : &ptype_all;
else
return pt->dev ? &pt->dev->ptype_specific :
&ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];否则，挂在ptype_base[type&15]上面
}
综上：tcpdump在刚开始工作时创建了PF_PACKET套接字，并在全局的ptype_all中挂载了该套接字的pt(packet_type *pt),其中pt的字段func设置了相应的回调函数packet_rcv(后面将分析该函数)，到此tcpdump抓包的socket(AF_PACKET)创建完成，相应的准备工作完成。
网络收包时tcpdump进行抓包
函数调用关系
调用关系：netif_receive_skb-->netif_receive_skb-->netif_receive_skb_internal（->__netif_receive_skb）-->__netif_receive_skb_core
核心函数__netif_receive_skb_core
static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
{
......
//遍历ptype_all,cpdump在创建socket时已将其packet_type挂载到了遍历ptype_all
list_for_each_entry_rcu(ptype, &ptype_all, list) {
if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);//deliver函数回调用paket_type.func()，也就是packet_rcv
pt_prev = ptype;
}
......
}
__netif_receive_skb_core函数在遍历ptype_all时，同时也执行了deliver_skb(skb, pt_prev, orig_dev);deliver函数调用了paket_type.func()，也就是packet_rcv ，如下源码所示：
static inline int deliver_skb(struct sk_buff *skb,
struct packet_type *pt_prev,
struct net_device *orig_dev)
{
if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
return -ENOMEM;
refcount_inc(&skb->users);
return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);//调用tcpdump挂载的packet_rcv 函数
}
下面将展开packet_rcv函数进行分析;函数接收到链路层网口的数据包后，会根据应用层设置的bpf过滤数据包，符合要求的最终会加到struct sock sk 的接收缓存中。使用BPF过滤过程将在后面进行分析。
static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
struct packet_type *pt, struct net_device *orig_dev)
{
......
if (sk->sk_type != SOCK_DGRAM)// 当 SOCK_DGRAM类型的时候，会截取掉链路层的数据包，从而返回给应用层的数据包是不包含链路层数据的
skb_push(skb, skb->data - skb_mac_header(skb));
else if (skb->pkt_type == PACKET_OUTGOING) {
/* Special case: outgoing packets have ll header at head */
skb_pull(skb, skb_network_offset(skb));
}
}
......
//最后将底层网口符合应用层的数据复制到接收缓存队列中
res = run_filter(skb, sk, snaplen); //将用户指定的过滤条件使用BPF进行过滤
......
spin_lock(&sk->sk_receive_queue.lock);
po->stats.stats1.tp_packets++;
sock_skb_set_dropcount(sk, skb);
__skb_queue_tail(&sk->sk_receive_queue, skb);//将skb放到当前的接收队列中
spin_unlock(&sk->sk_receive_queue.lock);
sk->sk_data_ready(sk);
return 0;
......
}
综上一旦关联上链路层抓到的包就会copy一份给上层接口（即PF_PACKET 注册的回调函数packet_rev）. 而回调函数会根据应用层设置的bpf过滤数据包，最终放入接收缓存的数据包肯定是符合应用层想截取的数据。因此最后一步recvfrom 也就是从接收缓存的数据包copy给应用层，如下源码：
static int packet_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
int flags)
{
......
skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);//从接收缓存中接收数据
......
err = skb_copy_datagram_msg(skb, 0, msg, copied);//将最终的数据copy到用户空间
......
}
到这，网络接收数据包时的抓包过程就结束了
网络发包时tcpdump进行抓包
Linux协议栈中提供的报文发送函数有两个，一个是链路层提供给网络层的发包函数dev_queue_xmit(),另一个就说软中断发吧包函数之间调用的sch_direct_xmit(),这两个函数最终都会调用dev_hard_start_xmit()
struct sk_buff *dev_hard_start_xmit(struct sk_buff *first, struct net_device *dev,
struct netdev_queue *txq, int *ret)
{
......
while (skb) {
struct sk_buff *next = skb->next;
skb->next = NULL;
rc = xmit_one(skb, dev, txq, next != NULL);//调用xmit_one来发送一个到多个数据包
......
}
xmit_one():发送一个到多个数据包
static int xmit_one(struct sk_buff *skb, struct net_device *dev,
struct netdev_queue *txq, bool more)
{
......
if (!list_empty(&ptype_all) || !list_empty(&dev->ptype_all))
dev_queue_xmit_nit(skb, dev);//通过调用dev_queue_xmit这个网络设备接口层函数发送给driver，
......
}
dev_queue_xmit_nit():将数据包发送给driver
void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
{
......
list_for_each_entry_rcu(ptype, ptype_list, list) {
/* Never send packets back to the socket
* they originated from - MvS ([email protected])
*/
if (skb_loop_sk(ptype, skb))
continue;
if (pt_prev) {
deliver_skb(skb2, pt_prev, skb->dev);
pt_prev = ptype;
continue;
}
......
}
在遍历ptype_all时，同时也执行了deliver_skb(skb, pt_prev, orig_dev);deliver函数调用了paket_type.func()，也就是packet_rcv ，如下源码所示：
static inline int deliver_skb(struct sk_buff *skb,
struct packet_type *pt_prev,
struct net_device *orig_dev)
{
if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
return -ENOMEM;
refcount_inc(&skb->users);
return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);//调用tcpdump挂载的packet_rcv 函数
}
下面的流程就和网络收包时tcpdump进行抓包一样了(packet_rcv函数中会将用户设置的过滤条件，通过BPF进行过滤，并将过滤的数据包添加到接收队列中,应用层在libpcap库中调用recvfrom 。 PF_PACKET 协议簇模块调用packet_recvmsg 将接收队列中的数据copy应用层)
tcpdump进行抓包的内核流程梳理
-
应用层通过libpcap库：调用系统调用创建socket,
sock_fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));tcpdump在socket创建过程中创建packet_type(struct packet_type),并挂载到全局的ptype_all链表上。(同时在packet_type设置回调函数packet_rcv -
网络收包/发包时，会在各自的处理函数(收包时：
__netif_receive_skb_core，发包时：dev_queue_xmit_nit)中遍历ptype_all链表，并同时执行其回调函数，这里tcpdump的注册的回调函数就是packet_rcv -
packet_rcv函数中会将用户设置的过滤条件，通过BPF进行过滤，并将过滤的数据包添加到接收队列中
-
应用层调用recvfrom 。 PF_PACKET 协议簇模块调用packet_recvmsg 将接收队列中的数据copy应用层，到此将数据包捕获到。
总结
本文主要从tcpdump抓包时调用的libpcap库开始梳理，从socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))进入系统调用，再从内核角度对Tcpdump在收包和发包的流程分析了一遍，其实还有一个重点：BPF的过滤过程，如下源码所示：run_filter(skb, sk, snaplen)，下次文章将对BPF的过滤过程进行一些分析。
static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
struct packet_type *pt, struct net_device *orig_dev)
{
......
res = run_filter(skb, sk, snaplen); //将用户指定的过滤条件使用BPF进行过滤
......
__skb_queue_tail(&sk->sk_receive_queue, skb);//将skb放到当前的接收队列中
......
}