5.2【Linux 内核网络协议栈源码剖析】socket 函数剖析 ☆☆☆

深度剖析网络协议栈中的 socket 函数，可以说是把前面介绍的串联起来，将网络协议栈各层关联起来。

应用层	FTP	SMTP	HTTP	...
传输层	TCP		UDP
网络层	IP ICMP			ARP
链路层	以太网	令牌环	FDDI	...

1、应用层——socket 函数

为了执行网络I/O，一个进程必须做的第一件事就是调用socket函数，指定期望的通信协议类型。该函数只是作为一个简单的接口函数供用户调用，调用该函数后将进入内核栈进行系统调用sock_socket 函数。

1. #include <sys/socket.h>
2. int socket(int family, int type, int protocol);
3. /*返回：非负描述字——成功， -1——出错
4. 其中family参数指明协议族，type参数指明套接口类型，后面protocol通常设为0，以选择所给定family 和 type组合的系统缺省值*/

2、BSD Socket 层——sock_socket 函数

从应用层进入该函数是通过一个共同的入口函数 sys_socket

1. /*
2. *  System call vectors. Since I (RIB) want to rewrite sockets as streams,
3. *  we have this level of indirection. Not a lot of overhead, since more of
4. *  the work is done via read/write/select directly.
5. *
6. *  I'm now expanding this up to a higher level to separate the assorted
7. *  kernel/user space manipulations and global assumptions from the protocol
8. *  layers proper - AC.
9. */
10. //本函数是网络栈专用操作函数集的总入口函数，主要是将请求分配，调用具体的底层函数进行处理
11. asmlinkage int sys_socketcall(int call, unsigned long *args)
12. {
13. int er;
14. switch(call)
15. {
16. case SYS_SOCKET://socket函数
17. er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
18. if(er)
19. return er;
20. return(sock_socket(get_fs_long(args+0),
21. get_fs_long(args+1),//返回地址上的值
22. get_fs_long(args+2)));//调用sock_socket函数
23. ……
24. }

下面就是sock_socket 函数主体

1. /*
2. *  系统调用，创建套接字socket。涉及到sock结构的创建.
3. */
4. static int sock_socket(int family, int type, int protocol)
5. {
6. int i, fd;
7. struct socket *sock;
8. struct proto_ops *ops;
9. /* 匹配应用程序调用socket()函数时指定的协议 */
10. for (i = 0; i < NPROTO; ++i)
11. {
12. if (pops[i] == NULL) continue;
13. if (pops[i]->family == family) //设置域
14. break;
15. }
16. //没有匹配的协议，则出错退出
17. if (i == NPROTO)
18. {
19. return -EINVAL;
20. }
21. //根据family输入参数决定域操作函数集用于ops字段的赋值
22. //操作函数集是跟域相关的，不同的域对应不同的操作函数集
23. ops = pops[i];
24. /*
25. *  Check that this is a type that we know how to manipulate and
26. *  the protocol makes sense here. The family can still reject the
27. *  protocol later.
28. */
29. //套接字类型检查
30. if ((type != SOCK_STREAM && type != SOCK_DGRAM &&
31. type != SOCK_SEQPACKET && type != SOCK_RAW &&
32. type != SOCK_PACKET) || protocol < 0)
33. return(-EINVAL);
34. /*
35. *  Allocate the socket and allow the family to set things up. if
36. *  the protocol is 0, the family is instructed to select an appropriate
37. *  default.
38. */
39. //分配socket套接字结构
40. if (!(sock = sock_alloc()))
41. {
42. printk("NET: sock_socket: no more sockets\n");
43. return(-ENOSR); /* Was: EAGAIN, but we are out of
44. system resources! */
45. }
46. //指定对应类型，协议，以及操作函数集
47. sock->type = type;
48. sock->ops = ops;
49. //分配下层sock结构，sock结构是比socket结构更底层的表示一个套接字的结构
50. //前面博文有说明:http://blog.csdn.net/wenqian1991/article/details/21740945
51. //socket是通用的套接字结构体，而sock与具体使用的协议相关
52. if ((i = sock->ops->create(sock, protocol)) < 0) //这里调用下层函数 create
53. {
54. sock_release(sock);//出错回滚销毁处理
55. return(i);
56. }
57. //分配一个文件描述符并在后面返回给应用层序作为以后的操作句柄
58. if ((fd = get_fd(SOCK_INODE(sock))) < 0)
59. {
60. sock_release(sock);
61. return(-EINVAL);
62. }
63. return(fd);//这个就是我们应用系统使用的套接字描述符
64. }

该要介绍的注释里，已经说明白了，可以看到，该函数又将调用下一层函数 create。（网络栈就是这样，上层调用下层函数）

sock_socket 函数内部还调用了一个函数 sock_alloc()，该函数主要是分配一个 socket 套接字结构（实际上找到一个空闲的inode结构，socket结构已经包含在inode结构中）

1. /*
2. *  分配一个socket结构
3. */
4. struct socket *sock_alloc(void)
5. {
6. struct inode * inode;
7. struct socket * sock;
8. inode = get_empty_inode();//分配一个inode对象
9. if (!inode)
10. return NULL;
11. //获得的inode结构的初始化
12. inode->i_mode = S_IFSOCK;
13. inode->i_sock = 1;
14. inode->i_uid = current->uid;
15. inode->i_gid = current->gid;
16. //可以看出socket结构体的实体空间，就已经存在了inode结构中的union类型中，
17. //所以无需单独的开辟空间分配一个socket 结构
18. sock = &inode->u.socket_i;//这里把inode的union结构中的socket变量地址传给sock
19. sock->state = SS_UNCONNECTED;
20. sock->flags = 0;
21. sock->ops = NULL;
22. sock->data = NULL;
23. sock->conn = NULL;
24. sock->iconn = NULL;
25. sock->next = NULL;
26. sock->wait = &inode->i_wait;
27. sock->inode = inode;//回绑
28. sock->fasync_list = NULL;
29. sockets_in_use++;//系统当前使用的套接字数量加1
30. return sock;
31. }

3、INET Socket 层——inet_create 函数

1. /*
2. *  Create an inet socket.
3. *
4. *  FIXME: Gcc would generate much better code if we set the parameters
5. *  up in in-memory structure order. Gcc68K even more so
6. */
7. //该函数被上层sock_socket函数调用，用于创建一个socket套接字对应的sock结构并对其进行初始化
8. //socket是通用结构，sock是具体到某种协议的结构
9. //代码是一大串，功能就是建立套接字对应的sock结构并对其进行初始化
10. static int inet_create(struct socket *sock, int protocol)
11. {
12. struct sock *sk;
13. struct proto *prot;
14. int err;
15. //分配一个sock结构，内存分配一个实体
16. sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
17. if (sk == NULL)
18. return(-ENOBUFS);
19. sk->num = 0;//本地端口号
20. sk->reuse = 0;
21. //根据类型进行相关字段的赋值
22. //关于哪种类型与协议的对应关系，请参考<UNP 卷1>，有些类型就只能和某种协议对应
23. switch(sock->type)
24. {
25. case SOCK_STREAM:
26. case SOCK_SEQPACKET:
27. if (protocol && protocol != IPPROTO_TCP)
28. {
29. kfree_s((void *)sk, sizeof(*sk));
30. return(-EPROTONOSUPPORT);
31. }
32. protocol = IPPROTO_TCP;//tcp协议
33. sk->no_check = TCP_NO_CHECK;
34. //这个prot变量表明了套接字使用的是何种协议
35. //然后使用的则是对应协议的操作函数
36. prot = &tcp_prot;
37. break;
38. case SOCK_DGRAM:
39. if (protocol && protocol != IPPROTO_UDP)
40. {
41. kfree_s((void *)sk, sizeof(*sk));
42. return(-EPROTONOSUPPORT);
43. }
44. protocol = IPPROTO_UDP;//udp协议
45. sk->no_check = UDP_NO_CHECK;//不使用校验
46. prot=&udp_prot;
47. break;
48. case SOCK_RAW:
49. if (!suser()) //超级用户才能处理
50. {
51. kfree_s((void *)sk, sizeof(*sk));
52. return(-EPERM);
53. }
54. if (!protocol)// 原始套接字类型，这里表示端口号
55. {
56. kfree_s((void *)sk, sizeof(*sk));
57. return(-EPROTONOSUPPORT);
58. }
59. prot = &raw_prot;
60. sk->reuse = 1;
61. sk->no_check = 0;    /*
62. * Doesn't matter no checksum is
63. * performed anyway.
64. */
65. sk->num = protocol;//本地端口号
66. break;
67. case SOCK_PACKET:
68. if (!suser())
69. {
70. kfree_s((void *)sk, sizeof(*sk));
71. return(-EPERM);
72. }
73. if (!protocol)
74. {
75. kfree_s((void *)sk, sizeof(*sk));
76. return(-EPROTONOSUPPORT);
77. }
78. prot = &packet_prot;
79. sk->reuse = 1;
80. sk->no_check = 0;    /* Doesn't matter no checksum is
81. * performed anyway.
82. */
83. sk->num = protocol;
84. break;
85. default://不符合以上任何类型，则返回
86. kfree_s((void *)sk, sizeof(*sk));
87. return(-ESOCKTNOSUPPORT);
88. }
89. sk->socket = sock;//建立与其对应的socket之间的关系
90. #ifdef CONFIG_TCP_NAGLE_OFF
91. sk->nonagle = 1;//如果定义了Nagle算法
92. #else
93. sk->nonagle = 0;
94. #endif
95. //各种初始化
96. //这里是sock结构
97. sk->type = sock->type;
98. sk->stamp.tv_sec=0;
99. sk->protocol = protocol;
100. sk->wmem_alloc = 0;
101. sk->rmem_alloc = 0;
102. sk->sndbuf = SK_WMEM_MAX;
103. sk->rcvbuf = SK_RMEM_MAX;
104. sk->pair = NULL;
105. sk->opt = NULL;
106. sk->write_seq = 0;
107. sk->acked_seq = 0;
108. sk->copied_seq = 0;
109. sk->fin_seq = 0;
110. sk->urg_seq = 0;
111. sk->urg_data = 0;
112. sk->proc = 0;
113. sk->rtt = 0;             /*TCP_WRITE_TIME << 3;*/
114. sk->rto = TCP_TIMEOUT_INIT;      /*TCP_WRITE_TIME*/
115. sk->mdev = 0;
116. sk->backoff = 0;
117. sk->packets_out = 0;
118. sk->cong_window = 1; /* start with only sending one packet at a time. */
119. sk->cong_count = 0;
120. sk->ssthresh = 0;
121. sk->max_window = 0;
122. sk->urginline = 0;
123. sk->intr = 0;
124. sk->linger = 0;
125. sk->destroy = 0;
126. sk->priority = 1;
127. sk->shutdown = 0;
128. sk->keepopen = 0;
129. sk->zapped = 0;
130. sk->done = 0;
131. sk->ack_backlog = 0;
132. sk->window = 0;
133. sk->bytes_rcv = 0;
134. sk->state = TCP_CLOSE;
135. sk->dead = 0;
136. sk->ack_timed = 0;
137. sk->partial = NULL;
138. sk->user_mss = 0;
139. sk->debug = 0;
140. /* this is how many unacked bytes we will accept for this socket.  */
141. sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
142. /* how many packets we should send before forcing an ack.
143. if this is set to zero it is the same as sk->delay_acks = 0 */
144. sk->max_ack_backlog = 0;
145. sk->inuse = 0;
146. sk->delay_acks = 0;
147. skb_queue_head_init(&sk->write_queue);
148. skb_queue_head_init(&sk->receive_queue);
149. sk->mtu = 576;//最大传输单元
150. sk->prot = prot;
151. sk->sleep = sock->wait;
152. sk->daddr = 0;//远端地址
153. sk->saddr = 0 /* 本地地址 */;
154. sk->err = 0;
155. sk->next = NULL;
156. sk->pair = NULL;
157. sk->send_tail = NULL;
158. sk->send_head = NULL;
159. sk->timeout = 0;
160. sk->broadcast = 0;
161. sk->localroute = 0;
162. init_timer(&sk->timer);
163. init_timer(&sk->retransmit_timer);
164. sk->timer.data = (unsigned long)sk;
165. sk->timer.function = &net_timer;
166. skb_queue_head_init(&sk->back_log);
167. sk->blog = 0;
168. sock->data =(void *) sk;
169. //下面是sock结构中tcp首部初始化
170. sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
171. sk->dummy_th.res1=0;
172. sk->dummy_th.res2=0;
173. sk->dummy_th.urg_ptr = 0;
174. sk->dummy_th.fin = 0;
175. sk->dummy_th.syn = 0;
176. sk->dummy_th.rst = 0;
177. sk->dummy_th.psh = 0;
178. sk->dummy_th.ack = 0;
179. sk->dummy_th.urg = 0;
180. sk->dummy_th.dest = 0;
181. //ip部分
182. sk->ip_tos=0;
183. sk->ip_ttl=64;
184. #ifdef CONFIG_IP_MULTICAST
185. sk->ip_mc_loop=1;
186. sk->ip_mc_ttl=1;
187. *sk->ip_mc_name=0;
188. sk->ip_mc_list=NULL;
189. #endif
190. sk->state_change = def_callback1;
191. sk->data_ready = def_callback2;
192. sk->write_space = def_callback3;
193. sk->error_report = def_callback1;
194. if (sk->num) //如果分配了本地端口号
195. {
196. /*
197. * It assumes that any protocol which allows
198. * the user to assign a number at socket
199. * creation time automatically
200. * shares.
201. */
202. //将具有确定端口号的新sock结构加入到sock_array数组表示的sock结构链表中
203. put_sock(sk->num, sk);//实际上这里确定的端口号一般为初始化0
204. sk->dummy_th.source = ntohs(sk->num);//tcp首部源端地址，就是端口号
205. //这里需要进行字节序转换，网络字节序转主机字节序
206. }
207. if (sk->prot->init) //根据不同协议类型，调用对应init函数
208. {
209. err = sk->prot->init(sk);//调用相对应4层协议的初始化函数
210. if (err != 0)
211. {
212. destroy_sock(sk);//出错了，就销毁
213. return(err);
214. }
215. }
216. return(0);
217. }

到这里一个 socket 套接字就创建完成了
可以看出socket 套接字的创建过程为：socket() -> sock_socket() -> inet_create()

我们简单的总结一下这几个函数的功能：

sock_socket() 内部的主要结构是 socket 结构体，其主要负责socket 结构体的创建（sock_alloc()）和初始化，以及指定socket套接字的类型和操作函数集，然后分配一个文件描述符作为socket套接字的操作句柄，该描述符就是我们常说的套接字描述符。socket 的创建主要是分配一个inode 对象来说实现的。inode 对面内部有一个 union 类型变量，里面包含了各种类型的结构体，这里采用的 socket 类型，然后二者建立关联，inode中的union采用socket，socket结构中的inode指针指向该inode对象。

inet_create() 内部的主要结构是 sock 结构体，sock 结构体比socket 结构更显复杂，其使用范围也更为广泛，socket 结构体是一个通用的结构，不涉及到具体的协议，而sock 结构则与具体的协议挂钩，属于具体层面上的一个结构。inet_create 函数的主要功能则是创建一个 sock 结构（kmalloc()）然后根据上层传值下来的协议（通常是类型与地址族组合成成对应的协议）进行初始化。最后将创建好的 sock 结构插入到 sock 表中。

网络栈的更下层用到的套接字就是 sock 结构体，在inet_create 函数中sock 套接字已经创建且初始化，socket() 至此完成。

有了源码，更清楚的了解到socket 函数的功能：创建套接字（sock struct），指定期望的通信协议类型。

到了这一步，套接字拥有自己的实体部分，指定了通信协议类型，但是既没有绑定本地地址信息（ip地址和端口号），也不知道对端的地址信息。