1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/kernel.h> |
3 | #include <linux/init.h> |
4 | #include <linux/module.h> |
5 | #include <linux/skbuff.h> |
6 | #include <linux/netfilter.h> |
7 | #include <linux/mutex.h> |
8 | #include <net/sock.h> |
9 | |
10 | #include "nf_internals.h" |
11 | |
12 | /* Sockopts only registered and called from user context, so |
13 | net locking would be overkill. Also, [gs]etsockopt calls may |
14 | sleep. */ |
15 | static DEFINE_MUTEX(nf_sockopt_mutex); |
16 | static LIST_HEAD(nf_sockopts); |
17 | |
18 | /* Do exclusive ranges overlap? */ |
19 | static inline int overlap(int min1, int max1, int min2, int max2) |
20 | { |
21 | return max1 > min2 && min1 < max2; |
22 | } |
23 | |
24 | /* Functions to register sockopt ranges (exclusive). */ |
25 | int nf_register_sockopt(struct nf_sockopt_ops *reg) |
26 | { |
27 | struct nf_sockopt_ops *ops; |
28 | int ret = 0; |
29 | |
30 | mutex_lock(&nf_sockopt_mutex); |
31 | list_for_each_entry(ops, &nf_sockopts, list) { |
32 | if (ops->pf == reg->pf |
33 | && (overlap(min1: ops->set_optmin, max1: ops->set_optmax, |
34 | min2: reg->set_optmin, max2: reg->set_optmax) |
35 | || overlap(min1: ops->get_optmin, max1: ops->get_optmax, |
36 | min2: reg->get_optmin, max2: reg->get_optmax))) { |
37 | pr_debug("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n" , |
38 | ops->set_optmin, ops->set_optmax, |
39 | ops->get_optmin, ops->get_optmax, |
40 | reg->set_optmin, reg->set_optmax, |
41 | reg->get_optmin, reg->get_optmax); |
42 | ret = -EBUSY; |
43 | goto out; |
44 | } |
45 | } |
46 | |
47 | list_add(new: ®->list, head: &nf_sockopts); |
48 | out: |
49 | mutex_unlock(lock: &nf_sockopt_mutex); |
50 | return ret; |
51 | } |
52 | EXPORT_SYMBOL(nf_register_sockopt); |
53 | |
54 | void nf_unregister_sockopt(struct nf_sockopt_ops *reg) |
55 | { |
56 | mutex_lock(&nf_sockopt_mutex); |
57 | list_del(entry: ®->list); |
58 | mutex_unlock(lock: &nf_sockopt_mutex); |
59 | } |
60 | EXPORT_SYMBOL(nf_unregister_sockopt); |
61 | |
62 | static struct nf_sockopt_ops *nf_sockopt_find(struct sock *sk, u_int8_t pf, |
63 | int val, int get) |
64 | { |
65 | struct nf_sockopt_ops *ops; |
66 | |
67 | mutex_lock(&nf_sockopt_mutex); |
68 | list_for_each_entry(ops, &nf_sockopts, list) { |
69 | if (ops->pf == pf) { |
70 | if (!try_module_get(module: ops->owner)) |
71 | goto out_nosup; |
72 | |
73 | if (get) { |
74 | if (val >= ops->get_optmin && |
75 | val < ops->get_optmax) |
76 | goto out; |
77 | } else { |
78 | if (val >= ops->set_optmin && |
79 | val < ops->set_optmax) |
80 | goto out; |
81 | } |
82 | module_put(module: ops->owner); |
83 | } |
84 | } |
85 | out_nosup: |
86 | ops = ERR_PTR(error: -ENOPROTOOPT); |
87 | out: |
88 | mutex_unlock(lock: &nf_sockopt_mutex); |
89 | return ops; |
90 | } |
91 | |
92 | int nf_setsockopt(struct sock *sk, u_int8_t pf, int val, sockptr_t opt, |
93 | unsigned int len) |
94 | { |
95 | struct nf_sockopt_ops *ops; |
96 | int ret; |
97 | |
98 | ops = nf_sockopt_find(sk, pf, val, get: 0); |
99 | if (IS_ERR(ptr: ops)) |
100 | return PTR_ERR(ptr: ops); |
101 | ret = ops->set(sk, val, opt, len); |
102 | module_put(module: ops->owner); |
103 | return ret; |
104 | } |
105 | EXPORT_SYMBOL(nf_setsockopt); |
106 | |
107 | int nf_getsockopt(struct sock *sk, u_int8_t pf, int val, char __user *opt, |
108 | int *len) |
109 | { |
110 | struct nf_sockopt_ops *ops; |
111 | int ret; |
112 | |
113 | ops = nf_sockopt_find(sk, pf, val, get: 1); |
114 | if (IS_ERR(ptr: ops)) |
115 | return PTR_ERR(ptr: ops); |
116 | ret = ops->get(sk, val, opt, len); |
117 | module_put(module: ops->owner); |
118 | return ret; |
119 | } |
120 | EXPORT_SYMBOL(nf_getsockopt); |
121 | |