Linux 内核中 IPv4 选项处理的深度解析
IP 选项是 IPv4 协议中的重要扩展机制，允许在标准 IP 头部之后附加额外信息。Linux 内核通过 net/ipv4/ip_options.c 文件实现了完整的 IP 选项处理逻辑，支持源路由、记录路由、时间戳等关键功能。本文将深入分析其实现机制。
一、IP 选项的核心数据结构
struct ip_options {
__be32 faddr; // 源路由的最终地址
__be32 nexthop; // 下一跳地址
unsigned char optlen; // 选项总长度
unsigned char srr; // 源路由偏移量
unsigned char rr; // 记录路由偏移量
unsigned char ts; // 时间戳偏移量
unsigned char is_strictroute:1; // 严格源路由标志
unsigned char srr_is_hit:1; // 源路由命中标志
unsigned char is_changed:1; // 选项被修改标志
// ... 其他标志位
unsigned char __data[0]; // 动态选项数据
};
该结构体精确追踪每个选项的位置和状态，为高效处理提供支持。标志位使用位域优化存储空间。
二、核心处理流程解析
1. 选项构建（发送路径）
ip_options_build() 函数负责将选项插入 IP 头部：
void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
__be32 daddr, struct rtable *rt, int is_frag)
{
// 复制选项到IP头部之后
memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
if (opt->srr) // 处理源路由
memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
if (!is_frag) {
if (opt->rr_needaddr) // 记录路由地址填充
ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, skb, rt);
if (opt->ts_needtime) // 时间戳填充
memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
}
}
关键点：
-
分片数据包清除 RR/TS 选项（RFC 791 要求）
-
非分片包实时获取出接口地址和时间戳
-
源路由目的地址在构建时动态更新
2. 选项编译与验证
__ip_options_compile() 实现选项的深度验证：
int __ip_options_compile(struct net *net, struct ip_options *opt,
struct sk_buff *skb, __be32 *info)
{
// 遍历所有选项
while (l > 0) {
switch (*optptr) {
case IPOPT_SSRR: case IPOPT_LSRR: // 源路由验证
if (optlen < 3 || optptr[2] < 4) goto error;
break;
case IPOPT_RR: // 记录路由
spec_dst_fill(&spec_dst, skb); // 填充接口地址
memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
break;
case IPOPT_CIPSO: // 安全选项
if (cipso_v4_validate(skb, &optptr)) goto error;
break;
}
// ... 其他选项处理
}
}
验证机制：
-
严格检查选项长度和偏移量
-
动态填充记录路由的接口地址
-
调用 CIPSO 模块进行安全标签验证
-
特权检查（CAP_NET_RAW）保护敏感选项
3. 选项转发处理
ip_forward_options() 更新转发路径中的选项：
void ip_forward_options(struct sk_buff *skb)
{
if (opt->rr_needaddr) { // 更新记录路由
ip_rt_get_source(&optptr[optptr[2]-5], skb, rt);
opt->is_changed = 1;
}
if (opt->srr_is_hit) { // 源路由下一跳处理
ip_hdr(skb)->daddr = opt->nexthop;
optptr[2] = srrptr+4; // 移动源路由指针
}
if (opt->is_changed) // 校验和重计算
ip_send_check(ip_hdr(skb));
}
动态调整：
-
记录路由（RR）：写入当前转发接口地址
-
源路由（SRR）：更新目的地址为下一跳
-
修改后重算 IP 校验和
三、特殊选项处理机制
1. 严格源路由处理
ip_options_rcv_srr() 实现严格源路由：
int ip_options_rcv_srr(struct sk_buff *skb)
{
for (srrptr = optptr[2]; srrptr <= srrspace; srrptr += 4) {
memcpy(&nexthop, &optptr[srrptr-1], 4);
err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, dev);
if (rt2->rt_type == RTN_UNICAST) break; // 有效路由
}
opt->srr_is_hit = 1; // 标记源路由命中
opt->nexthop = nexthop; // 保存下一跳
}
处理流程：
-
遍历源路由地址列表
-
对每个地址执行路由查找
-
找到第一个有效路由即终止
-
更新目的地址和选项状态
2. ICMP 响应选项处理
__ip_options_echo() 反转源路由路径：
int __ip_options_echo(...)
{
if (sopt->srr) {
// 反转地址顺序
for (soffset -= 4, doffset = 4; soffset > 3; soffset -= 4, doffset += 4)
memcpy(&dptr[doffset-1], &start[soffset-1], 4);
// 修复非法路由（RFC 1812）
if (memcmp(&ip_hdr(skb)->saddr, &start[soffset + 3], 4) == 0)
doffset -= 4;
}
}
该函数确保 ICMP 响应包正确携带反转后的源路由路径。
四、安全与错误处理设计
-
分层特权检查：
if (!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) { pp_ptr = optptr; goto error; }-
限制 IPOPT_SEC/IPOPT_SID 等敏感选项
-
基于网络命名空间实施权限控制
-
-
错误定位机制：
if (info) *info = htonl((pp_ptr-iph)<<24); // 高8位存储错误偏移量 return -EINVAL;-
精确返回错误位置（字节偏移）
-
ICMP 响应携带错误位置信息
-
-
CIPSO 集成：
-
调用
cipso_v4_validate()验证安全标签 -
拒绝非法或损坏的安全标签
-
五、总结
Linux 内核的 IP 选项处理模块展示了复杂协议功能的优雅实现：
-
分层处理：清晰分离构建、验证、转发逻辑
-
动态填充：路由信息、时间戳等实时生成
-
安全优先：特权检查与 CIPSO 深度集成
-
RFC 兼容：严格遵循 RFC 791/1122/1812 规范
该模块通过精细的状态跟踪（如 is_changed、srr_is_hit 等标志位）和动态内存管理，在保证功能完整性的同时，兼顾了处理效率。特别是对源路由路径的反转处理和严格验证，体现了 Linux 网络栈对协议规范的深刻理解和严谨实现。
// SPDX-License-Identifier: GPL-2.0
/*
* INET An implementation of the TCP/IP protocol suite for the LINUX
* operating system. INET is implemented using the BSD Socket
* interface as the means of communication with the user level.
*
* The options processing module for ip.c
*
* Authors: A.N.Kuznetsov
*
*/
#define pr_fmt(fmt) "IPv4: " fmt
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/*
* Write options to IP header, record destination address to
* source route option, address of outgoing interface
* (we should already know it, so that this function is allowed be
* called only after routing decision) and timestamp,
* if we originate this datagram.
*
* daddr is real destination address, next hop is recorded in IP header.
* saddr is address of outgoing interface.
*/
void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
__be32 daddr, struct rtable *rt, int is_frag)
{
unsigned char *iph = skb_network_header(skb);
memcpy(&(IPCB(skb)->opt), opt, sizeof(struct ip_options));
memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
opt = &(IPCB(skb)->opt);
if (opt->srr)
memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
if (!is_frag) {
if (opt->rr_needaddr)
ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, skb, rt);
if (opt->ts_needaddr)
ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, skb, rt);
if (opt->ts_needtime) {
__be32 midtime;
midtime = inet_current_timestamp();
memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
}
return;
}
if (opt->rr) {
memset(iph+opt->rr, IPOPT_NOP, iph[opt->rr+1]);
opt->rr = 0;
opt->rr_needaddr = 0;
}
if (opt->ts) {
memset(iph+opt->ts, IPOPT_NOP, iph[opt->ts+1]);
opt->ts = 0;
opt->ts_needaddr = opt->ts_needtime = 0;
}
}
/*
* Provided (sopt, skb) points to received options,
* build in dopt compiled option set appropriate for answering.
* i.e. invert SRR option, copy anothers,
* and grab room in RR/TS options.
*
* NOTE: dopt cannot point to skb.
*/
int __ip_options_echo(struct net *net, struct ip_options *dopt,
struct sk_buff *skb, const struct ip_options *sopt)
{
unsigned char *sptr, *dptr;
int soffset, doffset;
int optlen;
memset(dopt, 0, sizeof(struct ip_options));
if (sopt->optlen == 0)
return 0;
sptr = skb_network_header(skb);
dptr = dopt->__data;
if (sopt->rr) {
optlen = sptr[sopt->rr+1];
soffset = sptr[sopt->rr+2];
dopt->rr = dopt->optlen + sizeof(struct iphdr);
memcpy(dptr, sptr+sopt->rr, optlen);
if (sopt->rr_needaddr && soffset <= optlen) {
if (soffset + 3 > optlen)
return -EINVAL;
dptr[2] = soffset + 4;
dopt->rr_needaddr = 1;
}
dptr += optlen;
dopt->optlen += optlen;
}
if (sopt->ts) {
optlen = sptr[sopt->ts+1];
soffset = sptr[sopt->ts+2];
dopt->ts = dopt->optlen + sizeof(struct iphdr);
memcpy(dptr, sptr+sopt->ts, optlen);
if (soffset <= optlen) {
if (sopt->ts_needaddr) {
if (soffset + 3 > optlen)
return -EINVAL;
dopt->ts_needaddr = 1;
soffset += 4;
}
if (sopt->ts_needtime) {
if (soffset + 3 > optlen)
return -EINVAL;
if ((dptr[3]&0xF) != IPOPT_TS_PRESPEC) {
dopt->ts_needtime = 1;
soffset += 4;
} else {
dopt->ts_needtime = 0;
if (soffset + 7 <= optlen) {
__be32 addr;
memcpy(&addr, dptr+soffset-1, 4);
if (inet_addr_type(net, addr) != RTN_UNICAST) {
dopt->ts_needtime = 1;
soffset += 8;
}
}
}
}
dptr[2] = soffset;
}
dptr += optlen;
dopt->optlen += optlen;
}
if (sopt->srr) {
unsigned char *start = sptr+sopt->srr;
__be32 faddr;
optlen = start[1];
soffset = start[2];
doffset = 0;
if (soffset > optlen)
soffset = optlen + 1;
soffset -= 4;
if (soffset > 3) {
memcpy(&faddr, &start[soffset-1], 4);
for (soffset -= 4, doffset = 4; soffset > 3; soffset -= 4, doffset += 4)
memcpy(&dptr[doffset-1], &start[soffset-1], 4);
/*
* RFC1812 requires to fix illegal source routes.
*/
if (memcmp(&ip_hdr(skb)->saddr,
&start[soffset + 3], 4) == 0)
doffset -= 4;
}
if (doffset > 3) {
dopt->faddr = faddr;
dptr[0] = start[0];
dptr[1] = doffset+3;
dptr[2] = 4;
dptr += doffset+3;
dopt->srr = dopt->optlen + sizeof(struct iphdr);
dopt->optlen += doffset+3;
dopt->is_strictroute = sopt->is_strictroute;
}
}
if (sopt->cipso) {
optlen = sptr[sopt->cipso+1];
dopt->cipso = dopt->optlen+sizeof(struct iphdr);
memcpy(dptr, sptr+sopt->cipso, optlen);
dptr += optlen;
dopt->optlen += optlen;
}
while (dopt->optlen & 3) {
*dptr++ = IPOPT_END;
dopt->optlen++;
}
return 0;
}
/*
* Options "fragmenting", just fill options not
* allowed in fragments with NOOPs.
* Simple and stupid 8), but the most efficient way.
*/
void ip_options_fragment(struct sk_buff *skb)
{
unsigned char *optptr = skb_network_header(skb) + sizeof(struct iphdr);
struct ip_options *opt = &(IPCB(skb)->opt);
int l = opt->optlen;
int optlen;
while (l > 0) {
switch (*optptr) {
case IPOPT_END:
return;
case IPOPT_NOOP:
l--;
optptr++;
continue;
}
optlen = optptr[1];
if (optlen < 2 || optlen > l)
return;
if (!IPOPT_COPIED(*optptr))
memset(optptr, IPOPT_NOOP, optlen);
l -= optlen;
optptr += optlen;
}
opt->ts = 0;
opt->rr = 0;
opt->rr_needaddr = 0;
opt->ts_needaddr = 0;
opt->ts_needtime = 0;
}
/* helper used by ip_options_compile() to call fib_compute_spec_dst()
* at most one time.
*/
static void spec_dst_fill(__be32 *spec_dst, struct sk_buff *skb)
{
if (*spec_dst == htonl(INADDR_ANY))
*spec_dst = fib_compute_spec_dst(skb);
}
/*
* Verify options and fill pointers in struct options.
* Caller should clear *opt, and set opt->data.
* If opt == NULL, then skb->data should point to IP header.
*/
int __ip_options_compile(struct net *net,
struct ip_options *opt, struct sk_buff *skb,
__be32 *info)
{
__be32 spec_dst = htonl(INADDR_ANY);
unsigned char *pp_ptr = NULL;
struct rtable *rt = NULL;
unsigned char *optptr;
unsigned char *iph;
int optlen, l;
if (skb) {
rt = skb_rtable(skb);
optptr = (unsigned char *)&(ip_hdr(skb)[1]);
} else
optptr = opt->__data;
iph = optptr - sizeof(struct iphdr);
for (l = opt->optlen; l > 0; ) {
switch (*optptr) {
case IPOPT_END:
for (optptr++, l--; l > 0; optptr++, l--) {
if (*optptr != IPOPT_END) {
*optptr = IPOPT_END;
opt->is_changed = 1;
}
}
goto eol;
case IPOPT_NOOP:
l--;
optptr++;
continue;
}
if (unlikely(l < 2)) {
pp_ptr = optptr;
goto error;
}
optlen = optptr[1];
if (optlen < 2 || optlen > l) {
pp_ptr = optptr;
goto error;
}
switch (*optptr) {
case IPOPT_SSRR:
case IPOPT_LSRR:
if (optlen < 3) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 4) {
pp_ptr = optptr + 2;
goto error;
}
/* NB: cf RFC-1812 5.2.4.1 */
if (opt->srr) {
pp_ptr = optptr;
goto error;
}
if (!skb) {
if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
pp_ptr = optptr + 1;
goto error;
}
memcpy(&opt->faddr, &optptr[3], 4);
if (optlen > 7)
memmove(&optptr[3], &optptr[7], optlen-7);
}
opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
opt->srr = optptr - iph;
break;
case IPOPT_RR:
if (opt->rr) {
pp_ptr = optptr;
goto error;
}
if (optlen < 3) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 4) {
pp_ptr = optptr + 2;
goto error;
}
if (optptr[2] <= optlen) {
if (optptr[2]+3 > optlen) {
pp_ptr = optptr + 2;
goto error;
}
if (rt) {
spec_dst_fill(&spec_dst, skb);
memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
opt->is_changed = 1;
}
optptr[2] += 4;
opt->rr_needaddr = 1;
}
opt->rr = optptr - iph;
break;
case IPOPT_TIMESTAMP:
if (opt->ts) {
pp_ptr = optptr;
goto error;
}
if (optlen < 4) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 5) {
pp_ptr = optptr + 2;
goto error;
}
if (optptr[2] <= optlen) {
unsigned char *timeptr = NULL;
if (optptr[2]+3 > optlen) {
pp_ptr = optptr + 2;
goto error;
}
switch (optptr[3]&0xF) {
case IPOPT_TS_TSONLY:
if (skb)
timeptr = &optptr[optptr[2]-1];
opt->ts_needtime = 1;
optptr[2] += 4;
break;
case IPOPT_TS_TSANDADDR:
if (optptr[2]+7 > optlen) {
pp_ptr = optptr + 2;
goto error;
}
if (rt) {
spec_dst_fill(&spec_dst, skb);
memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
timeptr = &optptr[optptr[2]+3];
}
opt->ts_needaddr = 1;
opt->ts_needtime = 1;
optptr[2] += 8;
break;
case IPOPT_TS_PRESPEC:
if (optptr[2]+7 > optlen) {
pp_ptr = optptr + 2;
goto error;
}
{
__be32 addr;
memcpy(&addr, &optptr[optptr[2]-1], 4);
if (inet_addr_type(net, addr) == RTN_UNICAST)
break;
if (skb)
timeptr = &optptr[optptr[2]+3];
}
opt->ts_needtime = 1;
optptr[2] += 8;
break;
default:
if (!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) {
pp_ptr = optptr + 3;
goto error;
}
break;
}
if (timeptr) {
__be32 midtime;
midtime = inet_current_timestamp();
memcpy(timeptr, &midtime, 4);
opt->is_changed = 1;
}
} else if ((optptr[3]&0xF) != IPOPT_TS_PRESPEC) {
unsigned int overflow = optptr[3]>>4;
if (overflow == 15) {
pp_ptr = optptr + 3;
goto error;
}
if (skb) {
optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
opt->is_changed = 1;
}
}
opt->ts = optptr - iph;
break;
case IPOPT_RA:
if (optlen < 4) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] == 0 && optptr[3] == 0)
opt->router_alert = optptr - iph;
break;
case IPOPT_CIPSO:
if ((!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) || opt->cipso) {
pp_ptr = optptr;
goto error;
}
opt->cipso = optptr - iph;
if (cipso_v4_validate(skb, &optptr)) {
pp_ptr = optptr;
goto error;
}
break;
case IPOPT_SEC:
case IPOPT_SID:
default:
if (!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) {
pp_ptr = optptr;
goto error;
}
break;
}
l -= optlen;
optptr += optlen;
}
eol:
if (!pp_ptr)
return 0;
error:
if (info)
*info = htonl((pp_ptr-iph)<<24);
return -EINVAL;
}
int ip_options_compile(struct net *net,
struct ip_options *opt, struct sk_buff *skb)
{
int ret;
__be32 info;
ret = __ip_options_compile(net, opt, skb, &info);
if (ret != 0 && skb)
icmp_send(skb, ICMP_PARAMETERPROB, 0, info);
return ret;
}
EXPORT_SYMBOL(ip_options_compile);
/*
* Undo all the changes done by ip_options_compile().
*/
void ip_options_undo(struct ip_options *opt)
{
if (opt->srr) {
unsigned char *optptr = opt->__data+opt->srr-sizeof(struct iphdr);
memmove(optptr+7, optptr+3, optptr[1]-7);
memcpy(optptr+3, &opt->faddr, 4);
}
if (opt->rr_needaddr) {
unsigned char *optptr = opt->__data+opt->rr-sizeof(struct iphdr);
optptr[2] -= 4;
memset(&optptr[optptr[2]-1], 0, 4);
}
if (opt->ts) {
unsigned char *optptr = opt->__data+opt->ts-sizeof(struct iphdr);
if (opt->ts_needtime) {
optptr[2] -= 4;
memset(&optptr[optptr[2]-1], 0, 4);
if ((optptr[3]&0xF) == IPOPT_TS_PRESPEC)
optptr[2] -= 4;
}
if (opt->ts_needaddr) {
optptr[2] -= 4;
memset(&optptr[optptr[2]-1], 0, 4);
}
}
}
static struct ip_options_rcu *ip_options_get_alloc(const int optlen)
{
return kzalloc(sizeof(struct ip_options_rcu) + ((optlen + 3) & ~3),
GFP_KERNEL);
}
static int ip_options_get_finish(struct net *net, struct ip_options_rcu **optp,
struct ip_options_rcu *opt, int optlen)
{
while (optlen & 3)
opt->opt.__data[optlen++] = IPOPT_END;
opt->opt.optlen = optlen;
if (optlen && ip_options_compile(net, &opt->opt, NULL)) {
kfree(opt);
return -EINVAL;
}
kfree(*optp);
*optp = opt;
return 0;
}
int ip_options_get_from_user(struct net *net, struct ip_options_rcu **optp,
unsigned char __user *data, int optlen)
{
struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
if (!opt)
return -ENOMEM;
if (optlen && copy_from_user(opt->opt.__data, data, optlen)) {
kfree(opt);
return -EFAULT;
}
return ip_options_get_finish(net, optp, opt, optlen);
}
int ip_options_get(struct net *net, struct ip_options_rcu **optp,
unsigned char *data, int optlen)
{
struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
if (!opt)
return -ENOMEM;
if (optlen)
memcpy(opt->opt.__data, data, optlen);
return ip_options_get_finish(net, optp, opt, optlen);
}
void ip_forward_options(struct sk_buff *skb)
{
struct ip_options *opt = &(IPCB(skb)->opt);
unsigned char *optptr;
struct rtable *rt = skb_rtable(skb);
unsigned char *raw = skb_network_header(skb);
if (opt->rr_needaddr) {
optptr = (unsigned char *)raw + opt->rr;
ip_rt_get_source(&optptr[optptr[2]-5], skb, rt);
opt->is_changed = 1;
}
if (opt->srr_is_hit) {
int srrptr, srrspace;
optptr = raw + opt->srr;
for ( srrptr = optptr[2], srrspace = optptr[1];
srrptr <= srrspace;
srrptr += 4
) {
if (srrptr + 3 > srrspace)
break;
if (memcmp(&opt->nexthop, &optptr[srrptr-1], 4) == 0)
break;
}
if (srrptr + 3 <= srrspace) {
opt->is_changed = 1;
ip_hdr(skb)->daddr = opt->nexthop;
ip_rt_get_source(&optptr[srrptr-1], skb, rt);
optptr[2] = srrptr+4;
} else {
net_crit_ratelimited("%s(): Argh! Destination lost!\n",
__func__);
}
if (opt->ts_needaddr) {
optptr = raw + opt->ts;
ip_rt_get_source(&optptr[optptr[2]-9], skb, rt);
opt->is_changed = 1;
}
}
if (opt->is_changed) {
opt->is_changed = 0;
ip_send_check(ip_hdr(skb));
}
}
int ip_options_rcv_srr(struct sk_buff *skb, struct net_device *dev)
{
struct ip_options *opt = &(IPCB(skb)->opt);
int srrspace, srrptr;
__be32 nexthop;
struct iphdr *iph = ip_hdr(skb);
unsigned char *optptr = skb_network_header(skb) + opt->srr;
struct rtable *rt = skb_rtable(skb);
struct rtable *rt2;
unsigned long orefdst;
int err;
if (!rt)
return 0;
if (skb->pkt_type != PACKET_HOST)
return -EINVAL;
if (rt->rt_type == RTN_UNICAST) {
if (!opt->is_strictroute)
return 0;
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl(16<<24));
return -EINVAL;
}
if (rt->rt_type != RTN_LOCAL)
return -EINVAL;
for (srrptr = optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
if (srrptr + 3 > srrspace) {
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
return -EINVAL;
}
memcpy(&nexthop, &optptr[srrptr-1], 4);
orefdst = skb->_skb_refdst;
skb_dst_set(skb, NULL);
err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, dev);
rt2 = skb_rtable(skb);
if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
skb_dst_drop(skb);
skb->_skb_refdst = orefdst;
return -EINVAL;
}
refdst_drop(orefdst);
if (rt2->rt_type != RTN_LOCAL)
break;
/* Superfast 8) loopback forward */
iph->daddr = nexthop;
opt->is_changed = 1;
}
if (srrptr <= srrspace) {
opt->srr_is_hit = 1;
opt->nexthop = nexthop;
opt->is_changed = 1;
}
return 0;
}
EXPORT_SYMBOL(ip_options_rcv_srr); 这个文件是 Linux 内核中处理 IPv4 选项的核心实现，位于 net/ipv4/ip_options.c。它负责 IP 选项的构建、解析、验证和转发处理。以下是对代码的详细分析：
核心功能概述
-
IP 选项处理：
-
构建选项数据并插入 IP 头部
-
解析接收到的选项数据
-
验证选项的合法性
-
处理分片数据包的选项
-
实现源路由 (SSRR/LSRR)、记录路由 (RR)、时间戳 (Timestamp) 等选项的逻辑
-
-
关键操作：
-
ip_options_build()：构建选项数据到发送的数据包中 -
ip_options_compile()：编译和验证选项数据 -
ip_options_echo()：复制并修改选项（用于 ICMP 响应） -
ip_forward_options()：转发数据包时处理选项 -
ip_options_rcv_srr()：接收时处理严格源路由选项
-
关键函数解析
1. ip_options_build()
功能：将选项数据填充到 IP 头部后的位置。
-
处理逻辑：
-
复制选项数据到
skb的 IP 控制块 (IPCB(skb)->opt) -
处理源路由选项 (SRR)：将目的地址写入选项指定位置
-
非分片包的处理：
-
记录路由 (RR)：获取出接口地址并写入选项
-
时间戳 (Timestamp)：获取当前时间戳并写入选项
-
-
分片包的处理：清除 RR 和 TS 选项（用
IPOPT_NOP填充）
-
void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
__be32 daddr, struct rtable *rt, int is_frag) {
// ... 复制选项数据到 skb 头部
if (opt->srr)
memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4); // 写入 SRR 目的地址
if (!is_frag) {
if (opt->rr_needaddr)
ip_rt_get_source(/* 获取源地址并写入 RR */);
if (opt->ts_needaddr)
ip_rt_get_source(/* 获取源地址并写入 TS */);
if (opt->ts_needtime)
memcpy(/* 写入当前时间戳 */);
}
}
2. __ip_options_compile()
功能：编译和验证选项数据的核心函数。
-
处理逻辑：
-
遍历选项数据，检查每个选项的合法性和长度
-
特殊选项处理：
-
源路由 (SSRR/LSRR)：验证偏移量，记录路径地址
-
记录路由 (RR)：填充当前接口地址（通过
spec_dst_fill()） -
时间戳 (Timestamp)：根据子类型（TSONLY/TSANDADDR/PRESPEC）填充时间和地址
-
CIPSO：调用安全模块验证标签
-
-
错误处理：返回错误位置（通过
info参数）
-
int __ip_options_compile(struct net *net, struct ip_options *opt,
struct sk_buff *skb, __be32 *info) {
// ... 遍历选项
switch (*optptr) {
case IPOPT_SSRR: case IPOPT_LSRR:
// 验证偏移量和长度，记录源路由路径
break;
case IPOPT_RR:
// 填充当前接口地址到 RR 选项
spec_dst_fill(&spec_dst, skb);
memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
break;
case IPOPT_TIMESTAMP:
// 根据子类型填充时间戳/地址
break;
case IPOPT_CIPSO:
if (cipso_v4_validate(skb, &optptr)) goto error; // CIPSO 验证
break;
}
// ... 错误处理
}
3. ip_options_echo()
功能：复制接收到的选项并修改（用于 ICMP 响应）。
-
处理逻辑：
-
反转源路由路径（SRR 选项）
-
复制 RR/TS/CIPSO 选项并调整偏移量
-
确保选项长度对齐（4 字节）
-
int __ip_options_echo(struct net *net, struct ip_options *dopt,
struct sk_buff *skb, const struct ip_options *sopt) {
// ... 复制 RR 选项
if (sopt->rr)
memcpy(dptr, sptr+sopt->rr, optlen);
// ... 复制 TS 选项
if (sopt->srr) {
// 反转源路由路径
for (soffset -= 4, doffset = 4; soffset > 3; soffset -= 4, doffset += 4)
memcpy(&dptr[doffset-1], &start[soffset-1], 4);
}
// ... 对齐选项
while (dopt->optlen & 3) {
*dptr++ = IPOPT_END;
dopt->optlen++;
}
}
4. ip_forward_options()
功能：转发数据包时更新选项字段。
-
处理逻辑：
-
记录路由 (RR)：将转发接口地址写入选项
-
源路由 (SRR)：更新下一跳地址并调整指针
-
时间戳 (TS)：若需要地址，则写入转发接口地址
-
void ip_forward_options(struct sk_buff *skb) {
if (opt->rr_needaddr) {
ip_rt_get_source(/* 获取源地址写入 RR */);
}
if (opt->srr_is_hit) {
// 更新目的地址为下一跳
ip_hdr(skb)->daddr = opt->nexthop;
optptr[2] = srrptr+4; // 移动 SRR 指针
}
}
5. ip_options_rcv_srr()
功能：处理接收到的严格源路由 (SSRR) 选项。
-
处理逻辑：
-
检查数据包类型和路由类型（必须是单播或本地）
-
遍历源路由路径中的地址，通过
ip_route_input()查找下一跳 -
更新目的地址为下一跳地址，并标记选项状态
-
int ip_options_rcv_srr(struct sk_buff *skb) {
for (srrptr = optptr[2]; srrptr <= srrspace; srrptr += 4) {
// 获取下一跳地址
memcpy(&nexthop, &optptr[srrptr-1], 4);
// 路由查找
err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, dev);
if (rt2->rt_type == RTN_UNICAST) break; // 找到有效下一跳
}
// 更新选项状态
opt->srr_is_hit = 1;
opt->nexthop = nexthop;
}
关键数据结构
struct ip_options {
__be32 faddr; // 源路由的最终地址
__be32 nexthop; // 下一跳地址
unsigned char optlen; // 选项总长度
unsigned char srr; // 源路由偏移量
unsigned char rr; // 记录路由偏移量
unsigned char ts; // 时间戳偏移量
unsigned char is_strictroute:1; // 严格源路由标志
unsigned char srr_is_hit:1; // 源路由命中标志
unsigned char is_changed:1; // 选项被修改标志
unsigned char rr_needaddr:1; // RR 需要地址
unsigned char ts_needtime:1; // TS 需要时间戳
unsigned char ts_needaddr:1; // TS 需要地址
unsigned char router_alert; // 路由器告警选项位置
unsigned char cipso; // CIPSO 选项位置
unsigned char __data[0]; // 选项数据
};
处理流程总结
-
发送路径：
-
ip_options_build()将选项插入 IP 头部 -
非分片包：填充 RR/TS 选项的地址和时间戳
-
分片包：清除 RR/TS 选项
-
-
接收路径：
-
ip_options_compile()验证选项合法性 -
ip_options_rcv_srr()处理源路由选项（更新目的地址） -
ICMP 响应：
ip_options_echo()复制并反转选项
-
-
转发路径：
-
ip_forward_options()更新 RR/SRR 选项中的地址字段
-
注意事项
-
分片处理：
-
分片包中不允许携带 RR/TS 选项（
ip_options_fragment()会清除它们）
-
-
错误处理：
-
非法选项触发 ICMP
Parameter Problem消息（类型 12，代码 0） -
错误位置通过 32 位信息返回（高 8 位为错误偏移量）
-
-
安全机制：
-
CIPSO 选项通过
cipso_v4_validate()验证 -
特权检查（
CAP_NET_RAW）限制某些敏感选项（如IPOPT_SEC）
-
这个文件是 Linux 网络栈中处理 IP 选项的核心模块，实现了 RFC 791/1122/1812 定义的选项行为，并与路由、安全子系统紧密集成。