Linux内核--网络栈实现分析（二）--数据包的传递过程（上）

本文分析基于Linux Kernel 1.2.13

原创作品，转载请标明http://blog.csdn.net/yming0221/article/details/7492423

更多请看专栏，地址http://blog.csdn.net/column/details/linux-kernel-net.html

作者：闫明

注：标题中的”（上）“，”（下）“表示分析过程基于数据包的传递方向：”（上）“表示分析是从底层向上分析、”（下）“表示分析是从上向下分析。

上一篇博文中我们从宏观上分析了Linux内核中网络栈的初始化过程，这里我们再从宏观上分析一下一个数据包在各网络层的传递的过程。

我们知道网络的OSI模型和TCP/IP模型层次结构如下：

上文中我们看到了网络栈的层次结构：

我们就从最底层开始追溯一个数据包的传递流程。

1、网络接口层

* 硬件监听物理介质，进行数据的接收，当接收的数据填满了缓冲区，硬件就会产生中断，中断产生后，系统会转向中断服务子程序。

* 在中断服务子程序中，数据会从硬件的缓冲区复制到内核的空间缓冲区，并包装成一个数据结构（sk_buff），然后调用对驱动层的接口函数netif_rx()将数据包发送给链路层。该函数的实现在net/inet/dev.c中，（在整个网络栈实现中dev.c文件的作用重大，它衔接了其下的驱动层和其上的网络层，可以称它为链路层模块的实现）

该函数的实现如下：

[cpp]  view plain copy

1. /* 
2.  *  Receive a packet from a device driver and queue it for the upper 
3.  *  (protocol) levels.  It always succeeds. This is the recommended  
4.  *  interface to use. 
5.  *    从设备驱动层接受到的数据发送到协议的 
6.  *    上层，该函数实际是一个接口。 
7.  */  
8.   
9. void netif_rx(struct sk_buff *skb)  
10. {  
11.     static int dropping = 0;  
12.   
13.     /* 
14.      *  Any received buffers are un-owned and should be discarded 
15.      *  when freed. These will be updated later as the frames get 
16.      *  owners. 
17.      */  
18.     skb->sk = NULL;  
19.     skb->free = 1;  
20.     if(skb->stamp.tv_sec==0)  
21.         skb->stamp = xtime;  
22.   
23.     /* 
24.      *  Check that we aren't overdoing things. 
25.      */  
26.   
27.     if (!backlog_size)  
28.         dropping = 0;  
29.     else if (backlog_size > 300)  
30.         dropping = 1;  
31.   
32.     if (dropping)   
33.     {  
34.         kfree_skb(skb, FREE_READ);  
35.         return;  
36.     }  
37.   
38.     /* 
39.      *  Add it to the "backlog" queue.  
40.      */  
41. #ifdef CONFIG_SKB_CHECK  
42.     IS_SKB(skb);  
43. #endif    
44.     skb_queue_tail(&backlog,skb);//加入队列backlog  
45.     backlog_size++;  
46.     
47.     /* 
48.      *  If any packet arrived, mark it for processing after the 
49.      *  hardware interrupt returns. 
50.      */  
51.   
52.     mark_bh(NET_BH);//下半部分bottom half技术可以减少中断处理程序的执行时间  
53.     return;  
54. }  

该函数中用到了bootom half技术，该技术的原理是将中断处理程序人为的分为两部分，上半部分是实时性要求较高的任务，后半部分可以稍后完成，这样就可以节省中断程序的处理时间。可整体的提高系统的性能。该技术将会在后续的博文中详细分析。

我们从上一篇分析中知道，在网络栈初始化的时候，已经将NET的下半部分执行函数定义成了net_bh(在socket.c文件中1375行左右)

[cpp]  view plain copy

1. bh_base[NET_BH].routine= net_bh;//设置NET 下半部分的处理函数为net_bh  

* 函数net_bh的实现在net/inet/dev.c中

[cpp]  view plain copy

1. /* 
2.  *  When we are called the queue is ready to grab, the interrupts are 
3.  *  on and hardware can interrupt and queue to the receive queue a we 
4.  *  run with no problems. 
5.  *  This is run as a bottom half after an interrupt handler that does 
6.  *  mark_bh(NET_BH); 
7.  */  
8.    
9. void net_bh(void *tmp)  
10. {  
11.     struct sk_buff *skb;  
12.     struct packet_type *ptype;  
13.     struct packet_type *pt_prev;  
14.     unsigned short type;  
15.   
16.     /* 
17.      *  Atomically check and mark our BUSY state.  
18.      */  
19.   
20.     if (set_bit(1, (void*)&in_bh))//标记BUSY状态  
21.         return;  
22.   
23.     /* 
24.      *  Can we send anything now? We want to clear the 
25.      *  decks for any more sends that get done as we 
26.      *  process the input. 
27.      */  
28.   
29.     dev_transmit();//调用dev_tinit()函数发送数据  
30.     
31.     /* 
32.      *  Any data left to process. This may occur because a 
33.      *  mark_bh() is done after we empty the queue including 
34.      *  that from the device which does a mark_bh() just after 
35.      */  
36.   
37.     cli();//防止队列操作错误，需要关中断和开中断  
38.       
39.     /* 
40.      *  While the queue is not empty 
41.      */  
42.        
43.     while((skb=skb_dequeue(&backlog))!=NULL)//出队直到队列为空  
44.     {  
45.         /* 
46.          *  We have a packet. Therefore the queue has shrunk 
47.          */  
48.         backlog_size--;//队列元素个数减一  
49.   
50.         sti();  
51.           
52.            /* 
53.         *   Bump the pointer to the next structure. 
54.         *   This assumes that the basic 'skb' pointer points to 
55.         *   the MAC header, if any (as indicated by its "length" 
56.         *   field).  Take care now! 
57.         */  
58.   
59.         skb->h.raw = skb->data + skb->dev->hard_header_len;  
60.         skb->len -= skb->dev->hard_header_len;  
61.   
62.            /* 
63.         *   Fetch the packet protocol ID.  This is also quite ugly, as 
64.         *   it depends on the protocol driver (the interface itself) to 
65.         *   know what the type is, or where to get it from.  The Ethernet 
66.         *   interfaces fetch the ID from the two bytes in the Ethernet MAC 
67.         *   header (the h_proto field in struct ethhdr), but other drivers 
68.         *   may either use the ethernet ID's or extra ones that do not 
69.         *   clash (eg ETH_P_AX25). We could set this before we queue the 
70.         *   frame. In fact I may change this when I have time. 
71.         */  
72.           
73.         type = skb->dev->type_trans(skb, skb->dev);//取出该数据包所属的协议类型  
74.   
75.         /* 
76.          *  We got a packet ID.  Now loop over the "known protocols" 
77.          *  table (which is actually a linked list, but this will 
78.          *  change soon if I get my way- FvK), and forward the packet 
79.          *  to anyone who wants it. 
80.          * 
81.          *  [FvK didn't get his way but he is right this ought to be 
82.          *  hashed so we typically get a single hit. The speed cost 
83.          *  here is minimal but no doubt adds up at the 4,000+ pkts/second 
84.          *  rate we can hit flat out] 
85.          */  
86.         pt_prev = NULL;  
87.         for (ptype = ptype_base; ptype != NULL; ptype = ptype->next) //遍历ptype_base所指向的网络协议队列  
88.         {  
89.             //判断协议号是否匹配  
90.             if ((ptype->type == type || ptype->type == htons(ETH_P_ALL)) && (!ptype->dev || ptype->dev==skb->dev))  
91.             {  
92.                 /* 
93.                  *  We already have a match queued. Deliver 
94.                  *  to it and then remember the new match 
95.                  */  
96.                 if(pt_prev)  
97.                 {  
98.                     struct sk_buff *skb2;  
99.   
100.                     skb2=skb_clone(skb, GFP_ATOMIC);//复制数据包结构  
101.   
102.                     /* 
103.                      *  Kick the protocol handler. This should be fast 
104.                      *  and efficient code. 
105.                      */  
106.   
107.                     if(skb2)  
108.                         pt_prev->func(skb2, skb->dev, pt_prev);//调用相应协议的处理函数，  
109.                                             //这里和网络协议的种类有关系  
110.                                             //如IP 协议的处理函数就是ip_rcv  
111.                 }  
112.                 /* Remember the current last to do */  
113.                 pt_prev=ptype;  
114.             }  
115.         } /* End of protocol list loop */  
116.           
117.         /* 
118.          *  Is there a last item to send to ? 
119.          */  
120.   
121.         if(pt_prev)  
122.             pt_prev->func(skb, skb->dev, pt_prev);  
123.         /* 
124.          *  Has an unknown packet has been received ? 
125.          */  
126.        
127.         else  
128.             kfree_skb(skb, FREE_WRITE);  
129.   
130.         /* 
131.          *  Again, see if we can transmit anything now.  
132.          *  [Ought to take this out judging by tests it slows 
133.          *   us down not speeds us up] 
134.          */  
135.   
136.         dev_transmit();  
137.         cli();  
138.     }   /* End of queue loop */  
139.       
140.     /* 
141.      *  We have emptied the queue 
142.      */  
143.        
144.     in_bh = 0;//BUSY状态还原  
145.     sti();  
146.       
147.     /* 
148.      *  One last output flush. 
149.      */  
150.        
151.     dev_transmit();//清空缓冲区  
152. }  

2、网络层
* 就以IP数据包为例来说明，那么从链路层向网络层传递时将调用ip_rcv函数。该函数完成本层的处理后会根据IP首部中使用的传输层协议来调用相应协议的处理函数。

UDP对应udp_rcv、TCP对应tcp_rcv、ICMP对应icmp_rcv、IGMP对应igmp_rcv（虽然这里的ICMP,IGMP一般成为网络层协议，但是实际上他们都封装在IP协议里面，作为传输层对待）

这个函数比较复杂，后续会详细分析。这里粘贴一下，让我们对整体了解更清楚

[cpp]  view plain copy

1. /* 
2.  *  This function receives all incoming IP datagrams. 
3.  */  
4.   
5. int ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)  
6. {  
7.     struct iphdr *iph = skb->h.iph;  
8.     struct sock *raw_sk=NULL;  
9.     unsigned char hash;  
10.     unsigned char flag = 0;  
11.     unsigned char opts_p = 0;   /* Set iff the packet has options. */  
12.     struct inet_protocol *ipprot;  
13.     static struct options opt; /* since we don't use these yet, and they 
14.                 take up stack space. */  
15.     int brd=IS_MYADDR;  
16.     int is_frag=0;  
17. #ifdef CONFIG_IP_FIREWALL  
18.     int err;  
19. #endif    
20.   
21.     ip_statistics.IpInReceives++;  
22.   
23.     /* 
24.      *  Tag the ip header of this packet so we can find it 
25.      */  
26.   
27.     skb->ip_hdr = iph;  
28.   
29.     /* 
30.      *  Is the datagram acceptable? 
31.      * 
32.      *  1.  Length at least the size of an ip header 
33.      *  2.  Version of 4 
34.      *  3.  Checksums correctly. [Speed optimisation for later, skip loopback checksums] 
35.      *  (4. We ought to check for IP multicast addresses and undefined types.. does this matter ?) 
36.      */  
37.   
38.     if (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 ||  
39.         skb->len<ntohs(iph->tot_len) || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0)  
40.     {  
41.         ip_statistics.IpInHdrErrors++;  
42.         kfree_skb(skb, FREE_WRITE);  
43.         return(0);  
44.     }  
45.       
46.     /* 
47.      *  See if the firewall wants to dispose of the packet.  
48.      */  
49.   
50. #ifdef  CONFIG_IP_FIREWALL  
51.       
52.     if ((err=ip_fw_chk(iph,dev,ip_fw_blk_chain,ip_fw_blk_policy, 0))!=1)  
53.     {  
54.         if(err==-1)  
55.             icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);  
56.         kfree_skb(skb, FREE_WRITE);  
57.         return 0;     
58.     }  
59.   
60. #endif  
61.       
62.     /* 
63.      *  Our transport medium may have padded the buffer out. Now we know it 
64.      *  is IP we can trim to the true length of the frame. 
65.      */  
66.   
67.     skb->len=ntohs(iph->tot_len);  
68.   
69.     /* 
70.      *  Next analyse the packet for options. Studies show under one packet in 
71.      *  a thousand have options.... 
72.      */  
73.   
74.     if (iph->ihl != 5)  
75.     {   /* Fast path for the typical optionless IP packet. */  
76.         memset((char *) &opt, 0, sizeof(opt));  
77.         if (do_options(iph, &opt) != 0)  
78.             return 0;  
79.         opts_p = 1;  
80.     }  
81.   
82.     /* 
83.      *  Remember if the frame is fragmented. 
84.      */  
85.        
86.     if(iph->frag_off)  
87.     {  
88.         if (iph->frag_off & 0x0020)  
89.             is_frag|=1;  
90.         /* 
91.          *  Last fragment ? 
92.          */  
93.       
94.         if (ntohs(iph->frag_off) & 0x1fff)  
95.             is_frag|=2;  
96.     }  
97.       
98.     /* 
99.      *  Do any IP forwarding required.  chk_addr() is expensive -- avoid it someday. 
100.      * 
101.      *  This is inefficient. While finding out if it is for us we could also compute 
102.      *  the routing table entry. This is where the great unified cache theory comes 
103.      *  in as and when someone implements it 
104.      * 
105.      *  For most hosts over 99% of packets match the first conditional 
106.      *  and don't go via ip_chk_addr. Note: brd is set to IS_MYADDR at 
107.      *  function entry. 
108.      */  
109.   
110.     if ( iph->daddr != skb->dev->pa_addr && (brd = ip_chk_addr(iph->daddr)) == 0)  
111.     {  
112.         /* 
113.          *  Don't forward multicast or broadcast frames. 
114.          */  
115.   
116.         if(skb->pkt_type!=PACKET_HOST || brd==IS_BROADCAST)  
117.         {  
118.             kfree_skb(skb,FREE_WRITE);  
119.             return 0;  
120.         }  
121.   
122.         /* 
123.          *  The packet is for another target. Forward the frame 
124.          */  
125.   
126. #ifdef CONFIG_IP_FORWARD  
127.         ip_forward(skb, dev, is_frag);  
128. #else  
129. /*      printk("Machine %lx tried to use us as a forwarder to %lx but we have forwarding disabled!\n", 
130.             iph->saddr,iph->daddr);*/  
131.         ip_statistics.IpInAddrErrors++;  
132. #endif  
133.         /* 
134.          *  The forwarder is inefficient and copies the packet. We 
135.          *  free the original now. 
136.          */  
137.   
138.         kfree_skb(skb, FREE_WRITE);  
139.         return(0);  
140.     }  
141.       
142. #ifdef CONFIG_IP_MULTICAST    
143.   
144.     if(brd==IS_MULTICAST && iph->daddr!=IGMP_ALL_HOSTS && !(dev->flags&IFF_LOOPBACK))  
145.     {  
146.         /* 
147.          *  Check it is for one of our groups 
148.          */  
149.         struct ip_mc_list *ip_mc=dev->ip_mc_list;  
150.         do  
151.         {  
152.             if(ip_mc==NULL)  
153.             {     
154.                 kfree_skb(skb, FREE_WRITE);  
155.                 return 0;  
156.             }  
157.             if(ip_mc->multiaddr==iph->daddr)  
158.                 break;  
159.             ip_mc=ip_mc->next;  
160.         }  
161.         while(1);  
162.     }  
163. #endif  
164.     /* 
165.      *  Account for the packet 
166.      */  
167.        
168. #ifdef CONFIG_IP_ACCT  
169.     ip_acct_cnt(iph,dev, ip_acct_chain);  
170. #endif    
171.   
172.     /* 
173.      * Reassemble IP fragments. 
174.      */  
175.   
176.     if(is_frag)  
177.     {  
178.         /* Defragment. Obtain the complete packet if there is one */  
179.         skb=ip_defrag(iph,skb,dev);  
180.         if(skb==NULL)  
181.             return 0;  
182.         skb->dev = dev;  
183.         iph=skb->h.iph;  
184.     }  
185.       
186.            
187.   
188.     /* 
189.      *  Point into the IP datagram, just past the header. 
190.      */  
191.   
192.     skb->ip_hdr = iph;  
193.     skb->h.raw += iph->ihl*4;  
194.       
195.     /* 
196.      *  Deliver to raw sockets. This is fun as to avoid copies we want to make no surplus copies. 
197.      */  
198.        
199.     hash = iph->protocol & (SOCK_ARRAY_SIZE-1);  
200.       
201.     /* If there maybe a raw socket we must check - if not we don't care less */  
202.     if((raw_sk=raw_prot.sock_array[hash])!=NULL)  
203.     {  
204.         struct sock *sknext=NULL;  
205.         struct sk_buff *skb1;  
206.         raw_sk=get_sock_raw(raw_sk, hash,  iph->saddr, iph->daddr);  
207.         if(raw_sk)  /* Any raw sockets */  
208.         {  
209.             do  
210.             {  
211.                 /* Find the next */  
212.                 sknext=get_sock_raw(raw_sk->next, hash, iph->saddr, iph->daddr);  
213.                 if(sknext)  
214.                     skb1=skb_clone(skb, GFP_ATOMIC);  
215.                 else  
216.                     break;  /* One pending raw socket left */  
217.                 if(skb1)  
218.                     raw_rcv(raw_sk, skb1, dev, iph->saddr,iph->daddr);  
219.                 raw_sk=sknext;  
220.             }  
221.             while(raw_sk!=NULL);  
222.             /* Here either raw_sk is the last raw socket, or NULL if none */  
223.             /* We deliver to the last raw socket AFTER the protocol checks as it avoids a surplus copy */  
224.         }  
225.     }  
226.       
227.     /* 
228.      *  skb->h.raw now points at the protocol beyond the IP header. 
229.      */  
230.   
231.     hash = iph->protocol & (MAX_INET_PROTOS -1);  
232.     for (ipprot = (struct inet_protocol *)inet_protos[hash];ipprot != NULL;ipprot=(struct inet_protocol *)ipprot->next)  
233.     {  
234.         struct sk_buff *skb2;  
235.   
236.         if (ipprot->protocol != iph->protocol)  
237.             continue;  
238.        /* 
239.     *   See if we need to make a copy of it.  This will 
240.     *   only be set if more than one protocol wants it. 
241.     *   and then not for the last one. If there is a pending 
242.     *   raw delivery wait for that 
243.     */  
244.         if (ipprot->copy || raw_sk)  
245.         {  
246.             skb2 = skb_clone(skb, GFP_ATOMIC);  
247.             if(skb2==NULL)  
248.                 continue;  
249.         }  
250.         else  
251.         {  
252.             skb2 = skb;  
253.         }  
254.         flag = 1;  
255.   
256.            /* 
257.         * Pass on the datagram to each protocol that wants it, 
258.         * based on the datagram protocol.  We should really 
259.         * check the protocol handler's return values here... 
260.         */  
261.         ipprot->handler(skb2, dev, opts_p ? &opt : 0, iph->daddr,  
262.                 (ntohs(iph->tot_len) - (iph->ihl * 4)),  
263.                 iph->saddr, 0, ipprot);  
264.   
265.     }  
266.   
267.     /* 
268.      * All protocols checked. 
269.      * If this packet was a broadcast, we may *not* reply to it, since that 
270.      * causes (proven, grin) ARP storms and a leakage of memory (i.e. all 
271.      * ICMP reply messages get queued up for transmission...) 
272.      */  
273.   
274.     if(raw_sk!=NULL)    /* Shift to last raw user */  
275.         raw_rcv(raw_sk, skb, dev, iph->saddr, iph->daddr);  
276.     else if (!flag)     /* Free and report errors */  
277.     {  
278.         if (brd != IS_BROADCAST && brd!=IS_MULTICAST)  
279.             icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0, dev);  
280.         kfree_skb(skb, FREE_WRITE);  
281.     }  
282.   
283.     return(0);  
284. }  

3、传输层

如果在IP数据报的首部标明的是使用TCP传输数据，则在上述函数中会调用tcp_rcv函数。该函数的大体处理流程为：

“所有使用TCP 协议的套接字对应sock 结构都被挂入tcp_prot 全局变量表示的proto 结构之sock_array 数组中，采用以本地端口号为索引的插入方式，所以当tcp_rcv 函数接收到一个数据包，在完成必要的检查和处理后，其将以TCP 协议首部中目的端口号（对于一个接收的数据包而言，其目的端口号就是本地所使用的端口号）为索引，在tcp_prot 对应sock 结构之sock_array 数组中得到正确的sock 结构队列，在辅之以其他条件遍历该队列进行对应sock 结构的查询，在得到匹配的sock 结构后，将数据包挂入该sock 结构中的缓存队列中（由sock 结构中receive_queue 字段指向），从而完成数据包的最终接收。”

该函数的实现也会比较复杂，这是由TCP协议的复杂功能决定的。附代码如下：

[cpp]  view plain copy

1. /* 
2.  *  A TCP packet has arrived. 
3.  */  
4.    
5. int tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,  
6.     unsigned long daddr, unsigned short len,  
7.     unsigned long saddr, int redo, struct inet_protocol * protocol)  
8. {  
9.     struct tcphdr *th;  
10.     struct sock *sk;  
11.     int syn_ok=0;  
12.       
13.     if (!skb)   
14.     {  
15.         printk("IMPOSSIBLE 1\n");  
16.         return(0);  
17.     }  
18.   
19.     if (!dev)   
20.     {  
21.         printk("IMPOSSIBLE 2\n");  
22.         return(0);  
23.     }  
24.     
25.     tcp_statistics.TcpInSegs++;  
26.     
27.     if(skb->pkt_type!=PACKET_HOST)  
28.     {  
29.         kfree_skb(skb,FREE_READ);  
30.         return(0);  
31.     }  
32.     
33.     th = skb->h.th;  
34.   
35.     /* 
36.      *  Find the socket. 
37.      */  
38.   
39.     sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);  
40.   
41.     /* 
42.      *  If this socket has got a reset it's to all intents and purposes  
43.      *  really dead. Count closed sockets as dead. 
44.      * 
45.      *  Note: BSD appears to have a bug here. A 'closed' TCP in BSD 
46.      *  simply drops data. This seems incorrect as a 'closed' TCP doesn't 
47.      *  exist so should cause resets as if the port was unreachable. 
48.      */  
49.        
50.     if (sk!=NULL && (sk->zapped || sk->state==TCP_CLOSE))  
51.         sk=NULL;  
52.   
53.     if (!redo)   
54.     {  
55.         if (tcp_check(th, len, saddr, daddr ))   
56.         {  
57.             skb->sk = NULL;  
58.             kfree_skb(skb,FREE_READ);  
59.             /* 
60.              *  We don't release the socket because it was 
61.              *  never marked in use. 
62.              */  
63.             return(0);  
64.         }  
65.         th->seq = ntohl(th->seq);  
66.   
67.         /* See if we know about the socket. */  
68.         if (sk == NULL)   
69.         {  
70.             /* 
71.              *  No such TCB. If th->rst is 0 send a reset (checked in tcp_reset) 
72.              */  
73.             tcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);  
74.             skb->sk = NULL;  
75.             /* 
76.              *  Discard frame 
77.              */  
78.             kfree_skb(skb, FREE_READ);  
79.             return(0);  
80.         }  
81.   
82.         skb->len = len;  
83.         skb->acked = 0;  
84.         skb->used = 0;  
85.         skb->free = 0;  
86.         skb->saddr = daddr;  
87.         skb->daddr = saddr;  
88.       
89.         /* We may need to add it to the backlog here. */  
90.         cli();  
91.         if (sk->inuse)   
92.         {  
93.             skb_queue_tail(&sk->back_log, skb);  
94.             sti();  
95.             return(0);  
96.         }  
97.         sk->inuse = 1;  
98.         sti();  
99.     }  
100.     else  
101.     {  
102.         if (sk==NULL)   
103.         {  
104.             tcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);  
105.             skb->sk = NULL;  
106.             kfree_skb(skb, FREE_READ);  
107.             return(0);  
108.         }  
109.     }  
110.   
111.   
112.     if (!sk->prot)   
113.     {  
114.         printk("IMPOSSIBLE 3\n");  
115.         return(0);  
116.     }  
117.   
118.   
119.     /* 
120.      *  Charge the memory to the socket.  
121.      */  
122.        
123.     if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)   
124.     {  
125.         kfree_skb(skb, FREE_READ);  
126.         release_sock(sk);  
127.         return(0);  
128.     }  
129.   
130.     skb->sk=sk;  
131.     sk->rmem_alloc += skb->mem_len;  
132.   
133.     /* 
134.      *  This basically follows the flow suggested by RFC793, with the corrections in RFC1122. We 
135.      *  don't implement precedence and we process URG incorrectly (deliberately so) for BSD bug 
136.      *  compatibility. We also set up variables more thoroughly [Karn notes in the 
137.      *  KA9Q code the RFC793 incoming segment rules don't initialise the variables for all paths]. 
138.      */  
139.   
140.     if(sk->state!=TCP_ESTABLISHED)       /* Skip this lot for normal flow */  
141.     {  
142.       
143.         /* 
144.          *  Now deal with unusual cases. 
145.          */  
146.        
147.         if(sk->state==TCP_LISTEN)  
148.         {  
149.             if(th->ack)  /* These use the socket TOS.. might want to be the received TOS */  
150.                 tcp_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl);  
151.   
152.             /* 
153.              *  We don't care for RST, and non SYN are absorbed (old segments) 
154.              *  Broadcast/multicast SYN isn't allowed. Note - bug if you change the 
155.              *  netmask on a running connection it can go broadcast. Even Sun's have 
156.              *  this problem so I'm ignoring it  
157.              */  
158.                  
159.             if(th->rst || !th->syn || th->ack || ip_chk_addr(daddr)!=IS_MYADDR)  
160.             {  
161.                 kfree_skb(skb, FREE_READ);  
162.                 release_sock(sk);  
163.                 return 0;  
164.             }  
165.           
166.             /*   
167.              *  Guess we need to make a new socket up  
168.              */  
169.           
170.             tcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());  
171.           
172.             /* 
173.              *  Now we have several options: In theory there is nothing else 
174.              *  in the frame. KA9Q has an option to send data with the syn, 
175.              *  BSD accepts data with the syn up to the [to be] advertised window 
176.              *  and Solaris 2.1 gives you a protocol error. For now we just ignore 
177.              *  it, that fits the spec precisely and avoids incompatibilities. It 
178.              *  would be nice in future to drop through and process the data. 
179.              */  
180.                
181.             release_sock(sk);  
182.             return 0;  
183.         }  
184.       
185.         /* retransmitted SYN? */  
186.         if (sk->state == TCP_SYN_RECV && th->syn && th->seq+1 == sk->acked_seq)  
187.         {  
188.             kfree_skb(skb, FREE_READ);  
189.             release_sock(sk);  
190.             return 0;  
191.         }  
192.           
193.         /* 
194.          *  SYN sent means we have to look for a suitable ack and either reset 
195.          *  for bad matches or go to connected  
196.          */  
197.          
198.         if(sk->state==TCP_SYN_SENT)  
199.         {  
200.             /* Crossed SYN or previous junk segment */  
201.             if(th->ack)  
202.             {  
203.                 /* We got an ack, but it's not a good ack */  
204.                 if(!tcp_ack(sk,th,saddr,len))  
205.                 {  
206.                     /* Reset the ack - its an ack from a  
207.                        different connection  [ th->rst is checked in tcp_reset()] */  
208.                     tcp_statistics.TcpAttemptFails++;  
209.                     tcp_reset(daddr, saddr, th,  
210.                         sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);  
211.                     kfree_skb(skb, FREE_READ);  
212.                     release_sock(sk);  
213.                     return(0);  
214.                 }  
215.                 if(th->rst)  
216.                     return tcp_std_reset(sk,skb);  
217.                 if(!th->syn)  
218.                 {  
219.                     /* A valid ack from a different connection 
220.                        start. Shouldn't happen but cover it */  
221.                     kfree_skb(skb, FREE_READ);  
222.                     release_sock(sk);  
223.                     return 0;  
224.                 }  
225.                 /* 
226.                  *  Ok.. it's good. Set up sequence numbers and 
227.                  *  move to established. 
228.                  */  
229.                 syn_ok=1;   /* Don't reset this connection for the syn */  
230.                 sk->acked_seq=th->seq+1;  
231.                 sk->fin_seq=th->seq;  
232.                 tcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr);  
233.                 tcp_set_state(sk, TCP_ESTABLISHED);  
234.                 tcp_options(sk,th);  
235.                 sk->dummy_th.dest=th->source;  
236.                 sk->copied_seq = sk->acked_seq;  
237.                 if(!sk->dead)  
238.                 {  
239.                     sk->state_change(sk);  
240.                     sock_wake_async(sk->socket, 0);  
241.                 }  
242.                 if(sk->max_window==0)  
243.                 {  
244.                     sk->max_window = 32;  
245.                     sk->mss = min(sk->max_window, sk->mtu);  
246.                 }  
247.             }  
248.             else  
249.             {  
250.                 /* See if SYN's cross. Drop if boring */  
251.                 if(th->syn && !th->rst)  
252.                 {  
253.                     /* Crossed SYN's are fine - but talking to 
254.                        yourself is right out... */  
255.                     if(sk->saddr==saddr && sk->daddr==daddr &&  
256.                         sk->dummy_th.source==th->source &&  
257.                         sk->dummy_th.dest==th->dest)  
258.                     {  
259.                         tcp_statistics.TcpAttemptFails++;  
260.                         return tcp_std_reset(sk,skb);  
261.                     }  
262.                     tcp_set_state(sk,TCP_SYN_RECV);  
263.                       
264.                     /* 
265.                      *  FIXME: 
266.                      *  Must send SYN|ACK here 
267.                      */  
268.                 }         
269.                 /* Discard junk segment */  
270.                 kfree_skb(skb, FREE_READ);  
271.                 release_sock(sk);  
272.                 return 0;  
273.             }  
274.             /* 
275.              *  SYN_RECV with data maybe.. drop through 
276.              */  
277.             goto rfc_step6;  
278.         }  
279.   
280.     /* 
281.      *  BSD has a funny hack with TIME_WAIT and fast reuse of a port. There is 
282.      *  a more complex suggestion for fixing these reuse issues in RFC1644 
283.      *  but not yet ready for general use. Also see RFC1379. 
284.      */  
285.       
286. #define BSD_TIME_WAIT  
287. #ifdef BSD_TIME_WAIT  
288.         if (sk->state == TCP_TIME_WAIT && th->syn && sk->dead &&   
289.             after(th->seq, sk->acked_seq) && !th->rst)  
290.         {  
291.             long seq=sk->write_seq;  
292.             if(sk->debug)  
293.                 printk("Doing a BSD time wait\n");  
294.             tcp_statistics.TcpEstabResets++;         
295.             sk->rmem_alloc -= skb->mem_len;  
296.             skb->sk = NULL;  
297.             sk->err=ECONNRESET;  
298.             tcp_set_state(sk, TCP_CLOSE);  
299.             sk->shutdown = SHUTDOWN_MASK;  
300.             release_sock(sk);  
301.             sk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);  
302.             if (sk && sk->state==TCP_LISTEN)  
303.             {  
304.                 sk->inuse=1;  
305.                 skb->sk = sk;  
306.                 sk->rmem_alloc += skb->mem_len;  
307.                 tcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);  
308.                 release_sock(sk);  
309.                 return 0;  
310.             }  
311.             kfree_skb(skb, FREE_READ);  
312.             return 0;  
313.         }  
314. #endif    
315.     }  
316.   
317.     /* 
318.      *  We are now in normal data flow (see the step list in the RFC) 
319.      *  Note most of these are inline now. I'll inline the lot when 
320.      *  I have time to test it hard and look at what gcc outputs  
321.      */  
322.       
323.     if(!tcp_sequence(sk,th,len,opt,saddr,dev))  
324.     {  
325.         kfree_skb(skb, FREE_READ);  
326.         release_sock(sk);  
327.         return 0;  
328.     }  
329.   
330.     if(th->rst)  
331.         return tcp_std_reset(sk,skb);  
332.       
333.     /* 
334.      *  !syn_ok is effectively the state test in RFC793. 
335.      */  
336.        
337.     if(th->syn && !syn_ok)  
338.     {  
339.         tcp_reset(daddr,saddr,th, &tcp_prot, opt, dev, skb->ip_hdr->tos, 255);  
340.         return tcp_std_reset(sk,skb);     
341.     }  
342.   
343.     /* 
344.      *  Process the ACK 
345.      */  
346.        
347.   
348.     if(th->ack && !tcp_ack(sk,th,saddr,len))  
349.     {  
350.         /* 
351.          *  Our three way handshake failed. 
352.          */  
353.            
354.         if(sk->state==TCP_SYN_RECV)  
355.         {  
356.             tcp_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);  
357.         }  
358.         kfree_skb(skb, FREE_READ);  
359.         release_sock(sk);  
360.         return 0;  
361.     }  
362.       
363. rfc_step6:      /* I'll clean this up later */  
364.   
365.     /* 
366.      *  Process urgent data 
367.      */  
368.           
369.     if(tcp_urg(sk, th, saddr, len))  
370.     {  
371.         kfree_skb(skb, FREE_READ);  
372.         release_sock(sk);  
373.         return 0;  
374.     }  
375.       
376.       
377.     /* 
378.      *  Process the encapsulated data 
379.      */  
380.       
381.     if(tcp_data(skb,sk, saddr, len))  
382.     {  
383.         kfree_skb(skb, FREE_READ);  
384.         release_sock(sk);  
385.         return 0;  
386.     }  
387.   
388.     /* 
389.      *  And done 
390.      */   
391.       
392.     release_sock(sk);  
393.     return 0;  
394. }  

4、应用层

当用户需要接收数据时，首先根据文件描述符inode得到socket结构和sock结构，然后从sock结构中指向的队列recieve_queue中读取数据包，将数据包COPY到用户空间缓冲区。数据就完整的从硬件中传输到用户空间。这样也完成了一次完整的从下到上的传输。