linux ip选项处理（三）

（3）目的端接收syn到发送synack

从前文得知，当数据报每经过一个源路由路径节点时，ip选项中的offset字段的值就加4，那么到达源路由路径的最后一个节点并得到转发后，offset字段的值所表示的偏移地址已经指向选项的末尾了

void ip_forward_options(struct sk_buff *skb)
{
    ......
    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(&rt->rt_dst, &optptr[srrptr-1], 4) == 0)
                break;
        }
        if (srrptr + 3 <= srrspace) {
            opt->is_changed = 1;
            ip_rt_get_source(&optptr[srrptr-1], rt);
            skb->nh.iph->daddr = rt->rt_dst;
            optptr[2] = srrptr+4;//偏移量加4，即移动一个ip地址
        } else if (net_ratelimit())
            printk(KERN_CRIT "ip_forward(): Argh! Destination lost!\n");
        if (opt->ts_needaddr) {
            optptr = raw + opt->ts;
            ip_rt_get_source(&optptr[optptr[2]-9], rt);
            opt->is_changed = 1;
        }
    }
    if (opt->is_changed) {
        opt->is_changed = 0;
        ip_send_check(skb->nh.iph);
    }
}

当syn包到达目的地址时，将进入函数

int ip_options_rcv_srr(struct sk_buff *skb)
{
    struct ip_options *opt = &(IPCB(skb)->opt);
    int srrspace, srrptr;
    u32 nexthop;
    struct iphdr *iph = skb->nh.iph;
    unsigned char * optptr = skb->nh.raw + opt->srr;
    ......

    for (srrptr=optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
//optptr[1]为选项的长度，optptr[2]为offset；由于在目的端，offset指向选项的末尾，并且大小为options的长度+1（为对齐的选项长度）；则srrptr>srrspace,此for循环将不执行
        if (srrptr + 3 > srrspace) {
            icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
            return -EINVAL;
        }
        memcpy(&nexthop, &optptr[srrptr-1], 4);

        rt = (struct rtable*)skb->dst;
        skb->dst = NULL;
        err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
        rt2 = (struct rtable*)skb->dst;
        if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
            ip_rt_put(rt2);
            skb->dst = &rt->u.dst;
            return -EINVAL;
        }
        ip_rt_put(rt);
        if (rt2->rt_type != RTN_LOCAL)
            break;
        /* Superfast 8) loopback forward */
        memcpy(&iph->daddr, &optptr[srrptr-1], 4);
        opt->is_changed = 1;
    }
    if (srrptr <= srrspace) {//srrptr>srrspace,不执行
        opt->srr_is_hit = 1;
        opt->is_changed = 1;
    }
    return 0;//直接返回
}

返回到函数ip_rcv_finish

static inline int ip_rcv_finish(struct sk_buff *skb)
{
    struct iphdr *iph = skb->nh.iph;
    struct rtable *rt;

    /*
     *    Initialise the virtual path cache for the packet. It describes
     *    how the packet travels inside Linux networking.
     */
    if (skb->dst == NULL) {
        int err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos,
                     skb->dev);//dst->input注册为ip_local_deliver
        if (unlikely(err)) {
            if (err == -EHOSTUNREACH)
                IP_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
            else if (err == -ENETUNREACH)
                IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES);
            goto drop;
        }
    }

    ......
    if (iph->ihl > 5 && ip_rcv_options(skb))//dst->input没有被修改，因为此时数据包已经到达目
                                              的端
        goto drop;
    ......
    return dst_input(skb);//本机包的后续处理过程
    ......
}

此时接收到的数据的ip选项中保存了源路由路径节点ip地址，并且是按数据包通过节点的顺序存储的；选项保存在了skb的cb中可以通过&(IPCB(skb)->opt)得到。

现在我们来分析tcp层函数tcp_v4_conn_reques函数（不考虑syncookies的过程）

int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
    struct inet_request_sock *ireq;
    struct tcp_options_received tmp_opt;
    struct request_sock *req;
    __u32 saddr = skb->nh.iph->saddr;
    __u32 daddr = skb->nh.iph->daddr;
    __u32 isn = TCP_SKB_CB(skb)->when;
    struct dst_entry *dst = NULL;
    ......

    ireq = inet_rsk(req);
    ireq->loc_addr = daddr;
    ireq->rmt_addr = saddr;
    ireq->opt = tcp_v4_save_options(sk, skb);//将skb中cb保存的ip选项拷贝到ireq->opt中
    ......
    if (tcp_v4_send_synack(sk, req, dst))//发送synack
        goto drop_and_free;
    ......
}

现分析tcp_v4_save_options函数

static struct ip_options *tcp_v4_save_options(struct sock *sk,
                     struct sk_buff *skb)
{
    struct ip_options *opt = &(IPCB(skb)->opt);//opt指向skb中的cb
    struct ip_options *dopt = NULL;

    if (opt && opt->optlen) {
        int opt_size = optlength(opt);
        dopt = kmalloc(opt_size, GFP_ATOMIC);
        if (dopt) {
            if (ip_options_echo(dopt, skb)) {//处理skb中保存的ip选项
                kfree(dopt);
                dopt = NULL;
            }
        }
    }
    return dopt;
}

int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
{
    struct ip_options *sopt;
    unsigned char *sptr, *dptr;
    int soffset, doffset;
    int    optlen;
    u32    daddr;

    memset(dopt, 0, sizeof(struct ip_options));

    dopt->is_data = 1;

    sopt = &(IPCB(skb)->opt);//sopt指向skb的cb

    if (sopt->optlen == 0) {
        dopt->optlen = 0;
        return 0;
    }

    sptr = skb->nh.raw;
    dptr = dopt->__data;
    ......
    if (sopt->srr) {//只分析源路由选项，其他如记录路由选项和时间戳选项可类似分析
        unsigned char * start = sptr+sopt->srr;//start指向选项的一个字节
        u32 faddr;

        optlen = start[1];
        soffset = start[2];//此时为目的端，则相对于选项起始位置的偏移量指向了选项的末尾；譬如，客户端192.168.18.71 源路由路径节点192.168.18.72 目的端192.168.18.73，则此时len=7，offset=8（1个ip地址的长度（18.72）+1字节type+1字节len+1字节offset+1字节对齐）
        doffset = 0;
        if (soffset > optlen)
            soffset = optlen + 1;
        soffset -= 4;//偏移量减4，即向左移动一个ip地址长度（4字节）
        if (soffset > 3) {
            memcpy(&faddr, &start[soffset-1], 4);//现在偏移量标识的是倒数第一个ip地址（源路由路径节点中的最后的节点），譬如客户端A，路由节点B,路由节点C，服务器端D，那么此时的faddr为C的ip地址。faddr为我们发送synack的下一跳地址，也为synack的目的地址
            for (soffset-=4, doffset=4; soffset > 3; soffset-=4, doffset+=4)
                memcpy(&dptr[doffset-1], &start[soffset-1], 4);//将skb中保存的ip选项中的数据段（ip地址）拷贝到dopt->__data字段中，并且以逆序保存，譬如接收到的options中的ip顺序是18.71
18.72 18.73，faddr为18.73，那么现在dopt->__data中的是18.72 18.71
            /*
             * RFC1812 requires to fix illegal source routes.
             */
            if (memcmp(&skb->nh.iph->saddr, &start[soffset+3], 4) == 0)
                doffset -= 4;
        }
        if (doffset > 3) {
            memcpy(&start[doffset-1], &daddr, 4);
            dopt->faddr = faddr;//填充dopt的下一跳地址
            dptr[0] = start[0];//填充dopt的type位，和收到的options一致
            dptr[1] = doffset+3;//填充len位，doffset的值为源路由路径ip的个数*4,3为
                                  len+type+offset 3字节
            dptr[2] = 4;//指向源路由路径首个ip，也就是到达下一跳后，下一跳将选为目的ip地址的路径节点
            dptr += doffset+3;
            dopt->srr = dopt->optlen + sizeof(struct iphdr);//填充srr，相对于ip头的偏移量
            dopt->optlen += doffset+3;
            dopt->is_strictroute = sopt->is_strictroute;//如果接收的options是严格路由，设定
                                                          严格路由选项
        }
    }
    ......
    return 0;//返回
}

现在来分析tcp_v4_send_synack

static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
             struct dst_entry *dst)
{
    const struct inet_request_sock *ireq = inet_rsk(req);
    int err = -1;
    struct sk_buff * skb;

    /* First, grab a route. */
    if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)//查找路由，构造路由缓存项。目的
                                                              地址我faddr
        goto out;

    skb = tcp_make_synack(sk, dst, req);//构造skb并填充tcp头

    if (skb) {
        struct tcphdr *th = skb->h.th;

        th->check = tcp_v4_check(th, skb->len,
                     ireq->loc_addr,
                     ireq->rmt_addr,
                     csum_partial((char *)th, skb->len,
                         skb->csum));

        err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,//填充ip头和ip选项；
                           ireq->loc_addr为本地地址，ireq->rmt_addr为目的地址，即syn包的源地址
                     ireq->rmt_addr,
                     ireq->opt);
        if (err == NET_XMIT_CN)
            err = 0;
    }

out:
    dst_release(dst);
    return err;
}

struct dst_entry* inet_csk_route_req(struct sock *sk,
                 const struct request_sock *req)
{
    struct rtable *rt;
    const struct inet_request_sock *ireq = inet_rsk(req);
    struct ip_options *opt = inet_rsk(req)->opt;//tcp_v4_save_options函数将skb保存的
                                                  options拷贝到inet_rsk(req)->opt
    struct flowi fl = { .oif = sk->sk_bound_dev_if,
             .nl_u = { .ip4_u =
                 { .daddr = ((opt && opt->srr) ?//如果有源路由选项，则路由的下一跳为选项中的下一
                                                  跳地址，即options结构的faddr
                         opt->faddr :
                         ireq->rmt_addr),
                    .saddr = ireq->loc_addr,
                    .tos = RT_CONN_FLAGS(sk) } },
             .proto = sk->sk_protocol,
             .uli_u = { .ports =
                 { .sport = inet_sk(sk)->sport,
                     .dport = ireq->rmt_port } } };

    security_req_classify_flow(req, &fl);
    if (ip_route_output_flow(&rt, &fl, sk, 0)) {
        IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
        return NULL;
    }
    if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway) {//如果是严格路由选
                                                   项，并且路由的下一跳和网关不一致，就返回
        ip_rt_put(rt);
        IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
        return NULL;
    }
    return &rt->u.dst;
}

现在我们来看ip头的构造

int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
             u32 saddr, u32 daddr, struct ip_options *opt)
{
    struct inet_sock *inet = inet_sk(sk);
    struct rtable *rt = (struct rtable *)skb->dst;
    struct iphdr *iph;

    /* Build the IP header. */
    if (opt)
        iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr) + opt->optlen);
    else
        iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));

    iph->version = 4;
    iph->ihl = 5;
    iph->tos = inet->tos;
    if (ip_dont_fragment(sk, &rt->u.dst))
        iph->frag_off = htons(IP_DF);
    else
        iph->frag_off = 0;
    iph->ttl = ip_select_ttl(inet, &rt->u.dst);
    iph->daddr = rt->rt_dst;//synack包的目的地址为路由的下一跳地址，即options的faddr
    iph->saddr = rt->rt_src;//本地地址
    iph->protocol = sk->sk_protocol;
    iph->tot_len = htons(skb->len);
    ip_select_ident(iph, &rt->u.dst, sk);
    skb->nh.iph = iph;

    if (opt && opt->optlen) {
        iph->ihl += opt->optlen>>2;
        ip_options_build(skb, opt, daddr, rt, 0);//填充ip选项，daddr为syn包的源地址（客户端
                                                   地址）；opt为inet_rsk(req)->opt，为我们保
                                                   存的syn包的选项
    }
    ip_send_check(iph);

    skb->priority = sk->sk_priority;

    /* Send it out. */
    return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,//dst_output发送
         dst_output);
}

void ip_options_build(struct sk_buff * skb, struct ip_options * opt,
             u32 daddr, struct rtable *rt, int is_frag)
{
    unsigned char * iph = skb->nh.raw;

    memcpy(&(IPCB(skb)->opt), opt, sizeof(struct ip_options));
    memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
    opt = &(IPCB(skb)->opt);
    opt->is_data = 0;

    if (opt->srr)
        memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);//如果是源路径路由，则将syn包的源地
                                                            址放到ip选项源路径的尾部

    if (!is_frag) {//如果不是分片
        if (opt->rr_needaddr)//记录路由的地址部分
            ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, rt);//通过路由缓存获取源地址
        if (opt->ts_needaddr)//时间戳选项的地址部分
            ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, rt);
        if (opt->ts_needtime) {//时间戳选项的时间部分
            struct timeval tv;
            __u32 midtime;
            do_gettimeofday(&tv);
            midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
            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;
    }
}

下面是实例分析

实验（一）LSRR

客户端：192.168.18.73 路由节点1：192.168.18.71 路由节点2:192.168.18.72 服务器端：192.168.18.76 18.71上18.0网段有个网关192.168.18.79

在服务器端18.76上抓包：

上图为syn包

上图为synack包

如果设置网关不影响数据包的接收转发和发送

实验（二）SSRR

没有设置网关的时候数据包流程正常

如果在18.76上配置18.79的网关，则synack发送不了。

 

如是，ip选项基本上分析完了