从零开始—Socket系统调用和多态封装
1 重新搭建实验环境
前面都是用实验楼环境做的实验，偷的懒总是要还的，这一次重装环境前后花了十几个小时，踩了无数的坑。
1.1 Ubuntu和LINUX内核的区别
Ubuntu是基于LINUX内核编写的一个操作系统。LINUX内核定义了一些基本的系统功能，Ubuntu在内核之上加入了图形界面，包管理等功能，优化了人机交互。本次实验，要求使用LINUX内核5.0以上，所以，在下载安装完Ubuntu系统后，需要对内核进行更新。
$ uname -a
上面这个指令会显示Ubuntu当前的内核版本，我们可以通过它来观察内核的升级是否成功。
1.2 从零开始
下载安装Ubuntu
首先到Ubuntu官网上下载一个Ubuntu镜像，但是太慢了，我们可以在国内的镜像网站上去下载。指路网易镜像。
下载完成后，在VMware虚拟机中进行系统安装，没什么可说的。
- 设置超级管理员
新装的系统没有超级管理员，所以需要先设置一个。执行下面的命令，按照提示要求完成管理员注册。
sudo passwd root
- 设置共享文件夹
为了方便VMware内虚拟主机和我们的主机进行交互，可以设置一个共享文件夹
首先将虚拟主机关机，然后在虚拟机设置=》选项卡中设置共享文件夹。安装VMwareTools，在VMware菜单栏，点击“重新安装VMwareTools”。虚拟主机内会出现资源管理器，里面有下载好的压缩包，将它拷贝到桌面上解压。然后执行VMware底部弹出的建议命令，完成安装。查看共享文件夹。共享文件夹的位置在/mnt/hfgs/share/。
更换国内源
国外的资源下载速度实在太慢，所以在开始工作之前，建议先更换成国内镜像，指路科大镜像。
- 备份原始源
$ sudo cp /etc/apt/sources.list /etc/apt/sources_backup.list
- 修改配置文件
$ sudo gedit /etc/apt/sources.list
把从网上找到的资源列表复制拷贝过来，点击资源管理器右上角的save按钮
- 更新源
$ sudo apt-get update
下载编译LINUX5.0内核
先下载5.0以上linux内核。
- 解压内核文件
$ xz -d linux-5.0.1.tar.xz
$ tar -xvf linux-5.0.1.tar
- 安装依赖
$ sudo apt-get install build-essential
$ sudo apt-get install libelf-dev
$ sudo apt-get install libncurses-dev
$ sudo apt-get install flex
$ sudo apt-get install bison
$ sudo apt-get install libssl-dev
- 配置内核
$ cd /linux/5.0.1
$ sudo cp /boot/config-5.0.23-generic -r .config
$ sudo make oldconfig
$ sudo make localmodconfig
$ make menuconfig
在弹出的图形化界面中配置
kernel hacking -> compile-time and compiler options 勾选 [*] compiler the kernel with debug info
- 编译内核
$ sudo make
$ sudo make modules_install
# 更新
$ sudo make install
- 重启虚拟机
查看内核版本是否已经是5.0.1
$ uname -a
1.3 搭建实验环境
- 安装qemu模拟命令，加载linux内核
$ sudo apt install qemu
$ qemu-sysem-x86_64 -kernel linux-5.0.1/arch/x86_64/boot/bzIamge
- 剩余的部分主要是配置qemu环境，把写好的replyhi网络聊天程序集成到qemu中，和上一次实验内容相同，不再重复演示。
2 Socket系统调用分析
按照实验要求，我们分为两个方向来研究Socket系统调用。实验指出，内核将系统调用作为一个特殊中断来处理，因此首先我们对这一点进行验证；其次我们将探究，对于不同的协议，Socket系统调用源码中是如何封装协议细节的，是否使用了实验提到的“多态”机制，怎么实现的。
2.1 系统调用的中断实现
修改Makefile
为探究64位程序中socket的系统调用行为，我们首先需要对上一节使用到的Makefile进行修改
#
# Makefile for linuxnet/lab3
#
# ... 省略前文
rootfs:
gcc -o init linktable.c menu.c main.c -m64 -static -lpthread
find init | cpio -o -Hnewc |gzip -9 > ../../rootfs.img
qemu-system-x86_64 -kernel ../../linux-5.0.1/arch/x86/boot/bzImage -initrd ../../rootfs.img -append nokaslr -s -S
# ...省略后文
在编译指令gcc那一行，将编译选项由-m32改为-m64。
执行指令
$ make rootfs
我们得到了新的64位可执行文件init。
GDB调试
使用GDB调试init，在socket函数前打上断点。
$ gdb init
$ (gdb) break socket
打开汇编窗口，查看代码运行情况
$ (gdb) layout asm
可以看到，程序在socket函数入口处停下，下一条汇编指令是一个syscall的系统调用。
反汇编init
对init进行反汇编
$ objdump -d init > init_ASM.txt
查看init_ASM.txt文件，在第104553行找到socket对应的系统调用。
证明对于socket api的调用是通过socketcall这个特殊中断来实现的。
syscall的具体实现
利用同样的办法，我们按照上一节的方法启动qemu进行远程调试，设置如下断点:
$ (gdb) break sys_socketcall
跟踪到一个关键函数：SYSCALL_DEFINE2()，它位于linux-5.0.1/net/socket.c之中。
关键代码如下：
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_accept4(a0, (struct sockaddr __user *)a1,
(int __user *)a[2], 0);
break;
// ... 省略其余部分
}
可见，每次socket都会调用同一个函数，通过传入的call值不同，在分支语句中执行对应的系统服务例程。
2.2 Socket封装网络协议的多态机制
以__sys_socket()为例，其源码位于同一文件下，也是C语言实现的：
int __sys_socket(int family, int type, int protocol)
{
int retval;
struct socket *sock;
int flags;
/* Check the SOCK_* constants for consistency. */
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
flags = type & ~SOCK_TYPE_MASK;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
type &= SOCK_TYPE_MASK;
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
return retval;
return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
}
注意到函数的传入参数中有一个protocol变量，它用来指定传入的协议是多少。对于系统底层来说，不同的protocol值对应不同的协议类型，而对于socket通信来说，它只负责从高层接受这个字段值，然后交付更底层的函数，在这里，调用到的sock_create代码如下：
int __sock_create(struct net *net, int family, int type, int protocol,
struct socket **res, int kern)
{
int err;
struct socket *sock;
const struct net_proto_family *pf;
/*
* 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) {
pr_info_once("%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;
// 省略后文
可以发现这个函数仍然不是最底层的函数，它根据情况继续调用security_socket_creat()，或者返回协议错误信息。
从代码上来看，Socket封装协议细节，使用到的应该是名为socket的结构体，在__sys_bind()等函数中，协议字段作为地址长度被传入，说明对于socket来说是通过判断协议字段长度来区分ipv4和ipv6两种不同协议的。在socket结构体中，有一个名为sk_family的字段，通过它的取值不同来判断这个socket是使用ipv4还是ipv6。可以从socket.c中的代码印证这一点：
/* This routine returns the IP overhead imposed by a socket i.e.
* the length of the underlying IP header, depending on whether
* this is an IPv4 or IPv6 socket and the length from IP options turned
* on at the socket. Assumes that the caller has a lock on the socket.
*/
u32 kernel_sock_ip_overhead(struct sock *sk)
{
struct inet_sock *inet;
struct ip_options_rcu *opt;
u32 overhead = 0;
#if IS_ENABLED(CONFIG_IPV6)
struct ipv6_pinfo *np;
struct ipv6_txoptions *optv6 = NULL;
#endif /* IS_ENABLED(CONFIG_IPV6) */
if (!sk)
return overhead;
switch (sk->sk_family) {
case AF_INET:
inet = inet_sk(sk);
overhead += sizeof(struct iphdr);
opt = rcu_dereference_protected(inet->inet_opt,
sock_owned_by_user(sk));
if (opt)
overhead += opt->opt.optlen;
return overhead;
#if IS_ENABLED(CONFIG_IPV6)
case AF_INET6:
np = inet6_sk(sk);
overhead += sizeof(struct ipv6hdr);
if (np)
optv6 = rcu_dereference_protected(np->opt,
sock_owned_by_user(sk));
if (optv6)
overhead += (optv6->opt_flen + optv6->opt_nflen);
return overhead;
#endif /* IS_ENABLED(CONFIG_IPV6) */
default: /* Returns 0 overhead if the socket is not ipv4 or ipv6 */
return overhead;
}
}
EXPORT_SYMBOL(kernel_sock_ip_overhead);
综上所述，socket实现了协议封装的多态，它通过结构体的形式，用协议字段的长度作为划分协议的依据，以此将ipv4和ipv6区分开来。而对于调用这些函数和api的高层来说，不管自己是什么协议都调用同样的函数。
