[net-next-2.6.git] / net / bluetooth / cmtp / sock.c

/*
   CMTP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2002-2003 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/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/compat.h>
#include <net/sock.h>

#include <linux/isdn/capilli.h>

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

#include "cmtp.h"

static int cmtp_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 cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct cmtp_connadd_req ca;
	struct cmtp_conndel_req cd;
	struct cmtp_connlist_req cl;
	struct cmtp_conninfo ci;
	struct socket *nsock;
	void __user *argp = (void __user *)arg;
	int err;

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

	switch (cmd) {
	case CMTPCONNADD:
		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 = cmtp_add_connection(&ca, nsock);
		if (!err) {
			if (copy_to_user(argp, &ca, sizeof(ca)))
				err = -EFAULT;
		} else
			sockfd_put(nsock);

		return err;

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

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

		return cmtp_del_connection(&cd);

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

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

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

		return err;

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

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

		return err;
	}

	return -EINVAL;
}

#ifdef CONFIG_COMPAT
static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	if (cmd == CMTPGETCONNLIST) {
		struct cmtp_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 = cmtp_get_connlist(&cl);

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

		return err;
	}

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

static const struct proto_ops cmtp_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= cmtp_sock_release,
	.ioctl		= cmtp_sock_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= cmtp_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 cmtp_proto = {
	.name		= "CMTP",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct bt_sock)
};

static int cmtp_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, &cmtp_proto);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sock->ops = &cmtp_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 cmtp_sock_family_ops = {
	.family	= PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create	= cmtp_sock_create
};

int cmtp_init_sockets(void)
{
	int err;

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

	err = bt_sock_register(BTPROTO_CMTP, &cmtp_sock_family_ops);
	if (err < 0)
		goto error;

	return 0;

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

void cmtp_cleanup_sockets(void)
{
	if (bt_sock_unregister(BTPROTO_CMTP) < 0)
		BT_ERR("Can't unregister CMTP socket");

	proto_unregister(&cmtp_proto);
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	CMTP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2002-2003 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
1da177e4 LT	23	#include <linux/module.h>
	24
	25	#include <linux/types.h>
4fc268d2	26	#include <linux/capability.h>
1da177e4 LT	27	#include <linux/errno.h>
1da177e4 LT	28	#include <linux/kernel.h>
1da177e4 LT	29	#include <linux/slab.h>
	30	#include <linux/poll.h>
	31	#include <linux/fcntl.h>
	32	#include <linux/skbuff.h>
	33	#include <linux/socket.h>
	34	#include <linux/ioctl.h>
	35	#include <linux/file.h>
e9c5702e	36	#include <linux/compat.h>
1da177e4 LT	37	#include <net/sock.h>
	38
	39	#include <linux/isdn/capilli.h>
	40
	41	#include <asm/system.h>
	42	#include <asm/uaccess.h>
	43
	44	#include "cmtp.h"
	45
1da177e4 LT	46	static int cmtp_sock_release(struct socket *sock)
	47	{
	48	struct sock *sk = sock->sk;
	49
	50	BT_DBG("sock %p sk %p", sock, sk);
	51
	52	if (!sk)
	53	return 0;
	54
	55	sock_orphan(sk);
	56	sock_put(sk);
	57
	58	return 0;
	59	}
	60
	61	static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	62	{
	63	struct cmtp_connadd_req ca;
	64	struct cmtp_conndel_req cd;
	65	struct cmtp_connlist_req cl;
	66	struct cmtp_conninfo ci;
	67	struct socket *nsock;
	68	void __user argp = (void __user )arg;
	69	int err;
	70
	71	BT_DBG("cmd %x arg %lx", cmd, arg);
	72
	73	switch (cmd) {
	74	case CMTPCONNADD:
	75	if (!capable(CAP_NET_ADMIN))
	76	return -EACCES;
	77
	78	if (copy_from_user(&ca, argp, sizeof(ca)))
	79	return -EFAULT;
	80
	81	nsock = sockfd_lookup(ca.sock, &err);
	82	if (!nsock)
	83	return err;
	84
	85	if (nsock->sk->sk_state != BT_CONNECTED) {
67b23219	86	sockfd_put(nsock);
1da177e4 LT	87	return -EBADFD;
	88	}
	89
	90	err = cmtp_add_connection(&ca, nsock);
	91	if (!err) {
	92	if (copy_to_user(argp, &ca, sizeof(ca)))
	93	err = -EFAULT;
	94	} else
67b23219	95	sockfd_put(nsock);
1da177e4 LT	96
	97	return err;
	98
	99	case CMTPCONNDEL:
	100	if (!capable(CAP_NET_ADMIN))
	101	return -EACCES;
	102
	103	if (copy_from_user(&cd, argp, sizeof(cd)))
	104	return -EFAULT;
	105
	106	return cmtp_del_connection(&cd);
	107
	108	case CMTPGETCONNLIST:
	109	if (copy_from_user(&cl, argp, sizeof(cl)))
	110	return -EFAULT;
	111
	112	if (cl.cnum <= 0)
	113	return -EINVAL;
	114
	115	err = cmtp_get_connlist(&cl);
	116	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
	117	return -EFAULT;
	118
	119	return err;
	120
	121	case CMTPGETCONNINFO:
	122	if (copy_from_user(&ci, argp, sizeof(ci)))
	123	return -EFAULT;
	124
	125	err = cmtp_get_conninfo(&ci);
	126	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
	127	return -EFAULT;
	128
	129	return err;
	130	}
	131
	132	return -EINVAL;
	133	}
	134
e9c5702e MH	135	#ifdef CONFIG_COMPAT
	136	static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	137	{
	138	if (cmd == CMTPGETCONNLIST) {
	139	struct cmtp_connlist_req cl;
	140	uint32_t uci;
	141	int err;
	142
	143	if (get_user(cl.cnum, (uint32_t __user *) arg) \|\|
	144	get_user(uci, (u32 __user *) (arg + 4)))
	145	return -EFAULT;
	146
	147	cl.ci = compat_ptr(uci);
	148
	149	if (cl.cnum <= 0)
	150	return -EINVAL;
8e87d142	151
e9c5702e MH	152	err = cmtp_get_connlist(&cl);
	153
	154	if (!err && put_user(cl.cnum, (uint32_t __user *) arg))
	155	err = -EFAULT;
	156
	157	return err;
	158	}
	159
	160	return cmtp_sock_ioctl(sock, cmd, arg);
	161	}
	162	#endif
	163
90ddc4f0	164	static const struct proto_ops cmtp_sock_ops = {
1da177e4 LT	165	.family = PF_BLUETOOTH,
	166	.owner = THIS_MODULE,
	167	.release = cmtp_sock_release,
	168	.ioctl = cmtp_sock_ioctl,
e9c5702e MH	169	#ifdef CONFIG_COMPAT
	170	.compat_ioctl = cmtp_sock_compat_ioctl,
	171	#endif
1da177e4 LT	172	.bind = sock_no_bind,
	173	.getname = sock_no_getname,
	174	.sendmsg = sock_no_sendmsg,
	175	.recvmsg = sock_no_recvmsg,
	176	.poll = sock_no_poll,
	177	.listen = sock_no_listen,
	178	.shutdown = sock_no_shutdown,
	179	.setsockopt = sock_no_setsockopt,
	180	.getsockopt = sock_no_getsockopt,
	181	.connect = sock_no_connect,
	182	.socketpair = sock_no_socketpair,
	183	.accept = sock_no_accept,
	184	.mmap = sock_no_mmap
	185	};
	186
	187	static struct proto cmtp_proto = {
	188	.name = "CMTP",
	189	.owner = THIS_MODULE,
	190	.obj_size = sizeof(struct bt_sock)
	191	};
	192
1b8d7ae4	193	static int cmtp_sock_create(struct net net, struct socket sock, int protocol)
1da177e4 LT	194	{
	195	struct sock *sk;
	196
	197	BT_DBG("sock %p", sock);
	198
	199	if (sock->type != SOCK_RAW)
	200	return -ESOCKTNOSUPPORT;
	201
6257ff21	202	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &cmtp_proto);
1da177e4 LT	203	if (!sk)
	204	return -ENOMEM;
	205
	206	sock_init_data(sock, sk);
	207
	208	sock->ops = &cmtp_sock_ops;
	209
	210	sock->state = SS_UNCONNECTED;
	211
	212	sock_reset_flag(sk, SOCK_ZAPPED);
	213
	214	sk->sk_protocol = protocol;
	215	sk->sk_state = BT_OPEN;
	216
	217	return 0;
	218	}
	219
ec1b4cf7	220	static const struct net_proto_family cmtp_sock_family_ops = {
1da177e4 LT	221	.family = PF_BLUETOOTH,
	222	.owner = THIS_MODULE,
	223	.create = cmtp_sock_create
	224	};
	225
	226	int cmtp_init_sockets(void)
	227	{
	228	int err;
	229
	230	err = proto_register(&cmtp_proto, 0);
	231	if (err < 0)
	232	return err;
	233
	234	err = bt_sock_register(BTPROTO_CMTP, &cmtp_sock_family_ops);
	235	if (err < 0)
	236	goto error;
	237
	238	return 0;
	239
	240	error:
	241	BT_ERR("Can't register CMTP socket");
	242	proto_unregister(&cmtp_proto);
	243	return err;
	244	}
	245
	246	void cmtp_cleanup_sockets(void)
	247	{
	248	if (bt_sock_unregister(BTPROTO_CMTP) < 0)
	249	BT_ERR("Can't unregister CMTP socket");
	250
	251	proto_unregister(&cmtp_proto);
	252	}