Linux网络协议栈(一) -- socket入门

原文地址：（一)  http://www.cnblogs.com/hustcat/archive/2009/09/17/1568738.html

（二）http://www.cnblogs.com/hustcat/archive/2009/09/17/1568765.html

1、TCP/IP参考模型

为了实现各种网络的互连，国际标准化组织(ISO)制定了开放式系统互连(OSI)参考模型。尽管OSI的体系结构从理论上讲是比较完整的，但实际上，完全符合OSI各层协议的商用产品却很少进入市场。而使用TCP/IP 协议的产品却大量涌入市场，几乎所有的工作站都配有TCP/IP协议，使得TCP/IP 成为计算机网络的实际的国际标准。


2、套接字(socket) 
socket是操作系统的重要组成部分之一，它是网络应用程序的基础。从层次上来说，它位于应用层，是操作系统为应用程序员提供的API，通过它，应用程序可以访问传输层协议。
1、socket 位于传输层协议之上，屏蔽了不同网络协议之间的差异；
2、socket是网络编程的入口，它提供了大量的系统调用，构成了网络程序的主体；
3、在Linux系统中，socket属于文件系统的一部分，网络通信可以被看作是对文件的读取，使得我们对网络的控制和对文件的控制一样方便。

2.1、套接字地址
在传输层上，通信端点可由Internet上3个参数描述：所用的协议、IP地址和端口号。这些内容由sockaddr描述：

// usr/include/sys/socket.h
typedef unsigned  short     sa_family_t;
// 通用socket地址
struct  sockaddr {
    sa_family_t    sa_family;     /*  address family, AF_xxx,协议簇 */
     char         sa_data[ 14 ];     /*  14 bytes of protocol address     */
};

// usr/include/netinet/in.h
// INET地址簇的socket地址
struct  in_addr {
                    __u32 s_addr;
};
struct  sockaddr_in   {
   sa_family_t            sin_family;       /*  Address family: AF_INET  */
   unsigned  short   int      sin_port;         /*  Port number,端口 */
    struct  in_addr         sin_addr;         /*  Internet address,IP地址 */

    /*  Pad to size of 'struct sockaddr' .  */
   unsigned  char  sin_zero[ sizeof  ( struct  sockaddr)  -
                           sizeof  (sa_family_t)  -
                           sizeof  (uint16_t)  -
                           sizeof  ( struct  in_addr)];
};

Linux 支持的套接字地址族：

套接字地址族	描述
UNIX	UNIX 域套接字
INET	通过 TCP/IP 协议支持的 Internet 地址族
AX25	Amater radio X25
APPLETALK	Appletalk DDP
IPX	Novell IPX
X25	X25

Linux 所支持的BSD套接字类型：

BSD 套接字类型	描述
流（stream）	这种套接字提供了可靠的双向顺序数据流，可保证数据不会在传输过程中丢失、破坏或重复出现。流套接字通过 INET 地址族的 TCP 协议实现。
数据报（datagram）	这种套接字也提供双向的数据传输，但是并不对数据的传输提供担保，也就是说，数据可能会以错误的顺序传递，甚至丢失或破坏。这种类型的套接字通过 INET 地址族的 UDP 协议实现。
原始（raw）	利用这种类型的套接字，进程可以直接访问底层协议（因此称为原始）。例如，可在某个以太网设备上打开原始套接字，然后获取原始的 IP 数据传输信息。
可靠发送的消息	和数据报套接字类似，但保证数据被正确传输到目的端。
顺序数据包	和流套接字类似，但数据包大小是固定的。
数据包（packet）	这并不是标准的 BSD 套接字类型，它是 Linux 专有的 BSD 套接字扩展，可允许进程直接在设备级访问数据包。

  2.2、套接字操作
套接字(更确切的说是BSD套接字)为应用程序提供了基本的API，这些API是编写网络应用程序的基础。

3、套接字的实现
套接字最先是在UNIX的BSD版本实现的，所以也叫做BSD套接字，它隐藏了各个协议之间的差异，并向上提供统一的接口。Linux中实现套接字的基本结构：

3.1、BSD套接字
3.1.1、核心数据结构
为了实现BSD套接字，内核提供一个重要的数据结构struct socket，它的定义如下：

// BSD套接字(include/linux/net.h)

struct  socket {
    socket_state         state;   // 套接字状态
    unsigned  long         flags;
     struct  proto_ops      * ops;    // 操作函数集
     struct  fasync_struct     * fasync_list;
     struct  file           * file;   // 每个BSD套接字都有一个inode结点,通过文件对象与其关联起来  
     struct  sock           * sk;     // socket内部结构,与具体的协议簇(比如PF_INET)相关
    wait_queue_head_t    wait;
     short                 type;    // 套接字类型：如SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, and SOCK_PACKET
    unsigned  char         passcred; 
};

//BSD套接字操作函数集
struct  proto_ops {
     int     family;
     struct  module     * owner;
     int     ( * release)    ( struct  socket  * sock);
     int     ( * bind)       ( struct  socket  * sock,  struct  sockaddr  * myaddr,  int  sockaddr_len);
     int     ( * connect)    ( struct  socket  * sock,  struct  sockaddr  * vaddr,   int  sockaddr_len,  int  flags);
     int     ( * socketpair) ( struct  socket  * sock1, struct  socket  * sock2);
     int     ( * accept)     ( struct  socket  * sock,  struct  socket  * newsock,  int  flags);
     int     ( * getname)    ( struct  socket  * sock,  struct  sockaddr  * addr,  int   * sockaddr_len,  int  peer);
    unsigned  int    ( * poll)   ( struct  file  * file,  struct  socket  * sock,  struct  poll_table_struct  * wait);
     int     ( * ioctl)      ( struct  socket  * sock, unsigned  int  cmd, unsigned  long  arg);
     int     ( * listen)     ( struct  socket  * sock,  int  len);
     int     ( * shutdown)   ( struct  socket  * sock,  int  flags);
     int     ( * setsockopt) ( struct  socket  * sock,  int  level,  int  optname,  char  __user  * optval,  int  optlen);
     int     ( * getsockopt) ( struct  socket  * sock,  int  level,  int  optname,  char  __user  * optval,  int  __user  * optlen);
     int     ( * sendmsg)    ( struct  kiocb  * iocb,  struct  socket  * sock,  struct  msghdr  * m, size_t total_len);
     int     ( * recvmsg)    ( struct  kiocb  * iocb,  struct  socket  * sock,  struct  msghdr  * m, size_t total_len,  int  flags);
     int     ( * mmap)       ( struct  file  * file,   struct  socket  * sock,  struct  vm_area_struct  *  vma);
    ssize_t  ( * sendpage) ( struct  socket  * sock,  struct  page  * page,  int  offset, size_t size,  int  flags);
};

// BSD套接字状态
typedef  enum  {
    SS_FREE  =   0 ,             /*  not allocated         */
    SS_UNCONNECTED,             /*  unconnected to any socket     */
    SS_CONNECTING,             /*  in process of connecting     */
    SS_CONNECTED,             /*  connected to socket         */
    SS_DISCONNECTING         /*  in process of disconnecting     */
} socket_state; 

3.1.2、BSD套接字初始化

// net/socket.c

// BSD套接字的初始化
void  __init sock_init( void )
{
     int  i;
     /*
     *    Initialize all address (protocol) families. 
      */
     for  (i  =   0 ; i  <  NPROTO; i ++ ) 
        net_families[i]  =  NULL;  // 协议簇数组初始化
     /*
     *    Initialize sock SLAB cache.
      */  
    sk_init();//分配sock缓存

#ifdef SLAB_SKB
     /*
     *    Initialize skbuff SLAB cache 
      */
    skb_init();
#endif
     /*
     *    Initialize the protocols module. 
      */
    init_inodecache();

     // 注册sockfs文件系统
    register_filesystem( & sock_fs_type);
     // 安装sockfs
    sock_mnt  =  kern_mount( & sock_fs_type);
     /*  The real protocol initialization is performed when
     *  do_initcalls is run.  
      */
#ifdef CONFIG_NETFILTER
    netfilter_init();
#endif
}

// net/socket.c
// sockfs文件系统的安装点
static   struct  vfsmount  * sock_mnt;
// sockfs文件系统类型
static   struct  file_system_type sock_fs_type  =  {
    .name      =     " sockfs " ,
    .get_sb    =    sockfs_get_sb,
    .kill_sb   =    kill_anon_super,
}; 
// 地址簇及协议信息
static   struct  net_proto_family  * net_families[NPROTO]; 

sock_init在系统初始化的被调用：

3.1.3、BSD套接字的系统调用
实际上，Linux内核只提供了一个与套接字相关的系统调用，即sys_socketcall，应用程序的所有套接字调用都会映射到这个系统调用上。

// BSD套接字调用入口(net/socket.c)
asmlinkage  long  sys_socketcall( int  call, unsigned  long  __user  * args)
{
    unsigned  long  a[ 6 ];
    unsigned  long  a0,a1;
     int  err;

     if (call < 1 || call > SYS_RECVMSG)
         return   - EINVAL;

     /*  copy_from_user should be SMP safe.  */
     if  (copy_from_user(a, args, nargs[call])) // 从用户区拷贝参数
         return   - EFAULT;
        
    a0 = a[ 0 ];
    a1 = a[ 1 ];
    
     switch (call)   // 调用相应的函数
    {
         case  SYS_SOCKET:
            err  =  sys_socket(a0,a1,a[ 2 ]);
             break ;
         case  SYS_BIND:
            err  =  sys_bind(a0,( struct  sockaddr __user  * )a1, a[ 2 ]);
             break ;
         case  SYS_CONNECT:
            err  =  sys_connect(a0, ( struct  sockaddr __user  * )a1, a[ 2 ]);
             break ;
         case  SYS_LISTEN:
            err  =  sys_listen(a0,a1);
             break ;
         case  SYS_ACCEPT:
            err  =  sys_accept(a0,( struct  sockaddr __user  * )a1, ( int  __user  * )a[ 2 ]);
             break ;
         case  SYS_GETSOCKNAME:
            err  =  sys_getsockname(a0,( struct  sockaddr __user  * )a1, ( int  __user  * )a[ 2 ]);
             break ;
         case  SYS_GETPEERNAME:
            err  =  sys_getpeername(a0, ( struct  sockaddr __user  * )a1, ( int  __user  * )a[ 2 ]);
             break ;
         case  SYS_SOCKETPAIR:
            err  =  sys_socketpair(a0,a1, a[ 2 ], ( int  __user  * )a[ 3 ]);
             break ;
         case  SYS_SEND:
            err  =  sys_send(a0, ( void  __user  * )a1, a[ 2 ], a[ 3 ]);
             break ;
         case  SYS_SENDTO:
            err  =  sys_sendto(a0,( void  __user  * )a1, a[ 2 ], a[ 3 ],
                     ( struct  sockaddr __user  * )a[ 4 ], a[ 5 ]);
             break ;
         case  SYS_RECV:
            err  =  sys_recv(a0, ( void  __user  * )a1, a[ 2 ], a[ 3 ]);
             break ;
         case  SYS_RECVFROM:
            err  =  sys_recvfrom(a0, ( void  __user  * )a1, a[ 2 ], a[ 3 ],
                       ( struct  sockaddr __user  * )a[ 4 ], ( int  __user  * )a[ 5 ]);
             break ;
         case  SYS_SHUTDOWN:
            err  =  sys_shutdown(a0,a1);
             break ;
         case  SYS_SETSOCKOPT:
            err  =  sys_setsockopt(a0, a1, a[ 2 ], ( char  __user  * )a[ 3 ], a[ 4 ]);
             break ;
         case  SYS_GETSOCKOPT:
            err  =  sys_getsockopt(a0, a1, a[ 2 ], ( char  __user  * )a[ 3 ], ( int  __user  * )a[ 4 ]);
             break ;
         case  SYS_SENDMSG:
            err  =  sys_sendmsg(a0, ( struct  msghdr __user  * ) a1, a[ 2 ]);
             break ;
         case  SYS_RECVMSG:
            err  =  sys_recvmsg(a0, ( struct  msghdr __user  * ) a1, a[ 2 ]);
             break ;
         default :
            err  =   - EINVAL;
             break ;
    }
     return  err;
}

// include/asm/unistd.h
#define  __NR_socketcall        102   // 系统调用号

下面来看一下sys_socket的实现：

//net/socket.c
/*创建socket
**首先建立一个socket数据结构，然后将其“映射”到一个已打开的文件.
*/
asmlinkage long sys_socket(int family, int type, int protocol)
{
    int retval;
    struct socket *sock;
    //创建socket
    retval = sock_create(family, type, protocol, &sock);
    if (retval < 0)
        goto out;
    //将socket映射到文件描述符
    retval = sock_map_fd(sock);
    if (retval < 0)
        goto out_release;

out:
    /* It may be already another descriptor 8) Not kernel problem. */
    return retval;

out_release:
    sock_release(sock);
    return retval;
}

int sock_create(int family, int type, int protocol, struct socket **res)
{
    return __sock_create(family, type, protocol, res, 0);
}

static int __sock_create(int family, int type, int protocol, struct socket **res, int kern)
{
    int i;
    int err;
    struct socket *sock;

    /*
     *    Check protocol is in range
     */
     //检查协议是否可用
    if (family < 0 || family >= NPROTO)
        return -EAFNOSUPPORT;
    if (type < 0 || type >= SOCK_MAX)
        return -EINVAL;

    /* Compatibility.

       This uglymoron is moved from INET layer to here to avoid
       deadlock in module load.
     */
    if (family == PF_INET && type == SOCK_PACKET) {
        static int warned; 
        if (!warned) {
            warned = 1;
            printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", current->comm);
        }
        family = PF_PACKET;
    }

    err = security_socket_create(family, type, protocol, kern);
    if (err)
        return err;
        
#if defined(CONFIG_KMOD)
    /* Attempt to load a protocol module if the find failed. 
     * 
     * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 
     * requested real, full-featured networking support upon configuration.
     * Otherwise module support will break!
     */
    if (net_families[family]==NULL)
    {
        request_module("net-pf-%d",family);
    }
#endif

    net_family_read_lock();
    if (net_families[family] == NULL) {
        i = -EAFNOSUPPORT;
        goto out;
    }

/*
 *    Allocate the socket and allow the family to set things up. if
 *    the protocol is 0, the family is instructed to select an appropriate
 *    default.
 */
    //从sockfs分配一个inode,并为之分配一个套接字结构
    if (!(sock = sock_alloc())) 
    {
        printk(KERN_WARNING "socket: no more sockets\n");
        i = -ENFILE;        /* Not exactly a match, but its the
                       closest posix thing */
        goto out;
    }
    //设置类型
    sock->type  = type;

    /*
     * We will call the ->create function, that possibly is in a loadable
     * module, so we have to bump that loadable module refcnt first.
     */
    i = -EAFNOSUPPORT;
    if (!try_module_get(net_families[family]->owner))
        goto out_release;
    
    //调用具体协议的create函数
    if ((i = net_families[family]->create(sock, protocol)) < 0)
        goto out_module_put;
    /*
     * Now to bump the refcnt of the [loadable] module that owns this
     * socket at sock_release time we decrement its refcnt.
     */
    if (!try_module_get(sock->ops->owner)) {
        sock->ops = NULL;
        goto out_module_put;
    }
    /*
     * Now that we're done with the ->create function, the [loadable]
     * module can have its refcnt decremented
     */
    module_put(net_families[family]->owner);
    *res = sock;
    security_socket_post_create(sock, family, type, protocol, kern);

out:
    net_family_read_unlock();
    return i;
out_module_put:
    module_put(net_families[family]->owner);
out_release:
    sock_release(sock);
    goto out;
}
///////////////////////////////////////////////////////////

int sock_map_fd(struct socket *sock)
{
    int fd;
    struct qstr this;
    char name[32];

    /*
     *    Find a file descriptor suitable for return to the user. 
     */
    //分配一个没有使用的描述符
    fd = get_unused_fd();
    if (fd >= 0) {
        struct file *file = get_empty_filp();

        if (!file) {
            put_unused_fd(fd);
            fd = -ENFILE;
            goto out;
        }

        sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
        this.name = name;
        this.len = strlen(name);
        this.hash = SOCK_INODE(sock)->i_ino;
        
        //从sockfs文件系统中分配一个目录项对象
        file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
        if (!file->f_dentry) {
            put_filp(file);
            put_unused_fd(fd);
            fd = -ENOMEM;
            goto out;
        }
        file->f_dentry->d_op = &sockfs_dentry_operations;
        
        //将目录项对象与sock的索引节点关联起来
        d_add(file->f_dentry, SOCK_INODE(sock));
        file->f_vfsmnt = mntget(sock_mnt);
        file->f_mapping = file->f_dentry->d_inode->i_mapping;
        
        //设置sock对应的文件对象
        sock->file = file;
        
        //设置文件对象的操作函数
        file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops;
        file->f_mode = FMODE_READ | FMODE_WRITE;
        file->f_flags = O_RDWR;
        file->f_pos = 0;
        fd_install(fd, file);
    }

out:
    return fd;
}

3.2、INET套接字

INET套接字就是支持 Internet 地址族的套接字，它位于TCP协议之上， BSD套接字之下，如下：

3.2.1、数据结构

//include/net/sock.h
//与特定协议相关的socket
struct sock {
    /*
     * Now struct tcp_tw_bucket also uses sock_common, so please just
     * don't add nothing before this first member (__sk_common) --acme
     */
struct sock_common        __sk_common;
#define sk_family         __sk_common.skc_family
#define sk_state          __sk_common.skc_state
#define sk_reuse          __sk_common.skc_reuse
#define sk_bound_dev_if   __sk_common.skc_bound_dev_if
#define sk_node           __sk_common.skc_node
#define sk_bind_node      __sk_common.skc_bind_node
#define sk_refcnt         __sk_common.skc_refcnt
volatile unsigned char    sk_zapped;
    unsigned char        sk_shutdown;
    unsigned char        sk_use_write_queue;
    unsigned char        sk_userlocks;
    socket_lock_t        sk_lock;
    int            sk_rcvbuf;
    wait_queue_head_t    *sk_sleep;
    struct dst_entry    *sk_dst_cache;
    rwlock_t        sk_dst_lock;
    struct xfrm_policy    *sk_policy[2];
    atomic_t        sk_rmem_alloc;
    struct sk_buff_head    sk_receive_queue;
    atomic_t        sk_wmem_alloc;
    struct sk_buff_head    sk_write_queue;
    atomic_t        sk_omem_alloc;
    int            sk_wmem_queued;
    int            sk_forward_alloc;
    unsigned int        sk_allocation;
    int            sk_sndbuf;
    unsigned long         sk_flags;
    char             sk_no_check;
    unsigned char        sk_debug;
    unsigned char        sk_rcvtstamp;
    unsigned char        sk_no_largesend;
    int            sk_route_caps;
    unsigned long            sk_lingertime;
    int            sk_hashent;
    /*
     * The backlog queue is special, it is always used with
     * the per-socket spinlock held and requires low latency
     * access. Therefore we special case it's implementation.
     */
    struct {
        struct sk_buff *head;
        struct sk_buff *tail;
    } sk_backlog;
    rwlock_t        sk_callback_lock;
    struct sk_buff_head    sk_error_queue;
    
    struct proto        *sk_prot;
    
    int            sk_err,
                sk_err_soft;
    unsigned short        sk_ack_backlog;
    unsigned short        sk_max_ack_backlog;
    __u32            sk_priority;
    unsigned short        sk_type;
    unsigned char        sk_localroute;
    unsigned char        sk_protocol;
    struct ucred        sk_peercred;
    int            sk_rcvlowat;
    long            sk_rcvtimeo;
    long            sk_sndtimeo;
    struct sk_filter          *sk_filter;
    void            *sk_protinfo;
    kmem_cache_t        *sk_slab;
    struct timer_list    sk_timer;
    struct timeval        sk_stamp;
    struct socket        *sk_socket;
    void            *sk_user_data;
    struct module        *sk_owner;
    struct page        *sk_sndmsg_page;
    __u32            sk_sndmsg_off;
    struct sk_buff        *sk_send_head;
    int            sk_write_pending;
    void            *sk_security;
    __u8            sk_queue_shrunk;
    /* three bytes hole, try to pack */
    void            (*sk_state_change)(struct sock *sk);
    void            (*sk_data_ready)(struct sock *sk, int bytes);
    void            (*sk_write_space)(struct sock *sk);
    void            (*sk_error_report)(struct sock *sk);
      int            (*sk_backlog_rcv)(struct sock *sk,
                          struct sk_buff *skb);  
    void                    (*sk_destruct)(struct sock *sk);
};

//底层协议的操作函数
struct proto {
    void            (*close)(struct sock *sk, 
                    long timeout);
    int            (*connect)(struct sock *sk,
                        struct sockaddr *uaddr, 
                    int addr_len);
    int            (*disconnect)(struct sock *sk, int flags);

    struct sock *        (*accept) (struct sock *sk, int flags, int *err);

    int            (*ioctl)(struct sock *sk, int cmd,
                     unsigned long arg);
    int            (*init)(struct sock *sk);
    int            (*destroy)(struct sock *sk);
    void            (*shutdown)(struct sock *sk, int how);
    int            (*setsockopt)(struct sock *sk, int level, 
                    int optname, char __user *optval,
                    int optlen);
    int            (*getsockopt)(struct sock *sk, int level, 
                    int optname, char __user *optval, 
                    int __user *option);       
    int            (*sendmsg)(struct kiocb *iocb, struct sock *sk,
                       struct msghdr *msg, size_t len);
    int            (*recvmsg)(struct kiocb *iocb, struct sock *sk,
                       struct msghdr *msg,
                    size_t len, int noblock, int flags, 
                    int *addr_len);
    int            (*sendpage)(struct sock *sk, struct page *page,
                    int offset, size_t size, int flags);
    int            (*bind)(struct sock *sk, 
                    struct sockaddr *uaddr, int addr_len);

    int            (*backlog_rcv) (struct sock *sk, 
                        struct sk_buff *skb);

    /* Keeping track of sk's, looking them up, and port selection methods. */
    void            (*hash)(struct sock *sk);
    void            (*unhash)(struct sock *sk);
    int            (*get_port)(struct sock *sk, unsigned short snum);

    /* Memory pressure */
    void            (*enter_memory_pressure)(void);
    atomic_t        *memory_allocated;    /* Current allocated memory. */
    atomic_t        *sockets_allocated;    /* Current number of sockets. */
    /*
     * Pressure flag: try to collapse.
     * Technical note: it is used by multiple contexts non atomically.
     * All the sk_stream_mem_schedule() is of this nature: accounting
     * is strict, actions are advisory and have some latency.
     */
    int            *memory_pressure;
    int            *sysctl_mem;
    int            *sysctl_wmem;
    int            *sysctl_rmem;
    int            max_header;

    kmem_cache_t        *slab;
    int            slab_obj_size;

    struct module        *owner;

    char            name[32];

    struct {
        int inuse;
        u8  __pad[SMP_CACHE_BYTES - sizeof(int)];
    } stats[NR_CPUS];
};

inet_init()函数：

//net/ipv4/af_inet.c
/*系统初始化时被调用
**调用路径:start_kernel() -->init() -->do_basic_setup() -->do_initcalls()-->inet_init()
*/
static int __init inet_init(void)
{
    struct sk_buff *dummy_skb;
    struct inet_protosw *q;
    struct list_head *r;
    int rc = -EINVAL;

    if (sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb)) {
        printk(KERN_CRIT "%s: panic\n", __FUNCTION__);
        goto out;
    }

    rc = sk_alloc_slab(&tcp_prot, "tcp_sock");
    if (rc) {
        sk_alloc_slab_error(&tcp_prot);
        goto out;
    }
    rc = sk_alloc_slab(&udp_prot, "udp_sock");
    if (rc) {
        sk_alloc_slab_error(&udp_prot);
        goto out_tcp_free_slab;
    }
    rc = sk_alloc_slab(&raw_prot, "raw_sock");
    if (rc) {
        sk_alloc_slab_error(&raw_prot);
        goto out_udp_free_slab;
    }

    /*
     *    Tell SOCKET that we are alive 
     */
    //注册Internet协议簇的相关信息
      (void)sock_register(&inet_family_ops);

    /*
     *    Add all the base protocols.
     */
    //添加基本的协议
    if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
        printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
    if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
        printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
    if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
        printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
#ifdef CONFIG_IP_MULTICAST
    if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
        printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
#endif

    /* Register the socket-side information for inet_create. */
    for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
        INIT_LIST_HEAD(r);
        
  //将inetsw_array中元素加入到inetsw链表中
    for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
        inet_register_protosw(q);

    /*
     *    Set the ARP module up
     */

    arp_init(); //ARP协议初始化

      /*
       *    Set the IP module up
       */

    ip_init(); //IP协议初始化

    tcp_v4_init(&inet_family_ops);

    /* Setup TCP slab cache for open requests. */
    tcp_init();


    /*
     *    Set the ICMP layer up
     */

    icmp_init(&inet_family_ops);

    /*
     *    Initialise the multicast router
     */
#if defined(CONFIG_IP_MROUTE)
    ip_mr_init();
#endif
    /*
     *    Initialise per-cpu ipv4 mibs
     */ 

    if(init_ipv4_mibs())
        printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n"); ;
    
    ipv4_proc_init();

    ipfrag_init();

    rc = 0;
out:
    return rc;
out_tcp_free_slab:
    sk_free_slab(&tcp_prot);
out_udp_free_slab:
    sk_free_slab(&udp_prot);
    goto out;
}

//net/ipv4/af_inet.c
//INET协议簇信息
static struct net_proto_family inet_family_ops = {
    .family  = PF_INET,
    .create  = inet_create,
    .owner   = THIS_MODULE,
};

static struct list_head inetsw[SOCK_MAX];
//该数组中的所有元素都会插入到inetsw的链表中
static struct inet_protosw inetsw_array[] =
{
        {
                .type =       SOCK_STREAM,
                .protocol =   IPPROTO_TCP,
                .prot =       &tcp_prot,
                .ops =        &inet_stream_ops,
                .capability = -1,
                .no_check =   0,
                .flags =      INET_PROTOSW_PERMANENT,
        },

        {
                .type =       SOCK_DGRAM,
                .protocol =   IPPROTO_UDP,
                .prot =       &udp_prot,
                .ops =        &inet_dgram_ops,
                .capability = -1,
                .no_check =   UDP_CSUM_DEFAULT,
                .flags =      INET_PROTOSW_PERMANENT,
       },
        
       {
               .type =       SOCK_RAW,
               .protocol =   IPPROTO_IP,    /* wild card */
               .prot =       &raw_prot,
               .ops =        &inet_sockraw_ops,
               .capability = CAP_NET_RAW,
               .no_check =   UDP_CSUM_DEFAULT,
               .flags =      INET_PROTOSW_REUSE,
       }
};

//流套接字操作函数
struct proto_ops inet_stream_ops = {
    .family     =    PF_INET,
    .owner      =    THIS_MODULE,
    .release    =    inet_release,
    .bind       =    inet_bind,
    .connect    =    inet_stream_connect,
    .socketpair =    sock_no_socketpair,
    .accept     =    inet_accept,
    .getname    =    inet_getname,
    .poll       =    tcp_poll,
    .ioctl      =    inet_ioctl,
    .listen     =    inet_listen,
    .shutdown   =    inet_shutdown,
    .setsockopt =    sock_common_setsockopt,
    .getsockopt =    sock_common_getsockopt,
    .sendmsg    =    inet_sendmsg,
    .recvmsg    =    sock_common_recvmsg,
    .mmap       =    sock_no_mmap,
    .sendpage   =    tcp_sendpage
};
//tcp协议
static struct net_protocol tcp_protocol = {
    .handler     =   tcp_v4_rcv,
    .err_handler =   tcp_v4_err,
    .no_policy   =   1,
};

static struct net_protocol udp_protocol = {
    .handler     =   udp_rcv,
    .err_handler =   udp_err,
    .no_policy   =   1,
};

static struct net_protocol icmp_protocol = {
    .handler   =   icmp_rcv,
};


//net/ipv4/tcp_ipv4.c
//tcp协议的操作函数
struct proto tcp_prot = {
    .name             = "TCP",
    .owner            = THIS_MODULE,
    .close            = tcp_close,
    .connect          = tcp_v4_connect,
    .disconnect       = tcp_disconnect,
    .accept           = tcp_accept,
    .ioctl            = tcp_ioctl,
    .init             = tcp_v4_init_sock,
    .destroy          = tcp_v4_destroy_sock,
    .shutdown         = tcp_shutdown,
    .setsockopt       = tcp_setsockopt,
    .getsockopt       = tcp_getsockopt,
    .sendmsg          = tcp_sendmsg,
    .recvmsg          = tcp_recvmsg,
    .backlog_rcv      = tcp_v4_do_rcv,
    .hash             = tcp_v4_hash,
    .unhash           = tcp_unhash,
    .get_port         = tcp_v4_get_port,
    .enter_memory_pressure = tcp_enter_memory_pressure,
    .sockets_allocated     = &tcp_sockets_allocated,
    .memory_allocated      = &tcp_memory_allocated,
    .memory_pressure       = &tcp_memory_pressure,
    .sysctl_mem       = sysctl_tcp_mem,
    .sysctl_wmem      = sysctl_tcp_wmem,
    .sysctl_rmem      = sysctl_tcp_rmem,
    .max_header       = MAX_TCP_HEADER,
    .slab_obj_size    = sizeof(struct tcp_sock),
};

sock_register()函数：

//注册协议簇
int sock_register(struct net_proto_family *ops)
{
    int err;

    if (ops->family >= NPROTO) {
        printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
        return -ENOBUFS;
    }
    net_family_write_lock();
    err = -EEXIST;
    if (net_families[ops->family] == NULL) {
        net_families[ops->family]=ops;
        err = 0;
    }
    net_family_write_unlock();
    printk(KERN_INFO "NET: Registered protocol family %d\n",
           ops->family);
    return err;
}

inet_create()函数

//创建一个INET套接字
static int inet_create(struct socket *sock, int protocol)
{
    struct sock *sk;
    struct list_head *p;
    struct inet_protosw *answer;
    struct inet_opt *inet;
    struct proto *answer_prot;
    unsigned char answer_flags;
    char answer_no_check;
    int err;

    sock->state = SS_UNCONNECTED;

    /* Look for the requested type/protocol pair. */
    answer = NULL;
    rcu_read_lock();
    list_for_each_rcu(p, &inetsw[sock->type]) {
        answer = list_entry(p, struct inet_protosw, list);

        /* Check the non-wild match. */
        if (protocol == answer->protocol) {
            if (protocol != IPPROTO_IP)
                break;
        } else {
            /* Check for the two wild cases. */
            if (IPPROTO_IP == protocol) {
                protocol = answer->protocol;
                break;
            }
            if (IPPROTO_IP == answer->protocol)
                break;
        }
        answer = NULL;
    }

    err = -ESOCKTNOSUPPORT;
    if (!answer)
        goto out_rcu_unlock;
    err = -EPERM;
    if (answer->capability > 0 && !capable(answer->capability))
        goto out_rcu_unlock;
    err = -EPROTONOSUPPORT;
    if (!protocol)
        goto out_rcu_unlock;
    
    //BSD socket的操作函数
    sock->ops = answer->ops;
    answer_prot = answer->prot;
    
    answer_no_check = answer->no_check;
    answer_flags = answer->flags;
    rcu_read_unlock();

    BUG_TRAP(answer_prot->slab != NULL);

    err = -ENOBUFS;
    sk = sk_alloc(PF_INET, GFP_KERNEL,
              answer_prot->slab_obj_size,
              answer_prot->slab);
    if (sk == NULL)
        goto out;

    err = 0;
    //特定协议套接字的操作函数
    sk->sk_prot = answer_prot;
    sk->sk_no_check = answer_no_check;
    if (INET_PROTOSW_REUSE & answer_flags)
        sk->sk_reuse = 1;

    inet = inet_sk(sk);

    if (SOCK_RAW == sock->type) {
        inet->num = protocol;
        if (IPPROTO_RAW == protocol)
            inet->hdrincl = 1;
    }

    if (ipv4_config.no_pmtu_disc)
        inet->pmtudisc = IP_PMTUDISC_DONT;
    else
        inet->pmtudisc = IP_PMTUDISC_WANT;

    inet->id = 0;
    //将sock与sk关联起来
    sock_init_data(sock, sk);
    sk_set_owner(sk, sk->sk_prot->owner);

    sk->sk_destruct       = inet_sock_destruct;
    sk->sk_family       = PF_INET;
    sk->sk_protocol       = protocol;
    sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;

    inet->uc_ttl    = -1;
    inet->mc_loop    = 1;
    inet->mc_ttl    = 1;
    inet->mc_index    = 0;
    inet->mc_list    = NULL;

#ifdef INET_REFCNT_DEBUG
    atomic_inc(&inet_sock_nr);
#endif

    if (inet->num) {
        /* It assumes that any protocol which allows
         * the user to assign a number at socket
         * creation time automatically
         * shares.
         */
        inet->sport = htons(inet->num);
        /* Add to protocol hash chains. */
        sk->sk_prot->hash(sk);
    }
    //调用init函数
    if (sk->sk_prot->init) {
        err = sk->sk_prot->init(sk);
        if (err)
            sk_common_release(sk);
    }
out:
    return err;
out_rcu_unlock:
    rcu_read_unlock();
    goto out;
}