LXR linux/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
   7struct gre_base_hdr {
   8        __be16 flags;
   9        __be16 protocol;
  10} __packed;
  11
  12struct 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
  26struct gre_protocol {
  27        int  (*handler)(struct sk_buff *skb);
  28        void (*err_handler)(struct sk_buff *skb, u32 info);
  29};
  30
  31int gre_add_protocol(const struct gre_protocol *proto, u8 version);
  32int gre_del_protocol(const struct gre_protocol *proto, u8 version);
  33
  34struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
  35                                       u8 name_assign_type);
  36int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
  37                     bool *csum_err, __be16 proto, int nhs);
  38
  39static 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
  52static 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
  74static 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
  96static 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
 107static 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
 142