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
45static struct bt_sock_list cmtp_sk_list = {
46	.lock = __RW_LOCK_UNLOCKED(cmtp_sk_list.lock)
47};
48
49static 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
66static 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
141static 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
169static 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
192static struct proto cmtp_proto = {
193	.name		= "CMTP",
194	.owner		= THIS_MODULE,
195	.obj_size	= sizeof(struct bt_sock)
196};
197
198static 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
228static const struct net_proto_family cmtp_sock_family_ops = {
229	.family	= PF_BLUETOOTH,
230	.owner	= THIS_MODULE,
231	.create	= cmtp_sock_create
232};
233
234int 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
259error:
260	proto_unregister(&cmtp_proto);
261	return err;
262}
263
264void 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