xref: /openbmc/linux/net/bluetooth/cmtp/sock.c (revision 56a0eccd) 
1 /*
2    CMTP implementation for Linux Bluetooth stack (BlueZ).
3    Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
4 
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License version 2 as
7    published by the Free Software Foundation;
8 
9    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 
18    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20    SOFTWARE IS DISCLAIMED.
21 */
22 
23 #include <linux/export.h>
24 
25 #include <linux/types.h>
26 #include <linux/capability.h>
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/poll.h>
30 #include <linux/fcntl.h>
31 #include <linux/skbuff.h>
32 #include <linux/socket.h>
33 #include <linux/ioctl.h>
34 #include <linux/file.h>
35 #include <linux/compat.h>
36 #include <linux/gfp.h>
37 #include <linux/uaccess.h>
38 #include <net/sock.h>
39 
40 #include <linux/isdn/capilli.h>
41 
42 
43 #include "cmtp.h"
44 
45 static struct bt_sock_list cmtp_sk_list = {
46 	.lock = __RW_LOCK_UNLOCKED(cmtp_sk_list.lock)
47 };
48 
49 static int cmtp_sock_release(struct socket *sock)
50 {
51 	struct sock *sk = sock->sk;
52 
53 	BT_DBG("sock %p sk %p", sock, sk);
54 
55 	if (!sk)
56 		return 0;
57 
58 	bt_sock_unlink(&cmtp_sk_list, sk);
59 
60 	sock_orphan(sk);
61 	sock_put(sk);
62 
63 	return 0;
64 }
65 
66 static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
67 {
68 	struct cmtp_connadd_req ca;
69 	struct cmtp_conndel_req cd;
70 	struct cmtp_connlist_req cl;
71 	struct cmtp_conninfo ci;
72 	struct socket *nsock;
73 	void __user *argp = (void __user *)arg;
74 	int err;
75 
76 	BT_DBG("cmd %x arg %lx", cmd, arg);
77 
78 	switch (cmd) {
79 	case CMTPCONNADD:
80 		if (!capable(CAP_NET_ADMIN))
81 			return -EPERM;
82 
83 		if (copy_from_user(&ca, argp, sizeof(ca)))
84 			return -EFAULT;
85 
86 		nsock = sockfd_lookup(ca.sock, &err);
87 		if (!nsock)
88 			return err;
89 
90 		if (nsock->sk->sk_state != BT_CONNECTED) {
91 			sockfd_put(nsock);
92 			return -EBADFD;
93 		}
94 
95 		err = cmtp_add_connection(&ca, nsock);
96 		if (!err) {
97 			if (copy_to_user(argp, &ca, sizeof(ca)))
98 				err = -EFAULT;
99 		} else
100 			sockfd_put(nsock);
101 
102 		return err;
103 
104 	case CMTPCONNDEL:
105 		if (!capable(CAP_NET_ADMIN))
106 			return -EPERM;
107 
108 		if (copy_from_user(&cd, argp, sizeof(cd)))
109 			return -EFAULT;
110 
111 		return cmtp_del_connection(&cd);
112 
113 	case CMTPGETCONNLIST:
114 		if (copy_from_user(&cl, argp, sizeof(cl)))
115 			return -EFAULT;
116 
117 		if (cl.cnum <= 0)
118 			return -EINVAL;
119 
120 		err = cmtp_get_connlist(&cl);
121 		if (!err && copy_to_user(argp, &cl, sizeof(cl)))
122 			return -EFAULT;
123 
124 		return err;
125 
126 	case CMTPGETCONNINFO:
127 		if (copy_from_user(&ci, argp, sizeof(ci)))
128 			return -EFAULT;
129 
130 		err = cmtp_get_conninfo(&ci);
131 		if (!err && copy_to_user(argp, &ci, sizeof(ci)))
132 			return -EFAULT;
133 
134 		return err;
135 	}
136 
137 	return -EINVAL;
138 }
139 
140 #ifdef CONFIG_COMPAT
141 static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
142 {
143 	if (cmd == CMTPGETCONNLIST) {
144 		struct cmtp_connlist_req cl;
145 		u32 uci;
146 		int err;
147 
148 		if (get_user(cl.cnum, (u32 __user *) arg) ||
149 				get_user(uci, (u32 __user *) (arg + 4)))
150 			return -EFAULT;
151 
152 		cl.ci = compat_ptr(uci);
153 
154 		if (cl.cnum <= 0)
155 			return -EINVAL;
156 
157 		err = cmtp_get_connlist(&cl);
158 
159 		if (!err && put_user(cl.cnum, (u32 __user *) arg))
160 			err = -EFAULT;
161 
162 		return err;
163 	}
164 
165 	return cmtp_sock_ioctl(sock, cmd, arg);
166 }
167 #endif
168 
169 static const struct proto_ops cmtp_sock_ops = {
170 	.family		= PF_BLUETOOTH,
171 	.owner		= THIS_MODULE,
172 	.release	= cmtp_sock_release,
173 	.ioctl		= cmtp_sock_ioctl,
174 #ifdef CONFIG_COMPAT
175 	.compat_ioctl	= cmtp_sock_compat_ioctl,
176 #endif
177 	.bind		= sock_no_bind,
178 	.getname	= sock_no_getname,
179 	.sendmsg	= sock_no_sendmsg,
180 	.recvmsg	= sock_no_recvmsg,
181 	.poll		= sock_no_poll,
182 	.listen		= sock_no_listen,
183 	.shutdown	= sock_no_shutdown,
184 	.setsockopt	= sock_no_setsockopt,
185 	.getsockopt	= sock_no_getsockopt,
186 	.connect	= sock_no_connect,
187 	.socketpair	= sock_no_socketpair,
188 	.accept		= sock_no_accept,
189 	.mmap		= sock_no_mmap
190 };
191 
192 static struct proto cmtp_proto = {
193 	.name		= "CMTP",
194 	.owner		= THIS_MODULE,
195 	.obj_size	= sizeof(struct bt_sock)
196 };
197 
198 static int cmtp_sock_create(struct net *net, struct socket *sock, int protocol,
199 			    int kern)
200 {
201 	struct sock *sk;
202 
203 	BT_DBG("sock %p", sock);
204 
205 	if (sock->type != SOCK_RAW)
206 		return -ESOCKTNOSUPPORT;
207 
208 	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &cmtp_proto, kern);
209 	if (!sk)
210 		return -ENOMEM;
211 
212 	sock_init_data(sock, sk);
213 
214 	sock->ops = &cmtp_sock_ops;
215 
216 	sock->state = SS_UNCONNECTED;
217 
218 	sock_reset_flag(sk, SOCK_ZAPPED);
219 
220 	sk->sk_protocol = protocol;
221 	sk->sk_state    = BT_OPEN;
222 
223 	bt_sock_link(&cmtp_sk_list, sk);
224 
225 	return 0;
226 }
227 
228 static const struct net_proto_family cmtp_sock_family_ops = {
229 	.family	= PF_BLUETOOTH,
230 	.owner	= THIS_MODULE,
231 	.create	= cmtp_sock_create
232 };
233 
234 int cmtp_init_sockets(void)
235 {
236 	int err;
237 
238 	err = proto_register(&cmtp_proto, 0);
239 	if (err < 0)
240 		return err;
241 
242 	err = bt_sock_register(BTPROTO_CMTP, &cmtp_sock_family_ops);
243 	if (err < 0) {
244 		BT_ERR("Can't register CMTP socket");
245 		goto error;
246 	}
247 
248 	err = bt_procfs_init(&init_net, "cmtp", &cmtp_sk_list, NULL);
249 	if (err < 0) {
250 		BT_ERR("Failed to create CMTP proc file");
251 		bt_sock_unregister(BTPROTO_HIDP);
252 		goto error;
253 	}
254 
255 	BT_INFO("CMTP socket layer initialized");
256 
257 	return 0;
258 
259 error:
260 	proto_unregister(&cmtp_proto);
261 	return err;
262 }
263 
264 void cmtp_cleanup_sockets(void)
265 {
266 	bt_procfs_cleanup(&init_net, "cmtp");
267 	bt_sock_unregister(BTPROTO_CMTP);
268 	proto_unregister(&cmtp_proto);
269 }
270