xref: /openbmc/linux/net/nfc/rawsock.c (revision b34e08d5)
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, see <http://www.gnu.org/licenses/>.
20  */
21 
22 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
23 
24 #include <net/tcp_states.h>
25 #include <linux/nfc.h>
26 #include <linux/export.h>
27 
28 #include "nfc.h"
29 
30 static void rawsock_write_queue_purge(struct sock *sk)
31 {
32 	pr_debug("sk=%p\n", sk);
33 
34 	spin_lock_bh(&sk->sk_write_queue.lock);
35 	__skb_queue_purge(&sk->sk_write_queue);
36 	nfc_rawsock(sk)->tx_work_scheduled = false;
37 	spin_unlock_bh(&sk->sk_write_queue.lock);
38 }
39 
40 static void rawsock_report_error(struct sock *sk, int err)
41 {
42 	pr_debug("sk=%p err=%d\n", sk, err);
43 
44 	sk->sk_shutdown = SHUTDOWN_MASK;
45 	sk->sk_err = -err;
46 	sk->sk_error_report(sk);
47 
48 	rawsock_write_queue_purge(sk);
49 }
50 
51 static int rawsock_release(struct socket *sock)
52 {
53 	struct sock *sk = sock->sk;
54 
55 	pr_debug("sock=%p sk=%p\n", 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 rawsock_connect(struct socket *sock, struct sockaddr *_addr,
67 			   int len, int flags)
68 {
69 	struct sock *sk = sock->sk;
70 	struct sockaddr_nfc *addr = (struct sockaddr_nfc *)_addr;
71 	struct nfc_dev *dev;
72 	int rc = 0;
73 
74 	pr_debug("sock=%p sk=%p flags=%d\n", sock, sk, flags);
75 
76 	if (!addr || len < sizeof(struct sockaddr_nfc) ||
77 	    addr->sa_family != AF_NFC)
78 		return -EINVAL;
79 
80 	pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
81 		 addr->dev_idx, addr->target_idx, addr->nfc_protocol);
82 
83 	lock_sock(sk);
84 
85 	if (sock->state == SS_CONNECTED) {
86 		rc = -EISCONN;
87 		goto error;
88 	}
89 
90 	dev = nfc_get_device(addr->dev_idx);
91 	if (!dev) {
92 		rc = -ENODEV;
93 		goto error;
94 	}
95 
96 	if (addr->target_idx > dev->target_next_idx - 1 ||
97 	    addr->target_idx < dev->target_next_idx - dev->n_targets) {
98 		rc = -EINVAL;
99 		goto error;
100 	}
101 
102 	rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
103 	if (rc)
104 		goto put_dev;
105 
106 	nfc_rawsock(sk)->dev = dev;
107 	nfc_rawsock(sk)->target_idx = addr->target_idx;
108 	sock->state = SS_CONNECTED;
109 	sk->sk_state = TCP_ESTABLISHED;
110 	sk->sk_state_change(sk);
111 
112 	release_sock(sk);
113 	return 0;
114 
115 put_dev:
116 	nfc_put_device(dev);
117 error:
118 	release_sock(sk);
119 	return rc;
120 }
121 
122 static int rawsock_add_header(struct sk_buff *skb)
123 {
124 	*skb_push(skb, NFC_HEADER_SIZE) = 0;
125 
126 	return 0;
127 }
128 
129 static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
130 					   int err)
131 {
132 	struct sock *sk = (struct sock *) context;
133 
134 	BUG_ON(in_irq());
135 
136 	pr_debug("sk=%p err=%d\n", sk, err);
137 
138 	if (err)
139 		goto error;
140 
141 	err = rawsock_add_header(skb);
142 	if (err)
143 		goto error_skb;
144 
145 	err = sock_queue_rcv_skb(sk, skb);
146 	if (err)
147 		goto error_skb;
148 
149 	spin_lock_bh(&sk->sk_write_queue.lock);
150 	if (!skb_queue_empty(&sk->sk_write_queue))
151 		schedule_work(&nfc_rawsock(sk)->tx_work);
152 	else
153 		nfc_rawsock(sk)->tx_work_scheduled = false;
154 	spin_unlock_bh(&sk->sk_write_queue.lock);
155 
156 	sock_put(sk);
157 	return;
158 
159 error_skb:
160 	kfree_skb(skb);
161 
162 error:
163 	rawsock_report_error(sk, err);
164 	sock_put(sk);
165 }
166 
167 static void rawsock_tx_work(struct work_struct *work)
168 {
169 	struct sock *sk = to_rawsock_sk(work);
170 	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
171 	u32 target_idx = nfc_rawsock(sk)->target_idx;
172 	struct sk_buff *skb;
173 	int rc;
174 
175 	pr_debug("sk=%p target_idx=%u\n", sk, target_idx);
176 
177 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
178 		rawsock_write_queue_purge(sk);
179 		return;
180 	}
181 
182 	skb = skb_dequeue(&sk->sk_write_queue);
183 
184 	sock_hold(sk);
185 	rc = nfc_data_exchange(dev, target_idx, skb,
186 			       rawsock_data_exchange_complete, sk);
187 	if (rc) {
188 		rawsock_report_error(sk, rc);
189 		sock_put(sk);
190 	}
191 }
192 
193 static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
194 			   struct msghdr *msg, size_t len)
195 {
196 	struct sock *sk = sock->sk;
197 	struct nfc_dev *dev = nfc_rawsock(sk)->dev;
198 	struct sk_buff *skb;
199 	int rc;
200 
201 	pr_debug("sock=%p sk=%p len=%zu\n", sock, sk, len);
202 
203 	if (msg->msg_namelen)
204 		return -EOPNOTSUPP;
205 
206 	if (sock->state != SS_CONNECTED)
207 		return -ENOTCONN;
208 
209 	skb = nfc_alloc_send_skb(dev, sk, msg->msg_flags, len, &rc);
210 	if (skb == NULL)
211 		return rc;
212 
213 	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
214 	if (rc < 0) {
215 		kfree_skb(skb);
216 		return rc;
217 	}
218 
219 	spin_lock_bh(&sk->sk_write_queue.lock);
220 	__skb_queue_tail(&sk->sk_write_queue, skb);
221 	if (!nfc_rawsock(sk)->tx_work_scheduled) {
222 		schedule_work(&nfc_rawsock(sk)->tx_work);
223 		nfc_rawsock(sk)->tx_work_scheduled = true;
224 	}
225 	spin_unlock_bh(&sk->sk_write_queue.lock);
226 
227 	return len;
228 }
229 
230 static int rawsock_recvmsg(struct kiocb *iocb, struct socket *sock,
231 			   struct msghdr *msg, size_t len, int flags)
232 {
233 	int noblock = flags & MSG_DONTWAIT;
234 	struct sock *sk = sock->sk;
235 	struct sk_buff *skb;
236 	int copied;
237 	int rc;
238 
239 	pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags);
240 
241 	skb = skb_recv_datagram(sk, flags, noblock, &rc);
242 	if (!skb)
243 		return rc;
244 
245 	copied = skb->len;
246 	if (len < copied) {
247 		msg->msg_flags |= MSG_TRUNC;
248 		copied = len;
249 	}
250 
251 	rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
252 
253 	skb_free_datagram(sk, skb);
254 
255 	return rc ? : copied;
256 }
257 
258 static const struct proto_ops rawsock_ops = {
259 	.family         = PF_NFC,
260 	.owner          = THIS_MODULE,
261 	.release        = rawsock_release,
262 	.bind           = sock_no_bind,
263 	.connect        = rawsock_connect,
264 	.socketpair     = sock_no_socketpair,
265 	.accept         = sock_no_accept,
266 	.getname        = sock_no_getname,
267 	.poll           = datagram_poll,
268 	.ioctl          = sock_no_ioctl,
269 	.listen         = sock_no_listen,
270 	.shutdown       = sock_no_shutdown,
271 	.setsockopt     = sock_no_setsockopt,
272 	.getsockopt     = sock_no_getsockopt,
273 	.sendmsg        = rawsock_sendmsg,
274 	.recvmsg        = rawsock_recvmsg,
275 	.mmap           = sock_no_mmap,
276 };
277 
278 static void rawsock_destruct(struct sock *sk)
279 {
280 	pr_debug("sk=%p\n", sk);
281 
282 	if (sk->sk_state == TCP_ESTABLISHED) {
283 		nfc_deactivate_target(nfc_rawsock(sk)->dev,
284 				      nfc_rawsock(sk)->target_idx);
285 		nfc_put_device(nfc_rawsock(sk)->dev);
286 	}
287 
288 	skb_queue_purge(&sk->sk_receive_queue);
289 
290 	if (!sock_flag(sk, SOCK_DEAD)) {
291 		pr_err("Freeing alive NFC raw socket %p\n", sk);
292 		return;
293 	}
294 }
295 
296 static int rawsock_create(struct net *net, struct socket *sock,
297 			  const struct nfc_protocol *nfc_proto)
298 {
299 	struct sock *sk;
300 
301 	pr_debug("sock=%p\n", sock);
302 
303 	if (sock->type != SOCK_SEQPACKET)
304 		return -ESOCKTNOSUPPORT;
305 
306 	sock->ops = &rawsock_ops;
307 
308 	sk = sk_alloc(net, PF_NFC, GFP_ATOMIC, nfc_proto->proto);
309 	if (!sk)
310 		return -ENOMEM;
311 
312 	sock_init_data(sock, sk);
313 	sk->sk_protocol = nfc_proto->id;
314 	sk->sk_destruct = rawsock_destruct;
315 	sock->state = SS_UNCONNECTED;
316 
317 	INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
318 	nfc_rawsock(sk)->tx_work_scheduled = false;
319 
320 	return 0;
321 }
322 
323 static struct proto rawsock_proto = {
324 	.name     = "NFC_RAW",
325 	.owner    = THIS_MODULE,
326 	.obj_size = sizeof(struct nfc_rawsock),
327 };
328 
329 static const struct nfc_protocol rawsock_nfc_proto = {
330 	.id	  = NFC_SOCKPROTO_RAW,
331 	.proto    = &rawsock_proto,
332 	.owner    = THIS_MODULE,
333 	.create   = rawsock_create
334 };
335 
336 int __init rawsock_init(void)
337 {
338 	int rc;
339 
340 	rc = nfc_proto_register(&rawsock_nfc_proto);
341 
342 	return rc;
343 }
344 
345 void rawsock_exit(void)
346 {
347 	nfc_proto_unregister(&rawsock_nfc_proto);
348 }
349