igmp: Use next_net_device_rcu()
[linux-2.6.git] / net / ipv4 / tunnel4.c
1 /* tunnel4.c: Generic IP tunnel transformer.
2  *
3  * Copyright (C) 2003 David S. Miller (davem@redhat.com)
4  */
5
6 #include <linux/init.h>
7 #include <linux/module.h>
8 #include <linux/mutex.h>
9 #include <linux/netdevice.h>
10 #include <linux/skbuff.h>
11 #include <net/icmp.h>
12 #include <net/ip.h>
13 #include <net/protocol.h>
14 #include <net/xfrm.h>
15
16 static struct xfrm_tunnel *tunnel4_handlers;
17 static struct xfrm_tunnel *tunnel64_handlers;
18 static DEFINE_MUTEX(tunnel4_mutex);
19
20 static inline struct xfrm_tunnel **fam_handlers(unsigned short family)
21 {
22         return (family == AF_INET) ? &tunnel4_handlers : &tunnel64_handlers;
23 }
24
25 int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family)
26 {
27         struct xfrm_tunnel **pprev;
28         int ret = -EEXIST;
29         int priority = handler->priority;
30
31         mutex_lock(&tunnel4_mutex);
32
33         for (pprev = fam_handlers(family); *pprev; pprev = &(*pprev)->next) {
34                 if ((*pprev)->priority > priority)
35                         break;
36                 if ((*pprev)->priority == priority)
37                         goto err;
38         }
39
40         handler->next = *pprev;
41         *pprev = handler;
42
43         ret = 0;
44
45 err:
46         mutex_unlock(&tunnel4_mutex);
47
48         return ret;
49 }
50
51 EXPORT_SYMBOL(xfrm4_tunnel_register);
52
53 int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family)
54 {
55         struct xfrm_tunnel **pprev;
56         int ret = -ENOENT;
57
58         mutex_lock(&tunnel4_mutex);
59
60         for (pprev = fam_handlers(family); *pprev; pprev = &(*pprev)->next) {
61                 if (*pprev == handler) {
62                         *pprev = handler->next;
63                         ret = 0;
64                         break;
65                 }
66         }
67
68         mutex_unlock(&tunnel4_mutex);
69
70         synchronize_net();
71
72         return ret;
73 }
74
75 EXPORT_SYMBOL(xfrm4_tunnel_deregister);
76
77 static int tunnel4_rcv(struct sk_buff *skb)
78 {
79         struct xfrm_tunnel *handler;
80
81         if (!pskb_may_pull(skb, sizeof(struct iphdr)))
82                 goto drop;
83
84         for (handler = tunnel4_handlers; handler; handler = handler->next)
85                 if (!handler->handler(skb))
86                         return 0;
87
88         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
89
90 drop:
91         kfree_skb(skb);
92         return 0;
93 }
94
95 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
96 static int tunnel64_rcv(struct sk_buff *skb)
97 {
98         struct xfrm_tunnel *handler;
99
100         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
101                 goto drop;
102
103         for (handler = tunnel64_handlers; handler; handler = handler->next)
104                 if (!handler->handler(skb))
105                         return 0;
106
107         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
108
109 drop:
110         kfree_skb(skb);
111         return 0;
112 }
113 #endif
114
115 static void tunnel4_err(struct sk_buff *skb, u32 info)
116 {
117         struct xfrm_tunnel *handler;
118
119         for (handler = tunnel4_handlers; handler; handler = handler->next)
120                 if (!handler->err_handler(skb, info))
121                         break;
122 }
123
124 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
125 static void tunnel64_err(struct sk_buff *skb, u32 info)
126 {
127         struct xfrm_tunnel *handler;
128
129         for (handler = tunnel64_handlers; handler; handler = handler->next)
130                 if (!handler->err_handler(skb, info))
131                         break;
132 }
133 #endif
134
135 static const struct net_protocol tunnel4_protocol = {
136         .handler        =       tunnel4_rcv,
137         .err_handler    =       tunnel4_err,
138         .no_policy      =       1,
139         .netns_ok       =       1,
140 };
141
142 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
143 static const struct net_protocol tunnel64_protocol = {
144         .handler        =       tunnel64_rcv,
145         .err_handler    =       tunnel64_err,
146         .no_policy      =       1,
147         .netns_ok       =       1,
148 };
149 #endif
150
151 static int __init tunnel4_init(void)
152 {
153         if (inet_add_protocol(&tunnel4_protocol, IPPROTO_IPIP)) {
154                 printk(KERN_ERR "tunnel4 init: can't add protocol\n");
155                 return -EAGAIN;
156         }
157 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
158         if (inet_add_protocol(&tunnel64_protocol, IPPROTO_IPV6)) {
159                 printk(KERN_ERR "tunnel64 init: can't add protocol\n");
160                 inet_del_protocol(&tunnel4_protocol, IPPROTO_IPIP);
161                 return -EAGAIN;
162         }
163 #endif
164         return 0;
165 }
166
167 static void __exit tunnel4_fini(void)
168 {
169 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
170         if (inet_del_protocol(&tunnel64_protocol, IPPROTO_IPV6))
171                 printk(KERN_ERR "tunnel64 close: can't remove protocol\n");
172 #endif
173         if (inet_del_protocol(&tunnel4_protocol, IPPROTO_IPIP))
174                 printk(KERN_ERR "tunnel4 close: can't remove protocol\n");
175 }
176
177 module_init(tunnel4_init);
178 module_exit(tunnel4_fini);
179 MODULE_LICENSE("GPL");