上篇我们分析了accept函数,他是消费者,这篇我们看看生产者是怎么实现的。我们从tcp_rcv函数开始,这个函数是一个分发器。当接收到一个tcp包的时候,底层就会调这个函数交给tcp层处理。
// daddr,saddr是ip头的字段,len为tcp头+数据长度
int tcp_rcv(
struct sk_buff *skb,
struct device *dev,
struct options *opt,
unsigned long daddr,
unsigned short len,
unsigned long saddr,
int redo,
struct inet_protocol * protocol
){
// tcp报文头
th = skb->h.th;
// 从tcp的socket哈希链表中找到对应的socket结构
sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
// 读缓冲区已满,丢弃数据包
if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
{
kfree_skb(skb, FREE_READ);
release_sock(sk);
return(0);
}
// 这个就是上篇我们说的skb中关联的sock结构体。
skb->sk=sk;
// 增加读缓冲区已使用的内存的大小
sk->rmem_alloc += skb->mem_len;
// 连接还没有建立,不是通信数据包
if(sk->state!=TCP_ESTABLISHED)
{
// 是监听socket则可能是一个syn包
if(sk->state==TCP_LISTEN)
{
// 不存在这种可能的各种情况,直接丢包
if(th->rst || !th->syn || th->ack || ip_chk_addr(daddr)!=IS_MYADDR)
{
kfree_skb(skb, FREE_READ);
release_sock(sk);
return 0;
}
// 是个syn包,建立连接
tcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
release_sock(sk);
return 0;
}
}
}
上面的函数主要的逻辑两个
1 get_sock是根据源ip、端口和目的ip、端口从tcp的sock_array哈希表里找到对应的sock结构体。
/*
num 目的端口
raddr 源ip
rnum 源端口
laddr 目的ip
*/
struct sock *get_sock(struct proto *prot, unsigned short num,
unsigned long raddr,
unsigned short rnum, unsigned long laddr)
{
struct sock *s;
struct sock *result = NULL;
int badness = -1;
unsigned short hnum;
hnum = ntohs(num);
for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
s != NULL; s = s->next)
{
int score = 0;
// 绑定的端口是否等于报文中的目的端口
if (s->num != hnum)
continue;
// 该sock已经不用了,下一个
if(s->dead && (s->state == TCP_CLOSE))
continue;
/* local address matches? */
// 绑定的ip,bind的时候赋值
if (s->saddr) {
// 报文中的目的ip是不是等于该socket绑定的ip
if (s->saddr != laddr)
continue;
score++;
}
/* remote address matches? */
// 目的ip
if (s->daddr) {
if (s->daddr != raddr)
continue;
score++;
}
/* remote port matches? */
// 目的端口
if (s->dummy_th.dest) {
if (s->dummy_th.dest != rnum)
continue;
score++;
}
/* perfect match? */
// 全匹配,直接返回
if (score == 3)
return s;
/* no, check if this is the best so far.. */
if (score <= badness)
continue;
// 记录最好的匹配项
result = s;
badness = score;
}
return result;
}
对于监听型的socket,我们在bind的时候写入了绑定的ip和端口。对于监听型的socket,是没有目的ip和目的端口的。通信型的socket才有。所以上面的函数根据服务端绑定的ip和端口。判断是否等于tcp报文中的目的ip和端口。最后拿到监听型的sock结构体。
2 tcp_conn_request处理sync包,tcp_conn_request里完成了tcp的第一次和第二次握手。
// 收到一个syn包时的处理
static void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
unsigned long daddr, unsigned long saddr,
struct options *opt, struct device *dev, unsigned long seq)
{
struct sk_buff *buff;
struct tcphdr *t1;
unsigned char *ptr;
struct sock *newsk;
struct tcphdr *th;
struct device *ndev=NULL;
int tmp;
struct rtable *rt;
th = skb->h.th;
// 过载则丢包,防止ddos,max_ack_backlog即listen的参数
if (sk->ack_backlog >= sk->max_ack_backlog)
{
tcp_statistics.TcpAttemptFails++;
kfree_skb(skb, FREE_READ);
return;
}
// 分配一个新的sock结构用于通信。accept的时候返回的就是这个sock结构体
newsk = (struct sock *) kmalloc(sizeof(struct sock), GFP_ATOMIC);
// 从listen套接字复制内容,再覆盖某些字段
memcpy(newsk, sk, sizeof(*newsk));
skb_queue_head_init(&newsk->write_queue);
skb_queue_head_init(&newsk->receive_queue);
newsk->send_head = NULL;
newsk->send_tail = NULL;
skb_queue_head_init(&newsk->back_log);
newsk->rtt = 0; /*TCP_CONNECT_TIME<<3*/
newsk->rto = TCP_TIMEOUT_INIT;
newsk->mdev = 0;
newsk->max_window = 0;
newsk->cong_window = 1;
newsk->cong_count = 0;
newsk->ssthresh = 0;
newsk->backoff = 0;
newsk->blog = 0;
newsk->intr = 0;
newsk->proc = 0;
newsk->done = 0;
newsk->partial = NULL;
newsk->pair = NULL;
newsk->wmem_alloc = 0;
newsk->rmem_alloc = 0;
newsk->localroute = sk->localroute;
newsk->max_unacked = MAX_WINDOW - TCP_WINDOW_DIFF;
newsk->err = 0;
newsk->shutdown = 0;
newsk->ack_backlog = 0;
// 期待收到的对端下一个字节的序列号
newsk->acked_seq = skb->h.th->seq+1;
// 进程可以读但是还没有读取的字节序列号
newsk->copied_seq = skb->h.th->seq+1;
// 当收到对端fin包的时候,回复的ack包中的序列号
newsk->fin_seq = skb->h.th->seq;
// 进入syn_recv状态
newsk->state = TCP_SYN_RECV;
newsk->timeout = 0;
newsk->ip_xmit_timeout = 0;
// 下一个发送的字节的序列号
newsk->write_seq = seq;
// 可发送的字节序列号最大值
newsk->window_seq = newsk->write_seq;
// 序列号小于rcv_ack_seq的数据包都已经收到
newsk->rcv_ack_seq = newsk->write_seq;
newsk->urg_data = 0;
newsk->retransmits = 0;
// 关闭套接字的时候不需要等待一段时间才能关闭
newsk->linger=0;
newsk->destroy = 0;
init_timer(&newsk->timer);
newsk->timer.data = (unsigned long)newsk;
newsk->timer.function = &net_timer;
init_timer(&newsk->retransmit_timer);
newsk->retransmit_timer.data = (unsigned long)newsk;
newsk->retransmit_timer.function=&retransmit_timer;
// 记录端口,发送ack和get_sock的时候用
newsk->dummy_th.source = skb->h.th->dest;
newsk->dummy_th.dest = skb->h.th->source;
// 记录ip,发送ack和get_sock的时候用
newsk->daddr = saddr;
newsk->saddr = daddr;
// 放到tcp的sock哈希表
put_sock(newsk->num,newsk);
// tcp头
newsk->dummy_th.res1 = 0;
newsk->dummy_th.doff = 6;
newsk->dummy_th.fin = 0;
newsk->dummy_th.syn = 0;
newsk->dummy_th.rst = 0;
newsk->dummy_th.psh = 0;
newsk->dummy_th.ack = 0;
newsk->dummy_th.urg = 0;
newsk->dummy_th.res2 = 0;
newsk->acked_seq = skb->h.th->seq + 1;
newsk->copied_seq = skb->h.th->seq + 1;
newsk->socket = NULL;
newsk->ip_ttl=sk->ip_ttl;
newsk->ip_tos=skb->ip_hdr->tos;
rt=ip_rt_route(saddr, NULL,NULL);
if(rt!=NULL && (rt->rt_flags&RTF_WINDOW))
newsk->window_clamp = rt->rt_window;
else
newsk->window_clamp = 0;
if (sk->user_mss)
newsk->mtu = sk->user_mss;
else if(rt!=NULL && (rt->rt_flags&RTF_MSS))
newsk->mtu = rt->rt_mss - HEADER_SIZE;
else
{
#ifdef CONFIG_INET_SNARL /* Sub Nets Are Local */
if ((saddr ^ daddr) & default_mask(saddr))
#else
if ((saddr ^ daddr) & dev->pa_mask)
#endif
newsk->mtu = 576 - HEADER_SIZE;
else
newsk->mtu = MAX_WINDOW;
}
// mtu等于设备的mtu减去ip头和tcp头的大小
newsk->mtu = min(newsk->mtu, dev->mtu - HEADER_SIZE);
// 解析tcp选项
tcp_options(newsk,skb->h.th);
// 分配一个skb
buff = newsk->prot->wmalloc(newsk, MAX_SYN_SIZE, 1, GFP_ATOMIC);
// skb和sock关联,4个字节是用于tcp mss选项,告诉对端自己的mss
buff->len = sizeof(struct tcphdr)+4;
buff->sk = newsk;
buff->localroute = newsk->localroute;
t1 =(struct tcphdr *) buff->data;
// 构造ip和mac头
tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
buff->len += tmp;
// tcp头
t1 =(struct tcphdr *)((char *)t1 +tmp);
memcpy(t1, skb->h.th, sizeof(*t1));
buff->h.seq = newsk->write_seq;
t1->dest = skb->h.th->source;
t1->source = newsk->dummy_th.source;
t1->seq = ntohl(newsk->write_seq++);
// 是个ack包,即第二次握手
t1->ack = 1;
newsk->window = tcp_select_window(newsk);
newsk->sent_seq = newsk->write_seq;
t1->window = ntohs(newsk->window);
t1->res1 = 0;
t1->res2 = 0;
t1->rst = 0;
t1->urg = 0;
t1->psh = 0;
t1->syn = 1;
t1->ack_seq = ntohl(skb->h.th->seq+1);
t1->doff = sizeof(*t1)/4+1;
ptr =(unsigned char *)(t1+1);
ptr[0] = 2;
ptr[1] = 4;
ptr[2] = ((newsk->mtu) >> 8) & 0xff;
ptr[3] =(newsk->mtu) & 0xff;
tcp_send_check(t1, daddr, saddr, sizeof(*t1)+4, newsk);
// 发送ack,即第二次握手
newsk->prot->queue_xmit(newsk, ndev, buff, 0);
reset_xmit_timer(newsk, TIME_WRITE , TCP_TIMEOUT_INIT);
// skb关联的socket为newsk,accept的时候摘取skb时即拿到该socket返回给应用层
skb->sk = newsk;
// 把skb中数据的大小算在newsk中
sk->rmem_alloc -= skb->mem_len;
newsk->rmem_alloc += skb->mem_len;
// 插入监听型socket的接收队列,accept的时候摘取
skb_queue_tail(&sk->receive_queue,skb);
// 连接队列节点个数加1
sk->ack_backlog++;
release_sock(newsk);
tcp_statistics.TcpOutSegs++;
}
这个函数主要是生成一个sock结构体,挂载到skb中,然后把skb插入队列中。最后发送ack完成第二次握手。
我们继续来看第三次握手。前面说过tcp_rcv是处理tcp数据包的。所以我们还是回到这个函数。
// daddr,saddr是ip头的字段,len为tcp头+数据长度
int tcp_rcv(
struct sk_buff *skb,
struct device *dev,
struct options *opt,
unsigned long daddr,
unsigned short len,
unsigned long saddr,
int redo,
struct inet_protocol * protocol
){
// 从tcp的socket哈希链表中找到对应的socket结构
sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
// 省略大量代码
if(sk->state==TCP_SYN_RECV)
{
tcp_set_state(sk, TCP_ESTABLISHED);
}
}
这里的逻辑很简单,就是设置sock结构体的状态为建立。但是我们发现,get_sock的时候,拿到的不再是listen型的那个sock结构体了,而是tcp_conn_request中生成的那个。因为tcp_conn_request生成的sock里设置了源ip、端口、目的ip、端口。get_sock匹配的时候会全匹配到这个新的sock。
三次握手的过程中,第一次握手的时候,在监听型的sock结构体的接收队列里插入了一个sock节点。在第三次握手的时候,修改这个sock状态为已连接。我们看看accept函数是怎么摘取这个队列中的节点的。
// 返回一个完成的连接
static struct sk_buff *tcp_dequeue_established(struct sock *s)
{
struct sk_buff *skb;
unsigned long flags;
save_flags(flags);
cli();
skb=tcp_find_established(s);
if(skb!=NULL)
skb_unlink(skb); /* Take it off the queue */
restore_flags(flags);
return skb;
}
// 找出已经完成三次握手的socket
static struct sk_buff *tcp_find_established(struct sock *s)
{
struct sk_buff *p=skb_peek(&s->receive_queue);
if(p==NULL)
return NULL;
do
{
if(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
return p;
p=p->next;
}
while(p!=(struct sk_buff *)&s->receive_queue);
return NULL;
}
就是找到状态为TCP_ESTABLISHED的节点返回。另外监听型socket和通信型socket他的接收队列意义是不一样的,前者是已完成连接或者正在建立连接的队列,后者是数据包队列。这一版的linux把正在连接和已经完成连接的sock都放到一个队列里维护,现在的版本据说已经分为两个队列了。