【Linux 内核网络协议栈源码剖析】socket.c——BSD Socket层（1）


http://blog.csdn.net/wenqian1991/article/details/46546477


写在前面：本系列文章先把各个层对应的文件源码剖析一遍，最后再穿插起来，理清整个协议栈网络数据包的上下传送通道，从整体实现上进行把握。

       

图片来源于《Linux 内核网络栈源代码情景分析》

更上层函数：tcp socket函数介绍。本篇则是介绍BSD Socket层。其对应函数集定义在socket.c 文件中，阅读源码后，你会发现这些函数都是层层嵌套调用表现出了上下层之间的关系。内核版本：Linux 1.2.13

源码剖析：

为方便大家理清思路，先介绍几个中间函数。建议：像这些大型软件项目，函数内通常还会调用一些公用的基础类的工具函数，我们在阅读源码时，应该先弄清楚这些函数，这样当阅读对应函数时，能很好地把握该函数的内部细节。

[cpp] view plain copy print?
  1. /*下面两个函数实现地址用户空间和内核空间地址之间的相互移动*/  
  2. //从uaddr拷贝ulen大小的数据到kaddr  
  3. static int move_addr_to_kernel(void *uaddr, int ulen, void *kaddr)  
  4. {  
  5.     int err;  
  6.     if(ulen<0||ulen>MAX_SOCK_ADDR)  
  7.         return -EINVAL;  
  8.     if(ulen==0)  
  9.         return 0;  
  10.     //检查用户空间的指针所指的指定大小存储块是否可读  
  11.     if((err=verify_area(VERIFY_READ,uaddr,ulen))<0)  
  12.         return err;  
  13.     memcpy_fromfs(kaddr,uaddr,ulen);//实质是memcpy函数  
  14.     return 0;  
  15. }  
  16. //注意的是，从内核拷贝数据到用户空间是值-结果参数  
  17. //ulen这个指向某个整数变量的指针，当函数被调用的时候，它告诉内核需要拷贝多少  
  18. //函数返回时，该参数作为一个结果，告诉进程，内核实际拷贝了多少信息  
  19. static int move_addr_to_user(void *kaddr, int klen, void *uaddr, int *ulen)  
  20. {  
  21.     int err;  
  22.     int len;  
  23.   
  24.     //判断ulen指向的存储块是否可写，就是判断ulen是否可作为左值    
  25.     if((err=verify_area(VERIFY_WRITE,ulen,sizeof(*ulen)))<0)  
  26.         return err;  
  27.     len=get_fs_long(ulen);//len = *ulen，ulen作为值传入，告诉要拷贝多少数据  
  28.     if(len>klen)  
  29.         len=klen;//供不应求，按供的算。实际拷贝的数据  
  30.     if(len<0 || len> MAX_SOCK_ADDR)  
  31.         return -EINVAL;  
  32.     if(len)  
  33.     {  
  34.     //判断uaddr用户空间所指的存储块是否可写  
  35.         if((err=verify_area(VERIFY_WRITE,uaddr,len))<0)  
  36.             return err;  
  37.         memcpy_tofs(uaddr,kaddr,len);//实质是调用memcpy  
  38.     }  
  39.     put_fs_long(len,ulen);//*ulen = len，作为结果返回，即实际拷贝了多少数据  
  40.     return 0;  
  41. }  
下面这个函数一看就知道什么意思
[cpp] view plain copy print?
  1. static inline unsigned long get_user_long(const int *addr)  
  2. {  
  3.     return *addr;  
  4. }  
  5.   
  6. #define get_fs_long(addr) get_user_long((int *)(addr))  

为套接字分配文件描述符，套接字其实同普通的文件描述符差不多，分配文件描述符的同时需要一个file结构，file结构中f_inode字段指向inode(这里的形参)
[cpp] view plain copy print?
  1. /* 
  2.  *  为网络套接字分配一个文件描述符  
  3.  */  
  4.   
  5. static int get_fd(struct inode *inode)  
  6. {  
  7.     int fd;  
  8.     struct file *file;  
  9.   
  10.     /* 
  11.      *  Find a file descriptor suitable for return to the user.  
  12.      */  
  13.   
  14.     file = get_empty_filp();//分配文件对象，文件描述符对应实体，file结构体指示一个打开的文件，filp:file pointer  
  15.     if (!file)   
  16.         return(-1);  
  17.     //找到可用的文件描述符  
  18.     for (fd = 0; fd < NR_OPEN; ++fd)  
  19.         if (!current->files->fd[fd])   
  20.             break;  
  21.     //没有空闲可用的文件描述符，则退出  
  22.     if (fd == NR_OPEN)   
  23.     {  
  24.         file->f_count = 0;  
  25.         return(-1);  
  26.     }  
  27.     //在文件描述符集合中删除一个新的文件描述符  
  28.     FD_CLR(fd, ¤t->files->close_on_exec);  
  29.         current->files->fd[fd] = file;//赋值，挂钩  
  30.     file->f_op = &socket_file_ops;//指定操作函数集，实现了网络操作的普通文件接口  
  31.     file->f_mode = 3;//权限  
  32.     file->f_flags = O_RDWR;//标志，可读可写  
  33.     file->f_count = 1;//引用计数  
  34.     file->f_inode = inode;//与文件inode建立联系,inode为对文件的索引  
  35.     if (inode)   
  36.         inode->i_count++;//inode的引用计数也要增1  
  37.     file->f_pos = 0;//偏移值  
  38.     return(fd);  
  39. }  

每个文件描述符都与对应的inode结构关联，通过文件描述符可以找到file结构，通过file结构可以找到inode，而socket结构又是作为inode结构中的一个变量，反过来，inode也是作为socket结构的一个变量，分配套接字时，两者之间需要建立关联，见sock_alloc()。
[cpp] view plain copy print?
  1. /* 
  2.  *  通过inode结构查找对应的socket结构 
  3.  */  
  4. inline struct socket *socki_lookup(struct inode *inode)  
  5. {  
  6.     return &inode->u.socket_i;//socket结构是作为inode结构中的一个变量  
  7. }  
  8.   
  9. /* 
  10.  *  给定文件描述符返回socket结构以及file结构指针 
  11.  */  
  12.   
  13. static inline struct socket *sockfd_lookup(int fd, struct file **pfile)  
  14. {  
  15.     struct file *file;  
  16.     struct inode *inode;  
  17.     //有效性检查，并从文件描述符中得到对应的file结构  
  18.     if (fd < 0 || fd >= NR_OPEN || !(file = current->files->fd[fd]))   
  19.         return NULL;  
  20.     //得到对应inode结构  
  21.     inode = file->f_inode;  
  22.     if (!inode || !inode->i_sock)  
  23.         return NULL;  
  24.   
  25.     if (pfile)   
  26.         *pfile = file;//参数返回file结构指针  
  27.     //返回inode对应的socket结构  
  28.     return socki_lookup(inode);  
  29. }  
 下面开始socket结构的处理了

分配一个socket结构

[cpp] view plain copy print?
  1. /* 
  2.  *  分配一个socket结构 
  3.  */  
  4.   
  5. struct socket *sock_alloc(void)  
  6. {  
  7.     struct inode * inode;  
  8.     struct socket * sock;  
  9.   
  10.     inode = get_empty_inode();//分配一个inode对象  
  11.     if (!inode)  
  12.         return NULL;  
  13.     //获得的inode结构的初始化  
  14.     inode->i_mode = S_IFSOCK;  
  15.     inode->i_sock = 1;  
  16.     inode->i_uid = current->uid;  
  17.     inode->i_gid = current->gid;  
  18.   
  19.     sock = &inode->u.socket_i;  
  20.     sock->state = SS_UNCONNECTED;  
  21.     sock->flags = 0;  
  22.     sock->ops = NULL;  
  23.     sock->data = NULL;  
  24.     sock->conn = NULL;  
  25.     sock->iconn = NULL;  
  26.     sock->next = NULL;  
  27.     sock->wait = &inode->i_wait;  
  28.     sock->inode = inode;//回绑  
  29.     sock->fasync_list = NULL;  
  30.     sockets_in_use++;//系统当前使用的套接字数量加1  
  31.     return sock;  
  32. }  

释放（关闭）套接字
[cpp] view plain copy print?
  1. /* 
  2.  *  Release a socket. 
  3.  */  
  4. //释放对端的套接字  
  5. static inline void sock_release_peer(struct socket *peer)  
  6. {  
  7.     peer->state = SS_DISCONNECTING;//状态切换到正在处理关闭连接  
  8.     wake_up_interruptible(peer->wait);//唤醒指定的注册在等待队列上的进程  
  9.     sock_wake_async(peer, 1);//异步唤醒，涉及到套接字状态的改变，需要通知相应进程进行某种处理  
  10. }  
  11.   
  12. /* 
  13.  *  释放(关闭)一个套接字 
  14.  */  
  15.   
  16. void sock_release(struct socket *sock)  
  17. {  
  18.     int oldstate;  
  19.     struct socket *peersock, *nextsock;  
  20.   
  21. //只要套接字不是出于未连接状态，就将其置为正在处理关闭连接状态  
  22.     if ((oldstate = sock->state) != SS_UNCONNECTED)  
  23.         sock->state = SS_DISCONNECTING;  
  24.   
  25.     /* 
  26.      *  Wake up anyone waiting for connections.  
  27.      */  
  28. //iconn只用于服务器端，表示等待连接但尚未完成连接的客户端socket结构链表  
  29.     for (peersock = sock->iconn; peersock; peersock = nextsock)   
  30.     {  
  31.         nextsock = peersock->next;  
  32.         sock_release_peer(peersock);  
  33.     }  
  34.   
  35.     /* 
  36.      * Wake up anyone we're connected to. First, we release the 
  37.      * protocol, to give it a chance to flush data, etc. 
  38.      */  
  39.     //如果该套接字已连接，peersock指向其连接的服务器端套接字  
  40.     peersock = (oldstate == SS_CONNECTED) ? sock->conn : NULL;  
  41.     //转调用release函数  
  42.     if (sock->ops)   
  43.         sock->ops->release(sock, peersock);  
  44.     //释放对端套接字  
  45.     if (peersock)  
  46.         sock_release_peer(peersock);  
  47.     --sockets_in_use;   /* 数量减1 */  
  48.     iput(SOCK_INODE(sock));  
  49. }  
socket 结构
[cpp] view plain copy print?
  1. /* 
  2.  * Internal representation of a socket. not all the fields are used by 
  3.  * all configurations: 
  4.  * 
  5.  *      server          client 
  6.  * conn     client connected to server connected to 
  7.  * iconn    list of clients     -unused- 
  8.  *       awaiting connections 
  9.  * wait     sleep for clients,  sleep for connection, 
  10.  *      sleep for i/o       sleep for i/o 
  11.  */  
  12.  //该结构表示一个网络套接字  
  13. struct socket {  
  14.   short         type;       /* 套接字所用的流类型*/  
  15.   socket_state      state;//套接字所处状态  
  16.   long          flags;//标识字段，目前尚无明确作用  
  17.   struct proto_ops  *ops;       /* 操作函数集指针  */  
  18.     /* data保存指向‘私有'数据结构指针，在不同的域指向不同的数据结构        */  
  19.   //在INET域，指向sock结构，UNIX域指向unix_proto_data结构  
  20.   void          *data;    
  21.   //下面两个字段只用于UNIX域  
  22.   struct socket     *conn;      /* 指向客户端连接的服务器端套接字  */  
  23.   struct socket     *iconn;     /* 指向正等待连接的客户端  */  
  24.   struct socket     *next;//链表  
  25.   struct wait_queue **wait;     /* 等待队列 */  
  26.   struct inode      *inode;//inode结构指针  
  27.   struct fasync_struct  *fasync_list;   /* 异步唤醒链表结构 */  
  28. };  

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


给socket绑定一个端口，bind
[cpp] view plain copy print?
  1. /* 
  2.  *  Bind a name to a socket. Nothing much to do here since it's 
  3.  *  the protocol's responsibility to handle the local address. 
  4.  * 
  5.  *  We move the socket address to kernel space before we call 
  6.  *  the protocol layer (having also checked the address is ok). 
  7.  */  
  8.  //建议对于理解这类系统调用函数，先看看应用层的对应函数，如bind，listen等  
  9.  //bind函数对应的BSD层函数，用于绑定一个本地地址，服务器端  
  10.  //umyaddr表示需要绑定的地址结构，addrlen表示改地址结构的长度  
  11. static int sock_bind(int fd, struct sockaddr *umyaddr, int addrlen)  
  12. {  
  13.     struct socket *sock;  
  14.     int i;  
  15.     char address[MAX_SOCK_ADDR];  
  16.     int err;  
  17.     //套接字参数有效性检查  
  18.     if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)  
  19.         return(-EBADF);  
  20.     //获取fd对应的socket结构  
  21.     if (!(sock = sockfd_lookup(fd, NULL)))   
  22.         return(-ENOTSOCK);  
  23.     //将地址从用户缓冲区复制到内核缓冲区  
  24.     if((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)  
  25.         return err;  
  26.     //转调用bind指向的函数  
  27.     if ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0)   
  28.     {  
  29.         return(i);  
  30.     }  
  31.     return(0);  
  32. }  


监听客户端请求，listen
[cpp] view plain copy print?
  1. /* 
  2.  *  Perform a listen. Basically, we allow the protocol to do anything 
  3.  *  necessary for a listen, and if that works, we mark the socket as 
  4.  *  ready for listening. 
  5.  */  
  6.     //服务器端监听客户端的连接请求  
  7. //fd表示bind后的套接字，backlog表示排队的最大连接个数  
  8. //listen函数把一个未连接的套接字转换为一个被动套接字，  
  9. //指示内核应接受该套接字的连接请求  
  10.   
  11. static int sock_listen(int fd, int backlog)  
  12. {  
  13.     struct socket *sock;  
  14.   
  15.     if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)  
  16.         return(-EBADF);  
  17.     if (!(sock = sockfd_lookup(fd, NULL)))   
  18.         return(-ENOTSOCK);  
  19.     //前提是没有建立连接  
  20.     if (sock->state != SS_UNCONNECTED)   
  21.     {  
  22.         return(-EINVAL);  
  23.     }  
  24.     //调用底层实现函数  
  25.     if (sock->ops && sock->ops->listen)  
  26.         sock->ops->listen(sock, backlog);  
  27.     sock->flags |= SO_ACCEPTCON;//设置标识字段  
  28.     return(0);  
  29. }  

服务器接收请求，accept
[cpp] view plain copy print?
  1. /* 
  2.  *  For accept, we attempt to create a new socket, set up the link 
  3.  *  with the client, wake up the client, then return the new 
  4.  *  connected fd. We collect the address of the connector in kernel 
  5.  *  space and move it to user at the very end. This is buggy because 
  6.  *  we open the socket then return an error. 
  7.  */  
  8. //用于服务器接收一个客户端的连接请求，这里是值-结果参数，之前有说到  
  9. //fd 为监听后套接字。最后返回一个记录了本地与目的端信息的套接字  
  10. //upeer_sockaddr用来返回已连接客户的协议地址，如果对协议地址不感兴趣就NULL  
  11. static int sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen)  
  12. {  
  13.     struct file *file;  
  14.     struct socket *sock, *newsock;  
  15.     int i;  
  16.     char address[MAX_SOCK_ADDR];  
  17.     int len;  
  18.   
  19.     if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))  
  20.         return(-EBADF);  
  21.     if (!(sock = sockfd_lookup(fd, &file)))   
  22.         return(-ENOTSOCK);  
  23.     if (sock->state != SS_UNCONNECTED)//socket各个状态的演变是一步一步来的   
  24.     {  
  25.         return(-EINVAL);  
  26.     }  
  27.     //这是tcp连接，得按步骤来  
  28.     if (!(sock->flags & SO_ACCEPTCON))//没有listen  
  29.     {  
  30.         return(-EINVAL);  
  31.     }  
  32.     //分配一个新的套接字，用于表示后面可进行通信的套接字  
  33.     if (!(newsock = sock_alloc()))   
  34.     {  
  35.         printk("NET: sock_accept: no more sockets ");  
  36.         return(-ENOSR); /* Was: EAGAIN, but we are out of system 
  37.                    resources! */  
  38.     }  
  39.     newsock->type = sock->type;  
  40.     newsock->ops = sock->ops;  
  41.     //套接字重定向，目的是初始化新的用于数据传送的套接字  
  42.     //继承了第一参数传来的服务器的IP和端口号信息  
  43.     if ((i = sock->ops->dup(newsock, sock)) < 0)   
  44.     {  
  45.         sock_release(newsock);  
  46.         return(i);  
  47.     }  
  48.     //转调用inet_accept函数  
  49.     i = newsock->ops->accept(sock, newsock, file->f_flags);  
  50.     if ( i < 0)   
  51.     {  
  52.         sock_release(newsock);  
  53.         return(i);  
  54.     }  
  55.     //分配一个文件描述符，用于以后的数据传送  
  56.     if ((fd = get_fd(SOCK_INODE(newsock))) < 0)   
  57.     {  
  58.         sock_release(newsock);  
  59.         return(-EINVAL);  
  60.     }  
  61.     //返回通信远端的地址  
  62.     if (upeer_sockaddr)  
  63.     {//得到客户端地址，并复制到用户空间  
  64.         newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);  
  65.         move_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);  
  66.     }  
  67.     return(fd);  
  68. }  

客户端主动发起连接请求，connect
[cpp] view plain copy print?
  1. /* 
  2.  *  首先将要连接的源端地址从用户缓冲区复制到内核缓冲区，之后根据套接字目前所处状态 
  3.  *  采取对应措施，如果状态有效，转调用connect函数 
  4.  */  
  5.  //这是客户端，表示客户端向服务器端发送连接请求  
  6. static int sock_connect(int fd, struct sockaddr *uservaddr, int addrlen)  
  7. {  
  8.     struct socket *sock;  
  9.     struct file *file;  
  10.     int i;  
  11.     char address[MAX_SOCK_ADDR];  
  12.     int err;  
  13.   
  14.     if (fd < 0 || fd >= NR_OPEN || (file=current->files->fd[fd]) == NULL)  
  15.         return(-EBADF);  
  16.     if (!(sock = sockfd_lookup(fd, &file)))  
  17.         return(-ENOTSOCK);  
  18.   
  19.     if((err=move_addr_to_kernel(uservaddr,addrlen,address))<0)  
  20.         return err;  
  21.     //根据状态采取对应措施  
  22.     switch(sock->state)   
  23.     {  
  24.         case SS_UNCONNECTED:  
  25.             /* This is ok... continue with connect */  
  26.             break;  
  27.         case SS_CONNECTED:  
  28.             /* Socket is already connected */  
  29.             if(sock->type == SOCK_DGRAM) /* Hack for now - move this all into the protocol */  
  30.                 break;  
  31.             return -EISCONN;  
  32.         case SS_CONNECTING:  
  33.             /* Not yet connected... we will check this. */  
  34.           
  35.             /* 
  36.              *  FIXME:  for all protocols what happens if you start 
  37.              *  an async connect fork and both children connect. Clean 
  38.              *  this up in the protocols! 
  39.              */  
  40.             break;  
  41.         default:  
  42.             return(-EINVAL);  
  43.     }  
  44.     i = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);  
  45.     if (i < 0)   
  46.     {  
  47.         return(i);  
  48.     }  
  49.     return(0);  
  50. }  
上面几个函数则是我们应用编程是socket、bind、listen、accept、connect 函数对应的内核的系统调用函数，可以看出，对应的sock_ 函数内部也是转调用了下一层的函数。
所有网络调用函数都具有共同的入口函数 sys_socket
[cpp] view plain copy print?
  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)));  
  23.         case SYS_BIND://bind函数  
  24.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  25.             if(er)  
  26.                 return er;  
  27.             return(sock_bind(get_fs_long(args+0),  
  28.                 (struct sockaddr *)get_fs_long(args+1),  
  29.                 get_fs_long(args+2)));  
  30.         case SYS_CONNECT://connect函数  
  31.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  32.             if(er)  
  33.                 return er;  
  34.             return(sock_connect(get_fs_long(args+0),  
  35.                 (struct sockaddr *)get_fs_long(args+1),  
  36.                 get_fs_long(args+2)));  
  37.         case SYS_LISTEN://listen函数  
  38.             er=verify_area(VERIFY_READ, args, 2 * sizeof(long));  
  39.             if(er)  
  40.                 return er;  
  41.             return(sock_listen(get_fs_long(args+0),  
  42.                 get_fs_long(args+1)));  
  43.         case SYS_ACCEPT://accept函数  
  44.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  45.             if(er)  
  46.                 return er;  
  47.             return(sock_accept(get_fs_long(args+0),  
  48.                 (struct sockaddr *)get_fs_long(args+1),  
  49.                 (int *)get_fs_long(args+2)));  
  50.         case SYS_GETSOCKNAME://getsockname函数  
  51.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  52.             if(er)  
  53.                 return er;  
  54.             return(sock_getsockname(get_fs_long(args+0),  
  55.                 (struct sockaddr *)get_fs_long(args+1),  
  56.                 (int *)get_fs_long(args+2)));  
  57.         case SYS_GETPEERNAME://getpeername函数  
  58.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  59.             if(er)  
  60.                 return er;  
  61.             return(sock_getpeername(get_fs_long(args+0),  
  62.                 (struct sockaddr *)get_fs_long(args+1),  
  63.                 (int *)get_fs_long(args+2)));  
  64.         case SYS_SOCKETPAIR://socketpair函数  
  65.             er=verify_area(VERIFY_READ, args, 4 * sizeof(long));  
  66.             if(er)  
  67.                 return er;  
  68.             return(sock_socketpair(get_fs_long(args+0),  
  69.                 get_fs_long(args+1),  
  70.                 get_fs_long(args+2),  
  71.                 (unsigned long *)get_fs_long(args+3)));  
  72.         case SYS_SEND://send函数  
  73.             er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));  
  74.             if(er)  
  75.                 return er;  
  76.             return(sock_send(get_fs_long(args+0),  
  77.                 (void *)get_fs_long(args+1),  
  78.                 get_fs_long(args+2),  
  79.                 get_fs_long(args+3)));  
  80.         case SYS_SENDTO://sendto函数  
  81.             er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));  
  82.             if(er)  
  83.                 return er;  
  84.             return(sock_sendto(get_fs_long(args+0),  
  85.                 (void *)get_fs_long(args+1),  
  86.                 get_fs_long(args+2),  
  87.                 get_fs_long(args+3),  
  88.                 (struct sockaddr *)get_fs_long(args+4),  
  89.                 get_fs_long(args+5)));  
  90.         case SYS_RECV://recv函数  
  91.             er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));  
  92.             if(er)  
  93.                 return er;  
  94.             return(sock_recv(get_fs_long(args+0),  
  95.                 (void *)get_fs_long(args+1),  
  96.                 get_fs_long(args+2),  
  97.                 get_fs_long(args+3)));  
  98.         case SYS_RECVFROM://recvfrom函数  
  99.             er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));  
  100.             if(er)  
  101.                 return er;  
  102.             return(sock_recvfrom(get_fs_long(args+0),  
  103.                 (void *)get_fs_long(args+1),  
  104.                 get_fs_long(args+2),  
  105.                 get_fs_long(args+3),  
  106.                 (struct sockaddr *)get_fs_long(args+4),  
  107.                 (int *)get_fs_long(args+5)));  
  108.         case SYS_SHUTDOWN://shutdown函数  
  109.             er=verify_area(VERIFY_READ, args, 2* sizeof(unsigned long));  
  110.             if(er)  
  111.                 return er;  
  112.             return(sock_shutdown(get_fs_long(args+0),  
  113.                 get_fs_long(args+1)));  
  114.         case SYS_SETSOCKOPT://setsockopt函数  
  115.             er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));  
  116.             if(er)  
  117.                 return er;  
  118.             return(sock_setsockopt(get_fs_long(args+0),  
  119.                 get_fs_long(args+1),  
  120.                 get_fs_long(args+2),  
  121.                 (char *)get_fs_long(args+3),  
  122.                 get_fs_long(args+4)));  
  123.         case SYS_GETSOCKOPT://getsockopt函数  
  124.             er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));  
  125.             if(er)  
  126.                 return er;  
  127.             return(sock_getsockopt(get_fs_long(args+0),  
  128.                 get_fs_long(args+1),  
  129.                 get_fs_long(args+2),  
  130.                 (char *)get_fs_long(args+3),  
  131.                 (int *)get_fs_long(args+4)));  
  132.         default:  
  133.             return(-EINVAL);  
  134.     }  
  135. }  

下面再看看socket.c 即BSD socket层中的其余函数
[cpp] view plain copy print?
  1. /* 
  2.  *  Sockets are not seekable. 
  3.  */  
  4.   
  5. static int sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)  
  6. {  
  7.     return(-ESPIPE);  
  8. }  
  9.   
  10. /* 
  11.  *  Read data from a socket. ubuf is a user mode pointer. We make sure the user 
  12.  *  area ubuf...ubuf+size-1 is writable before asking the protocol. 
  13.  */  
  14.   
  15. static int sock_read(struct inode *inode, struct file *file, char *ubuf, int size)  
  16. {  
  17.     struct socket *sock;  
  18.     int err;  
  19.     
  20.     if (!(sock = socki_lookup(inode)))   
  21.     {  
  22.         printk("NET: sock_read: can't find socket for inode! ");  
  23.         return(-EBADF);  
  24.     }  
  25.     if (sock->flags & SO_ACCEPTCON)   
  26.         return(-EINVAL);  
  27.   
  28.     if(size<0)  
  29.         return -EINVAL;  
  30.     if(size==0)  
  31.         return 0;  
  32.     if ((err=verify_area(VERIFY_WRITE,ubuf,size))<0)  
  33.         return err;  
  34.     return(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));  
  35. }  
  36.   
  37. /* 
  38.  *  Write data to a socket. We verify that the user area ubuf..ubuf+size-1 is 
  39.  *  readable by the user process. 
  40.  */  
  41.   
  42. static int sock_write(struct inode *inode, struct file *file, char *ubuf, int size)  
  43. {  
  44.     struct socket *sock;  
  45.     int err;  
  46.       
  47.     if (!(sock = socki_lookup(inode)))   
  48.     {  
  49.         printk("NET: sock_write: can't find socket for inode! ");  
  50.         return(-EBADF);  
  51.     }  
  52.   
  53.     if (sock->flags & SO_ACCEPTCON)   
  54.         return(-EINVAL);  
  55.       
  56.     if(size<0)  
  57.         return -EINVAL;  
  58.     if(size==0)  
  59.         return 0;  
  60.           
  61.     if ((err=verify_area(VERIFY_READ,ubuf,size))<0)  
  62.         return err;  
  63.     return(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));  
  64. }  
  65.   
  66. /* 
  67.  *  You can't read directories from a socket! 
  68.  */  
  69.    
  70. static int sock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,  
  71.          int count)  
  72. {  
  73.     return(-EBADF);  
  74. }  
  75.   
  76. /* 
  77.  *  With an ioctl arg may well be a user mode pointer, but we don't know what to do 
  78.  *  with it - thats up to the protocol still. 
  79.  */  
  80.   
  81. int sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,  
  82.        unsigned long arg)  
  83. {  
  84.     struct socket *sock;  
  85.   
  86.     if (!(sock = socki_lookup(inode)))   
  87.     {  
  88.         printk("NET: sock_ioctl: can't find socket for inode! ");  
  89.         return(-EBADF);  
  90.     }  
  91.     return(sock->ops->ioctl(sock, cmd, arg));  
  92. }  
  93.   
  94.   
  95. static int sock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)  
  96. {  
  97.     struct socket *sock;  
  98.   
  99.     if (!(sock = socki_lookup(inode)))   
  100.     {  
  101.         printk("NET: sock_select: can't find socket for inode! ");  
  102.         return(0);  
  103.     }  
  104.   
  105.     /* 
  106.      *  We can't return errors to select, so it's either yes or no.  
  107.      */  
  108.   
  109.     if (sock->ops && sock->ops->select)  
  110.         return(sock->ops->select(sock, sel_type, wait));  
  111.     return(0);  
  112. }  
  113.   
  114.   
  115. void sock_close(struct inode *inode, struct file *filp)  
  116. {  
  117.     struct socket *sock;  
  118.   
  119.     /* 
  120.      *  It's possible the inode is NULL if we're closing an unfinished socket.  
  121.      */  
  122.   
  123.     if (!inode)   
  124.         return;  
  125. //找对inode对应的socket结构  
  126.     if (!(sock = socki_lookup(inode)))   
  127.     {  
  128.         printk("NET: sock_close: can't find socket for inode! ");  
  129.         return;  
  130.     }  
  131.     sock_fasync(inode, filp, 0);//更新异步通知列表  
  132.     sock_release(sock);//释放套接字  
  133. }  
  134.   
  135. /* 
  136.  *  Update the socket async list 
  137.  */  
  138. //输入参数on的取值决定是分配还是释放一个fasync_struct结构，该结构用于异步唤醒  
  139. static int sock_fasync(struct inode *inode, struct file *filp, int on)  
  140. {  
  141.     struct fasync_struct *fa, *fna=NULL, **prev;  
  142.     struct socket *sock;  
  143.     unsigned long flags;  
  144.       
  145.     if (on)//分配  
  146.     {  
  147.         fna=(struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);  
  148.         if(fna==NULL)  
  149.             return -ENOMEM;  
  150.     }  
  151.   
  152.     sock = socki_lookup(inode);  
  153.       
  154.     prev=&(sock->fasync_list);  
  155.       
  156.     save_flags(flags);//保存当前状态  
  157.     cli();  
  158.   
  159.     //从链表中找到与file结构对应的fasync_struct  
  160.     for(fa=*prev; fa!=NULL; prev=&fa->fa_next,fa=*prev)  
  161.         if(fa->fa_file==filp)  
  162.             break;  
  163.       
  164.     if(on)//分配后的建立联系  
  165.     {  
  166.         //如果已经有对应的file结构，则释放之前创建的  
  167.         if(fa!=NULL)  
  168.         {  
  169.             kfree_s(fna,sizeof(struct fasync_struct));  
  170.             restore_flags(flags);  
  171.             return 0;  
  172.         }  
  173.         //如果没有，则挂载这个新创建的结构  
  174.         fna->fa_file=filp;  
  175.         fna->magic=FASYNC_MAGIC;  
  176.         fna->fa_next=sock->fasync_list;  
  177.         sock->fasync_list=fna;  
  178.     }  
  179.     //释放  
  180.     else  
  181.     {  
  182.         if(fa!=NULL)  
  183.         {  
  184.             *prev=fa->fa_next;  
  185.             kfree_s(fa,sizeof(struct fasync_struct));  
  186.         }  
  187.     }  
  188.     restore_flags(flags);//恢复状态  
  189.     return 0;  
  190. }  
  191.   
  192. /*  
  193.  * 异步唤醒函数，通过遍历socket结构中fasync_list变量指向的队列， 
  194.  * 对队列中每个元素调用kill_fasync函数 
  195.  */  
  196. int sock_wake_async(struct socket *sock, int how)  
  197. {  
  198.     if (!sock || !sock->fasync_list)  
  199.         return -1;  
  200.     switch (how)  
  201.     {  
  202.         case 0:  
  203.             //kill_fasync函数即通过相应的进程发送信号。这就是异步唤醒功能  
  204.             kill_fasync(sock->fasync_list, SIGIO);  
  205.             break;  
  206.         case 1:  
  207.             if (!(sock->flags & SO_WAITDATA))  
  208.                 kill_fasync(sock->fasync_list, SIGIO);  
  209.             break;  
  210.         case 2:  
  211.             if (sock->flags & SO_NOSPACE)  
  212.             {  
  213.                 kill_fasync(sock->fasync_list, SIGIO);  
  214.                 sock->flags &= ~SO_NOSPACE;  
  215.             }  
  216.             break;  
  217.     }  
  218.     return 0;  
  219. }  
  220.   
  221.       
  222. /* 
  223.  *  只用于UNIX域名(iconn,conn只用于UNIX域)，用于处理一个客户端连接请求 
  224.  */  
  225.   
  226. int sock_awaitconn(struct socket *mysock, struct socket *servsock, int flags)  
  227. {  
  228.     struct socket *last;  
  229.   
  230.     /* 
  231.      *  We must be listening 
  232.      */  
  233.      //检查服务器端是否是处于监听状态，即可以进行连接  
  234.     if (!(servsock->flags & SO_ACCEPTCON))   
  235.     {  
  236.         return(-EINVAL);  
  237.     }  
  238.   
  239.     /* 
  240.      *  Put ourselves on the server's incomplete connection queue.  
  241.      */  
  242.      //将本次客户端连接的套接字插入服务器端，socket结构iconn字段指向的链表  
  243.      //表示客户端正等待连接  
  244.     mysock->next = NULL;  
  245.     cli();  
  246.     if (!(last = servsock->iconn))   
  247.         servsock->iconn = mysock;  
  248.     else   
  249.     {  
  250.         while (last->next)   
  251.             last = last->next;  
  252.         last->next = mysock;  
  253.     }  
  254.     mysock->state = SS_CONNECTING;//正在处理连接  
  255.     mysock->conn = servsock;//客户端连接的服务器端套接字  
  256.     sti();  
  257.   
  258.     /* 
  259.      * Wake up server, then await connection. server will set state to 
  260.      * SS_CONNECTED if we're connected. 
  261.      */  
  262.      //唤醒服务器端进程，以处理本地客户端连接  
  263.     wake_up_interruptible(servsock->wait);  
  264.     sock_wake_async(servsock, 0);  
  265.   
  266.     //检查连接状态  
  267.     if (mysock->state != SS_CONNECTED)   
  268.     {  
  269.         if (flags & O_NONBLOCK)  
  270.             return -EINPROGRESS;  
  271.         //等待服务器端处理本次连接  
  272.         interruptible_sleep_on(mysock->wait);  
  273.           
  274.         //检查连接状态，如果仍然没有建立连接  
  275.         if (mysock->state != SS_CONNECTED &&  
  276.             mysock->state != SS_DISCONNECTING)   
  277.         {  
  278.         /*原因如下 
  279.          * if we're not connected we could have been 
  280.          * 1) interrupted, so we need to remove ourselves 
  281.          *    from the server list 
  282.          * 2) rejected (mysock->conn == NULL), and have 
  283.          *    already been removed from the list 
  284.          */  
  285.          //如果被其他中断，需要主动将本地socket从对方服务器中iconn中删除  
  286.             if (mysock->conn == servsock)   
  287.             {  
  288.                 cli();  
  289.                 //找到iconn中的本地socket结构  
  290.                 if ((last = servsock->iconn) == mysock)  
  291.                     servsock->iconn = mysock->next;  
  292.                 else   
  293.                 {  
  294.                     while (last->next != mysock)   
  295.                         last = last->next;  
  296.                     last->next = mysock->next;  
  297.                 }  
  298.                 sti();  
  299.             }  
  300.             //被服务器拒绝，本地socket已经被删除，无需手动删除  
  301.             return(mysock->conn ? -EINTR : -EACCES);//两种原因情况的返回  
  302.         }  
  303.     }  
  304.     return(0);  
  305. }  
其余没有贴出的函数，也基本上是这么个流程。
socket.c 文件中函数的实现绝大多数都是简单调用下层函数，而这些下层函数就是af_inet.c 文件中定义的函数。socket.c 对应 BSD socket层，文件af_inet.c 则对应的是INET socket层。这些上下层次的表示从函数的嵌套调用关系上体现出来。

参考资料：《Linux 内核网络栈源代码情景分析》、Linux kernel 1.2.13
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ztguang/p/12645509.html