38f7f164e4848537422f4d732ed91c02413b5a00
[releases.git] / ioctl.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* ATM ioctl handling */
3
4 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
5 /* 2003 John Levon  <levon@movementarian.org> */
6
7 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
8
9 #include <linux/module.h>
10 #include <linux/kmod.h>
11 #include <linux/net.h>          /* struct socket, struct proto_ops */
12 #include <linux/atm.h>          /* ATM stuff */
13 #include <linux/atmdev.h>
14 #include <linux/atmclip.h>      /* CLIP_*ENCAP */
15 #include <linux/atmarp.h>       /* manifest constants */
16 #include <linux/capability.h>
17 #include <linux/sonet.h>        /* for ioctls */
18 #include <linux/atmsvc.h>
19 #include <linux/atmmpc.h>
20 #include <net/atmclip.h>
21 #include <linux/atmlec.h>
22 #include <linux/mutex.h>
23 #include <asm/ioctls.h>
24 #include <net/compat.h>
25
26 #include "resources.h"
27 #include "signaling.h"          /* for WAITING and sigd_attach */
28 #include "common.h"
29
30
31 static DEFINE_MUTEX(ioctl_mutex);
32 static LIST_HEAD(ioctl_list);
33
34
35 void register_atm_ioctl(struct atm_ioctl *ioctl)
36 {
37         mutex_lock(&ioctl_mutex);
38         list_add_tail(&ioctl->list, &ioctl_list);
39         mutex_unlock(&ioctl_mutex);
40 }
41 EXPORT_SYMBOL(register_atm_ioctl);
42
43 void deregister_atm_ioctl(struct atm_ioctl *ioctl)
44 {
45         mutex_lock(&ioctl_mutex);
46         list_del(&ioctl->list);
47         mutex_unlock(&ioctl_mutex);
48 }
49 EXPORT_SYMBOL(deregister_atm_ioctl);
50
51 static int do_vcc_ioctl(struct socket *sock, unsigned int cmd,
52                         unsigned long arg, int compat)
53 {
54         struct sock *sk = sock->sk;
55         struct atm_vcc *vcc;
56         int error;
57         struct list_head *pos;
58         void __user *argp = (void __user *)arg;
59
60         vcc = ATM_SD(sock);
61         switch (cmd) {
62         case SIOCOUTQ:
63                 if (sock->state != SS_CONNECTED ||
64                     !test_bit(ATM_VF_READY, &vcc->flags)) {
65                         error =  -EINVAL;
66                         goto done;
67                 }
68                 error = put_user(sk->sk_sndbuf - sk_wmem_alloc_get(sk),
69                                  (int __user *)argp) ? -EFAULT : 0;
70                 goto done;
71         case SIOCINQ:
72         {
73                 struct sk_buff *skb;
74                 int amount;
75
76                 if (sock->state != SS_CONNECTED) {
77                         error = -EINVAL;
78                         goto done;
79                 }
80                 spin_lock_irq(&sk->sk_receive_queue.lock);
81                 skb = skb_peek(&sk->sk_receive_queue);
82                 amount = skb ? skb->len : 0;
83                 spin_unlock_irq(&sk->sk_receive_queue.lock);
84                 error = put_user(amount, (int __user *)argp) ? -EFAULT : 0;
85                 goto done;
86         }
87         case SIOCGSTAMP: /* borrowed from IP */
88 #ifdef CONFIG_COMPAT
89                 if (compat)
90                         error = compat_sock_get_timestamp(sk, argp);
91                 else
92 #endif
93                         error = sock_get_timestamp(sk, argp);
94                 goto done;
95         case SIOCGSTAMPNS: /* borrowed from IP */
96 #ifdef CONFIG_COMPAT
97                 if (compat)
98                         error = compat_sock_get_timestampns(sk, argp);
99                 else
100 #endif
101                         error = sock_get_timestampns(sk, argp);
102                 goto done;
103         case ATM_SETSC:
104                 net_warn_ratelimited("ATM_SETSC is obsolete; used by %s:%d\n",
105                                      current->comm, task_pid_nr(current));
106                 error = 0;
107                 goto done;
108         case ATMSIGD_CTRL:
109                 if (!capable(CAP_NET_ADMIN)) {
110                         error = -EPERM;
111                         goto done;
112                 }
113                 /*
114                  * The user/kernel protocol for exchanging signalling
115                  * info uses kernel pointers as opaque references,
116                  * so the holder of the file descriptor can scribble
117                  * on the kernel... so we should make sure that we
118                  * have the same privileges that /proc/kcore needs
119                  */
120                 if (!capable(CAP_SYS_RAWIO)) {
121                         error = -EPERM;
122                         goto done;
123                 }
124 #ifdef CONFIG_COMPAT
125                 /* WTF? I don't even want to _think_ about making this
126                    work for 32-bit userspace. TBH I don't really want
127                    to think about it at all. dwmw2. */
128                 if (compat) {
129                         net_warn_ratelimited("32-bit task cannot be atmsigd\n");
130                         error = -EINVAL;
131                         goto done;
132                 }
133 #endif
134                 error = sigd_attach(vcc);
135                 if (!error)
136                         sock->state = SS_CONNECTED;
137                 goto done;
138         case ATM_SETBACKEND:
139         case ATM_NEWBACKENDIF:
140         {
141                 atm_backend_t backend;
142                 error = get_user(backend, (atm_backend_t __user *)argp);
143                 if (error)
144                         goto done;
145                 switch (backend) {
146                 case ATM_BACKEND_PPP:
147                         request_module("pppoatm");
148                         break;
149                 case ATM_BACKEND_BR2684:
150                         request_module("br2684");
151                         break;
152                 }
153                 break;
154         }
155         case ATMMPC_CTRL:
156         case ATMMPC_DATA:
157                 request_module("mpoa");
158                 break;
159         case ATMARPD_CTRL:
160                 request_module("clip");
161                 break;
162         case ATMLEC_CTRL:
163                 request_module("lec");
164                 break;
165         }
166
167         error = -ENOIOCTLCMD;
168
169         mutex_lock(&ioctl_mutex);
170         list_for_each(pos, &ioctl_list) {
171                 struct atm_ioctl *ic = list_entry(pos, struct atm_ioctl, list);
172                 if (try_module_get(ic->owner)) {
173                         error = ic->ioctl(sock, cmd, arg);
174                         module_put(ic->owner);
175                         if (error != -ENOIOCTLCMD)
176                                 break;
177                 }
178         }
179         mutex_unlock(&ioctl_mutex);
180
181         if (error != -ENOIOCTLCMD)
182                 goto done;
183
184         error = atm_dev_ioctl(cmd, argp, compat);
185
186 done:
187         return error;
188 }
189
190 int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
191 {
192         return do_vcc_ioctl(sock, cmd, arg, 0);
193 }
194
195 #ifdef CONFIG_COMPAT
196 /*
197  * FIXME:
198  * The compat_ioctl handling is duplicated, using both these conversion
199  * routines and the compat argument to the actual handlers. Both
200  * versions are somewhat incomplete and should be merged, e.g. by
201  * moving the ioctl number translation into the actual handlers and
202  * killing the conversion code.
203  *
204  * -arnd, November 2009
205  */
206 #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct compat_atmif_sioc)
207 #define ATM_GETNAMES32    _IOW('a', ATMIOC_ITF+3, struct compat_atm_iobuf)
208 #define ATM_GETTYPE32     _IOW('a', ATMIOC_ITF+4, struct compat_atmif_sioc)
209 #define ATM_GETESI32      _IOW('a', ATMIOC_ITF+5, struct compat_atmif_sioc)
210 #define ATM_GETADDR32     _IOW('a', ATMIOC_ITF+6, struct compat_atmif_sioc)
211 #define ATM_RSTADDR32     _IOW('a', ATMIOC_ITF+7, struct compat_atmif_sioc)
212 #define ATM_ADDADDR32     _IOW('a', ATMIOC_ITF+8, struct compat_atmif_sioc)
213 #define ATM_DELADDR32     _IOW('a', ATMIOC_ITF+9, struct compat_atmif_sioc)
214 #define ATM_GETCIRANGE32  _IOW('a', ATMIOC_ITF+10, struct compat_atmif_sioc)
215 #define ATM_SETCIRANGE32  _IOW('a', ATMIOC_ITF+11, struct compat_atmif_sioc)
216 #define ATM_SETESI32      _IOW('a', ATMIOC_ITF+12, struct compat_atmif_sioc)
217 #define ATM_SETESIF32     _IOW('a', ATMIOC_ITF+13, struct compat_atmif_sioc)
218 #define ATM_GETSTAT32     _IOW('a', ATMIOC_SARCOM+0, struct compat_atmif_sioc)
219 #define ATM_GETSTATZ32    _IOW('a', ATMIOC_SARCOM+1, struct compat_atmif_sioc)
220 #define ATM_GETLOOP32     _IOW('a', ATMIOC_SARCOM+2, struct compat_atmif_sioc)
221 #define ATM_SETLOOP32     _IOW('a', ATMIOC_SARCOM+3, struct compat_atmif_sioc)
222 #define ATM_QUERYLOOP32   _IOW('a', ATMIOC_SARCOM+4, struct compat_atmif_sioc)
223
224 static struct {
225         unsigned int cmd32;
226         unsigned int cmd;
227 } atm_ioctl_map[] = {
228         { ATM_GETLINKRATE32, ATM_GETLINKRATE },
229         { ATM_GETNAMES32,    ATM_GETNAMES },
230         { ATM_GETTYPE32,     ATM_GETTYPE },
231         { ATM_GETESI32,      ATM_GETESI },
232         { ATM_GETADDR32,     ATM_GETADDR },
233         { ATM_RSTADDR32,     ATM_RSTADDR },
234         { ATM_ADDADDR32,     ATM_ADDADDR },
235         { ATM_DELADDR32,     ATM_DELADDR },
236         { ATM_GETCIRANGE32,  ATM_GETCIRANGE },
237         { ATM_SETCIRANGE32,  ATM_SETCIRANGE },
238         { ATM_SETESI32,      ATM_SETESI },
239         { ATM_SETESIF32,     ATM_SETESIF },
240         { ATM_GETSTAT32,     ATM_GETSTAT },
241         { ATM_GETSTATZ32,    ATM_GETSTATZ },
242         { ATM_GETLOOP32,     ATM_GETLOOP },
243         { ATM_SETLOOP32,     ATM_SETLOOP },
244         { ATM_QUERYLOOP32,   ATM_QUERYLOOP },
245 };
246
247 #define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map)
248
249 static int do_atm_iobuf(struct socket *sock, unsigned int cmd,
250                         unsigned long arg)
251 {
252         struct atm_iobuf __user *iobuf;
253         struct compat_atm_iobuf __user *iobuf32;
254         u32 data;
255         void __user *datap;
256         int len, err;
257
258         iobuf = compat_alloc_user_space(sizeof(*iobuf));
259         iobuf32 = compat_ptr(arg);
260
261         if (get_user(len, &iobuf32->length) ||
262             get_user(data, &iobuf32->buffer))
263                 return -EFAULT;
264         datap = compat_ptr(data);
265         if (put_user(len, &iobuf->length) ||
266             put_user(datap, &iobuf->buffer))
267                 return -EFAULT;
268
269         err = do_vcc_ioctl(sock, cmd, (unsigned long) iobuf, 0);
270
271         if (!err) {
272                 if (copy_in_user(&iobuf32->length, &iobuf->length,
273                                  sizeof(int)))
274                         err = -EFAULT;
275         }
276
277         return err;
278 }
279
280 static int do_atmif_sioc(struct socket *sock, unsigned int cmd,
281                          unsigned long arg)
282 {
283         struct atmif_sioc __user *sioc;
284         struct compat_atmif_sioc __user *sioc32;
285         u32 data;
286         void __user *datap;
287         int err;
288
289         sioc = compat_alloc_user_space(sizeof(*sioc));
290         sioc32 = compat_ptr(arg);
291
292         if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) ||
293             get_user(data, &sioc32->arg))
294                 return -EFAULT;
295         datap = compat_ptr(data);
296         if (put_user(datap, &sioc->arg))
297                 return -EFAULT;
298
299         err = do_vcc_ioctl(sock, cmd, (unsigned long) sioc, 0);
300
301         if (!err) {
302                 if (copy_in_user(&sioc32->length, &sioc->length,
303                                  sizeof(int)))
304                         err = -EFAULT;
305         }
306         return err;
307 }
308
309 static int do_atm_ioctl(struct socket *sock, unsigned int cmd32,
310                         unsigned long arg)
311 {
312         int i;
313         unsigned int cmd = 0;
314
315         switch (cmd32) {
316         case SONET_GETSTAT:
317         case SONET_GETSTATZ:
318         case SONET_GETDIAG:
319         case SONET_SETDIAG:
320         case SONET_CLRDIAG:
321         case SONET_SETFRAMING:
322         case SONET_GETFRAMING:
323         case SONET_GETFRSENSE:
324                 return do_atmif_sioc(sock, cmd32, arg);
325         }
326
327         for (i = 0; i < NR_ATM_IOCTL; i++) {
328                 if (cmd32 == atm_ioctl_map[i].cmd32) {
329                         cmd = atm_ioctl_map[i].cmd;
330                         break;
331                 }
332         }
333         if (i == NR_ATM_IOCTL)
334                 return -EINVAL;
335
336         switch (cmd) {
337         case ATM_GETNAMES:
338                 return do_atm_iobuf(sock, cmd, arg);
339
340         case ATM_GETLINKRATE:
341         case ATM_GETTYPE:
342         case ATM_GETESI:
343         case ATM_GETADDR:
344         case ATM_RSTADDR:
345         case ATM_ADDADDR:
346         case ATM_DELADDR:
347         case ATM_GETCIRANGE:
348         case ATM_SETCIRANGE:
349         case ATM_SETESI:
350         case ATM_SETESIF:
351         case ATM_GETSTAT:
352         case ATM_GETSTATZ:
353         case ATM_GETLOOP:
354         case ATM_SETLOOP:
355         case ATM_QUERYLOOP:
356                 return do_atmif_sioc(sock, cmd, arg);
357         }
358
359         return -EINVAL;
360 }
361
362 int vcc_compat_ioctl(struct socket *sock, unsigned int cmd,
363                      unsigned long arg)
364 {
365         int ret;
366
367         ret = do_vcc_ioctl(sock, cmd, arg, 1);
368         if (ret != -ENOIOCTLCMD)
369                 return ret;
370
371         return do_atm_ioctl(sock, cmd, arg);
372 }
373 #endif