[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.
*/

/*
 * $Id: sock.c,v 1.4 2002/08/04 21:23:58 maxk Exp $
 */ 

#include <linux/module.h>

#include <linux/types.h>
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.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"

#ifndef CONFIG_BT_BNEP_DEBUG
#undef  BT_DBG
#define BT_DBG( A... )
#endif

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) {
			fput(nsock->file);
			return -EBADFD;
		}

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

		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 socket *sock, int protocol)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

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

	sk = sk_alloc(PF_BLUETOOTH, GFP_ATOMIC, &bnep_proto, 1);
	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 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;
}

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

	proto_unregister(&bnep_proto);

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	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
	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
	20	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	21
	22	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
	23	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
	24	SOFTWARE IS DISCLAIMED.
	25	*/
	26
	27	/*
	28	* $Id: sock.c,v 1.4 2002/08/04 21:23:58 maxk Exp $
	29	*/
	30
1da177e4 LT	31	#include <linux/module.h>
	32
	33	#include <linux/types.h>
4fc268d2	34	#include <linux/capability.h>
1da177e4 LT	35	#include <linux/errno.h>
1da177e4 LT	36	#include <linux/kernel.h>
1da177e4 LT	37	#include <linux/sched.h>
	38	#include <linux/slab.h>
	39	#include <linux/poll.h>
	40	#include <linux/fcntl.h>
	41	#include <linux/skbuff.h>
	42	#include <linux/socket.h>
	43	#include <linux/ioctl.h>
	44	#include <linux/file.h>
	45	#include <linux/init.h>
e9c5702e	46	#include <linux/compat.h>
1da177e4 LT	47	#include <net/sock.h>
	48
	49	#include <asm/system.h>
	50	#include <asm/uaccess.h>
	51
	52	#include "bnep.h"
	53
	54	#ifndef CONFIG_BT_BNEP_DEBUG
	55	#undef BT_DBG
	56	#define BT_DBG( A... )
	57	#endif
	58
	59	static int bnep_sock_release(struct socket *sock)
	60	{
	61	struct sock *sk = sock->sk;
	62
	63	BT_DBG("sock %p sk %p", sock, sk);
	64
	65	if (!sk)
	66	return 0;
	67
	68	sock_orphan(sk);
	69	sock_put(sk);
	70	return 0;
	71	}
	72
	73	static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	74	{
	75	struct bnep_connlist_req cl;
	76	struct bnep_connadd_req ca;
	77	struct bnep_conndel_req cd;
	78	struct bnep_conninfo ci;
	79	struct socket *nsock;
	80	void __user argp = (void __user )arg;
	81	int err;
	82
	83	BT_DBG("cmd %x arg %lx", cmd, arg);
	84
	85	switch (cmd) {
	86	case BNEPCONNADD:
	87	if (!capable(CAP_NET_ADMIN))
	88	return -EACCES;
	89
	90	if (copy_from_user(&ca, argp, sizeof(ca)))
	91	return -EFAULT;
	92
	93	nsock = sockfd_lookup(ca.sock, &err);
	94	if (!nsock)
	95	return err;
	96
	97	if (nsock->sk->sk_state != BT_CONNECTED) {
	98	fput(nsock->file);
	99	return -EBADFD;
	100	}
	101
	102	err = bnep_add_connection(&ca, nsock);
	103	if (!err) {
	104	if (copy_to_user(argp, &ca, sizeof(ca)))
	105	err = -EFAULT;
	106	} else
	107	fput(nsock->file);
	108
	109	return err;
	110
111	case BNEPCONNDEL:
112	if (!capable(CAP_NET_ADMIN))
113	return -EACCES;
114
115	if (copy_from_user(&cd, argp, sizeof(cd)))
116	return -EFAULT;
117
118	return bnep_del_connection(&cd);
119
120	case BNEPGETCONNLIST:
121	if (copy_from_user(&cl, argp, sizeof(cl)))
122	return -EFAULT;
123
124	if (cl.cnum <= 0)
125	return -EINVAL;
126
127	err = bnep_get_connlist(&cl);
128	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
129	return -EFAULT;
130
131	return err;
132
133	case BNEPGETCONNINFO:
134	if (copy_from_user(&ci, argp, sizeof(ci)))
135	return -EFAULT;
136
137	err = bnep_get_conninfo(&ci);
138	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
139	return -EFAULT;
140
141	return err;
142
143	default:
144	return -EINVAL;
145	}
146
147	return 0;
148	}
149
e9c5702e MH	150	#ifdef CONFIG_COMPAT
	151	static int bnep_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	152	{
	153	if (cmd == BNEPGETCONNLIST) {
	154	struct bnep_connlist_req cl;
	155	uint32_t uci;
	156	int err;
	157
	158	if (get_user(cl.cnum, (uint32_t __user *) arg) \|\|
	159	get_user(uci, (u32 __user *) (arg + 4)))
	160	return -EFAULT;
	161
	162	cl.ci = compat_ptr(uci);
	163
	164	if (cl.cnum <= 0)
	165	return -EINVAL;
	166
	167	err = bnep_get_connlist(&cl);
	168
	169	if (!err && put_user(cl.cnum, (uint32_t __user *) arg))
	170	err = -EFAULT;
	171
	172	return err;
	173	}
	174
	175	return bnep_sock_ioctl(sock, cmd, arg);
	176	}
	177	#endif
	178
90ddc4f0	179	static const struct proto_ops bnep_sock_ops = {
e9c5702e MH	180	.family = PF_BLUETOOTH,
	181	.owner = THIS_MODULE,
	182	.release = bnep_sock_release,
	183	.ioctl = bnep_sock_ioctl,
	184	#ifdef CONFIG_COMPAT
	185	.compat_ioctl = bnep_sock_compat_ioctl,
	186	#endif
	187	.bind = sock_no_bind,
	188	.getname = sock_no_getname,
	189	.sendmsg = sock_no_sendmsg,
	190	.recvmsg = sock_no_recvmsg,
	191	.poll = sock_no_poll,
	192	.listen = sock_no_listen,
	193	.shutdown = sock_no_shutdown,
	194	.setsockopt = sock_no_setsockopt,
	195	.getsockopt = sock_no_getsockopt,
	196	.connect = sock_no_connect,
	197	.socketpair = sock_no_socketpair,
	198	.accept = sock_no_accept,
	199	.mmap = sock_no_mmap
1da177e4 LT	200	};
	201
	202	static struct proto bnep_proto = {
	203	.name = "BNEP",
	204	.owner = THIS_MODULE,
	205	.obj_size = sizeof(struct bt_sock)
	206	};
	207
	208	static int bnep_sock_create(struct socket *sock, int protocol)
	209	{
	210	struct sock *sk;
	211
	212	BT_DBG("sock %p", sock);
	213
	214	if (sock->type != SOCK_RAW)
	215	return -ESOCKTNOSUPPORT;
	216
74da626a	217	sk = sk_alloc(PF_BLUETOOTH, GFP_ATOMIC, &bnep_proto, 1);
1da177e4 LT	218	if (!sk)
	219	return -ENOMEM;
	220
	221	sock_init_data(sock, sk);
	222
	223	sock->ops = &bnep_sock_ops;
	224
	225	sock->state = SS_UNCONNECTED;
	226
	227	sock_reset_flag(sk, SOCK_ZAPPED);
	228
	229	sk->sk_protocol = protocol;
	230	sk->sk_state = BT_OPEN;
	231
	232	return 0;
	233	}
	234
	235	static struct net_proto_family bnep_sock_family_ops = {
	236	.family = PF_BLUETOOTH,
	237	.owner = THIS_MODULE,
	238	.create = bnep_sock_create
	239	};
	240
	241	int __init bnep_sock_init(void)
	242	{
	243	int err;
	244
	245	err = proto_register(&bnep_proto, 0);
	246	if (err < 0)
	247	return err;
	248
	249	err = bt_sock_register(BTPROTO_BNEP, &bnep_sock_family_ops);
	250	if (err < 0)
	251	goto error;
	252
	253	return 0;
	254
	255	error:
	256	BT_ERR("Can't register BNEP socket");
	257	proto_unregister(&bnep_proto);
	258	return err;
	259	}
	260
	261	int __exit bnep_sock_cleanup(void)
	262	{
	263	if (bt_sock_unregister(BTPROTO_BNEP) < 0)
	264	BT_ERR("Can't unregister BNEP socket");
	265
	266	proto_unregister(&bnep_proto);
	267
	268	return 0;
	269	}