[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"

#ifndef CONFIG_BT_CMTP_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

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

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

		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 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
	46	#ifndef CONFIG_BT_CMTP_DEBUG
	47	#undef BT_DBG
	48	#define BT_DBG(D...)
	49	#endif
	50
	51	static int cmtp_sock_release(struct socket *sock)
	52	{
	53	struct sock *sk = sock->sk;
	54
	55	BT_DBG("sock %p sk %p", sock, sk);
	56
	57	if (!sk)
	58	return 0;
	59
	60	sock_orphan(sk);
	61	sock_put(sk);
	62
	63	return 0;
	64	}
	65
	66	static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	67	{
	68	struct cmtp_connadd_req ca;
	69	struct cmtp_conndel_req cd;
	70	struct cmtp_connlist_req cl;
	71	struct cmtp_conninfo ci;
	72	struct socket *nsock;
	73	void __user argp = (void __user )arg;
	74	int err;
	75
	76	BT_DBG("cmd %x arg %lx", cmd, arg);
	77
	78	switch (cmd) {
	79	case CMTPCONNADD:
	80	if (!capable(CAP_NET_ADMIN))
	81	return -EACCES;
	82
	83	if (copy_from_user(&ca, argp, sizeof(ca)))
	84	return -EFAULT;
	85
	86	nsock = sockfd_lookup(ca.sock, &err);
	87	if (!nsock)
	88	return err;
	89
	90	if (nsock->sk->sk_state != BT_CONNECTED) {
	91	fput(nsock->file);
	92	return -EBADFD;
	93	}
	94
	95	err = cmtp_add_connection(&ca, nsock);
	96	if (!err) {
	97	if (copy_to_user(argp, &ca, sizeof(ca)))
	98	err = -EFAULT;
	99	} else
	100	fput(nsock->file);
101
102	return err;
103
104	case CMTPCONNDEL:
105	if (!capable(CAP_NET_ADMIN))
106	return -EACCES;
107
108	if (copy_from_user(&cd, argp, sizeof(cd)))
109	return -EFAULT;
110
111	return cmtp_del_connection(&cd);
112
113	case CMTPGETCONNLIST:
114	if (copy_from_user(&cl, argp, sizeof(cl)))
115	return -EFAULT;
116
117	if (cl.cnum <= 0)
118	return -EINVAL;
119
120	err = cmtp_get_connlist(&cl);
121	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
122	return -EFAULT;
123
124	return err;
125
126	case CMTPGETCONNINFO:
127	if (copy_from_user(&ci, argp, sizeof(ci)))
128	return -EFAULT;
129
130	err = cmtp_get_conninfo(&ci);
131	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
132	return -EFAULT;
133
134	return err;
135	}
136
137	return -EINVAL;
138	}
139
e9c5702e MH	140	#ifdef CONFIG_COMPAT
	141	static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	142	{
	143	if (cmd == CMTPGETCONNLIST) {
	144	struct cmtp_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 = cmtp_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 cmtp_sock_ioctl(sock, cmd, arg);
	166	}
	167	#endif
	168
90ddc4f0	169	static const struct proto_ops cmtp_sock_ops = {
1da177e4 LT	170	.family = PF_BLUETOOTH,
	171	.owner = THIS_MODULE,
	172	.release = cmtp_sock_release,
	173	.ioctl = cmtp_sock_ioctl,
e9c5702e MH	174	#ifdef CONFIG_COMPAT
	175	.compat_ioctl = cmtp_sock_compat_ioctl,
	176	#endif
1da177e4 LT	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
	190	};
	191
	192	static struct proto cmtp_proto = {
	193	.name = "CMTP",
	194	.owner = THIS_MODULE,
	195	.obj_size = sizeof(struct bt_sock)
	196	};
	197
1b8d7ae4	198	static int cmtp_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, &cmtp_proto);
1da177e4 LT	208	if (!sk)
	209	return -ENOMEM;
	210
	211	sock_init_data(sock, sk);
	212
	213	sock->ops = &cmtp_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
	225	static struct net_proto_family cmtp_sock_family_ops = {
	226	.family = PF_BLUETOOTH,
	227	.owner = THIS_MODULE,
	228	.create = cmtp_sock_create
	229	};
	230
	231	int cmtp_init_sockets(void)
	232	{
	233	int err;
	234
	235	err = proto_register(&cmtp_proto, 0);
	236	if (err < 0)
	237	return err;
	238
	239	err = bt_sock_register(BTPROTO_CMTP, &cmtp_sock_family_ops);
	240	if (err < 0)
	241	goto error;
	242
	243	return 0;
	244
	245	error:
	246	BT_ERR("Can't register CMTP socket");
	247	proto_unregister(&cmtp_proto);
	248	return err;
	249	}
	250
	251	void cmtp_cleanup_sockets(void)
	252	{
	253	if (bt_sock_unregister(BTPROTO_CMTP) < 0)
	254	BT_ERR("Can't unregister CMTP socket");
	255
	256	proto_unregister(&cmtp_proto);
	257	}