2 * GRE over IPv4 demultiplexer driver
4 * Authors: Dmitry Kozlov (xeb@mail.ru)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/kmod.h>
18 #include <linux/skbuff.h>
21 #include <linux/netdevice.h>
22 #include <linux/if_tunnel.h>
23 #include <linux/spinlock.h>
24 #include <net/protocol.h>
28 static const struct gre_protocol __rcu
*gre_proto
[GREPROTO_MAX
] __read_mostly
;
29 static DEFINE_SPINLOCK(gre_proto_lock
);
31 int gre_add_protocol(const struct gre_protocol
*proto
, u8 version
)
33 if (version
>= GREPROTO_MAX
)
36 spin_lock(&gre_proto_lock
);
37 if (gre_proto
[version
])
40 RCU_INIT_POINTER(gre_proto
[version
], proto
);
41 spin_unlock(&gre_proto_lock
);
45 spin_unlock(&gre_proto_lock
);
49 EXPORT_SYMBOL_GPL(gre_add_protocol
);
51 int gre_del_protocol(const struct gre_protocol
*proto
, u8 version
)
53 if (version
>= GREPROTO_MAX
)
56 spin_lock(&gre_proto_lock
);
57 if (rcu_dereference_protected(gre_proto
[version
],
58 lockdep_is_held(&gre_proto_lock
)) != proto
)
60 RCU_INIT_POINTER(gre_proto
[version
], NULL
);
61 spin_unlock(&gre_proto_lock
);
66 spin_unlock(&gre_proto_lock
);
70 EXPORT_SYMBOL_GPL(gre_del_protocol
);
72 static int gre_rcv(struct sk_buff
*skb
)
74 const struct gre_protocol
*proto
;
78 if (!pskb_may_pull(skb
, 12))
81 ver
= skb
->data
[1]&0x7f;
82 if (ver
>= GREPROTO_MAX
)
86 proto
= rcu_dereference(gre_proto
[ver
]);
87 if (!proto
|| !proto
->handler
)
89 ret
= proto
->handler(skb
);
100 static void gre_err(struct sk_buff
*skb
, u32 info
)
102 const struct gre_protocol
*proto
;
103 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
104 u8 ver
= skb
->data
[(iph
->ihl
<<2) + 1]&0x7f;
106 if (ver
>= GREPROTO_MAX
)
110 proto
= rcu_dereference(gre_proto
[ver
]);
111 if (proto
&& proto
->err_handler
)
112 proto
->err_handler(skb
, info
);
116 static struct sk_buff
*gre_gso_segment(struct sk_buff
*skb
,
117 netdev_features_t features
)
119 struct sk_buff
*segs
= ERR_PTR(-EINVAL
);
120 netdev_features_t enc_features
;
121 int ghl
= GRE_HEADER_SECTION
;
122 struct gre_base_hdr
*greh
;
123 int mac_len
= skb
->mac_len
;
124 __be16 protocol
= skb
->protocol
;
128 if (unlikely(skb_shinfo(skb
)->gso_type
&
137 if (unlikely(!pskb_may_pull(skb
, sizeof(*greh
))))
140 greh
= (struct gre_base_hdr
*)skb_transport_header(skb
);
142 if (greh
->flags
& GRE_KEY
)
143 ghl
+= GRE_HEADER_SECTION
;
144 if (greh
->flags
& GRE_SEQ
)
145 ghl
+= GRE_HEADER_SECTION
;
146 if (greh
->flags
& GRE_CSUM
) {
147 ghl
+= GRE_HEADER_SECTION
;
152 /* setup inner skb. */
153 skb
->protocol
= greh
->protocol
;
154 skb
->encapsulation
= 0;
156 if (unlikely(!pskb_may_pull(skb
, ghl
)))
158 __skb_pull(skb
, ghl
);
159 skb_reset_mac_header(skb
);
160 skb_set_network_header(skb
, skb_inner_network_offset(skb
));
161 skb
->mac_len
= skb_inner_network_offset(skb
);
163 /* segment inner packet. */
164 enc_features
= skb
->dev
->hw_enc_features
& netif_skb_features(skb
);
165 segs
= skb_mac_gso_segment(skb
, enc_features
);
166 if (!segs
|| IS_ERR(segs
))
170 tnl_hlen
= skb_tnl_header_len(skb
);
172 __skb_push(skb
, ghl
);
176 if (skb_has_shared_frag(skb
)) {
179 err
= __skb_linearize(skb
);
181 kfree_skb_list(segs
);
187 greh
= (struct gre_base_hdr
*)(skb
->data
);
188 pcsum
= (__be32
*)(greh
+ 1);
190 *(__sum16
*)pcsum
= csum_fold(skb_checksum(skb
, 0, skb
->len
, 0));
192 __skb_push(skb
, tnl_hlen
- ghl
);
194 skb_reset_mac_header(skb
);
195 skb_set_network_header(skb
, mac_len
);
196 skb
->mac_len
= mac_len
;
197 skb
->protocol
= protocol
;
198 } while ((skb
= skb
->next
));
203 static int gre_gso_send_check(struct sk_buff
*skb
)
205 if (!skb
->encapsulation
)
210 static const struct net_protocol net_gre_protocol
= {
212 .err_handler
= gre_err
,
216 static const struct net_offload gre_offload
= {
218 .gso_send_check
= gre_gso_send_check
,
219 .gso_segment
= gre_gso_segment
,
223 static int __init
gre_init(void)
225 pr_info("GRE over IPv4 demultiplexor driver\n");
227 if (inet_add_protocol(&net_gre_protocol
, IPPROTO_GRE
) < 0) {
228 pr_err("can't add protocol\n");
232 if (inet_add_offload(&gre_offload
, IPPROTO_GRE
)) {
233 pr_err("can't add protocol offload\n");
234 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
241 static void __exit
gre_exit(void)
243 inet_del_offload(&gre_offload
, IPPROTO_GRE
);
244 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
247 module_init(gre_init
);
248 module_exit(gre_exit
);
250 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
251 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
252 MODULE_LICENSE("GPL");