[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / bnep / sock.c

/*
   BNEP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2001-2002 Inventel Systemes
   Written 2001-2002 by
	David Libault  <david.libault@inventel.fr>

   Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>

   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/module.h>

#include <linux/types.h>
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/skbuff.h>
#include <linux/socket.h>
#include <linux/ioctl.h>
#include <linux/file.h>
#include <linux/init.h>
#include <linux/compat.h>
#include <net/sock.h>

#include <asm/system.h>
#include <asm/uaccess.h>

#include "bnep.h"

static int bnep_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 bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct bnep_connlist_req cl;
	struct bnep_connadd_req  ca;
	struct bnep_conndel_req  cd;
	struct bnep_conninfo ci;
	struct socket *nsock;
	void __user *argp = (void __user *)arg;
	int err;

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

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

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

		nsock = sockfd_lookup(ca.sock, &err);
		if (!nsock)
			return err;

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

		err = bnep_add_connection(&ca, nsock);
		if (!err) {
			if (copy_to_user(argp, &ca, sizeof(ca)))
				err = -EFAULT;
		} else
			sockfd_put(nsock);

		return err;

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

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

		return bnep_del_connection(&cd);

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

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

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

		return err;

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

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

		return err;

	default:
		return -EINVAL;
	}

	return 0;
}

#ifdef CONFIG_COMPAT
static int bnep_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	if (cmd == BNEPGETCONNLIST) {
		struct bnep_connlist_req cl;
		uint32_t uci;
		int err;

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

		cl.ci = compat_ptr(uci);

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

		err = bnep_get_connlist(&cl);

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

		return err;
	}

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

static const struct proto_ops bnep_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= bnep_sock_release,
	.ioctl		= bnep_sock_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= bnep_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 bnep_proto = {
	.name		= "BNEP",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct bt_sock)
};

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

	BT_DBG("sock %p", sock);

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

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

	sock_init_data(sock, sk);

	sock->ops = &bnep_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 bnep_sock_family_ops = {
	.family = PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create = bnep_sock_create
};

int __init bnep_sock_init(void)
{
	int err;

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

	err = bt_sock_register(BTPROTO_BNEP, &bnep_sock_family_ops);
	if (err < 0)
		goto error;

	return 0;

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

void __exit bnep_sock_cleanup(void)
{
	if (bt_sock_unregister(BTPROTO_BNEP) < 0)
		BT_ERR("Can't unregister BNEP socket");

	proto_unregister(&bnep_proto);
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	BNEP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2001-2002 Inventel Systemes
	4	Written 2001-2002 by
	5	David Libault <david.libault@inventel.fr>
	6
	7	Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License version 2 as
	11	published by the Free Software Foundation;
	12
	13	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	14	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	15	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	16	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	17	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	18	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	19	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	20	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	21
8e87d142 YH	22	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	23	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	24	SOFTWARE IS DISCLAIMED.
	25	*/
	26
1da177e4 LT	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
4fc268d2	30	#include <linux/capability.h>
1da177e4 LT	31	#include <linux/errno.h>
1da177e4 LT	32	#include <linux/kernel.h>
1da177e4 LT	33	#include <linux/slab.h>
	34	#include <linux/poll.h>
	35	#include <linux/fcntl.h>
	36	#include <linux/skbuff.h>
	37	#include <linux/socket.h>
	38	#include <linux/ioctl.h>
	39	#include <linux/file.h>
	40	#include <linux/init.h>
e9c5702e	41	#include <linux/compat.h>
1da177e4 LT	42	#include <net/sock.h>
	43
	44	#include <asm/system.h>
	45	#include <asm/uaccess.h>
	46
	47	#include "bnep.h"
	48
1da177e4 LT	49	static int bnep_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	sock_orphan(sk);
	59	sock_put(sk);
	60	return 0;
	61	}
	62
	63	static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	64	{
	65	struct bnep_connlist_req cl;
	66	struct bnep_connadd_req ca;
	67	struct bnep_conndel_req cd;
	68	struct bnep_conninfo ci;
	69	struct socket *nsock;
	70	void __user argp = (void __user )arg;
	71	int err;
	72
	73	BT_DBG("cmd %x arg %lx", cmd, arg);
	74
	75	switch (cmd) {
	76	case BNEPCONNADD:
	77	if (!capable(CAP_NET_ADMIN))
	78	return -EACCES;
	79
	80	if (copy_from_user(&ca, argp, sizeof(ca)))
	81	return -EFAULT;
8e87d142	82
1da177e4 LT	83	nsock = sockfd_lookup(ca.sock, &err);
	84	if (!nsock)
	85	return err;
	86
	87	if (nsock->sk->sk_state != BT_CONNECTED) {
67b23219	88	sockfd_put(nsock);
1da177e4 LT	89	return -EBADFD;
	90	}
	91
	92	err = bnep_add_connection(&ca, nsock);
	93	if (!err) {
8e87d142	94	if (copy_to_user(argp, &ca, sizeof(ca)))
1da177e4 LT	95	err = -EFAULT;
1da177e4 LT	96	} else
67b23219	97	sockfd_put(nsock);
1da177e4 LT	98
1da177e4 LT	99	return err;
8e87d142	100
1da177e4 LT	101	case BNEPCONNDEL:
	102	if (!capable(CAP_NET_ADMIN))
	103	return -EACCES;
	104
	105	if (copy_from_user(&cd, argp, sizeof(cd)))
	106	return -EFAULT;
8e87d142	107
1da177e4 LT	108	return bnep_del_connection(&cd);
	109
	110	case BNEPGETCONNLIST:
	111	if (copy_from_user(&cl, argp, sizeof(cl)))
	112	return -EFAULT;
	113
	114	if (cl.cnum <= 0)
	115	return -EINVAL;
8e87d142	116
1da177e4 LT	117	err = bnep_get_connlist(&cl);
	118	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
	119	return -EFAULT;
	120
	121	return err;
	122
	123	case BNEPGETCONNINFO:
	124	if (copy_from_user(&ci, argp, sizeof(ci)))
	125	return -EFAULT;
	126
	127	err = bnep_get_conninfo(&ci);
	128	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
	129	return -EFAULT;
	130
	131	return err;
	132
	133	default:
	134	return -EINVAL;
	135	}
	136
	137	return 0;
	138	}
	139
e9c5702e MH	140	#ifdef CONFIG_COMPAT
	141	static int bnep_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	142	{
	143	if (cmd == BNEPGETCONNLIST) {
	144	struct bnep_connlist_req cl;
	145	uint32_t uci;
	146	int err;
	147
	148	if (get_user(cl.cnum, (uint32_t __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;
8e87d142	156
e9c5702e MH	157	err = bnep_get_connlist(&cl);
	158
	159	if (!err && put_user(cl.cnum, (uint32_t __user *) arg))
	160	err = -EFAULT;
	161
	162	return err;
	163	}
	164
	165	return bnep_sock_ioctl(sock, cmd, arg);
	166	}
	167	#endif
	168
90ddc4f0	169	static const struct proto_ops bnep_sock_ops = {
e9c5702e MH	170	.family = PF_BLUETOOTH,
	171	.owner = THIS_MODULE,
	172	.release = bnep_sock_release,
	173	.ioctl = bnep_sock_ioctl,
	174	#ifdef CONFIG_COMPAT
	175	.compat_ioctl = bnep_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
1da177e4 LT	190	};
	191
	192	static struct proto bnep_proto = {
	193	.name = "BNEP",
	194	.owner = THIS_MODULE,
	195	.obj_size = sizeof(struct bt_sock)
	196	};
	197
1b8d7ae4	198	static int bnep_sock_create(struct net net, struct socket sock, int protocol)
1da177e4 LT	199	{
	200	struct sock *sk;
	201
	202	BT_DBG("sock %p", sock);
	203
	204	if (sock->type != SOCK_RAW)
	205	return -ESOCKTNOSUPPORT;
	206
6257ff21	207	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &bnep_proto);
1da177e4 LT	208	if (!sk)
	209	return -ENOMEM;
	210
	211	sock_init_data(sock, sk);
	212
	213	sock->ops = &bnep_sock_ops;
	214
	215	sock->state = SS_UNCONNECTED;
	216
	217	sock_reset_flag(sk, SOCK_ZAPPED);
	218
	219	sk->sk_protocol = protocol;
	220	sk->sk_state = BT_OPEN;
	221
	222	return 0;
	223	}
	224
ec1b4cf7	225	static const struct net_proto_family bnep_sock_family_ops = {
1da177e4 LT	226	.family = PF_BLUETOOTH,
	227	.owner = THIS_MODULE,
	228	.create = bnep_sock_create
	229	};
	230
	231	int __init bnep_sock_init(void)
	232	{
	233	int err;
	234
	235	err = proto_register(&bnep_proto, 0);
	236	if (err < 0)
	237	return err;
	238
	239	err = bt_sock_register(BTPROTO_BNEP, &bnep_sock_family_ops);
	240	if (err < 0)
	241	goto error;
	242
	243	return 0;
	244
	245	error:
	246	BT_ERR("Can't register BNEP socket");
	247	proto_unregister(&bnep_proto);
	248	return err;
	249	}
	250
a4e2acf0	251	void __exit bnep_sock_cleanup(void)
1da177e4 LT	252	{
	253	if (bt_sock_unregister(BTPROTO_BNEP) < 0)
	254	BT_ERR("Can't unregister BNEP socket");
	255
	256	proto_unregister(&bnep_proto);
1da177e4	257	}