Linux kernel--Network stack Implementation Analysis (ix)--UDP protocol for Transport layer (bottom)

This paper analyzes Linux Kernel 1.2.13 based on

Original works, reproduced please mark http://blog.csdn.net/yming0221/article/details/7549340

See column, Address http://blog.csdn.net/column/details/linux-kernel-net.html

Shuming

Note: In the title, "(UP)", "(bottom)" means that the analysis process is based on the delivery direction of the packet: "(top)" means that the analysis is parsed from the bottom up, and "(bottom)" indicates that the analysis is parsed from the top down.

In this paper, the application layer through the BSD socket layer to the INET socket layer function call relationship and data processing flow, the inet layer will invoke the specific transport layer protocol, or the UDP protocol as an example

Udp_write () function

[CPP]View Plaincopy

1. static int udp_write (struct sock *sk, unsigned char *buff, int len, int noblock,
2. Unsigned flags)
3. {
4. Return (Udp_sendto (SK, Buff, Len, Noblock, Flags, NULL, 0));
5. }

Before analyzing the Udp_sendto () function, let's look at the sockaddr_in structure, which is the definition of the standard network interface address structure.

[CPP]View Plaincopy

2. struct SOCKADDR_IN {
4. short int sin_family; /* Address Family family */
6. unsigned short int sin_port; /* Port number Port numbers */
8. struct IN_ADDR sin_addr; /* Internet Address network addresses */
12. /* Pad to size of ' struct sockaddr '. */
14. unsigned char __pad[__sock_size__-sizeof (short int)-
16. sizeof (unsigned short int)-sizeof (struct in_addr)];
18. };
20. #define Sin_zero __pad/* for BSD UNIX comp.-FVK */

Udp_sentdto () function

[CPP]View Plaincopy

2. static int udp_sendto (struct sock *sk, unsigned char *from, int len, int noblock,
4. Unsigned flags, struct sockaddr_in *usin, int addr_len)
6. {
8. struct sockaddr_in sin;
10. int tmp;
14. /*
16. * Check the flags. WE Support No flags for UDP sending
18. */
20. if (Flags&~msg_dontroute)
22. return (-einval);
24. /*
26. * Get and verify the address.
28. */
32. if (usin)//If usin is not empty
34. {
36. if (Addr_len < sizeof (sin))
38. return (-einval);
40. memcpy (&sin,usin,sizeof (sin));
42. if (sin.sin_family && sin.sin_family! = af_inet)
44. return (-einval);
46. if (Sin.sin_port = = 0)
48. return (-einval);
50. }
52. else//usin is empty
54. {
56. if (sk->state! = tcp_established)
58. return (-einval);
60. sin.sin_family = af_inet;//protocol Family
62. Sin.sin_port = sk->dummy_th.dest;//Destination port
64. SIN.SIN_ADDR.S_ADDR = sk->daddr;//Destination Address
66. }
70. /*
72. * BSD socket semantics. You must set So_broadcast to permit
74. * Broadcasting of data.
76. */
80. if (sin.sin_addr.s_addr==inaddr_any)//Destination address is a full 0 address, corresponding to the current host
82. SIN.SIN_ADDR.S_ADDR=IP_MY_ADDR ();//Set the destination to the network address of the current host
86. if (!sk->broadcast && ip_chk_addr (sin.sin_addr.s_addr) ==is_broadcast)
88. Return-eacces; /* must turn broadcast on first */
92. Sk->inuse = 1;
96. /* Send the packet. */
98. TMP = Udp_send (SK, &sin, from, Len, flags);//Call Udp_send () to actually send the data
102. /* The datagram has been sent off. Release the socket. */
104. Release_sock (SK);
106. return (TMP);
108. }

Udp_send () function

[CPP]View Plaincopy

2. static int udp_send (struct sock *sk,//sock structure used for packets to be sent using the protocol pair
4. The standard network interface address of the struct sockaddr_in *sin,//destination
6. unsigned char *from,//the address of the data to be sent
8. int len,//The length of the sent data
10. int RT)
12. {
14. struct Sk_buff *skb;
16. struct device *dev;
18. struct UDPHDR *uh;
20. unsigned char *buff;
22. unsigned long saddr;
24. int size, TMP;
26. int ttl;
30. /*
32. * Allocate an sk_buff copy of the packet.
34. */
38. Size = Sk->prot->max_header + len;//Compute the longest header + data length for UDP
40. SKB = SOCK_ALLOC_SEND_SKB (sk, size, 0, &tmp);//Allocate sk_buff structure space based on data to be sent and check for current socket status
46. if (SKB = = NULL)
48. return TMP;
52. Skb->sk = NULL; /* To avoid changing sk->saddr */
54. Skb->free = 1;
56. Skb->localroute = sk->localroute| (Rt&msg_dontroute);
60. /*
62. * Now build the IP and MAC header.
64. */
68. Buff = skb->data;//Assigns a data pointer in SKB to the buff pointer
70. SADDR = sk->saddr;//Local Address
72. dev = NULL;
74. TTL = sk->ip_ttl;//time to Live
76. #ifdef Config_ip_multicast
78. if (multicast (SIN->SIN_ADDR.S_ADDR))
80. TTL = sk->ip_mc_ttl;
82. #endif
84. TMP = Sk->prot->build_header (SKB, saddr, SIN->SIN_ADDR.S_ADDR,
86. &dev, IPPROTO_UDP, sk->opt, Skb->mem_len,sk->ip_tos,ttl);//Call Ip_build_header () to create an IP header and invoke Ip_send () Create a Mac Header
90. skb->sk=sk; /* So memory is freed correctly */
94. /*
96. * Unable to put a header on the packet.
98. */
102. if (TMP < 0)
104. {
106. Sk->prot->wfree (SK, SKB->MEM_ADDR, Skb->mem_len);
108. return (TMP);
110. }
114. Buff + = tmp;
116. SADDR = skb->saddr; /*dev->pa_addr;*/
118. Skb->len = tmp + sizeof (struct UDPHDR) + len; /* len + UDP + IP + MAC */
120. Skb->dev = Dev;
124. /*
126. * Fill in the UDP header. Fill in the header of the UDP
128. */
132. Uh = (struct UDPHDR *) buff;
134. Uh->len = htons (len + sizeof (struct UDPHDR));//Packet length
136. Uh->source = sk->dummy_th.source;//Local Port
138. Uh->dest = sin->sin_port;//Remote port
140. Buff = (unsigned char *) (uh + 1);
144. /*
146. * Copy the user data.
148. */
152. Memcpy_fromfs (Buff, from, Len);//Copy User data
156. /*
158. * Set up the UDP checksum.
160. */
164. Udp_send_check (uh, saddr, SIN->SIN_ADDR.S_ADDR, Skb->len-tmp, SK);//Calculate the checksum of the UDP header
168. /*
170. * Send the datagram to the interface.
172. */
176. Udp_statistics. udpoutdatagrams++;
180. Sk->prot->queue_xmit (SK, Dev, SKB, 1);//Call the IP layer function to send the data
182. return (LEN);
184. }

This sends the data to the Sk_buff structure that is populated after the IP data header and the Mac frame header are added to the UDP packet. Finally, the Send function of the IP layer is called to send the packet.

Linux kernel--Network stack Implementation Analysis (ix)--UDP protocol for Transport layer (bottom)