[NET] NETNS: Omit sock->sk_net without CONFIG_NET_NS.
[linux-3.10.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, int pf,
64                 int val, int get)
65 {
66         struct nf_sockopt_ops *ops;
67
68         if (sock_net(sk) != &init_net)
69                 return ERR_PTR(-ENOPROTOOPT);
70
71         if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
72                 return ERR_PTR(-EINTR);
73
74         list_for_each_entry(ops, &nf_sockopts, list) {
75                 if (ops->pf == pf) {
76                         if (!try_module_get(ops->owner))
77                                 goto out_nosup;
78
79                         if (get) {
80                                 if (val >= ops->get_optmin &&
81                                                 val < ops->get_optmax)
82                                         goto out;
83                         } else {
84                                 if (val >= ops->set_optmin &&
85                                                 val < ops->set_optmax)
86                                         goto out;
87                         }
88                         module_put(ops->owner);
89                 }
90         }
91 out_nosup:
92         ops = ERR_PTR(-ENOPROTOOPT);
93 out:
94         mutex_unlock(&nf_sockopt_mutex);
95         return ops;
96 }
97
98 /* Call get/setsockopt() */
99 static int nf_sockopt(struct sock *sk, int pf, int val,
100                       char __user *opt, int *len, int get)
101 {
102         struct nf_sockopt_ops *ops;
103         int ret;
104
105         ops = nf_sockopt_find(sk, pf, val, get);
106         if (IS_ERR(ops))
107                 return PTR_ERR(ops);
108
109         if (get)
110                 ret = ops->get(sk, val, opt, len);
111         else
112                 ret = ops->set(sk, val, opt, *len);
113
114         module_put(ops->owner);
115         return ret;
116 }
117
118 int nf_setsockopt(struct sock *sk, int pf, int val, char __user *opt,
119                   int len)
120 {
121         return nf_sockopt(sk, pf, val, opt, &len, 0);
122 }
123 EXPORT_SYMBOL(nf_setsockopt);
124
125 int nf_getsockopt(struct sock *sk, int pf, int val, char __user *opt, int *len)
126 {
127         return nf_sockopt(sk, pf, val, opt, len, 1);
128 }
129 EXPORT_SYMBOL(nf_getsockopt);
130
131 #ifdef CONFIG_COMPAT
132 static int compat_nf_sockopt(struct sock *sk, int pf, int val,
133                              char __user *opt, int *len, int get)
134 {
135         struct nf_sockopt_ops *ops;
136         int ret;
137
138         ops = nf_sockopt_find(sk, pf, val, get);
139         if (IS_ERR(ops))
140                 return PTR_ERR(ops);
141
142         if (get) {
143                 if (ops->compat_get)
144                         ret = ops->compat_get(sk, val, opt, len);
145                 else
146                         ret = ops->get(sk, val, opt, len);
147         } else {
148                 if (ops->compat_set)
149                         ret = ops->compat_set(sk, val, opt, *len);
150                 else
151                         ret = ops->set(sk, val, opt, *len);
152         }
153
154         module_put(ops->owner);
155         return ret;
156 }
157
158 int compat_nf_setsockopt(struct sock *sk, int pf,
159                 int val, char __user *opt, int len)
160 {
161         return compat_nf_sockopt(sk, pf, val, opt, &len, 0);
162 }
163 EXPORT_SYMBOL(compat_nf_setsockopt);
164
165 int compat_nf_getsockopt(struct sock *sk, int pf,
166                 int val, char __user *opt, int *len)
167 {
168         return compat_nf_sockopt(sk, pf, val, opt, len, 1);
169 }
170 EXPORT_SYMBOL(compat_nf_getsockopt);
171 #endif