include/net/gre.h

   1 #ifndef __LINUX_GRE_H
   2 #define __LINUX_GRE_H
   3
   4 #include <linux/skbuff.h>
   5 #include <net/ip_tunnels.h>
   6
   7 struct gre_base_hdr {
   8         __be16 flags;
   9         __be16 protocol;
  10 } __packed;
  11
  12 struct gre_full_hdr {
  13         struct gre_base_hdr fixed_header;
  14         __be16 csum;
  15         __be16 reserved1;
  16         __be32 key;
  17         __be32 seq;
  18 } __packed;
  19 #define GRE_HEADER_SECTION 4
  20
  21 #define GREPROTO_CISCO          0
  22 #define GREPROTO_PPTP           1
  23 #define GREPROTO_MAX            2
  24 #define GRE_IP_PROTO_MAX        2
  25
  26 struct gre_protocol {
  27         int  (*handler)(struct sk_buff *skb);
  28         void (*err_handler)(struct sk_buff *skb, u32 info);
  29 };
  30
  31 int gre_add_protocol(const struct gre_protocol *proto, u8 version);
  32 int gre_del_protocol(const struct gre_protocol *proto, u8 version);
  33
  34 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
  35                                        u8 name_assign_type);
  36 int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
  37                      bool *csum_err, __be16 proto, int nhs);
  38
  39 static inline int gre_calc_hlen(__be16 o_flags)
  40 {
  41         int addend = 4;
  42
  43         if (o_flags & TUNNEL_CSUM)
  44                 addend += 4;
  45         if (o_flags & TUNNEL_KEY)
  46                 addend += 4;
  47         if (o_flags & TUNNEL_SEQ)
  48                 addend += 4;
  49         return addend;
  50 }
  51
  52 static inline __be16 gre_flags_to_tnl_flags(__be16 flags)
  53 {
  54         __be16 tflags = 0;
  55
  56         if (flags & GRE_CSUM)
  57                 tflags |= TUNNEL_CSUM;
  58         if (flags & GRE_ROUTING)
  59                 tflags |= TUNNEL_ROUTING;
  60         if (flags & GRE_KEY)
  61                 tflags |= TUNNEL_KEY;
  62         if (flags & GRE_SEQ)
  63                 tflags |= TUNNEL_SEQ;
  64         if (flags & GRE_STRICT)
  65                 tflags |= TUNNEL_STRICT;
  66         if (flags & GRE_REC)
  67                 tflags |= TUNNEL_REC;
  68         if (flags & GRE_VERSION)
  69                 tflags |= TUNNEL_VERSION;
  70
  71         return tflags;
  72 }
  73
  74 static inline __be16 gre_tnl_flags_to_gre_flags(__be16 tflags)
  75 {
  76         __be16 flags = 0;
  77
  78         if (tflags & TUNNEL_CSUM)
  79                 flags |= GRE_CSUM;
  80         if (tflags & TUNNEL_ROUTING)
  81                 flags |= GRE_ROUTING;
  82         if (tflags & TUNNEL_KEY)
  83                 flags |= GRE_KEY;
  84         if (tflags & TUNNEL_SEQ)
  85                 flags |= GRE_SEQ;
  86         if (tflags & TUNNEL_STRICT)
  87                 flags |= GRE_STRICT;
  88         if (tflags & TUNNEL_REC)
  89                 flags |= GRE_REC;
  90         if (tflags & TUNNEL_VERSION)
  91                 flags |= GRE_VERSION;
  92
  93         return flags;
  94 }
  95
  96 static inline __sum16 gre_checksum(struct sk_buff *skb)
  97 {
  98         __wsum csum;
  99
 100         if (skb->ip_summed == CHECKSUM_PARTIAL)
 101                 csum = lco_csum(skb);
 102         else
 103                 csum = skb_checksum(skb, 0, skb->len, 0);
 104         return csum_fold(csum);
 105 }
 106
 107 static inline void gre_build_header(struct sk_buff *skb, int hdr_len,
 108                                     __be16 flags, __be16 proto,
 109                                     __be32 key, __be32 seq)
 110 {
 111         struct gre_base_hdr *greh;
 112
 113         skb_push(skb, hdr_len);
 114
 115         skb_set_inner_protocol(skb, proto);
 116         skb_reset_transport_header(skb);
 117         greh = (struct gre_base_hdr *)skb->data;
 118         greh->flags = gre_tnl_flags_to_gre_flags(flags);
 119         greh->protocol = proto;
 120
 121         if (flags & (TUNNEL_KEY | TUNNEL_CSUM | TUNNEL_SEQ)) {
 122                 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
 123
 124                 if (flags & TUNNEL_SEQ) {
 125                         *ptr = seq;
 126                         ptr--;
 127                 }
 128                 if (flags & TUNNEL_KEY) {
 129                         *ptr = key;
 130                         ptr--;
 131                 }
 132                 if (flags & TUNNEL_CSUM &&
 133                     !(skb_shinfo(skb)->gso_type &
 134                       (SKB_GSO_GRE | SKB_GSO_GRE_CSUM))) {
 135                         *ptr = 0;
 136                         *(__sum16 *)ptr = gre_checksum(skb);
 137                 }
 138         }
 139 }
 140
 141 #endif