[mirror_ubuntu-jammy-kernel.git] / net / bluetooth / hidp / sock.c

/*
   HIDP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2003-2004 Marcel Holtmann <marcel@holtmann.org>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

#include <linux/export.h>
#include <linux/file.h>

#include "hidp.h"

static int hidp_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;

	BT_DBG("sock %p sk %p", sock, sk);

	if (!sk)
		return 0;

	sock_orphan(sk);
	sock_put(sk);

	return 0;
}

static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *) arg;
	struct hidp_connadd_req ca;
	struct hidp_conndel_req cd;
	struct hidp_connlist_req cl;
	struct hidp_conninfo ci;
	struct socket *csock;
	struct socket *isock;
	int err;

	BT_DBG("cmd %x arg %lx", cmd, arg);

	switch (cmd) {
	case HIDPCONNADD:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;

		if (copy_from_user(&ca, argp, sizeof(ca)))
			return -EFAULT;

		csock = sockfd_lookup(ca.ctrl_sock, &err);
		if (!csock)
			return err;

		isock = sockfd_lookup(ca.intr_sock, &err);
		if (!isock) {
			sockfd_put(csock);
			return err;
		}

		if (csock->sk->sk_state != BT_CONNECTED ||
				isock->sk->sk_state != BT_CONNECTED) {
			sockfd_put(csock);
			sockfd_put(isock);
			return -EBADFD;
		}

		err = hidp_add_connection(&ca, csock, isock);
		if (!err) {
			if (copy_to_user(argp, &ca, sizeof(ca)))
				err = -EFAULT;
		} else {
			sockfd_put(csock);
			sockfd_put(isock);
		}

		return err;

	case HIDPCONNDEL:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;

		if (copy_from_user(&cd, argp, sizeof(cd)))
			return -EFAULT;

		return hidp_del_connection(&cd);

	case HIDPGETCONNLIST:
		if (copy_from_user(&cl, argp, sizeof(cl)))
			return -EFAULT;

		if (cl.cnum <= 0)
			return -EINVAL;

		err = hidp_get_connlist(&cl);
		if (!err && copy_to_user(argp, &cl, sizeof(cl)))
			return -EFAULT;

		return err;

	case HIDPGETCONNINFO:
		if (copy_from_user(&ci, argp, sizeof(ci)))
			return -EFAULT;

		err = hidp_get_conninfo(&ci);
		if (!err && copy_to_user(argp, &ci, sizeof(ci)))
			return -EFAULT;

		return err;
	}

	return -EINVAL;
}

#ifdef CONFIG_COMPAT
struct compat_hidp_connadd_req {
	int   ctrl_sock;	/* Connected control socket */
	int   intr_sock;	/* Connected interrupt socket */
	__u16 parser;
	__u16 rd_size;
	compat_uptr_t rd_data;
	__u8  country;
	__u8  subclass;
	__u16 vendor;
	__u16 product;
	__u16 version;
	__u32 flags;
	__u32 idle_to;
	char  name[128];
};

static int hidp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	if (cmd == HIDPGETCONNLIST) {
		struct hidp_connlist_req cl;
		u32 uci;
		int err;

		if (get_user(cl.cnum, (u32 __user *) arg) ||
				get_user(uci, (u32 __user *) (arg + 4)))
			return -EFAULT;

		cl.ci = compat_ptr(uci);

		if (cl.cnum <= 0)
			return -EINVAL;

		err = hidp_get_connlist(&cl);

		if (!err && put_user(cl.cnum, (u32 __user *) arg))
			err = -EFAULT;

		return err;
	} else if (cmd == HIDPCONNADD) {
		struct compat_hidp_connadd_req ca;
		struct hidp_connadd_req __user *uca;

		uca = compat_alloc_user_space(sizeof(*uca));

		if (copy_from_user(&ca, (void __user *) arg, sizeof(ca)))
			return -EFAULT;

		if (put_user(ca.ctrl_sock, &uca->ctrl_sock) ||
				put_user(ca.intr_sock, &uca->intr_sock) ||
				put_user(ca.parser, &uca->parser) ||
				put_user(ca.rd_size, &uca->rd_size) ||
				put_user(compat_ptr(ca.rd_data), &uca->rd_data) ||
				put_user(ca.country, &uca->country) ||
				put_user(ca.subclass, &uca->subclass) ||
				put_user(ca.vendor, &uca->vendor) ||
				put_user(ca.product, &uca->product) ||
				put_user(ca.version, &uca->version) ||
				put_user(ca.flags, &uca->flags) ||
				put_user(ca.idle_to, &uca->idle_to) ||
				copy_to_user(&uca->name[0], &ca.name[0], 128))
			return -EFAULT;

		arg = (unsigned long) uca;

		/* Fall through. We don't actually write back any _changes_
		   to the structure anyway, so there's no need to copy back
		   into the original compat version */
	}

	return hidp_sock_ioctl(sock, cmd, arg);
}
#endif

static const struct proto_ops hidp_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= hidp_sock_release,
	.ioctl		= hidp_sock_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= hidp_sock_compat_ioctl,
#endif
	.bind		= sock_no_bind,
	.getname	= sock_no_getname,
	.sendmsg	= sock_no_sendmsg,
	.recvmsg	= sock_no_recvmsg,
	.poll		= sock_no_poll,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= sock_no_setsockopt,
	.getsockopt	= sock_no_getsockopt,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.mmap		= sock_no_mmap
};

static struct proto hidp_proto = {
	.name		= "HIDP",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct bt_sock)
};

static int hidp_sock_create(struct net *net, struct socket *sock, int protocol,
			    int kern)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

	if (sock->type != SOCK_RAW)
		return -ESOCKTNOSUPPORT;

	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hidp_proto);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sock->ops = &hidp_sock_ops;

	sock->state = SS_UNCONNECTED;

	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = protocol;
	sk->sk_state	= BT_OPEN;

	return 0;
}

static const struct net_proto_family hidp_sock_family_ops = {
	.family	= PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create	= hidp_sock_create
};

int __init hidp_init_sockets(void)
{
	int err;

	err = proto_register(&hidp_proto, 0);
	if (err < 0)
		return err;

	err = bt_sock_register(BTPROTO_HIDP, &hidp_sock_family_ops);
	if (err < 0)
		goto error;

	return 0;

error:
	BT_ERR("Can't register HIDP socket");
	proto_unregister(&hidp_proto);
	return err;
}

void __exit hidp_cleanup_sockets(void)
{
	if (bt_sock_unregister(BTPROTO_HIDP) < 0)
		BT_ERR("Can't unregister HIDP socket");

	proto_unregister(&hidp_proto);
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	HIDP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2003-2004 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
8e87d142 YH	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
1da177e4 LT	16	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	17
8e87d142 YH	18	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	19	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	20	SOFTWARE IS DISCLAIMED.
	21	*/
	22
8c520a59	23	#include <linux/export.h>
1da177e4	24	#include <linux/file.h>
1da177e4 LT	25
	26	#include "hidp.h"
	27
1da177e4 LT	28	static int hidp_sock_release(struct socket *sock)
	29	{
	30	struct sock *sk = sock->sk;
	31
	32	BT_DBG("sock %p sk %p", sock, sk);
	33
	34	if (!sk)
	35	return 0;
	36
	37	sock_orphan(sk);
	38	sock_put(sk);
	39
	40	return 0;
	41	}
	42
	43	static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	44	{
	45	void __user argp = (void __user ) arg;
	46	struct hidp_connadd_req ca;
	47	struct hidp_conndel_req cd;
	48	struct hidp_connlist_req cl;
	49	struct hidp_conninfo ci;
	50	struct socket *csock;
	51	struct socket *isock;
	52	int err;
	53
	54	BT_DBG("cmd %x arg %lx", cmd, arg);
	55
	56	switch (cmd) {
	57	case HIDPCONNADD:
	58	if (!capable(CAP_NET_ADMIN))
	59	return -EACCES;
	60
	61	if (copy_from_user(&ca, argp, sizeof(ca)))
	62	return -EFAULT;
	63
	64	csock = sockfd_lookup(ca.ctrl_sock, &err);
	65	if (!csock)
	66	return err;
	67
	68	isock = sockfd_lookup(ca.intr_sock, &err);
	69	if (!isock) {
67b23219	70	sockfd_put(csock);
1da177e4 LT	71	return err;
	72	}
	73
17f09a7e SJ	74	if (csock->sk->sk_state != BT_CONNECTED \|\|
17f09a7e SJ	75	isock->sk->sk_state != BT_CONNECTED) {
67b23219 JL	76	sockfd_put(csock);
67b23219 JL	77	sockfd_put(isock);
1da177e4 LT	78	return -EBADFD;
	79	}
	80
	81	err = hidp_add_connection(&ca, csock, isock);
	82	if (!err) {
	83	if (copy_to_user(argp, &ca, sizeof(ca)))
	84	err = -EFAULT;
	85	} else {
67b23219 JL	86	sockfd_put(csock);
67b23219 JL	87	sockfd_put(isock);
1da177e4 LT	88	}
	89
	90	return err;
	91
	92	case HIDPCONNDEL:
	93	if (!capable(CAP_NET_ADMIN))
	94	return -EACCES;
	95
	96	if (copy_from_user(&cd, argp, sizeof(cd)))
	97	return -EFAULT;
	98
	99	return hidp_del_connection(&cd);
	100
	101	case HIDPGETCONNLIST:
	102	if (copy_from_user(&cl, argp, sizeof(cl)))
	103	return -EFAULT;
	104
	105	if (cl.cnum <= 0)
	106	return -EINVAL;
	107
	108	err = hidp_get_connlist(&cl);
	109	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
	110	return -EFAULT;
	111
	112	return err;
	113
	114	case HIDPGETCONNINFO:
	115	if (copy_from_user(&ci, argp, sizeof(ci)))
	116	return -EFAULT;
	117
	118	err = hidp_get_conninfo(&ci);
	119	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
	120	return -EFAULT;
	121
	122	return err;
	123	}
	124
	125	return -EINVAL;
	126	}
	127
e9c5702e MH	128	#ifdef CONFIG_COMPAT
e9c5702e MH	129	struct compat_hidp_connadd_req {
17f09a7e SJ	130	int ctrl_sock; /* Connected control socket */
17f09a7e SJ	131	int intr_sock; /* Connected interrupt socket */
e9c5702e MH	132	__u16 parser;
	133	__u16 rd_size;
	134	compat_uptr_t rd_data;
	135	__u8 country;
	136	__u8 subclass;
	137	__u16 vendor;
	138	__u16 product;
	139	__u16 version;
	140	__u32 flags;
	141	__u32 idle_to;
	142	char name[128];
	143	};
	144
	145	static int hidp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	146	{
	147	if (cmd == HIDPGETCONNLIST) {
	148	struct hidp_connlist_req cl;
816a11d5	149	u32 uci;
e9c5702e MH	150	int err;
e9c5702e MH	151
816a11d5	152	if (get_user(cl.cnum, (u32 __user *) arg) \|\|
e9c5702e MH	153	get_user(uci, (u32 __user *) (arg + 4)))
	154	return -EFAULT;
	155
	156	cl.ci = compat_ptr(uci);
	157
	158	if (cl.cnum <= 0)
	159	return -EINVAL;
	160
	161	err = hidp_get_connlist(&cl);
	162
816a11d5	163	if (!err && put_user(cl.cnum, (u32 __user *) arg))
e9c5702e MH	164	err = -EFAULT;
	165
	166	return err;
	167	} else if (cmd == HIDPCONNADD) {
	168	struct compat_hidp_connadd_req ca;
	169	struct hidp_connadd_req __user *uca;
	170
	171	uca = compat_alloc_user_space(sizeof(*uca));
	172
55e74744	173	if (copy_from_user(&ca, (void __user *) arg, sizeof(ca)))
e9c5702e MH	174	return -EFAULT;
	175
	176	if (put_user(ca.ctrl_sock, &uca->ctrl_sock) \|\|
	177	put_user(ca.intr_sock, &uca->intr_sock) \|\|
	178	put_user(ca.parser, &uca->parser) \|\|
a83d6c0d	179	put_user(ca.rd_size, &uca->rd_size) \|\|
e9c5702e MH	180	put_user(compat_ptr(ca.rd_data), &uca->rd_data) \|\|
	181	put_user(ca.country, &uca->country) \|\|
	182	put_user(ca.subclass, &uca->subclass) \|\|
	183	put_user(ca.vendor, &uca->vendor) \|\|
	184	put_user(ca.product, &uca->product) \|\|
	185	put_user(ca.version, &uca->version) \|\|
	186	put_user(ca.flags, &uca->flags) \|\|
	187	put_user(ca.idle_to, &uca->idle_to) \|\|
	188	copy_to_user(&uca->name[0], &ca.name[0], 128))
	189	return -EFAULT;
8e87d142	190
e9c5702e MH	191	arg = (unsigned long) uca;
	192
	193	/* Fall through. We don't actually write back any _changes_
	194	to the structure anyway, so there's no need to copy back
	195	into the original compat version */
	196	}
	197
	198	return hidp_sock_ioctl(sock, cmd, arg);
	199	}
	200	#endif
	201
90ddc4f0	202	static const struct proto_ops hidp_sock_ops = {
1da177e4 LT	203	.family = PF_BLUETOOTH,
	204	.owner = THIS_MODULE,
	205	.release = hidp_sock_release,
	206	.ioctl = hidp_sock_ioctl,
e9c5702e MH	207	#ifdef CONFIG_COMPAT
	208	.compat_ioctl = hidp_sock_compat_ioctl,
	209	#endif
1da177e4 LT	210	.bind = sock_no_bind,
	211	.getname = sock_no_getname,
	212	.sendmsg = sock_no_sendmsg,
	213	.recvmsg = sock_no_recvmsg,
	214	.poll = sock_no_poll,
	215	.listen = sock_no_listen,
	216	.shutdown = sock_no_shutdown,
	217	.setsockopt = sock_no_setsockopt,
	218	.getsockopt = sock_no_getsockopt,
	219	.connect = sock_no_connect,
	220	.socketpair = sock_no_socketpair,
	221	.accept = sock_no_accept,
	222	.mmap = sock_no_mmap
	223	};
	224
	225	static struct proto hidp_proto = {
	226	.name = "HIDP",
	227	.owner = THIS_MODULE,
	228	.obj_size = sizeof(struct bt_sock)
	229	};
	230
3f378b68 EP	231	static int hidp_sock_create(struct net net, struct socket sock, int protocol,
3f378b68 EP	232	int kern)
1da177e4 LT	233	{
	234	struct sock *sk;
	235
	236	BT_DBG("sock %p", sock);
	237
	238	if (sock->type != SOCK_RAW)
	239	return -ESOCKTNOSUPPORT;
	240
6257ff21	241	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hidp_proto);
1da177e4 LT	242	if (!sk)
	243	return -ENOMEM;
	244
	245	sock_init_data(sock, sk);
	246
	247	sock->ops = &hidp_sock_ops;
	248
	249	sock->state = SS_UNCONNECTED;
	250
	251	sock_reset_flag(sk, SOCK_ZAPPED);
	252
	253	sk->sk_protocol = protocol;
	254	sk->sk_state = BT_OPEN;
	255
	256	return 0;
	257	}
	258
ec1b4cf7	259	static const struct net_proto_family hidp_sock_family_ops = {
1da177e4 LT	260	.family = PF_BLUETOOTH,
	261	.owner = THIS_MODULE,
	262	.create = hidp_sock_create
	263	};
	264
	265	int __init hidp_init_sockets(void)
	266	{
	267	int err;
	268
	269	err = proto_register(&hidp_proto, 0);
	270	if (err < 0)
	271	return err;
	272
	273	err = bt_sock_register(BTPROTO_HIDP, &hidp_sock_family_ops);
	274	if (err < 0)
	275	goto error;
	276
	277	return 0;
	278
	279	error:
	280	BT_ERR("Can't register HIDP socket");
	281	proto_unregister(&hidp_proto);
	282	return err;
	283	}
	284
	285	void __exit hidp_cleanup_sockets(void)
	286	{
	287	if (bt_sock_unregister(BTPROTO_HIDP) < 0)
	288	BT_ERR("Can't unregister HIDP socket");
	289
	290	proto_unregister(&hidp_proto);
	291	}