zoukankan      html  css  js  c++  java

  • 【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
  • 相关阅读:
    学习WindowsPhone 2013/12/22
    spring-aop学习
    easymock+junit+spring学习·
    javaWeb实现文件上传与下载 （转）
    Java实现视频网站的视频上传、视频转码、视频关键帧抽图, 及视频播放功能
    jsp自定义标签
    listener监听器
    移植一个项目到本地的问题
    struts1拦截器
    eclipse开发 javafx（转）
  • 原文地址：https://www.cnblogs.com/ztguang/p/12645509.html
Copyright © 2011-2022 走看看