]>
Commit | Line | Data |
---|---|---|
f6ebe77f HW |
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> | |
4a3e2f71 | 6 | #include <linux/mutex.h> |
f6ebe77f HW |
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. */ | |
4a3e2f71 | 14 | static DEFINE_MUTEX(nf_sockopt_mutex); |
f6ebe77f HW |
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 | { | |
55d84acd | 26 | struct nf_sockopt_ops *ops; |
f6ebe77f HW |
27 | int ret = 0; |
28 | ||
4a3e2f71 | 29 | if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0) |
f6ebe77f HW |
30 | return -EINTR; |
31 | ||
55d84acd | 32 | list_for_each_entry(ops, &nf_sockopts, list) { |
f6ebe77f | 33 | if (ops->pf == reg->pf |
601e68e1 | 34 | && (overlap(ops->set_optmin, ops->set_optmax, |
f6ebe77f | 35 | reg->set_optmin, reg->set_optmax) |
601e68e1 | 36 | || overlap(ops->get_optmin, ops->get_optmax, |
f6ebe77f HW |
37 | reg->get_optmin, reg->get_optmax))) { |
38 | NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n", | |
601e68e1 YH |
39 | ops->set_optmin, ops->set_optmax, |
40 | ops->get_optmin, ops->get_optmax, | |
f6ebe77f HW |
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(®->list, &nf_sockopts); | |
49 | out: | |
4a3e2f71 | 50 | mutex_unlock(&nf_sockopt_mutex); |
f6ebe77f HW |
51 | return ret; |
52 | } | |
53 | EXPORT_SYMBOL(nf_register_sockopt); | |
54 | ||
55 | void nf_unregister_sockopt(struct nf_sockopt_ops *reg) | |
56 | { | |
4a3e2f71 | 57 | mutex_lock(&nf_sockopt_mutex); |
f6ebe77f | 58 | list_del(®->list); |
4a3e2f71 | 59 | mutex_unlock(&nf_sockopt_mutex); |
f6ebe77f HW |
60 | } |
61 | EXPORT_SYMBOL(nf_unregister_sockopt); | |
62 | ||
76108cea | 63 | static struct nf_sockopt_ops *nf_sockopt_find(struct sock *sk, u_int8_t pf, |
4ce5ba6a | 64 | int val, int get) |
f6ebe77f | 65 | { |
f6ebe77f | 66 | struct nf_sockopt_ops *ops; |
f6ebe77f | 67 | |
4a3e2f71 | 68 | if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0) |
4ce5ba6a | 69 | return ERR_PTR(-EINTR); |
f6ebe77f | 70 | |
55d84acd | 71 | list_for_each_entry(ops, &nf_sockopts, list) { |
f6ebe77f | 72 | if (ops->pf == pf) { |
16fcec35 NH |
73 | if (!try_module_get(ops->owner)) |
74 | goto out_nosup; | |
4ce5ba6a | 75 | |
f6ebe77f | 76 | if (get) { |
4ce5ba6a PE |
77 | if (val >= ops->get_optmin && |
78 | val < ops->get_optmax) | |
f6ebe77f | 79 | goto out; |
f6ebe77f | 80 | } else { |
4ce5ba6a PE |
81 | if (val >= ops->set_optmin && |
82 | val < ops->set_optmax) | |
f6ebe77f | 83 | goto out; |
f6ebe77f | 84 | } |
16fcec35 | 85 | module_put(ops->owner); |
f6ebe77f HW |
86 | } |
87 | } | |
4ce5ba6a PE |
88 | out_nosup: |
89 | ops = ERR_PTR(-ENOPROTOOPT); | |
90 | out: | |
4a3e2f71 | 91 | mutex_unlock(&nf_sockopt_mutex); |
4ce5ba6a PE |
92 | return ops; |
93 | } | |
94 | ||
95 | /* Call get/setsockopt() */ | |
76108cea | 96 | static int nf_sockopt(struct sock *sk, u_int8_t pf, int val, |
4ce5ba6a PE |
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); | |
601e68e1 | 110 | |
16fcec35 | 111 | module_put(ops->owner); |
f6ebe77f HW |
112 | return ret; |
113 | } | |
114 | ||
76108cea | 115 | int nf_setsockopt(struct sock *sk, u_int8_t pf, int val, char __user *opt, |
b7058842 | 116 | unsigned int len) |
f6ebe77f HW |
117 | { |
118 | return nf_sockopt(sk, pf, val, opt, &len, 0); | |
119 | } | |
120 | EXPORT_SYMBOL(nf_setsockopt); | |
121 | ||
76108cea JE |
122 | int nf_getsockopt(struct sock *sk, u_int8_t pf, int val, char __user *opt, |
123 | int *len) | |
f6ebe77f HW |
124 | { |
125 | return nf_sockopt(sk, pf, val, opt, len, 1); | |
126 | } | |
127 | EXPORT_SYMBOL(nf_getsockopt); | |
128 | ||
3fdadf7d | 129 | #ifdef CONFIG_COMPAT |
76108cea | 130 | static int compat_nf_sockopt(struct sock *sk, u_int8_t pf, int val, |
543d9cfe | 131 | char __user *opt, int *len, int get) |
3fdadf7d | 132 | { |
3fdadf7d DM |
133 | struct nf_sockopt_ops *ops; |
134 | int ret; | |
135 | ||
4ce5ba6a PE |
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 | |
6452a5fd | 144 | ret = ops->get(sk, val, opt, len); |
4ce5ba6a PE |
145 | } else { |
146 | if (ops->compat_set) | |
6452a5fd | 147 | ret = ops->compat_set(sk, val, opt, *len); |
4ce5ba6a | 148 | else |
6452a5fd | 149 | ret = ops->set(sk, val, opt, *len); |
3fdadf7d | 150 | } |
3fdadf7d | 151 | |
16fcec35 | 152 | module_put(ops->owner); |
3fdadf7d DM |
153 | return ret; |
154 | } | |
155 | ||
76108cea | 156 | int compat_nf_setsockopt(struct sock *sk, u_int8_t pf, |
b7058842 | 157 | int val, char __user *opt, unsigned int len) |
3fdadf7d DM |
158 | { |
159 | return compat_nf_sockopt(sk, pf, val, opt, &len, 0); | |
160 | } | |
161 | EXPORT_SYMBOL(compat_nf_setsockopt); | |
162 | ||
76108cea | 163 | int compat_nf_getsockopt(struct sock *sk, u_int8_t pf, |
3fdadf7d DM |
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 |