Socket接口（基于 Linux-2.4.0已更新）

Socket接口的分层

Socket的英文原本意思是 孔 或 插座。但在计算机科学中通常被称作为 套接字，主要用于相同机器的不同进程间或者不同机器间的通信。Socket的使用很多网络编程的书籍都有介绍，所以本文不打算介绍Socket的使用，只讨论Socket的具体实现，所以如果对Socket不太了解的同学可以先查阅Socket相关的资料或者书籍。

在Linux内核中，Socket的实现分为三层，第一层是 GLIBC接口层，第二层是 BSD接口层，第三层是 具体的协议层（如Unix sokcet或者INET socket）。如下图所示：

GLIBC层在用户态实现，提供一系列的socket族系统调用让用户使用。BSD层在内核态实现，主要是为了让不同的协议能够使用同一套接口来访问而创造的，如上图所示， Unix socket 和 Inet socket 都可以通过接入 BSD接口层 来向用户提供相同的接口。 具体的协议层 是为了实现不同的协议或者功能而存在的，如 Unix socket 主要是用于进程间通信，Inet socket 主要用于网络数据传输等。

GLIBC接口层

GLIBC接口层 提供了一系列的接口函数供用户使用（可以成为 Socket族系统调用），如下：

socket()
bind()
listen()
accept()
connect()
recv()
send()
recvfrom()
sendto()
...

例如 socket() 接口用于创建一个socket句柄，而 bind() 函数将一个socket绑定到指定的IP和端口上。当然，系统调用最终都会调用到内核态的某个内核函数来进行处理，在系统调用一章我们介绍过相关的原理，所以这里只会介绍一下这些系统调用最终会调用哪些内核函数。

GLIBC层实现原理

我们先来看看 GLIBC 是怎么定义这些系统调用的吧，首先来看看 socket() 函数的定义如下：

#define P(a, b) P2(a, b)
#define P2(a, b) a##b

    .text

.globl P(__,socket)
ENTRY (P(__,socket))
    movl %ebx, %edx

    movl $SYS_ify(socketcall), %eax        // 系统调用号

    movl $P(SOCKOP_,socket), %ebx          // 系统调用的第一个参数
    lea 4(%esp), %ecx                      // 系统调用的第二个参数

    int $0x80

    movl %edx, %ebx

    cmpl $-125, %eax
    jae syscall_error

    ret

虽然 socket() 函数是使用汇编来实现的，但是也比较容易理解，我们已经知道在用户态必须使用 int 0x80 中断来触发系统调用的，而要调用的系统调用编号保存在寄存器 eax 中，第一个参数保存在 ebx 寄存器中，而第二个参数保存在 ecx 中。

所以从上面的代码可以看出，调用 socket() 函数时会把 eax 的值设置为 sys_socketcall，把 ebx 的值会设置为 SOCKOP_socket，而把 ecx 的值设置为调用 socket() 函数时第一个参数的地址。然后通过代码 int 0x80 来触发一次系统调用中断，那么最终调用的是 sys_socketcall() 内核函数，而第一个参数的值为 SOCKOP_socket，第二个参数的值为调用 socket() 函数时第一个参数的地址。

那么 bind() 函数又是怎么定义的呢？因为有了 socket() 函数的定义，那么所有 Socket族系统调用 都可以使用这个模板来实现，例如 bind() 函数的定义如下：

#define	socket	bind
#include <socket.S>

可以看到，bind() 函数直接套用了 socket() 函数实现的模板，只是把 socket 这个名字替换成 bind 而已，替换之后 ebx 的值就会变成 SOCKOP_bind，其他都跟 socket() 函数一样，所以这时传给 sys_socketcall() 函数的第一个参数就变成 SOCKOP_bind了。

BSD接口层

前面说了，BSD接口层 是为了能够使用相同的接口来操作不同协议而创造的。有面向对象编程经验的读者可能会发现，BSD接口层 使用的技巧与面向对象的 接口 概念非常相似。主要的方式是 BSD接口层 定义了一些接口，具体的协议层 必须实现这些接口才能接入到 BSD接口层。

为了实现这种机制，Linux定义了一个 struct socket 的结构体，每个socket都与一个 struct socket 的结构对应，其定义如下：

struct socket
{
    socket_state          state;

    unsigned long         flags;
    struct proto_ops     *ops;
    struct inode         *inode;
    struct fasync_struct *fasync_list;
    struct file          *file;
    struct sock          *sk;
    wait_queue_head_t    wait;

    short                type;
    unsigned char        passcred;
};

可以把这个结构体想象成钩子，要在上面挂什么由用户自己决定。其比较重要的字段是 ops 和 sk。ops 字段类型为 struct proto_ops，其定义了一系列操作socket的方法。而 sk 字段的类型为 struct sock，用于保存具体协议所操作的真实对象。

我们先来看看 struct proto_ops 结构的定义：

struct proto_ops {
  int   family;

  int   (*release)(struct socket *sock);
  int   (*bind)(struct socket *sock, struct sockaddr *umyaddr,
                int sockaddr_len);
  int   (*connect)(struct socket *sock, struct sockaddr *uservaddr,
             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 *uaddr,
                   int *usockaddr_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 *optval, int optlen);
  int   (*getsockopt)(struct socket *sock, int level, int optname,
                      char *optval, int *optlen);
  int   (*sendmsg)(struct socket *sock, struct msghdr *m, int total_len, struct scm_cookie *scm);
  int   (*recvmsg)(struct socket *sock, struct msghdr *m, int total_len, int flags, struct scm_cookie *scm);
  int   (*mmap)(struct file *file, struct socket *sock, struct vm_area_struct * vma);
};

从上面的代码可以看出，struct proto_ops 结构主要是定义一系列的函数接口，每个 具体的协议层 必须提供一个 struct proto_ops 结构挂载到 struct socket 结构的 ops 字段上。所以当用户调用 bind() 系统调用时真实调用的是：socket->ops->bind()。

sys_socketcall()函数

前面说过，所有的 Socket族系统调用 最终都会调用 sys_socketcall() 函数来处理用户的请求，我们来看看 sys_socketcall() 函数的实现：

asmlinkage long sys_socketcall(int call, unsigned long *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 *)a1, a[2]);
            break;
        case SYS_CONNECT:
            err = sys_connect(a0, (struct sockaddr *)a1, a[2]);
            break;
        ...
    }
    return err;
}

从 sys_socketcall() 函数可以看出，根据参数 call 不同的值会调用不同的内核函数，譬如 call 的值为 SYS_SOCKET 时会调用 sys_socket() 函数，而 call 的值为 SYS_BIND 时会调用 sys_bind() 函数。而参数 args 就是在用户态给 Socket族系统调用 传入的参数列表地址，Linux内核会先使用 copy_from_user() 函数把这些参数复制到内核空间。

前面说过，在用户空间调用 socket() 系统调用时会把参数 call 的值设置为 SOCKOP_socket，它的值跟 sys_socketcall() 函数中 SYS_SOCKET 是一致的，我们可以通过下面的代码看出端倪：

// GLIBC 的定义
#define SOCKOP_socket       1
#define SOCKOP_bind         2
#define SOCKOP_connect      3
#define SOCKOP_listen       4
#define SOCKOP_accept       5
#define SOCKOP_getsockname  6
#define SOCKOP_getpeername  7
#define SOCKOP_socketpair   8
#define SOCKOP_send         9
#define SOCKOP_recv         10
#define SOCKOP_sendto       11
#define SOCKOP_recvfrom     12
#define SOCKOP_shutdown     13
#define SOCKOP_setsockopt   14
#define SOCKOP_getsockopt   15
#define SOCKOP_sendmsg      16
#define SOCKOP_recvmsg      17

// Linux 内核的定义
#define SYS_SOCKET      1       /* sys_socket(2)        */
#define SYS_BIND        2       /* sys_bind(2)          */
#define SYS_CONNECT     3       /* sys_connect(2)       */
#define SYS_LISTEN      4       /* sys_listen(2)        */
#define SYS_ACCEPT      5       /* sys_accept(2)        */
#define SYS_GETSOCKNAME 6       /* sys_getsockname(2)   */
#define SYS_GETPEERNAME 7       /* sys_getpeername(2)   */
#define SYS_SOCKETPAIR  8       /* sys_socketpair(2)    */
#define SYS_SEND        9       /* sys_send(2)          */
#define SYS_RECV        10      /* sys_recv(2)          */
#define SYS_SENDTO      11      /* sys_sendto(2)        */
#define SYS_RECVFROM    12      /* sys_recvfrom(2)      */
#define SYS_SHUTDOWN    13      /* sys_shutdown(2)      */
#define SYS_SETSOCKOPT  14      /* sys_setsockopt(2)    */
#define SYS_GETSOCKOPT  15      /* sys_getsockopt(2)    */
#define SYS_SENDMSG     16      /* sys_sendmsg(2)       */
#define SYS_RECVMSG     17      /* sys_recvmsg(2)       */

从上面的定义可以看出，在 GLIBC 中的定义跟 Linux 内核中的定义是一一对应的。

所以从中得到，当在用户态调用 socket() 函数时实际调用的是 sys_socket() 内核函数，其他的 Socket族系统调用 道理与 socket() 系统调用一致。

通过下面一幅图来展示 Socket族系统调用 的原理：

sys_socket()函数

sys_socket() 函数用于创建一个 socket 对象，并且返回一个文件描述符。其实现如下：

asmlinkage long sys_socket(int family, int type, int protocol)
{
    int retval;
    struct socket *sock;

    retval = sock_create(family, type, protocol, &sock);
    if (retval < 0)
        goto out;

    retval = sock_map_fd(sock);
    if (retval < 0)
        goto out_release;

out:
    return retval;

out_release:
    sock_release(sock);
    return retval;
}

参数 family 指定 具体协议层，可以选择的协议非常多，下面列举几个：

#define AF_UNIX     1   /* Unix domain sockets      */
#define AF_LOCAL    1   /* POSIX name for AF_UNIX   */
#define AF_INET     2   /* Internet IP Protocol     */
#define AF_AX25     3   /* Amateur Radio AX.25      */
#define AF_IPX      4   /* Novell IPX               */
...

例如 AF_UNIX 指定的是 Unix socket，AF_INET 指定的是 以太网协议 等。而参数 type 用于指定传输数据的类型，有一下几种选择：

#define SOCK_STREAM 1       /* stream (connection) socket   */
#define SOCK_DGRAM  2       /* datagram (conn.less) socket  */
#define SOCK_RAW    3       /* raw socket                   */
#define SOCK_RDM    4       /* reliably-delivered message   */
#define SOCK_SEQPACKET  5   /* sequential packet socket     */
#define SOCK_PACKET 10      /* linux specific way of        */

例如 SOCK_STREAM 类型指定的是流方式，而 SOCK_DGRAM 类型指定的是数据报方式等。最后一个 protocol 参数看起来也是协议的意思，跟 family 好像重复了。事实上 family 所指定的协议偏向于物理介质，如 Unix socket 是用于进程间通信的，而 Inet socket 是用于以太网传输数据的。而 protocol 所指定的协议偏向于逻辑上的协议，如 TCP、UDP 等。举个栗子，如果把 family 比作是不同交通工具（飞机、汽车、火车等）的话，那么 protocol 就是大巴、的士和小车。

sys_socket() 函数首先调用 sock_create() 创建一个 struct socket 结构，然后通过调用 sock_map_fd() 函数把此 struct socket 结构与一个文件描述符关联起来，最后把文件描述符返回给用户。我们先来看看 sock_create() 函数的实现：

int sock_create(int family, int type, int protocol, struct socket **res)
{
    int i;
    struct socket *sock;

    ...
    net_family_read_lock();
    ...

    if (!(sock = sock_alloc())) {
        printk(KERN_WARNING "socket: no more sockets\n");
        i = -ENFILE;
        goto out;
    }

    sock->type  = type;

    if ((i = net_families[family]->create(sock, protocol)) < 0)  {
        sock_release(sock);
        goto out;
    }

    *res = sock;

out:
    net_family_read_unlock();
    return i;
}

sock_create() 函数首先调用 sock_alloc() 申请一个 struct socket 结构，然后调用指定协议族的 create() 函数（net_families[family]->create()）进行进一步的创建功能。net_families 变量的类型为 struct net_proto_family，其定义如下：

struct net_proto_family {
    int family;
    int (*create)(struct socket *sock, int protocol);
    ...
};

family 字段对应的就是具体的协议族，而 create 字段指定了其创建socket的方法。一个具体协议族需要通过调用 sock_register() 函数向系统注册其创建socket的方法。例如 Unix socket 就在初始化时通过下面的代码注册：

struct net_proto_family unix_family_ops = {
    PF_UNIX,
    unix_create
};

static int __init af_unix_init(void)
{
    ...
    sock_register(&unix_family_ops);
    ...
    return 0;
}

所以从上面的代码可以指定，对于 Unix socket 的话，net_families[family]->create() 这行代码实际调用的是 unix_create() 函数。

posted @ 2021-06-25 16:56 Smah 阅读(970) 评论(0) 收藏举报

刷新页面返回顶部

no code no life