[deliverable/linux.git] / net / nfc / rawsock.c

/*
 * Copyright (C) 2011 Instituto Nokia de Tecnologia
 *
 * Authors:
 *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
 *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__

#include <net/tcp_states.h>
#include <linux/nfc.h>
#include <linux/export.h>

#include "nfc.h"

static void rawsock_write_queue_purge(struct sock *sk)
{
	pr_debug("sk=%p\n", sk);

	spin_lock_bh(&sk->sk_write_queue.lock);
	__skb_queue_purge(&sk->sk_write_queue);
	nfc_rawsock(sk)->tx_work_scheduled = false;
	spin_unlock_bh(&sk->sk_write_queue.lock);
}

static void rawsock_report_error(struct sock *sk, int err)
{
	pr_debug("sk=%p err=%d\n", sk, err);

	sk->sk_shutdown = SHUTDOWN_MASK;
	sk->sk_err = -err;
	sk->sk_error_report(sk);

	rawsock_write_queue_purge(sk);
}

static int rawsock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;

	pr_debug("sock=%p\n", sock);

	sock_orphan(sk);
	sock_put(sk);

	return 0;
}

static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
							int len, int flags)
{
	struct sock *sk = sock->sk;
	struct sockaddr_nfc *addr = (struct sockaddr_nfc *)_addr;
	struct nfc_dev *dev;
	int rc = 0;

	pr_debug("sock=%p sk=%p flags=%d\n", sock, sk, flags);

	if (!addr || len < sizeof(struct sockaddr_nfc) ||
		addr->sa_family != AF_NFC)
		return -EINVAL;

	pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
		 addr->dev_idx, addr->target_idx, addr->nfc_protocol);

	lock_sock(sk);

	if (sock->state == SS_CONNECTED) {
		rc = -EISCONN;
		goto error;
	}

	dev = nfc_get_device(addr->dev_idx);
	if (!dev) {
		rc = -ENODEV;
		goto error;
	}

	if (addr->target_idx > dev->target_idx - 1 ||
		addr->target_idx < dev->target_idx - dev->n_targets) {
		rc = -EINVAL;
		goto error;
	}

	if (addr->target_idx > dev->target_idx - 1 ||
		addr->target_idx < dev->target_idx - dev->n_targets) {
		rc = -EINVAL;
		goto error;
	}

	rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
	if (rc)
		goto put_dev;

	nfc_rawsock(sk)->dev = dev;
	nfc_rawsock(sk)->target_idx = addr->target_idx;
	sock->state = SS_CONNECTED;
	sk->sk_state = TCP_ESTABLISHED;
	sk->sk_state_change(sk);

	release_sock(sk);
	return 0;

put_dev:
	nfc_put_device(dev);
error:
	release_sock(sk);
	return rc;
}

static int rawsock_add_header(struct sk_buff *skb)
{
	*skb_push(skb, NFC_HEADER_SIZE) = 0;

	return 0;
}

static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
								int err)
{
	struct sock *sk = (struct sock *) context;

	BUG_ON(in_irq());

	pr_debug("sk=%p err=%d\n", sk, err);

	if (err)
		goto error;

	err = rawsock_add_header(skb);
	if (err)
		goto error;

	err = sock_queue_rcv_skb(sk, skb);
	if (err)
		goto error;

	spin_lock_bh(&sk->sk_write_queue.lock);
	if (!skb_queue_empty(&sk->sk_write_queue))
		schedule_work(&nfc_rawsock(sk)->tx_work);
	else
		nfc_rawsock(sk)->tx_work_scheduled = false;
	spin_unlock_bh(&sk->sk_write_queue.lock);

	sock_put(sk);
	return;

error:
	rawsock_report_error(sk, err);
	sock_put(sk);
}

static void rawsock_tx_work(struct work_struct *work)
{
	struct sock *sk = to_rawsock_sk(work);
	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
	u32 target_idx = nfc_rawsock(sk)->target_idx;
	struct sk_buff *skb;
	int rc;

	pr_debug("sk=%p target_idx=%u\n", sk, target_idx);

	if (sk->sk_shutdown & SEND_SHUTDOWN) {
		rawsock_write_queue_purge(sk);
		return;
	}

	skb = skb_dequeue(&sk->sk_write_queue);

	sock_hold(sk);
	rc = nfc_data_exchange(dev, target_idx, skb,
				rawsock_data_exchange_complete, sk);
	if (rc) {
		rawsock_report_error(sk, rc);
		sock_put(sk);
	}
}

static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
					struct msghdr *msg, size_t len)
{
	struct sock *sk = sock->sk;
	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
	struct sk_buff *skb;
	int rc;

	pr_debug("sock=%p sk=%p len=%zu\n", sock, sk, len);

	if (msg->msg_namelen)
		return -EOPNOTSUPP;

	if (sock->state != SS_CONNECTED)
		return -ENOTCONN;

	skb = sock_alloc_send_skb(sk, len + dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE,
					msg->msg_flags & MSG_DONTWAIT, &rc);
	if (!skb)
		return rc;

	skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);

	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
	if (rc < 0) {
		kfree_skb(skb);
		return rc;
	}

	spin_lock_bh(&sk->sk_write_queue.lock);
	__skb_queue_tail(&sk->sk_write_queue, skb);
	if (!nfc_rawsock(sk)->tx_work_scheduled) {
		schedule_work(&nfc_rawsock(sk)->tx_work);
		nfc_rawsock(sk)->tx_work_scheduled = true;
	}
	spin_unlock_bh(&sk->sk_write_queue.lock);

	return len;
}

static int rawsock_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	int copied;
	int rc;

	pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags);

	skb = skb_recv_datagram(sk, flags, noblock, &rc);
	if (!skb)
		return rc;

	msg->msg_namelen = 0;

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);

	skb_free_datagram(sk, skb);

	return rc ? : copied;
}


static const struct proto_ops rawsock_ops = {
	.family         = PF_NFC,
	.owner          = THIS_MODULE,
	.release        = rawsock_release,
	.bind           = sock_no_bind,
	.connect        = rawsock_connect,
	.socketpair     = sock_no_socketpair,
	.accept         = sock_no_accept,
	.getname        = sock_no_getname,
	.poll           = datagram_poll,
	.ioctl          = sock_no_ioctl,
	.listen         = sock_no_listen,
	.shutdown       = sock_no_shutdown,
	.setsockopt     = sock_no_setsockopt,
	.getsockopt     = sock_no_getsockopt,
	.sendmsg        = rawsock_sendmsg,
	.recvmsg        = rawsock_recvmsg,
	.mmap           = sock_no_mmap,
};

static void rawsock_destruct(struct sock *sk)
{
	pr_debug("sk=%p\n", sk);

	if (sk->sk_state == TCP_ESTABLISHED) {
		nfc_deactivate_target(nfc_rawsock(sk)->dev,
					nfc_rawsock(sk)->target_idx);
		nfc_put_device(nfc_rawsock(sk)->dev);
	}

	skb_queue_purge(&sk->sk_receive_queue);

	if (!sock_flag(sk, SOCK_DEAD)) {
		pr_err("Freeing alive NFC raw socket %p\n", sk);
		return;
	}
}

static int rawsock_create(struct net *net, struct socket *sock,
				const struct nfc_protocol *nfc_proto)
{
	struct sock *sk;

	pr_debug("sock=%p\n", sock);

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

	sock->ops = &rawsock_ops;

	sk = sk_alloc(net, PF_NFC, GFP_KERNEL, nfc_proto->proto);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);
	sk->sk_protocol = nfc_proto->id;
	sk->sk_destruct = rawsock_destruct;
	sock->state = SS_UNCONNECTED;

	INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
	nfc_rawsock(sk)->tx_work_scheduled = false;

	return 0;
}

static struct proto rawsock_proto = {
	.name     = "NFC_RAW",
	.owner    = THIS_MODULE,
	.obj_size = sizeof(struct nfc_rawsock),
};

static const struct nfc_protocol rawsock_nfc_proto = {
	.id	  = NFC_SOCKPROTO_RAW,
	.proto    = &rawsock_proto,
	.owner    = THIS_MODULE,
	.create   = rawsock_create
};

int __init rawsock_init(void)
{
	int rc;

	rc = nfc_proto_register(&rawsock_nfc_proto);

	return rc;
}

void rawsock_exit(void)
{
	nfc_proto_unregister(&rawsock_nfc_proto);
}
Commit	Line	Data
23b7869c LRV	1	/*
	2	* Copyright (C) 2011 Instituto Nokia de Tecnologia
	3	*
	4	* Authors:
	5	* Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
	6	* Lauro Ramos Venancio <lauro.venancio@openbossa.org>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the
	20	* Free Software Foundation, Inc.,
	21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*/
	23
52858b51	24	#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
ed1e0ad8	25
23b7869c LRV	26	#include <net/tcp_states.h>
23b7869c LRV	27	#include <linux/nfc.h>
bc3b2d7f	28	#include <linux/export.h>
23b7869c LRV	29
	30	#include "nfc.h"
	31
	32	static void rawsock_write_queue_purge(struct sock *sk)
	33	{
20c239c1	34	pr_debug("sk=%p\n", sk);
23b7869c LRV	35
	36	spin_lock_bh(&sk->sk_write_queue.lock);
	37	__skb_queue_purge(&sk->sk_write_queue);
	38	nfc_rawsock(sk)->tx_work_scheduled = false;
	39	spin_unlock_bh(&sk->sk_write_queue.lock);
	40	}
	41
	42	static void rawsock_report_error(struct sock *sk, int err)
	43	{
20c239c1	44	pr_debug("sk=%p err=%d\n", sk, err);
23b7869c LRV	45
	46	sk->sk_shutdown = SHUTDOWN_MASK;
	47	sk->sk_err = -err;
	48	sk->sk_error_report(sk);
	49
	50	rawsock_write_queue_purge(sk);
	51	}
	52
	53	static int rawsock_release(struct socket *sock)
	54	{
	55	struct sock *sk = sock->sk;
	56
20c239c1	57	pr_debug("sock=%p\n", sock);
23b7869c LRV	58
	59	sock_orphan(sk);
	60	sock_put(sk);
	61
	62	return 0;
	63	}
	64
	65	static int rawsock_connect(struct socket sock, struct sockaddr _addr,
	66	int len, int flags)
	67	{
	68	struct sock *sk = sock->sk;
	69	struct sockaddr_nfc addr = (struct sockaddr_nfc )_addr;
	70	struct nfc_dev *dev;
	71	int rc = 0;
	72
20c239c1	73	pr_debug("sock=%p sk=%p flags=%d\n", sock, sk, flags);
23b7869c LRV	74
	75	if (!addr \|\| len < sizeof(struct sockaddr_nfc) \|\|
	76	addr->sa_family != AF_NFC)
	77	return -EINVAL;
	78
20c239c1 JP	79	pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
20c239c1 JP	80	addr->dev_idx, addr->target_idx, addr->nfc_protocol);
23b7869c LRV	81
	82	lock_sock(sk);
	83
	84	if (sock->state == SS_CONNECTED) {
	85	rc = -EISCONN;
	86	goto error;
	87	}
	88
	89	dev = nfc_get_device(addr->dev_idx);
	90	if (!dev) {
	91	rc = -ENODEV;
	92	goto error;
	93	}
	94
	95	if (addr->target_idx > dev->target_idx - 1 \|\|
	96	addr->target_idx < dev->target_idx - dev->n_targets) {
	97	rc = -EINVAL;
	98	goto error;
	99	}
	100
	101	if (addr->target_idx > dev->target_idx - 1 \|\|
	102	addr->target_idx < dev->target_idx - dev->n_targets) {
	103	rc = -EINVAL;
	104	goto error;
	105	}
	106
	107	rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
	108	if (rc)
	109	goto put_dev;
	110
	111	nfc_rawsock(sk)->dev = dev;
	112	nfc_rawsock(sk)->target_idx = addr->target_idx;
	113	sock->state = SS_CONNECTED;
	114	sk->sk_state = TCP_ESTABLISHED;
	115	sk->sk_state_change(sk);
	116
	117	release_sock(sk);
	118	return 0;
	119
	120	put_dev:
	121	nfc_put_device(dev);
	122	error:
	123	release_sock(sk);
	124	return rc;
	125	}
	126
	127	static int rawsock_add_header(struct sk_buff *skb)
	128	{
e8753043	129	*skb_push(skb, NFC_HEADER_SIZE) = 0;
23b7869c LRV	130
	131	return 0;
	132	}
	133
	134	static void rawsock_data_exchange_complete(void context, struct sk_buff skb,
	135	int err)
	136	{
	137	struct sock sk = (struct sock ) context;
	138
	139	BUG_ON(in_irq());
	140
20c239c1	141	pr_debug("sk=%p err=%d\n", sk, err);
23b7869c LRV	142
	143	if (err)
	144	goto error;
	145
	146	err = rawsock_add_header(skb);
	147	if (err)
	148	goto error;
	149
	150	err = sock_queue_rcv_skb(sk, skb);
	151	if (err)
	152	goto error;
	153
	154	spin_lock_bh(&sk->sk_write_queue.lock);
	155	if (!skb_queue_empty(&sk->sk_write_queue))
	156	schedule_work(&nfc_rawsock(sk)->tx_work);
	157	else
	158	nfc_rawsock(sk)->tx_work_scheduled = false;
	159	spin_unlock_bh(&sk->sk_write_queue.lock);
	160
	161	sock_put(sk);
	162	return;
	163
	164	error:
	165	rawsock_report_error(sk, err);
	166	sock_put(sk);
	167	}
	168
	169	static void rawsock_tx_work(struct work_struct *work)
	170	{
	171	struct sock *sk = to_rawsock_sk(work);
	172	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
	173	u32 target_idx = nfc_rawsock(sk)->target_idx;
	174	struct sk_buff *skb;
	175	int rc;
	176
20c239c1	177	pr_debug("sk=%p target_idx=%u\n", sk, target_idx);
23b7869c LRV	178
	179	if (sk->sk_shutdown & SEND_SHUTDOWN) {
	180	rawsock_write_queue_purge(sk);
	181	return;
	182	}
	183
	184	skb = skb_dequeue(&sk->sk_write_queue);
	185
	186	sock_hold(sk);
	187	rc = nfc_data_exchange(dev, target_idx, skb,
	188	rawsock_data_exchange_complete, sk);
	189	if (rc) {
	190	rawsock_report_error(sk, rc);
	191	sock_put(sk);
	192	}
	193	}
	194
	195	static int rawsock_sendmsg(struct kiocb iocb, struct socket sock,
	196	struct msghdr *msg, size_t len)
	197	{
	198	struct sock *sk = sock->sk;
e8753043	199	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
23b7869c LRV	200	struct sk_buff *skb;
	201	int rc;
	202
20c239c1	203	pr_debug("sock=%p sk=%p len=%zu\n", sock, sk, len);
23b7869c LRV	204
	205	if (msg->msg_namelen)
	206	return -EOPNOTSUPP;
	207
	208	if (sock->state != SS_CONNECTED)
	209	return -ENOTCONN;
	210
e8753043 SO	211	skb = sock_alloc_send_skb(sk, len + dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE,
e8753043 SO	212	msg->msg_flags & MSG_DONTWAIT, &rc);
23b7869c LRV	213	if (!skb)
	214	return rc;
	215
e8753043 SO	216	skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
e8753043 SO	217
23b7869c LRV	218	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
	219	if (rc < 0) {
	220	kfree_skb(skb);
	221	return rc;
	222	}
	223
	224	spin_lock_bh(&sk->sk_write_queue.lock);
	225	__skb_queue_tail(&sk->sk_write_queue, skb);
	226	if (!nfc_rawsock(sk)->tx_work_scheduled) {
	227	schedule_work(&nfc_rawsock(sk)->tx_work);
	228	nfc_rawsock(sk)->tx_work_scheduled = true;
	229	}
	230	spin_unlock_bh(&sk->sk_write_queue.lock);
	231
	232	return len;
	233	}
	234
	235	static int rawsock_recvmsg(struct kiocb iocb, struct socket sock,
	236	struct msghdr *msg, size_t len, int flags)
	237	{
	238	int noblock = flags & MSG_DONTWAIT;
	239	struct sock *sk = sock->sk;
	240	struct sk_buff *skb;
	241	int copied;
	242	int rc;
	243
20c239c1	244	pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags);
23b7869c LRV	245
	246	skb = skb_recv_datagram(sk, flags, noblock, &rc);
	247	if (!skb)
	248	return rc;
	249
	250	msg->msg_namelen = 0;
	251
	252	copied = skb->len;
	253	if (len < copied) {
	254	msg->msg_flags \|= MSG_TRUNC;
	255	copied = len;
	256	}
	257
	258	rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	259
	260	skb_free_datagram(sk, skb);
	261
	262	return rc ? : copied;
	263	}
	264
	265
	266	static const struct proto_ops rawsock_ops = {
	267	.family = PF_NFC,
	268	.owner = THIS_MODULE,
	269	.release = rawsock_release,
	270	.bind = sock_no_bind,
	271	.connect = rawsock_connect,
	272	.socketpair = sock_no_socketpair,
	273	.accept = sock_no_accept,
	274	.getname = sock_no_getname,
	275	.poll = datagram_poll,
	276	.ioctl = sock_no_ioctl,
	277	.listen = sock_no_listen,
	278	.shutdown = sock_no_shutdown,
	279	.setsockopt = sock_no_setsockopt,
	280	.getsockopt = sock_no_getsockopt,
	281	.sendmsg = rawsock_sendmsg,
	282	.recvmsg = rawsock_recvmsg,
	283	.mmap = sock_no_mmap,
	284	};
	285
	286	static void rawsock_destruct(struct sock *sk)
	287	{
20c239c1	288	pr_debug("sk=%p\n", sk);
23b7869c LRV	289
	290	if (sk->sk_state == TCP_ESTABLISHED) {
	291	nfc_deactivate_target(nfc_rawsock(sk)->dev,
	292	nfc_rawsock(sk)->target_idx);
	293	nfc_put_device(nfc_rawsock(sk)->dev);
	294	}
	295
	296	skb_queue_purge(&sk->sk_receive_queue);
	297
	298	if (!sock_flag(sk, SOCK_DEAD)) {
ed1e0ad8	299	pr_err("Freeing alive NFC raw socket %p\n", sk);
23b7869c LRV	300	return;
	301	}
	302	}
	303
	304	static int rawsock_create(struct net net, struct socket sock,
	305	const struct nfc_protocol *nfc_proto)
	306	{
	307	struct sock *sk;
	308
20c239c1	309	pr_debug("sock=%p\n", sock);
23b7869c LRV	310
	311	if (sock->type != SOCK_SEQPACKET)
	312	return -ESOCKTNOSUPPORT;
	313
	314	sock->ops = &rawsock_ops;
	315
	316	sk = sk_alloc(net, PF_NFC, GFP_KERNEL, nfc_proto->proto);
	317	if (!sk)
	318	return -ENOMEM;
	319
	320	sock_init_data(sock, sk);
	321	sk->sk_protocol = nfc_proto->id;
	322	sk->sk_destruct = rawsock_destruct;
	323	sock->state = SS_UNCONNECTED;
	324
	325	INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
	326	nfc_rawsock(sk)->tx_work_scheduled = false;
	327
	328	return 0;
	329	}
	330
	331	static struct proto rawsock_proto = {
	332	.name = "NFC_RAW",
	333	.owner = THIS_MODULE,
	334	.obj_size = sizeof(struct nfc_rawsock),
	335	};
	336
	337	static const struct nfc_protocol rawsock_nfc_proto = {
	338	.id = NFC_SOCKPROTO_RAW,
	339	.proto = &rawsock_proto,
	340	.owner = THIS_MODULE,
	341	.create = rawsock_create
	342	};
	343
	344	int __init rawsock_init(void)
	345	{
	346	int rc;
	347
	348	rc = nfc_proto_register(&rawsock_nfc_proto);
	349
	350	return rc;
	351	}
	352
	353	void rawsock_exit(void)
	354	{
	355	nfc_proto_unregister(&rawsock_nfc_proto);
	356	}