本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。
msn: yfydz_no1@hotmail.com
来源：http://yfydz.cublog.cn
1. 前言
打开一个网络socket后可以使用set/getsockopt(2)可实现用户空间与内核的通信，本质和ioctl差不多，区别在于set/getsockopt不用新建设备，直接利用系统已有的socket类型就可以进行，可用setsockopt函数向内核写数据，用getsockopt向内核读数据。
本文内核代码版本为2.6.19.2。
2. 基本过程
首先在内核中要登记相关协议的set/getsockopt的选项命令字和相关的处理函数，然后在用户空间打开该协议的socket后就可以直接调用set/getsockopt来指定命令字执行相关的数据交互操作，常见的TCP、UDP的socket都用这两个系统调用来iptables<->netfilter，ipvsadm<->ip_vs就是这么实现的。
3. set/getsockopt(2)
set/getsockopt(2)函数的基本使用格式为：
int setsockopt(int sockfd, int proto, int cmd, void *data, int datalen)
int getsockopt(int sockfd, int proto, int cmd, void *data, int datalen)
int getsockopt(int sockfd, int proto, int cmd, void *data, int datalen)
第一个参数是socket描述符；第2个参数proto是sock协议，IP RAW的就用SOL_SOCKET/SOL_IP等，TCP/UDP socket的可用SOL_SOCKET/SOL_IP/SOL_TCP/SOL_UDP等，即高层的socket是都可以使用低层socket的命令字的；第3个参数cmd是操作命令字，由自己定义；第4个参数是数据缓冲区起始位置指针，set操作时是将缓冲区数据写入内核，get的时候是将内核中的数据读入该缓冲区；第5个参数数据长度。
4. 内核实现
内核实现新的sockopt命令字有两类，一类是添加完整的新的协议后引入，一类是在原有协议命令集的基础上增加新的命令字。
sockopt命令字定义没有什么特别之处，就是一个整数，只要对这个协议内部是一个唯一的的即可，不象ioctl的命令字还有一定格式要求。
4.1 完整协议
每个协议都是用struct proto结构(include/net/sock.h)来描述的，Linux内核中缺省定义了三种：TCP、UDP和RAW，所有非TCP、UDP的都用RAW来描述。在net/core/sock.c的sock_get/setsockopt()函数中内核实现了一个所有socket共同的sockopt读写命令集合，在各个协议的内部再单独定义各自协议的独有命令字。
struct proto中有setsockopt和getsocket成员函数，用来定义每个协议的独有相关的命令字。
如对于UDP协议的setsockopt成员函数：
static int udp_setsockopt(struct sock *sk, int level, int optname,
char __user *optval, int optlen)
{
// 先判断是否是UDP层，不是的话调IP层的sockopt处理
if (level != SOL_UDP)
return ip_setsockopt(sk, level, optname, optval, optlen);
// 是UDP级别命令，调用UDP协议本身的sockopt处理
return do_udp_setsockopt(sk, level, optname, optval, optlen);
}
char __user *optval, int optlen)
{
// 先判断是否是UDP层，不是的话调IP层的sockopt处理
if (level != SOL_UDP)
return ip_setsockopt(sk, level, optname, optval, optlen);
// 是UDP级别命令，调用UDP协议本身的sockopt处理
return do_udp_setsockopt(sk, level, optname, optval, optlen);
}
static int do_udp_setsockopt(struct sock *sk, int level, int optname,
char __user *optval, int optlen)
{
struct udp_sock *up = udp_sk(sk);
int val;
int err = 0;
if(optlen<sizeof(int))
return -EINVAL;
return -EINVAL;
if (get_user(val, (int __user *)optval))
return -EFAULT;
// 实际UDP独有的命令字就这两个
switch(optname) {
case UDP_CORK:
if (val != 0) {
up->corkflag = 1;
} else {
up->corkflag = 0;
lock_sock(sk);
udp_push_pending_frames(sk, up);
release_sock(sk);
}
break;
return -EFAULT;
// 实际UDP独有的命令字就这两个
switch(optname) {
case UDP_CORK:
if (val != 0) {
up->corkflag = 1;
} else {
up->corkflag = 0;
lock_sock(sk);
udp_push_pending_frames(sk, up);
release_sock(sk);
}
break;
// UDP封装,在IPSEC的NAT-T时使用
case UDP_ENCAP:
switch (val) {
case 0:
case UDP_ENCAP_ESPINUDP:
case UDP_ENCAP_ESPINUDP_NON_IKE:
up->encap_type = val;
break;
default:
err = -ENOPROTOOPT;
break;
}
break;
case UDP_ENCAP:
switch (val) {
case 0:
case UDP_ENCAP_ESPINUDP:
case UDP_ENCAP_ESPINUDP_NON_IKE:
up->encap_type = val;
break;
default:
err = -ENOPROTOOPT;
break;
}
break;
default:
err = -ENOPROTOOPT;
break;
};
err = -ENOPROTOOPT;
break;
};
return err;
}
}
所以要实现一个新协议的sockopt控制，只需要类似方法处理即可，定义好struct proto结构后将其注册到系统中即可，对于IP族内协议用inet_register_protosw()函数，其他协议族可类似处理。
4.2 命令扩充
实际使用中单独定义新协议的可能性不是很大，通常只是添加新的命令字即可，对于TCP、UDP的新命令字的添加，需要自己修改内核tcp/udp实现代码，把自己的命令字添加进去后重新编译内核才能生效。
对于IP RAW级别的命令字，netfilter提供了nf_register_sockopt()和nf_unregister_sockopt()来动态登记或取消sockopt命令字，这样可以不用修改内核原来的代码。方法是将netfilter的sockopt操作集合定义为一个链表，要定义新的opt操作就定义一个新的opt操作节点挂接到该链表中，在系统sockopt调用时，会依次查找链表中的命令字，匹配上了就可以成功调用，因此opt的命令字不能和原来IP RAW中定义相同，不过命令字是个32位的数，取值范围很大，只要稍微注意一点是不会冲突的。
netfilter的sock是RAW级别的。
sockopt操作节点结构,结构比较简单明了,就是定义各自命令字的范围空间和相关的处理函数：
/* include/linux/netfilter.h */
struct nf_sockopt_ops
{
// 链表节点
struct list_head list;
{
// 链表节点
struct list_head list;
// 协议族
int pf;
int pf;
/* Non-inclusive ranges: use 0/0/NULL to never get called. */
// set命令的最小值
int set_optmin;
// set命令的最大值
int set_optmax;
// set函数实现
int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
int (*compat_set)(struct sock *sk, int optval,
void __user *user, unsigned int len);
// set命令的最小值
int set_optmin;
// set命令的最大值
int set_optmax;
// set函数实现
int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
int (*compat_set)(struct sock *sk, int optval,
void __user *user, unsigned int len);
// get命令的最小值
int get_optmin;
// get命令的最大值
int get_optmax;
// get函数实现
int (*get)(struct sock *sk, int optval, void __user *user, int *len);
int (*compat_get)(struct sock *sk, int optval,
void __user *user, int *len);
int get_optmin;
// get命令的最大值
int get_optmax;
// get函数实现
int (*get)(struct sock *sk, int optval, void __user *user, int *len);
int (*compat_get)(struct sock *sk, int optval,
void __user *user, int *len);
/* Number of users inside set() or get(). */
unsigned int use;
struct task_struct *cleanup_task;
};
unsigned int use;
struct task_struct *cleanup_task;
};
opt操作结构登记和撤销函数:
/* net/netfilter/nf_sockopt.c */
// nf的sockopt的链表,所有sockopt命令处理都挂接到这个链表
static LIST_HEAD(nf_sockopts);
static LIST_HEAD(nf_sockopts);
/* Functions to register sockopt ranges (exclusive). */
int nf_register_sockopt(struct nf_sockopt_ops *reg)
{
struct list_head *i;
int ret = 0;
// 加锁
if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
return -EINTR;
int nf_register_sockopt(struct nf_sockopt_ops *reg)
{
struct list_head *i;
int ret = 0;
// 加锁
if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
return -EINTR;
// 检查当前链表中是否已经挂接了该sockopt操作节点
list_for_each(i, &nf_sockopts) {
struct nf_sockopt_ops *ops = (struct nf_sockopt_ops *)i;
if (ops->pf == reg->pf
&& (overlap(ops->set_optmin, ops->set_optmax,
reg->set_optmin, reg->set_optmax)
|| overlap(ops->get_optmin, ops->get_optmax,
reg->get_optmin, reg->get_optmax))) {
NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n",
ops->set_optmin, ops->set_optmax,
ops->get_optmin, ops->get_optmax,
reg->set_optmin, reg->set_optmax,
reg->get_optmin, reg->get_optmax);
ret = -EBUSY;
goto out;
}
}
// 新节点,添加到opt链表中
list_add(®->list, &nf_sockopts);
out:
// 解锁
mutex_unlock(&nf_sockopt_mutex);
return ret;
}
EXPORT_SYMBOL(nf_register_sockopt);
list_for_each(i, &nf_sockopts) {
struct nf_sockopt_ops *ops = (struct nf_sockopt_ops *)i;
if (ops->pf == reg->pf
&& (overlap(ops->set_optmin, ops->set_optmax,
reg->set_optmin, reg->set_optmax)
|| overlap(ops->get_optmin, ops->get_optmax,
reg->get_optmin, reg->get_optmax))) {
NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n",
ops->set_optmin, ops->set_optmax,
ops->get_optmin, ops->get_optmax,
reg->set_optmin, reg->set_optmax,
reg->get_optmin, reg->get_optmax);
ret = -EBUSY;
goto out;
}
}
// 新节点,添加到opt链表中
list_add(®->list, &nf_sockopts);
out:
// 解锁
mutex_unlock(&nf_sockopt_mutex);
return ret;
}
EXPORT_SYMBOL(nf_register_sockopt);
void nf_unregister_sockopt(struct nf_sockopt_ops *reg)
{
/* No point being interruptible: we're probably in cleanup_module() */
restart:
mutex_lock(&nf_sockopt_mutex);
if (reg->use != 0) {
// 操作节点还在使用中,阻塞进程直到所有操作完成
/* To be woken by nf_sockopt call... */
/* FIXME: Stuart Young's name appears gratuitously. */
set_current_state(TASK_UNINTERRUPTIBLE);
reg->cleanup_task = current;
mutex_unlock(&nf_sockopt_mutex);
schedule();
goto restart;
}
// 从链表中删除
list_del(®->list);
mutex_unlock(&nf_sockopt_mutex);
}
EXPORT_SYMBOL(nf_unregister_sockopt);
{
/* No point being interruptible: we're probably in cleanup_module() */
restart:
mutex_lock(&nf_sockopt_mutex);
if (reg->use != 0) {
// 操作节点还在使用中,阻塞进程直到所有操作完成
/* To be woken by nf_sockopt call... */
/* FIXME: Stuart Young's name appears gratuitously. */
set_current_state(TASK_UNINTERRUPTIBLE);
reg->cleanup_task = current;
mutex_unlock(&nf_sockopt_mutex);
schedule();
goto restart;
}
// 从链表中删除
list_del(®->list);
mutex_unlock(&nf_sockopt_mutex);
}
EXPORT_SYMBOL(nf_unregister_sockopt);
下面来看一下具体调用流程是如何进行的,首先打开的socket是一个RAW类型的IP socket,对这类socket的setsockopt操作会调用到ip_setsockopt()函数:
/* net/ipv4/ip_sockglue.c */
int ip_setsockopt(struct sock *sk, int level,
int optname, char __user *optval, int optlen)
{
int err;
int optname, char __user *optval, int optlen)
{
int err;
if (level != SOL_IP)
return -ENOPROTOOPT;
return -ENOPROTOOPT;
// 先按普通IP的sockopt操作执行
err = do_ip_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
// 内核要支持netfilter
/* we need to exclude all possible ENOPROTOOPTs except default case */
if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
#ifdef CONFIG_IP_MROUTE
&& (optname < MRT_BASE || optname > (MRT_BASE + 10))
#endif
) {
// 如果IP中没有这个opt命令字,调用netfilter的sockopt
lock_sock(sk);
err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
release_sock(sk);
}
#endif
return err;
}
err = do_ip_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
// 内核要支持netfilter
/* we need to exclude all possible ENOPROTOOPTs except default case */
if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
#ifdef CONFIG_IP_MROUTE
&& (optname < MRT_BASE || optname > (MRT_BASE + 10))
#endif
) {
// 如果IP中没有这个opt命令字,调用netfilter的sockopt
lock_sock(sk);
err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
release_sock(sk);
}
#endif
return err;
}
/* net/netfilter/nf_sockopt.c */
int nf_setsockopt(struct sock *sk, int pf, int val, char __user *opt,
int len)
{
// 实际调用nf_sockopt函数
return nf_sockopt(sk, pf, val, opt, &len, 0);
}
int nf_setsockopt(struct sock *sk, int pf, int val, char __user *opt,
int len)
{
// 实际调用nf_sockopt函数
return nf_sockopt(sk, pf, val, opt, &len, 0);
}
static int nf_sockopt(struct sock *sk, int pf, int val,
char __user *opt, int *len, int get)
{
struct list_head *i;
struct nf_sockopt_ops *ops;
int ret;
if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
return -EINTR;
return -EINTR;
// 扫描netfilter的sockopt链表
list_for_each(i, &nf_sockopts) {
// 取出opt操作节点
ops = (struct nf_sockopt_ops *)i;
// 根据协议,命令字范围判断是否处理该命令字
if (ops->pf == pf) {
if (get) {
// get操作
if (val >= ops->get_optmin
&& val < ops->get_optmax) {
// opt结构节点使用计数加1
ops->use++;
mutex_unlock(&nf_sockopt_mutex);
ret = ops->get(sk, val, opt, len);
goto out;
}
} else {
// set操作
if (val >= ops->set_optmin
&& val < ops->set_optmax) {
ops->use++;
mutex_unlock(&nf_sockopt_mutex);
ret = ops->set(sk, val, opt, *len);
goto out;
}
}
}
}
mutex_unlock(&nf_sockopt_mutex);
return -ENOPROTOOPT;
out:
mutex_lock(&nf_sockopt_mutex);
// 操作完成,opt结构节点使用减一
ops->use--;
if (ops->cleanup_task)
wake_up_process(ops->cleanup_task);
mutex_unlock(&nf_sockopt_mutex);
return ret;
}
list_for_each(i, &nf_sockopts) {
// 取出opt操作节点
ops = (struct nf_sockopt_ops *)i;
// 根据协议,命令字范围判断是否处理该命令字
if (ops->pf == pf) {
if (get) {
// get操作
if (val >= ops->get_optmin
&& val < ops->get_optmax) {
// opt结构节点使用计数加1
ops->use++;
mutex_unlock(&nf_sockopt_mutex);
ret = ops->get(sk, val, opt, len);
goto out;
}
} else {
// set操作
if (val >= ops->set_optmin
&& val < ops->set_optmax) {
ops->use++;
mutex_unlock(&nf_sockopt_mutex);
ret = ops->set(sk, val, opt, *len);
goto out;
}
}
}
}
mutex_unlock(&nf_sockopt_mutex);
return -ENOPROTOOPT;
out:
mutex_lock(&nf_sockopt_mutex);
// 操作完成,opt结构节点使用减一
ops->use--;
if (ops->cleanup_task)
wake_up_process(ops->cleanup_task);
mutex_unlock(&nf_sockopt_mutex);
return ret;
}
这样,自己定义的nf的opt节点就可以被遍历到,操作也就有效.
具体实例, ip_vs opt操作节点:
/* net/ipv4/ipvs/ip_vs_ctl.c */
static struct nf_sockopt_ops ip_vs_sockopts = {
.pf = PF_INET,
// 定义set命令字范围
.set_optmin = IP_VS_BASE_CTL,
.set_optmax = IP_VS_SO_SET_MAX+1,
.set = do_ip_vs_set_ctl,
// get命令字范围
.get_optmin = IP_VS_BASE_CTL,
.get_optmax = IP_VS_SO_GET_MAX+1,
.get = do_ip_vs_get_ctl,
};
.pf = PF_INET,
// 定义set命令字范围
.set_optmin = IP_VS_BASE_CTL,
.set_optmax = IP_VS_SO_SET_MAX+1,
.set = do_ip_vs_set_ctl,
// get命令字范围
.get_optmin = IP_VS_BASE_CTL,
.get_optmax = IP_VS_SO_GET_MAX+1,
.get = do_ip_vs_get_ctl,
};
set/get函数就很简单了,就进行一些合法性检查,然后根据命令字进行相关处理即可:
static int
do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
{
int ret;
unsigned char arg[MAX_ARG_LEN];
struct ip_vs_service_user *usvc;
struct ip_vs_service *svc;
struct ip_vs_dest_user *udest;
do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
{
int ret;
unsigned char arg[MAX_ARG_LEN];
struct ip_vs_service_user *usvc;
struct ip_vs_service *svc;
struct ip_vs_dest_user *udest;
// 用户权限检查
if (!capable(CAP_NET_ADMIN))
return -EPERM;
if (!capable(CAP_NET_ADMIN))
return -EPERM;
// 数据长度检查
if (len != set_arglen[SET_CMDID(cmd)]) {
IP_VS_ERR("set_ctl: len %u != %u\n",
len, set_arglen[SET_CMDID(cmd)]);
return -EINVAL;
}
// 拷贝数据
if (copy_from_user(arg, user, len) != 0)
return -EFAULT;
if (len != set_arglen[SET_CMDID(cmd)]) {
IP_VS_ERR("set_ctl: len %u != %u\n",
len, set_arglen[SET_CMDID(cmd)]);
return -EINVAL;
}
// 拷贝数据
if (copy_from_user(arg, user, len) != 0)
return -EFAULT;
/* increase the module use count */
// ipvs模块使用计数
ip_vs_use_count_inc();
// ipvs模块使用计数
ip_vs_use_count_inc();
// 加锁
if (mutex_lock_interruptible(&__ip_vs_mutex)) {
ret = -ERESTARTSYS;
goto out_dec;
}
if (mutex_lock_interruptible(&__ip_vs_mutex)) {
ret = -ERESTARTSYS;
goto out_dec;
}
// 以下进行具体的命令实现操作:
if (cmd == IP_VS_SO_SET_FLUSH) {
/* Flush the virtual service */
ret = ip_vs_flush();
goto out_unlock;
......
/* Flush the virtual service */
ret = ip_vs_flush();
goto out_unlock;
......
5. 用户空间
用户空间的操作很简单,就是用socket(2)打开相关协议类型的socket,直接调用set/getsockopt函数就可以进行操作了.
实例: ipvsadm
int ipvs_init(void)
{
socklen_t len;
{
socklen_t len;
len = sizeof(ipvs_info);
// 打开RAW类型的socket
if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1)
return -1;
// 读取ipvs基本信息
if (getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
(char *)&ipvs_info, &len))
return -1;
// 打开RAW类型的socket
if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1)
return -1;
// 读取ipvs基本信息
if (getsockopt(sockfd, IPPROTO_IP, IP_VS_SO_GET_INFO,
(char *)&ipvs_info, &len))
return -1;
return 0;
}
}
5. 结论
用setgetsockopt()在用户空间和内核空间传递数据也是常用方法之一，比较简单方便，而且可以在同一个socket中对不同的命令传送不同的数据结构。
新命令字的添加可以按新协议添加，也可以添加到现有的实现中，但没有特别需求的话，netfilter提供的动态登记opt命令字可以动态添加删除sockopt操作命令字，而且不用修改内核原有的程序。
