IPv6: fix race between cleanup and add/delete address
[linux-2.6.git] / net / netfilter / nf_sockopt.c
1 #include <linux/kernel.h>
2 #include <linux/init.h>
3 #include <linux/module.h>
4 #include <linux/skbuff.h>
5 #include <linux/netfilter.h>
6 #include <linux/mutex.h>
7 #include <net/sock.h>
8
9 #include "nf_internals.h"
10
11 /* Sockopts only registered and called from user context, so
12    net locking would be overkill.  Also, [gs]etsockopt calls may
13    sleep. */
14 static DEFINE_MUTEX(nf_sockopt_mutex);
15 static LIST_HEAD(nf_sockopts);
16
17 /* Do exclusive ranges overlap? */
18 static inline int overlap(int min1, int max1, int min2, int max2)
19 {
20         return max1 > min2 && min1 < max2;
21 }
22
23 /* Functions to register sockopt ranges (exclusive). */
24 int nf_register_sockopt(struct nf_sockopt_ops *reg)
25 {
26         struct nf_sockopt_ops *ops;
27         int ret = 0;
28
29         if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
30                 return -EINTR;
31
32         list_for_each_entry(ops, &nf_sockopts, list) {
33                 if (ops->pf == reg->pf
34                     && (overlap(ops->set_optmin, ops->set_optmax,
35                                 reg->set_optmin, reg->set_optmax)
36                         || overlap(ops->get_optmin, ops->get_optmax,
37                                    reg->get_optmin, reg->get_optmax))) {
38                         NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n",
39                                 ops->set_optmin, ops->set_optmax,
40                                 ops->get_optmin, ops->get_optmax,
41                                 reg->set_optmin, reg->set_optmax,
42                                 reg->get_optmin, reg->get_optmax);
43                         ret = -EBUSY;
44                         goto out;
45                 }
46         }
47
48         list_add(&reg->list, &nf_sockopts);
49 out:
50         mutex_unlock(&nf_sockopt_mutex);
51         return ret;
52 }
53 EXPORT_SYMBOL(nf_register_sockopt);
54
55 void nf_unregister_sockopt(struct nf_sockopt_ops *reg)
56 {
57         mutex_lock(&nf_sockopt_mutex);
58         list_del(&reg->list);
59         mutex_unlock(&nf_sockopt_mutex);
60 }
61 EXPORT_SYMBOL(nf_unregister_sockopt);
62
63 static struct nf_sockopt_ops *nf_sockopt_find(struct sock *sk, u_int8_t pf,
64                 int val, int get)
65 {
66         struct nf_sockopt_ops *ops;
67
68         if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
69                 return ERR_PTR(-EINTR);
70
71         list_for_each_entry(ops, &nf_sockopts, list) {
72                 if (ops->pf == pf) {
73                         if (!try_module_get(ops->owner))
74                                 goto out_nosup;
75
76                         if (get) {
77                                 if (val >= ops->get_optmin &&
78                                                 val < ops->get_optmax)
79                                         goto out;
80                         } else {
81                                 if (val >= ops->set_optmin &&
82                                                 val < ops->set_optmax)
83                                         goto out;
84                         }
85                         module_put(ops->owner);
86                 }
87         }
88 out_nosup:
89         ops = ERR_PTR(-ENOPROTOOPT);
90 out:
91         mutex_unlock(&nf_sockopt_mutex);
92         return ops;
93 }
94
95 /* Call get/setsockopt() */
96 static int nf_sockopt(struct sock *sk, u_int8_t pf, int val,
97                       char __user *opt, int *len, int get)
98 {
99         struct nf_sockopt_ops *ops;
100         int ret;
101
102         ops = nf_sockopt_find(sk, pf, val, get);
103         if (IS_ERR(ops))
104                 return PTR_ERR(ops);
105
106         if (get)
107                 ret = ops->get(sk, val, opt, len);
108         else
109                 ret = ops->set(sk, val, opt, *len);
110
111         module_put(ops->owner);
112         return ret;
113 }
114
115 int nf_setsockopt(struct sock *sk, u_int8_t pf, int val, char __user *opt,
116                   unsigned int len)
117 {
118         return nf_sockopt(sk, pf, val, opt, &len, 0);
119 }
120 EXPORT_SYMBOL(nf_setsockopt);
121
122 int nf_getsockopt(struct sock *sk, u_int8_t pf, int val, char __user *opt,
123                   int *len)
124 {
125         return nf_sockopt(sk, pf, val, opt, len, 1);
126 }
127 EXPORT_SYMBOL(nf_getsockopt);
128
129 #ifdef CONFIG_COMPAT
130 static int compat_nf_sockopt(struct sock *sk, u_int8_t pf, int val,
131                              char __user *opt, int *len, int get)
132 {
133         struct nf_sockopt_ops *ops;
134         int ret;
135
136         ops = nf_sockopt_find(sk, pf, val, get);
137         if (IS_ERR(ops))
138                 return PTR_ERR(ops);
139
140         if (get) {
141                 if (ops->compat_get)
142                         ret = ops->compat_get(sk, val, opt, len);
143                 else
144                         ret = ops->get(sk, val, opt, len);
145         } else {
146                 if (ops->compat_set)
147                         ret = ops->compat_set(sk, val, opt, *len);
148                 else
149                         ret = ops->set(sk, val, opt, *len);
150         }
151
152         module_put(ops->owner);
153         return ret;
154 }
155
156 int compat_nf_setsockopt(struct sock *sk, u_int8_t pf,
157                 int val, char __user *opt, unsigned int len)
158 {
159         return compat_nf_sockopt(sk, pf, val, opt, &len, 0);
160 }
161 EXPORT_SYMBOL(compat_nf_setsockopt);
162
163 int compat_nf_getsockopt(struct sock *sk, u_int8_t pf,
164                 int val, char __user *opt, int *len)
165 {
166         return compat_nf_sockopt(sk, pf, val, opt, len, 1);
167 }
168 EXPORT_SYMBOL(compat_nf_getsockopt);
169 #endif