[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/export.h>
#include <linux/file.h>

#include "bnep.h"

static struct bt_sock_list bnep_sk_list = {
	.lock = __RW_LOCK_UNLOCKED(bnep_sk_list.lock)
};

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;

	bt_sock_unlink(&bnep_sk_list, sk);

	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 -EPERM;

		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;
		}
		ca.device[sizeof(ca.device)-1] = 0;

		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 -EPERM;

		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;
		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 = bnep_get_connlist(&cl);

		if (!err && put_user(cl.cnum, (u32 __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,
			    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, &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;

	bt_sock_link(&bnep_sk_list, sk);
	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) {
		BT_ERR("Can't register BNEP socket");
		goto error;
	}

	err = bt_procfs_init(&init_net, "bnep", &bnep_sk_list, NULL);
	if (err < 0) {
		BT_ERR("Failed to create BNEP proc file");
		bt_sock_unregister(BTPROTO_BNEP);
		goto error;
	}

	BT_INFO("BNEP socket layer initialized");

	return 0;

error:
	proto_unregister(&bnep_proto);
	return err;
}

void __exit bnep_sock_cleanup(void)
{
	bt_procfs_cleanup(&init_net, "bnep");
	bt_sock_unregister(BTPROTO_BNEP);
	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
8c520a59	27	#include <linux/export.h>
1da177e4	28	#include <linux/file.h>
1da177e4 LT	29
	30	#include "bnep.h"
	31
77cf5585 MY	32	static struct bt_sock_list bnep_sk_list = {
	33	.lock = __RW_LOCK_UNLOCKED(bnep_sk_list.lock)
	34	};
	35
1da177e4 LT	36	static int bnep_sock_release(struct socket *sock)
	37	{
	38	struct sock *sk = sock->sk;
	39
	40	BT_DBG("sock %p sk %p", sock, sk);
	41
	42	if (!sk)
	43	return 0;
	44
77cf5585 MY	45	bt_sock_unlink(&bnep_sk_list, sk);
77cf5585 MY	46
1da177e4 LT	47	sock_orphan(sk);
	48	sock_put(sk);
	49	return 0;
	50	}
	51
	52	static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	53	{
	54	struct bnep_connlist_req cl;
	55	struct bnep_connadd_req ca;
	56	struct bnep_conndel_req cd;
	57	struct bnep_conninfo ci;
	58	struct socket *nsock;
	59	void __user argp = (void __user )arg;
	60	int err;
	61
	62	BT_DBG("cmd %x arg %lx", cmd, arg);
	63
	64	switch (cmd) {
	65	case BNEPCONNADD:
	66	if (!capable(CAP_NET_ADMIN))
bf5b30b8	67	return -EPERM;
1da177e4 LT	68
	69	if (copy_from_user(&ca, argp, sizeof(ca)))
	70	return -EFAULT;
8e87d142	71
1da177e4 LT	72	nsock = sockfd_lookup(ca.sock, &err);
	73	if (!nsock)
	74	return err;
	75
	76	if (nsock->sk->sk_state != BT_CONNECTED) {
67b23219	77	sockfd_put(nsock);
1da177e4 LT	78	return -EBADFD;
1da177e4 LT	79	}
43629f8f	80	ca.device[sizeof(ca.device)-1] = 0;
1da177e4 LT	81
	82	err = bnep_add_connection(&ca, nsock);
	83	if (!err) {
8e87d142	84	if (copy_to_user(argp, &ca, sizeof(ca)))
1da177e4 LT	85	err = -EFAULT;
1da177e4 LT	86	} else
67b23219	87	sockfd_put(nsock);
1da177e4 LT	88
1da177e4 LT	89	return err;
8e87d142	90
1da177e4 LT	91	case BNEPCONNDEL:
1da177e4 LT	92	if (!capable(CAP_NET_ADMIN))
bf5b30b8	93	return -EPERM;
1da177e4 LT	94
	95	if (copy_from_user(&cd, argp, sizeof(cd)))
	96	return -EFAULT;
8e87d142	97
1da177e4 LT	98	return bnep_del_connection(&cd);
	99
	100	case BNEPGETCONNLIST:
	101	if (copy_from_user(&cl, argp, sizeof(cl)))
	102	return -EFAULT;
	103
	104	if (cl.cnum <= 0)
	105	return -EINVAL;
8e87d142	106
1da177e4 LT	107	err = bnep_get_connlist(&cl);
	108	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
	109	return -EFAULT;
	110
	111	return err;
	112
	113	case BNEPGETCONNINFO:
	114	if (copy_from_user(&ci, argp, sizeof(ci)))
	115	return -EFAULT;
	116
	117	err = bnep_get_conninfo(&ci);
	118	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
	119	return -EFAULT;
	120
	121	return err;
	122
	123	default:
	124	return -EINVAL;
	125	}
	126
	127	return 0;
	128	}
	129
e9c5702e MH	130	#ifdef CONFIG_COMPAT
	131	static int bnep_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	132	{
	133	if (cmd == BNEPGETCONNLIST) {
	134	struct bnep_connlist_req cl;
816a11d5	135	u32 uci;
e9c5702e MH	136	int err;
e9c5702e MH	137
816a11d5	138	if (get_user(cl.cnum, (u32 __user *) arg) \|\|
e9c5702e MH	139	get_user(uci, (u32 __user *) (arg + 4)))
	140	return -EFAULT;
	141
	142	cl.ci = compat_ptr(uci);
	143
	144	if (cl.cnum <= 0)
	145	return -EINVAL;
8e87d142	146
e9c5702e MH	147	err = bnep_get_connlist(&cl);
e9c5702e MH	148
816a11d5	149	if (!err && put_user(cl.cnum, (u32 __user *) arg))
e9c5702e MH	150	err = -EFAULT;
	151
	152	return err;
	153	}
	154
	155	return bnep_sock_ioctl(sock, cmd, arg);
	156	}
	157	#endif
	158
90ddc4f0	159	static const struct proto_ops bnep_sock_ops = {
e9c5702e MH	160	.family = PF_BLUETOOTH,
	161	.owner = THIS_MODULE,
	162	.release = bnep_sock_release,
	163	.ioctl = bnep_sock_ioctl,
	164	#ifdef CONFIG_COMPAT
	165	.compat_ioctl = bnep_sock_compat_ioctl,
	166	#endif
	167	.bind = sock_no_bind,
	168	.getname = sock_no_getname,
	169	.sendmsg = sock_no_sendmsg,
	170	.recvmsg = sock_no_recvmsg,
	171	.poll = sock_no_poll,
	172	.listen = sock_no_listen,
	173	.shutdown = sock_no_shutdown,
	174	.setsockopt = sock_no_setsockopt,
	175	.getsockopt = sock_no_getsockopt,
	176	.connect = sock_no_connect,
	177	.socketpair = sock_no_socketpair,
	178	.accept = sock_no_accept,
	179	.mmap = sock_no_mmap
1da177e4 LT	180	};
	181
	182	static struct proto bnep_proto = {
	183	.name = "BNEP",
	184	.owner = THIS_MODULE,
	185	.obj_size = sizeof(struct bt_sock)
	186	};
	187
3f378b68 EP	188	static int bnep_sock_create(struct net net, struct socket sock, int protocol,
3f378b68 EP	189	int kern)
1da177e4 LT	190	{
	191	struct sock *sk;
	192
	193	BT_DBG("sock %p", sock);
	194
	195	if (sock->type != SOCK_RAW)
	196	return -ESOCKTNOSUPPORT;
	197
6257ff21	198	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &bnep_proto);
1da177e4 LT	199	if (!sk)
	200	return -ENOMEM;
	201
	202	sock_init_data(sock, sk);
	203
	204	sock->ops = &bnep_sock_ops;
	205
	206	sock->state = SS_UNCONNECTED;
	207
	208	sock_reset_flag(sk, SOCK_ZAPPED);
	209
	210	sk->sk_protocol = protocol;
	211	sk->sk_state = BT_OPEN;
	212
77cf5585	213	bt_sock_link(&bnep_sk_list, sk);
1da177e4 LT	214	return 0;
	215	}
	216
ec1b4cf7	217	static const struct net_proto_family bnep_sock_family_ops = {
1da177e4 LT	218	.family = PF_BLUETOOTH,
	219	.owner = THIS_MODULE,
	220	.create = bnep_sock_create
	221	};
	222
	223	int __init bnep_sock_init(void)
	224	{
	225	int err;
	226
	227	err = proto_register(&bnep_proto, 0);
	228	if (err < 0)
	229	return err;
	230
	231	err = bt_sock_register(BTPROTO_BNEP, &bnep_sock_family_ops);
77cf5585 MY	232	if (err < 0) {
77cf5585 MY	233	BT_ERR("Can't register BNEP socket");
1da177e4	234	goto error;
77cf5585 MY	235	}
77cf5585 MY	236
b0316615	237	err = bt_procfs_init(&init_net, "bnep", &bnep_sk_list, NULL);
77cf5585 MY	238	if (err < 0) {
	239	BT_ERR("Failed to create BNEP proc file");
	240	bt_sock_unregister(BTPROTO_BNEP);
	241	goto error;
	242	}
	243
	244	BT_INFO("BNEP socket layer initialized");
1da177e4 LT	245
	246	return 0;
	247
	248	error:
1da177e4 LT	249	proto_unregister(&bnep_proto);
	250	return err;
	251	}
	252
a4e2acf0	253	void __exit bnep_sock_cleanup(void)
1da177e4	254	{
77cf5585	255	bt_procfs_cleanup(&init_net, "bnep");
5e9d7f86	256	bt_sock_unregister(BTPROTO_BNEP);
1da177e4	257	proto_unregister(&bnep_proto);
1da177e4	258	}