[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 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;
		}
		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 -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;
		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;

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