Linux下TCP协议和SCTP协议的数据包传输流程分析

一.Linux下基于TCP协议和SCTP协议的本地产生的数据包传输是通过调用ip_queue_xmit函数实现的。它们与UDP/ICMP/IGMP的数据包传输调用的函数接口不同。

1.套接字数据结构：因为网络层（TCP/UDP等）信息都存储在sock数据接口中。它被分配成为协议簇专用的结构的一部分。就PF——INET套接字而言，此结构就是inet_sock。

 

struct sock {


        struct sock_common __sk_common;


#define sk_family __sk_common.skc_family


#define sk_state __sk_common.skc_state


#define sk_reuse __sk_common.skc_reuse


#define sk_bound_dev_if __sk_common.skc_bound_dev_if


#define sk_node __sk_common.skc_node


#define sk_bind_node __sk_common.skc_bind_node


#define sk_refcnt __sk_common.skc_refcnt


  /*

         * sk_shutdown是一组标志位，SEND_SHUTDOWN and/or RCV_SHUTDOWN。


         * sk_userlocks， SO_SNDBUF and SO_RCVBUF。

         */


        unsigned char sk_shutdown : 2,


                            sk_no_check : 2,


                            sk_userlocks : 4;


        //sk_protocol表示在当前域中套接字所属的协议


        unsigned char sk_protocol;


        //sk_type表示套接字的类型，如SOCK_STREAM


        unsigned short sk_type;


        int sk_rcvbuf;

//sk_rcvbuf表示接收缓冲区的字节长度。


        socket_lock_t sk_lock;


        wait_queue_head_t *sk_sleep;


        struct dst_entry *sk_dst_cache;


        struct xfrm_policy *sk_policy[2];


        rwlock_t sk_dst_lock;




//sk_rmem_alloc表示接收队列已提交的字节数


        atomic_t sk_rmem_alloc;

  // sk_wmem_alloc表示发送队列已提交的字节数


        atomic_t sk_wmem_alloc;


        atomic_t sk_omem_alloc;


  //


sk_receive_queue表示接收的数据包的队列

        struct sk_buff_head sk_receive_queue;

        //sk_write_queue表示发送数据包的队列


        struct sk_buff_head sk_write_queue;


        int sk_wmem_queued;


        int sk_forward_alloc;


        unsigned int sk_allocation;


  // sk_sndbuf表示发送缓冲区的字节长度


        int sk_sndbuf;


        int sk_route_caps;


        int sk_hashent;


        // sk_flags，SO_LINGER (l_onoff)，SO_BROADCAST，SO_KEEPALIVE，SO_OOBINLINE


        unsigned long sk_flags;


        unsigned long sk_lingertime;


        struct {


            struct sk_buff *head;


            struct sk_buff *tail;


        } sk_backlog;


        struct sk_buff_head sk_error_queue;


        /*

         * sk_prot是指定的域内部的协议处理函数集，

         * 它是套接口层跟传输层之间的一个接口，提供诸如bind, accept, close等操作

         */

        struct proto *sk_prot;


        struct proto *sk_prot_creator;


        rwlock_t sk_callback_lock;


        int sk_err,


                    sk_err_soft;


        // sk_ack_backlog表示当前的侦听队列


        unsigned short sk_ack_backlog;


        // sk_max_ack_backlog表示最大的侦听队列


        unsigned short sk_max_ack_backlog;


        __u32 sk_priority;


        struct ucred sk_peercred;


        int sk_rcvlowat;


        long sk_rcvtimeo;


        long sk_sndtimeo;


        struct sk_filter *sk_filter;


        void *sk_protinfo;


        struct timer_list sk_timer;


        struct timeval sk_stamp;


        struct socket *sk_socket;


        void *sk_user_data;


        struct page *sk_sndmsg_page;


        struct sk_buff *sk_send_head;


        __u32 sk_sndmsg_off;


        int sk_write_pending;


        void *sk_security;

  /*

         * 几个函数指针均属回调函数，分别在套接口状态变化，

         * 有数据到达需要处理，有发送空间可用，有错误等时候被回调。

         * 最后一个函数sk_destruct在套接口释放时被回调。

         */


        void (*sk_state_change)(struct sock *sk);


        void (*sk_data_ready)(struct sock *sk, int bytes);


        void (*sk_write_space)(struct sock *sk);


        void (*sk_error_report)(struct sock *sk);


        int (*sk_backlog_rcv)(struct sock *sk,


                        struct sk_buff *skb);


        void (*sk_destruct)(struct sock *sk);


    };



    __sk_common是套接口在网络层的最小表示。下面是其定义：


    struct sock_common {


        unsigned short skc_family; /*地址族*/


        volatile unsigned char skc_state; /*连接状态*/


        unsigned char skc_reuse; /*SO_REUSEADDR设置*/


        int skc_bound_dev_if;


        struct hlist_node skc_node;


        struct hlist_node skc_bind_node; /*哈希表相关*/


        atomic_t skc_refcnt; /*引用计数*/


    };



struct inet_sock {


    struct sock sk;


#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)


    struct ipv6_pinfo *pinet6;


#endif


    __be32 daddr; //IPv4的目的地址(远程地址)



    __be32 rcv_saddr; //IPv4的本地接收地址



    __be16 dport; //目的端口(远程端口)



    __u16 num; //本地端口(主机字节序)



    __be32 saddr; //本地发送地址



    __s16 uc_ttl; //单播的ttl



    __u16 cmsg_flags;


    struct ip_options *opt;


    __be16 sport; //本地端口



    __u16 id; //单调递增的一个值，用于赋给iphdr的id域



    __u8 tos; //服务类型



    __u8 mc_ttl; //组播的ttl



    __u8 pmtudisc;


    __u8 recverr:1,


                            is_icsk:1,


                            freebind:1,


                            hdrincl:1, //是否自己构建ip首部(用于raw协议)



                            mc_loop:1; //组播是否发向回路



    int mc_index; -//组播使用的本地设备接口的索引



    __be32 mc_addr; //组播源地址



    struct ip_mc_socklist *mc_list; -//组播组列表



    struct {


        unsigned int flags;


        unsigned int fragsize;


        struct ip_options *opt;


        struct rtable *rt;


        int length;


        __be32 addr;


        struct flowi fl;


    } cork;


};

 

2.ip_queue_xmit的两个参数中，ipfragok主要由SCTP便用的标志，用来指出是否允许分段。

 

int ip_queue_xmit(struct sk_buff *skb, int ipfragok)


{


struct sock *sk = skb->sk;


struct inet_sock *inet = inet_sk(sk);


struct ip_options *opt = inet->opt;


struct rtable *rt;


struct iphdr *iph;




/* Skip all of this if the packet is already routed,


 * f.e. by something like SCTP.


       * 当缓冲区由SCTP协议处理过后，有可能skb中包含路由信息,即skb->dst != NULL。

 */


rt = (struct rtable *) skb->dst;


if (rt != NULL)


goto packet_routed;




/* Make sure we can route this packet. */


      /*

       * 在cache中查找是否有记录，没有返回NULL

       * 如果rt==NULL，调用 ip_route_output_flow寻找出一条新路径

       */

rt = (struct rtable *)__sk_dst_check(sk, 0);


if (rt == NULL) {


u32 daddr;




/* Use correct destination address if we have options. */


            /* 从套接字中获取最终目的地址 */

daddr = inet->daddr;


            /* 如果有选项且存在来源地路由，获取下一个跳点的地址 */

if(opt && opt->srr)


daddr = opt->faddr;




{


struct flowi fl = { .oif = sk->sk_bound_dev_if,


    .nl_u = { .ip4_u =


      { .daddr = daddr,


.saddr = inet->saddr,


.tos = RT_CONN_FLAGS(sk) } },


    .proto = sk->sk_protocol,


    .uli_u = { .ports =


       { .sport = inet->sport,


 .dport = inet->dport } } };




/* If this fails, retransmit mechanism of transport layer will


 * keep trying until route appears or the connection times


 * itself out.


 * 如果寻找失败，传输层的重传机制会一直试，

 * 直到寻找到可用路由或者直到该连接超时。

 */


if (ip_route_output_flow(&rt, &fl, sk, 0))


goto no_route;


}


            /*

             * ip_route_output_flow找到新路经后，

             * 调用__sk_dst_set保存到sk数据结构中。

             */

__sk_dst_set(sk, &rt->u.dst);


tcp_v4_setup_caps(sk, &rt->u.dst);


}


skb->dst = dst_clone(&rt->u.dst);




packet_routed:


/* 选项提供的下一个跳点和路由表所传回的下一个跳点不吻合，丢弃该包。*/

if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)


goto no_route;




/* OK, we know where to send it, allocate and build IP header. */


      /* 创建IP报头 */

iph = (struct iphdr *) skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));


      /*

       * 4 << 12 version

       * 5 << 8 header length

       * inet->tos&0xff tos type

       */

*((__u16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));


iph->tot_len = htons(skb->len);

/* 总长度 */

if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)


iph->frag_off = htons(IP_DF);


else


iph->frag_off = 0;


iph->ttl = ip_select_ttl(inet, &rt->u.dst);


iph->protocol = sk->sk_protocol;

 /* 协议值 */

iph->saddr = rt->rt_src;


 /* 源地址 */

iph->daddr = rt->rt_dst;


 /* 目的地址 */

skb->nh.iph = iph;


/* Transport layer set skb->h.foo itself. */




if (opt && opt->optlen) {


iph->ihl += opt->optlen >> 2;


            /* 把选项写入IP报头 */

ip_options_build(skb, opt, inet->daddr, rt, 0);


}



/* 根据该封包是否可能被分段而在报头中设定IP ID */

ip_select_ident_more(iph, &rt->u.dst, sk, skb_shinfo(skb)->tso_segs);




/* Add an IP checksum.进行IP校验和 */


ip_send_check(iph);



      /*

       * priority把封包排入那一个外出队列

       * 这个决定该封包多快会被传输

       */

skb->priority = sk->sk_priority;



/* 调用dst_output传出 */

return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,


       dst_output);




no_route:


IP_INC_STATS(IPSTATS_MIB_OUTNOROUTES);


kfree_skb(skb);


return -EHOSTUNREACH;


}