[deliverable/linux.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/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 <linux/gfp.h>
#include <linux/uaccess.h>
#include <net/sock.h>

#include <linux/isdn/capilli.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 -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;
		}

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

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

		if (!err && put_user(cl.cnum, (u32 __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,
			    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, &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/poll.h>
	30	#include <linux/fcntl.h>
	31	#include <linux/skbuff.h>
	32	#include <linux/socket.h>
	33	#include <linux/ioctl.h>
	34	#include <linux/file.h>
e9c5702e	35	#include <linux/compat.h>
5a0e3ad6	36	#include <linux/gfp.h>
ffd13320	37	#include <linux/uaccess.h>
1da177e4 LT	38	#include <net/sock.h>
	39
	40	#include <linux/isdn/capilli.h>
	41
1da177e4 LT	42
	43	#include "cmtp.h"
	44
1da177e4 LT	45	static int cmtp_sock_release(struct socket *sock)
	46	{
	47	struct sock *sk = sock->sk;
	48
	49	BT_DBG("sock %p sk %p", sock, sk);
	50
	51	if (!sk)
	52	return 0;
	53
	54	sock_orphan(sk);
	55	sock_put(sk);
	56
	57	return 0;
	58	}
	59
	60	static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	61	{
	62	struct cmtp_connadd_req ca;
	63	struct cmtp_conndel_req cd;
	64	struct cmtp_connlist_req cl;
	65	struct cmtp_conninfo ci;
	66	struct socket *nsock;
	67	void __user argp = (void __user )arg;
	68	int err;
	69
	70	BT_DBG("cmd %x arg %lx", cmd, arg);
	71
	72	switch (cmd) {
	73	case CMTPCONNADD:
	74	if (!capable(CAP_NET_ADMIN))
bf5b30b8	75	return -EPERM;
1da177e4 LT	76
	77	if (copy_from_user(&ca, argp, sizeof(ca)))
	78	return -EFAULT;
	79
	80	nsock = sockfd_lookup(ca.sock, &err);
	81	if (!nsock)
	82	return err;
	83
	84	if (nsock->sk->sk_state != BT_CONNECTED) {
67b23219	85	sockfd_put(nsock);
1da177e4 LT	86	return -EBADFD;
	87	}
	88
	89	err = cmtp_add_connection(&ca, nsock);
	90	if (!err) {
	91	if (copy_to_user(argp, &ca, sizeof(ca)))
	92	err = -EFAULT;
	93	} else
67b23219	94	sockfd_put(nsock);
1da177e4 LT	95
	96	return err;
	97
	98	case CMTPCONNDEL:
	99	if (!capable(CAP_NET_ADMIN))
bf5b30b8	100	return -EPERM;
1da177e4 LT	101
	102	if (copy_from_user(&cd, argp, sizeof(cd)))
	103	return -EFAULT;
	104
	105	return cmtp_del_connection(&cd);
	106
	107	case CMTPGETCONNLIST:
	108	if (copy_from_user(&cl, argp, sizeof(cl)))
	109	return -EFAULT;
	110
	111	if (cl.cnum <= 0)
	112	return -EINVAL;
	113
	114	err = cmtp_get_connlist(&cl);
	115	if (!err && copy_to_user(argp, &cl, sizeof(cl)))
	116	return -EFAULT;
	117
	118	return err;
	119
	120	case CMTPGETCONNINFO:
	121	if (copy_from_user(&ci, argp, sizeof(ci)))
	122	return -EFAULT;
	123
	124	err = cmtp_get_conninfo(&ci);
	125	if (!err && copy_to_user(argp, &ci, sizeof(ci)))
	126	return -EFAULT;
	127
	128	return err;
	129	}
	130
	131	return -EINVAL;
	132	}
	133
e9c5702e MH	134	#ifdef CONFIG_COMPAT
	135	static int cmtp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	136	{
	137	if (cmd == CMTPGETCONNLIST) {
	138	struct cmtp_connlist_req cl;
816a11d5	139	u32 uci;
e9c5702e MH	140	int err;
e9c5702e MH	141
816a11d5	142	if (get_user(cl.cnum, (u32 __user *) arg) \|\|
e9c5702e MH	143	get_user(uci, (u32 __user *) (arg + 4)))
	144	return -EFAULT;
	145
	146	cl.ci = compat_ptr(uci);
	147
	148	if (cl.cnum <= 0)
	149	return -EINVAL;
8e87d142	150
e9c5702e MH	151	err = cmtp_get_connlist(&cl);
e9c5702e MH	152
816a11d5	153	if (!err && put_user(cl.cnum, (u32 __user *) arg))
e9c5702e MH	154	err = -EFAULT;
	155
	156	return err;
	157	}
	158
	159	return cmtp_sock_ioctl(sock, cmd, arg);
	160	}
	161	#endif
	162
90ddc4f0	163	static const struct proto_ops cmtp_sock_ops = {
1da177e4 LT	164	.family = PF_BLUETOOTH,
	165	.owner = THIS_MODULE,
	166	.release = cmtp_sock_release,
	167	.ioctl = cmtp_sock_ioctl,
e9c5702e MH	168	#ifdef CONFIG_COMPAT
	169	.compat_ioctl = cmtp_sock_compat_ioctl,
	170	#endif
1da177e4 LT	171	.bind = sock_no_bind,
	172	.getname = sock_no_getname,
	173	.sendmsg = sock_no_sendmsg,
	174	.recvmsg = sock_no_recvmsg,
	175	.poll = sock_no_poll,
	176	.listen = sock_no_listen,
	177	.shutdown = sock_no_shutdown,
	178	.setsockopt = sock_no_setsockopt,
	179	.getsockopt = sock_no_getsockopt,
	180	.connect = sock_no_connect,
	181	.socketpair = sock_no_socketpair,
	182	.accept = sock_no_accept,
	183	.mmap = sock_no_mmap
	184	};
	185
	186	static struct proto cmtp_proto = {
	187	.name = "CMTP",
	188	.owner = THIS_MODULE,
	189	.obj_size = sizeof(struct bt_sock)
	190	};
	191
3f378b68 EP	192	static int cmtp_sock_create(struct net net, struct socket sock, int protocol,
3f378b68 EP	193	int kern)
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	}