网络链路层加密实现01-skb

/** 
 *  struct sk_buff - socket buffer
 *  @next: Next buffer in list
 *  @prev: Previous buffer in list
 *  @tstamp: Time we arrived/left
 *  @rbnode: RB tree node, alternative to next/prev for netem/tcp
 *  @sk: Socket we are owned by
 *  @dev: Device we arrived on/are leaving by
 *  @cb: Control buffer. Free for use by every layer. Put private vars here
 *  @_skb_refdst: destination entry (with norefcount bit)
 *  @sp: the security path, used for xfrm
 *  @len: Length of actual data
 *  @data_len: Data length
 *  @mac_len: Length of link layer header
 *  @hdr_len: writable header length of cloned skb
 *  @csum: Checksum (must include start/offset pair)
 *  @csum_start: Offset from skb->head where checksumming should start
 *  @csum_offset: Offset from csum_start where checksum should be stored
 *  @priority: Packet queueing priority
 *  @ignore_df: allow local fragmentation
 *  @cloned: Head may be cloned (check refcnt to be sure)
 *  @ip_summed: Driver fed us an IP checksum
 *  @nohdr: Payload reference only, must not modify header
 *  @nfctinfo: Relationship of this skb to the connection
 *  @pkt_type: Packet class
 *  @fclone: skbuff clone status
 *  @ipvs_property: skbuff is owned by ipvs
 *  @peeked: this packet has been seen already, so stats have been
 *    done for it, don't do them again
 *  @nf_trace: netfilter packet trace flag
 *  @protocol: Packet protocol from driver
 *  @destructor: Destruct function
 *  @nfct: Associated connection, if any
 *  @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
 *  @skb_iif: ifindex of device we arrived on
 *  @tc_index: Traffic control index
 *  @tc_verd: traffic control verdict
 *  @hash: the packet hash
 *  @queue_mapping: Queue mapping for multiqueue devices
 *  @xmit_more: More SKBs are pending for this queue
 *  @pfmemalloc: skbuff was allocated from PFMEMALLOC reserves
 *  @ndisc_nodetype: router type (from link layer)
 *  @ooo_okay: allow the mapping of a socket to a queue to be changed
 *  @l4_hash: indicate hash is a canonical 4-tuple hash over transport
 *    ports.
 *  @sw_hash: indicates hash was computed in software stack
 *  @wifi_acked_valid: wifi_acked was set
 *  @wifi_acked: whether frame was acked on wifi or not
 *  @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
  *  @napi_id: id of the NAPI struct this skb came from
 *  @secmark: security marking
 *  @offload_fwd_mark: fwding offload mark
 *  @mark: Generic packet mark
 *  @vlan_proto: vlan encapsulation protocol
 *  @vlan_tci: vlan tag control information
 *  @inner_protocol: Protocol (encapsulation)
 *  @inner_transport_header: Inner transport layer header (encapsulation)
 *  @inner_network_header: Network layer header (encapsulation)
 *  @inner_mac_header: Link layer header (encapsulation)
 *  @transport_header: Transport layer header
 *  @network_header: Network layer header
 *  @mac_header: Link layer header
 *  @tail: Tail pointer
 *  @end: End pointer
 *  @head: Head of buffer
 *  @data: Data head pointer
 *  @truesize: Buffer size
 *  @users: User count - see {datagram,tcp}.c
 */


struct sk_buff {
  union {
    struct {
      /* These two members must be first. */
      struct sk_buff    *next;
      struct sk_buff    *prev;


      union {
        ktime_t    tstamp;
        struct skb_mstamp skb_mstamp;
      };
    };
    struct rb_node    rbnode; /* used in netem, ip4 defrag, and tcp stack */
  };


  union {
    struct sock    *sk;
    int      ip_defrag_offset;
  };


  struct net_device  *dev;


  /*
   * This is the control buffer. It is free to use for every
   * layer. Please put your private variables there. If you
   * want to keep them across layers you have to do a skb_clone()
   * first. This is owned by whoever has the skb queued ATM.
   */
  char      cb[48] __aligned(8);


  unsigned long    _skb_refdst;
  void      (*destructor)(struct sk_buff *skb);
#ifdef CONFIG_XFRM
  struct  sec_path  *sp;
#endif
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  struct nf_conntrack  *nfct;
#endif
#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
  struct nf_bridge_info  *nf_bridge;
#endif
  unsigned int    len,
        data_len;
  __u16      mac_len,
        hdr_len;


  /* Following fields are _not_ copied in __copy_skb_header()
   * Note that queue_mapping is here mostly to fill a hole.
   */
  kmemcheck_bitfield_begin(flags1);
  __u16      queue_mapping;
  __u8      cloned:1,
        nohdr:1,
        fclone:2,
        peeked:1,
        head_frag:1,
        xmit_more:1,
        pfmemalloc:1;
  kmemcheck_bitfield_end(flags1);


  /* fields enclosed in headers_start/headers_end are copied
   * using a single memcpy() in __copy_skb_header()
   */
  /* private: */
  __u32      headers_start[0];
  /* public: */


/* if you move pkt_type around you also must adapt those constants */
#ifdef __BIG_ENDIAN_BITFIELD
#define PKT_TYPE_MAX  (7 << 5)
#else
#define PKT_TYPE_MAX  7
#endif
#define PKT_TYPE_OFFSET()  offsetof(struct sk_buff, __pkt_type_offset)


  __u8      __pkt_type_offset[0];
  __u8      pkt_type:3;
  __u8      ignore_df:1;
  __u8      nfctinfo:3;
  __u8      nf_trace:1;


  __u8      ip_summed:2;
  __u8      ooo_okay:1;
  __u8      l4_hash:1;
  __u8      sw_hash:1;
  __u8      wifi_acked_valid:1;
  __u8      wifi_acked:1;
  __u8      no_fcs:1;


  /* Indicates the inner headers are valid in the skbuff. */
  __u8      encapsulation:1;
  __u8      encap_hdr_csum:1;
  __u8      csum_valid:1;
  __u8      csum_complete_sw:1;
  __u8      csum_level:2;
  __u8      csum_bad:1;
#ifdef CONFIG_IPV6_NDISC_NODETYPE
  __u8      ndisc_nodetype:2;
#endif
  __u8      ipvs_property:1;


  __u8      inner_protocol_type:1;
  __u8      remcsum_offload:1;
  /* 3 or 5 bit hole */


#ifdef CONFIG_NET_SCHED
  __u16      tc_index;  /* traffic control index */
#ifdef CONFIG_NET_CLS_ACT
  __u16      tc_verd;  /* traffic control verdict */
#endif
#endif


  union {
    __wsum    csum;
    struct {
      __u16  csum_start;
      __u16  csum_offset;
    };
  };
  __u32      priority;
  int      skb_iif;
  __u32      hash;
  __be16      vlan_proto;
  __u16      vlan_tci;
#if defined(CONFIG_NET_RX_BUSY_POLL) || defined(CONFIG_XPS)
  union {
    unsigned int  napi_id;
    unsigned int  sender_cpu;
  };
#endif
  union {
#ifdef CONFIG_NETWORK_SECMARK
    __u32    secmark;
#endif
#ifdef CONFIG_NET_SWITCHDEV
    __u32    offload_fwd_mark;
#endif
  };


  union {
    __u32    mark;
    __u32    reserved_tailroom;
  };


  union {
    __be16    inner_protocol;
    __u8    inner_ipproto;
  };


  __u16      inner_transport_header;
  __u16      inner_network_header;
  __u16      inner_mac_header;


  __be16      protocol;
  __u16      transport_header;
  __u16      network_header;
  __u16      mac_header;


  /* private: */
  __u32      headers_end[0];
  /* public: */


  /* These elements must be at the end, see alloc_skb() for details.  */
  sk_buff_data_t    tail;
  sk_buff_data_t    end;
  unsigned char    *head,
        *data;
  unsigned int    truesize;
  atomic_t    users;
};

struct sk_buff_head {
     /* These two members must be first. */
     struct sk_buff*next;
     struct sk_buff*prev;
     __u32qlen;//skb链表中的节点数，队列长度
     spinlock_tlock;//用于控制对skb链表并发操作的自旋锁
};

union {
    ktime_ttstamp;
    struct skb_mstamp skb_mstamp;
};

union {
    __wsumcsum;
    struct {
        __u16csum_start;
        __u16csum_offset;
    };
};

enum {
     SKB_FCLONE_UNAVAILABLE, /* skb has no fclone (from head_cache) 未被克隆*/
     SKB_FCLONE_ORIG,    /* orig skb (from fclone_cache) 分配的父skb，可以被克隆*/
     SKB_FCLONE_CLONE,   /* companion fclone skb (from fclone_cache) 分配的子skb，从父skb克隆得到的*/
};