projects/linux·blob master · refs

1105 lines · 23.2 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2011 Intel Corporation. All rights reserved.
4 */
5
6#define pr_fmt(fmt) "llcp: %s: " fmt, __func__
7
8#include <linux/init.h>
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/nfc.h>
12#include <linux/sched/signal.h>
13
14#include "nfc.h"
15#include "llcp.h"
16
17static int sock_wait_state(struct sock *sk, int state, unsigned long timeo)
18{
19 DECLARE_WAITQUEUE(wait, current);
20 int err = 0;
21
22 pr_debug("sk %p", sk);
23
24 add_wait_queue(sk_sleep(sk), &wait);
25 set_current_state(TASK_INTERRUPTIBLE);
26
27 while (sk->sk_state != state) {
28 if (!timeo) {
29 err = -EINPROGRESS;
30 break;
31 }
32
33 if (signal_pending(current)) {
34 err = sock_intr_errno(timeo);
35 break;
36 }
37
38 release_sock(sk);
39 timeo = schedule_timeout(timeo);
40 lock_sock(sk);
41 set_current_state(TASK_INTERRUPTIBLE);
42
43 err = sock_error(sk);
44 if (err)
45 break;
46 }
47
48 __set_current_state(TASK_RUNNING);
49 remove_wait_queue(sk_sleep(sk), &wait);
50 return err;
51}
52
53static struct proto llcp_sock_proto = {
54 .name = "NFC_LLCP",
55 .owner = THIS_MODULE,
56 .obj_size = sizeof(struct nfc_llcp_sock),
57};
58
59static int llcp_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int alen)
60{
61 struct sock *sk = sock->sk;
62 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
63 struct nfc_llcp_local *local;
64 struct nfc_dev *dev;
65 struct sockaddr_nfc_llcp llcp_addr;
66 int len, ret = 0;
67
68 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
69 addr->sa_family != AF_NFC)
70 return -EINVAL;
71
72 pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
73
74 memset(&llcp_addr, 0, sizeof(llcp_addr));
75 len = min_t(unsigned int, sizeof(llcp_addr), alen);
76 memcpy(&llcp_addr, addr, len);
77
78 /* This is going to be a listening socket, dsap must be 0 */
79 if (llcp_addr.dsap != 0)
80 return -EINVAL;
81
82 lock_sock(sk);
83
84 if (sk->sk_state != LLCP_CLOSED) {
85 ret = -EBADFD;
86 goto error;
87 }
88
89 dev = nfc_get_device(llcp_addr.dev_idx);
90 if (dev == NULL) {
91 ret = -ENODEV;
92 goto error;
93 }
94
95 local = nfc_llcp_find_local(dev);
96 if (local == NULL) {
97 ret = -ENODEV;
98 goto put_dev;
99 }
100
101 llcp_sock->dev = dev;
102 llcp_sock->local = local;
103 llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
104 llcp_sock->service_name_len = min_t(unsigned int,
105 llcp_addr.service_name_len,
106 NFC_LLCP_MAX_SERVICE_NAME);
107 llcp_sock->service_name = kmemdup(llcp_addr.service_name,
108 llcp_sock->service_name_len,
109 GFP_KERNEL);
110 if (!llcp_sock->service_name) {
111 ret = -ENOMEM;
112 goto sock_llcp_put_local;
113 }
114 llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);
115 if (llcp_sock->ssap == LLCP_SAP_MAX) {
116 ret = -EADDRINUSE;
117 goto free_service_name;
118 }
119
120 llcp_sock->reserved_ssap = llcp_sock->ssap;
121
122 nfc_llcp_sock_link(&local->sockets, sk);
123
124 pr_debug("Socket bound to SAP %d\n", llcp_sock->ssap);
125
126 sk->sk_state = LLCP_BOUND;
127 nfc_put_device(dev);
128 release_sock(sk);
129
130 return 0;
131
132free_service_name:
133 kfree(llcp_sock->service_name);
134 llcp_sock->service_name = NULL;
135
136sock_llcp_put_local:
137 nfc_llcp_local_put(llcp_sock->local);
138 llcp_sock->local = NULL;
139 llcp_sock->dev = NULL;
140
141put_dev:
142 nfc_put_device(dev);
143
144error:
145 release_sock(sk);
146 return ret;
147}
148
149static int llcp_raw_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
150 int alen)
151{
152 struct sock *sk = sock->sk;
153 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
154 struct nfc_llcp_local *local;
155 struct nfc_dev *dev;
156 struct sockaddr_nfc_llcp llcp_addr;
157 int len, ret = 0;
158
159 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
160 addr->sa_family != AF_NFC)
161 return -EINVAL;
162
163 pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
164
165 memset(&llcp_addr, 0, sizeof(llcp_addr));
166 len = min_t(unsigned int, sizeof(llcp_addr), alen);
167 memcpy(&llcp_addr, addr, len);
168
169 lock_sock(sk);
170
171 if (sk->sk_state != LLCP_CLOSED) {
172 ret = -EBADFD;
173 goto error;
174 }
175
176 dev = nfc_get_device(llcp_addr.dev_idx);
177 if (dev == NULL) {
178 ret = -ENODEV;
179 goto error;
180 }
181
182 local = nfc_llcp_find_local(dev);
183 if (local == NULL) {
184 ret = -ENODEV;
185 goto put_dev;
186 }
187
188 llcp_sock->dev = dev;
189 llcp_sock->local = local;
190 llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
191
192 nfc_llcp_sock_link(&local->raw_sockets, sk);
193
194 sk->sk_state = LLCP_BOUND;
195
196put_dev:
197 nfc_put_device(dev);
198
199error:
200 release_sock(sk);
201 return ret;
202}
203
204static int llcp_sock_listen(struct socket *sock, int backlog)
205{
206 struct sock *sk = sock->sk;
207 int ret = 0;
208
209 pr_debug("sk %p backlog %d\n", sk, backlog);
210
211 lock_sock(sk);
212
213 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM) ||
214 sk->sk_state != LLCP_BOUND) {
215 ret = -EBADFD;
216 goto error;
217 }
218
219 sk->sk_max_ack_backlog = backlog;
220 sk->sk_ack_backlog = 0;
221
222 pr_debug("Socket listening\n");
223 sk->sk_state = LLCP_LISTEN;
224
225error:
226 release_sock(sk);
227
228 return ret;
229}
230
231static int nfc_llcp_setsockopt(struct socket *sock, int level, int optname,
232 sockptr_t optval, unsigned int optlen)
233{
234 struct sock *sk = sock->sk;
235 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
236 u32 opt;
237 int err = 0;
238
239 pr_debug("%p optname %d\n", sk, optname);
240
241 if (level != SOL_NFC)
242 return -ENOPROTOOPT;
243
244 lock_sock(sk);
245
246 switch (optname) {
247 case NFC_LLCP_RW:
248 if (sk->sk_state == LLCP_CONNECTED ||
249 sk->sk_state == LLCP_BOUND ||
250 sk->sk_state == LLCP_LISTEN) {
251 err = -EINVAL;
252 break;
253 }
254
255 err = copy_safe_from_sockptr(&opt, sizeof(opt),
256 optval, optlen);
257 if (err)
258 break;
259
260 if (opt > LLCP_MAX_RW) {
261 err = -EINVAL;
262 break;
263 }
264
265 llcp_sock->rw = (u8) opt;
266
267 break;
268
269 case NFC_LLCP_MIUX:
270 if (sk->sk_state == LLCP_CONNECTED ||
271 sk->sk_state == LLCP_BOUND ||
272 sk->sk_state == LLCP_LISTEN) {
273 err = -EINVAL;
274 break;
275 }
276
277 err = copy_safe_from_sockptr(&opt, sizeof(opt),
278 optval, optlen);
279 if (err)
280 break;
281
282 if (opt > LLCP_MAX_MIUX) {
283 err = -EINVAL;
284 break;
285 }
286
287 llcp_sock->miux = cpu_to_be16((u16) opt);
288
289 break;
290
291 default:
292 err = -ENOPROTOOPT;
293 break;
294 }
295
296 release_sock(sk);
297
298 pr_debug("%p rw %d miux %d\n", llcp_sock,
299 llcp_sock->rw, llcp_sock->miux);
300
301 return err;
302}
303
304static int nfc_llcp_getsockopt(struct socket *sock, int level, int optname,
305 char __user *optval, int __user *optlen)
306{
307 struct nfc_llcp_local *local;
308 struct sock *sk = sock->sk;
309 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
310 int len, err = 0;
311 u16 miux, remote_miu;
312 u8 rw;
313
314 pr_debug("%p optname %d\n", sk, optname);
315
316 if (level != SOL_NFC)
317 return -ENOPROTOOPT;
318
319 if (get_user(len, optlen))
320 return -EFAULT;
321
322 if (len < 0)
323 return -EINVAL;
324
325 if (len < sizeof(u32))
326 return -EINVAL;
327
328 len = min_t(u32, len, sizeof(u32));
329
330 lock_sock(sk);
331
332 local = llcp_sock->local;
333 if (!local) {
334 release_sock(sk);
335 return -ENODEV;
336 }
337
338 switch (optname) {
339 case NFC_LLCP_RW:
340 rw = llcp_sock->rw > LLCP_MAX_RW ? local->rw : llcp_sock->rw;
341 if (put_user(rw, (u32 __user *) optval))
342 err = -EFAULT;
343
344 break;
345
346 case NFC_LLCP_MIUX:
347 miux = be16_to_cpu(llcp_sock->miux) > LLCP_MAX_MIUX ?
348 be16_to_cpu(local->miux) : be16_to_cpu(llcp_sock->miux);
349
350 if (put_user(miux, (u32 __user *) optval))
351 err = -EFAULT;
352
353 break;
354
355 case NFC_LLCP_REMOTE_MIU:
356 remote_miu = llcp_sock->remote_miu > LLCP_MAX_MIU ?
357 local->remote_miu : llcp_sock->remote_miu;
358
359 if (put_user(remote_miu, (u32 __user *) optval))
360 err = -EFAULT;
361
362 break;
363
364 case NFC_LLCP_REMOTE_LTO:
365 if (put_user(local->remote_lto / 10, (u32 __user *) optval))
366 err = -EFAULT;
367
368 break;
369
370 case NFC_LLCP_REMOTE_RW:
371 if (put_user(llcp_sock->remote_rw, (u32 __user *) optval))
372 err = -EFAULT;
373
374 break;
375
376 default:
377 err = -ENOPROTOOPT;
378 break;
379 }
380
381 release_sock(sk);
382
383 if (put_user(len, optlen))
384 return -EFAULT;
385
386 return err;
387}
388
389void nfc_llcp_accept_unlink(struct sock *sk)
390{
391 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
392
393 pr_debug("state %d\n", sk->sk_state);
394
395 if (llcp_sock->parent) {
396 list_del_init(&llcp_sock->accept_queue);
397 sk_acceptq_removed(llcp_sock->parent);
398 llcp_sock->parent = NULL;
399 sock_put(sk);
400 }
401}
402
403void nfc_llcp_accept_enqueue(struct sock *parent, struct sock *sk)
404{
405 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
406 struct nfc_llcp_sock *llcp_sock_parent = nfc_llcp_sock(parent);
407
408 /* Lock will be free from unlink */
409 sock_hold(sk);
410
411 list_add_tail(&llcp_sock->accept_queue,
412 &llcp_sock_parent->accept_queue);
413 llcp_sock->parent = parent;
414 sk_acceptq_added(parent);
415}
416
417struct sock *nfc_llcp_accept_dequeue(struct sock *parent,
418 struct socket *newsock)
419{
420 struct nfc_llcp_sock *lsk, *n, *llcp_parent;
421 struct sock *sk;
422
423 llcp_parent = nfc_llcp_sock(parent);
424
425 list_for_each_entry_safe(lsk, n, &llcp_parent->accept_queue,
426 accept_queue) {
427 struct nfc_llcp_local *local;
428
429 sk = &lsk->sk;
430 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
431
432 if (sk->sk_state == LLCP_CLOSED) {
433 local = nfc_llcp_sock(sk)->local;
434
435 nfc_llcp_accept_unlink(sk);
436 if (local)
437 nfc_llcp_sock_unlink(&local->sockets, sk);
438 sock_orphan(sk);
439 release_sock(sk);
440 sock_put(sk);
441 continue;
442 }
443
444 if (sk->sk_state == LLCP_CONNECTED || !newsock) {
445 list_del_init(&lsk->accept_queue);
446 sock_put(sk);
447
448 if (newsock)
449 sock_graft(sk, newsock);
450
451 release_sock(sk);
452
453 pr_debug("Returning sk state %d\n", sk->sk_state);
454
455 sk_acceptq_removed(parent);
456
457 return sk;
458 }
459
460 release_sock(sk);
461 }
462
463 return NULL;
464}
465
466static int llcp_sock_accept(struct socket *sock, struct socket *newsock,
467 struct proto_accept_arg *arg)
468{
469 DECLARE_WAITQUEUE(wait, current);
470 struct sock *sk = sock->sk, *new_sk;
471 long timeo;
472 int ret = 0;
473
474 pr_debug("parent %p\n", sk);
475
476 lock_sock(sk);
477
478 if (sk->sk_state != LLCP_LISTEN) {
479 ret = -EBADFD;
480 goto error;
481 }
482
483 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
484
485 /* Wait for an incoming connection. */
486 add_wait_queue_exclusive(sk_sleep(sk), &wait);
487 while (!(new_sk = nfc_llcp_accept_dequeue(sk, newsock))) {
488 set_current_state(TASK_INTERRUPTIBLE);
489
490 if (!timeo) {
491 ret = -EAGAIN;
492 break;
493 }
494
495 if (signal_pending(current)) {
496 ret = sock_intr_errno(timeo);
497 break;
498 }
499
500 release_sock(sk);
501 timeo = schedule_timeout(timeo);
502 lock_sock(sk);
503
504 if (sk->sk_state != LLCP_LISTEN) {
505 ret = -EBADFD;
506 break;
507 }
508 }
509 __set_current_state(TASK_RUNNING);
510 remove_wait_queue(sk_sleep(sk), &wait);
511
512 if (ret)
513 goto error;
514
515 newsock->state = SS_CONNECTED;
516
517 pr_debug("new socket %p\n", new_sk);
518
519error:
520 release_sock(sk);
521
522 return ret;
523}
524
525static int llcp_sock_getname(struct socket *sock, struct sockaddr *uaddr,
526 int peer)
527{
528 struct sock *sk = sock->sk;
529 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
530 DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, llcp_addr, uaddr);
531
532 if (llcp_sock == NULL || llcp_sock->dev == NULL)
533 return -EBADFD;
534
535 pr_debug("%p %d %d %d\n", sk, llcp_sock->target_idx,
536 llcp_sock->dsap, llcp_sock->ssap);
537
538 memset(llcp_addr, 0, sizeof(*llcp_addr));
539
540 lock_sock(sk);
541 if (!llcp_sock->dev) {
542 release_sock(sk);
543 return -EBADFD;
544 }
545 llcp_addr->sa_family = AF_NFC;
546 llcp_addr->dev_idx = llcp_sock->dev->idx;
547 llcp_addr->target_idx = llcp_sock->target_idx;
548 llcp_addr->nfc_protocol = llcp_sock->nfc_protocol;
549 llcp_addr->dsap = llcp_sock->dsap;
550 llcp_addr->ssap = llcp_sock->ssap;
551 llcp_addr->service_name_len = llcp_sock->service_name_len;
552 memcpy(llcp_addr->service_name, llcp_sock->service_name,
553 llcp_addr->service_name_len);
554 release_sock(sk);
555
556 return sizeof(struct sockaddr_nfc_llcp);
557}
558
559static inline __poll_t llcp_accept_poll(struct sock *parent)
560{
561 struct nfc_llcp_sock *llcp_sock, *parent_sock;
562 struct sock *sk;
563
564 parent_sock = nfc_llcp_sock(parent);
565
566 list_for_each_entry(llcp_sock, &parent_sock->accept_queue,
567 accept_queue) {
568 sk = &llcp_sock->sk;
569
570 if (sk->sk_state == LLCP_CONNECTED)
571 return EPOLLIN | EPOLLRDNORM;
572 }
573
574 return 0;
575}
576
577static __poll_t llcp_sock_poll(struct file *file, struct socket *sock,
578 poll_table *wait)
579{
580 struct sock *sk = sock->sk;
581 __poll_t mask = 0;
582
583 pr_debug("%p\n", sk);
584
585 sock_poll_wait(file, sock, wait);
586
587 if (sk->sk_state == LLCP_LISTEN)
588 return llcp_accept_poll(sk);
589
590 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
591 mask |= EPOLLERR |
592 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
593
594 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
595 mask |= EPOLLIN | EPOLLRDNORM;
596
597 if (sk->sk_state == LLCP_CLOSED)
598 mask |= EPOLLHUP;
599
600 if (sk->sk_shutdown & RCV_SHUTDOWN)
601 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
602
603 if (sk->sk_shutdown == SHUTDOWN_MASK)
604 mask |= EPOLLHUP;
605
606 if (sock_writeable(sk) && sk->sk_state == LLCP_CONNECTED)
607 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
608 else
609 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
610
611 pr_debug("mask 0x%x\n", mask);
612
613 return mask;
614}
615
616static int llcp_sock_release(struct socket *sock)
617{
618 struct sock *sk = sock->sk;
619 struct nfc_llcp_local *local;
620 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
621 int err = 0;
622
623 if (!sk)
624 return 0;
625
626 pr_debug("%p\n", sk);
627
628 local = llcp_sock->local;
629 if (local == NULL) {
630 err = -ENODEV;
631 goto out;
632 }
633
634 lock_sock(sk);
635
636 /* Send a DISC */
637 if (sk->sk_state == LLCP_CONNECTED)
638 nfc_llcp_send_disconnect(llcp_sock);
639
640 if (sk->sk_state == LLCP_LISTEN) {
641 struct nfc_llcp_sock *lsk, *n;
642 struct sock *accept_sk;
643
644 list_for_each_entry_safe(lsk, n, &llcp_sock->accept_queue,
645 accept_queue) {
646 bool put_creation = false;
647
648 accept_sk = &lsk->sk;
649 lock_sock_nested(accept_sk, SINGLE_DEPTH_NESTING);
650
651 if (nfc_llcp_sock(accept_sk)->parent == sk) {
652 nfc_llcp_send_disconnect(lsk);
653 nfc_llcp_accept_unlink(accept_sk);
654 nfc_llcp_sock_unlink(&local->sockets, accept_sk);
655
656 accept_sk->sk_state = LLCP_CLOSED;
657 sock_orphan(accept_sk);
658 put_creation = true;
659 }
660
661 release_sock(accept_sk);
662 if (put_creation)
663 sock_put(accept_sk); /* creation ref */
664 }
665 }
666
667 if (sock->type == SOCK_RAW)
668 nfc_llcp_sock_unlink(&local->raw_sockets, sk);
669 else if (sk->sk_state == LLCP_CONNECTING)
670 nfc_llcp_sock_unlink(&local->connecting_sockets, sk);
671 else
672 nfc_llcp_sock_unlink(&local->sockets, sk);
673
674 if (llcp_sock->reserved_ssap < LLCP_SAP_MAX)
675 nfc_llcp_put_ssap(llcp_sock->local, llcp_sock->ssap);
676
677 release_sock(sk);
678
679out:
680 sock_orphan(sk);
681 sock_put(sk);
682
683 return err;
684}
685
686static int llcp_sock_connect(struct socket *sock, struct sockaddr_unsized *_addr,
687 int len, int flags)
688{
689 struct sock *sk = sock->sk;
690 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
691 struct sockaddr_nfc_llcp *addr = (struct sockaddr_nfc_llcp *)_addr;
692 struct nfc_dev *dev;
693 struct nfc_llcp_local *local;
694 int ret = 0;
695
696 pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags);
697
698 if (!addr || len < sizeof(*addr) || addr->sa_family != AF_NFC)
699 return -EINVAL;
700
701 if (addr->service_name_len == 0 && addr->dsap == 0)
702 return -EINVAL;
703
704 pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n", addr->dev_idx,
705 addr->target_idx, addr->nfc_protocol);
706
707 lock_sock(sk);
708
709 if (sk->sk_state == LLCP_CONNECTED) {
710 ret = -EISCONN;
711 goto error;
712 }
713 if (sk->sk_state == LLCP_CONNECTING) {
714 ret = -EINPROGRESS;
715 goto error;
716 }
717
718 dev = nfc_get_device(addr->dev_idx);
719 if (dev == NULL) {
720 ret = -ENODEV;
721 goto error;
722 }
723
724 local = nfc_llcp_find_local(dev);
725 if (local == NULL) {
726 ret = -ENODEV;
727 goto put_dev;
728 }
729
730 device_lock(&dev->dev);
731 if (dev->dep_link_up == false) {
732 ret = -ENOLINK;
733 device_unlock(&dev->dev);
734 goto sock_llcp_put_local;
735 }
736 device_unlock(&dev->dev);
737
738 if (local->rf_mode == NFC_RF_INITIATOR &&
739 addr->target_idx != local->target_idx) {
740 ret = -ENOLINK;
741 goto sock_llcp_put_local;
742 }
743
744 llcp_sock->dev = dev;
745 llcp_sock->local = local;
746 llcp_sock->ssap = nfc_llcp_get_local_ssap(local);
747 if (llcp_sock->ssap == LLCP_SAP_MAX) {
748 ret = -ENOMEM;
749 goto sock_llcp_nullify;
750 }
751
752 llcp_sock->reserved_ssap = llcp_sock->ssap;
753
754 if (addr->service_name_len == 0)
755 llcp_sock->dsap = addr->dsap;
756 else
757 llcp_sock->dsap = LLCP_SAP_SDP;
758 llcp_sock->nfc_protocol = addr->nfc_protocol;
759 llcp_sock->service_name_len = min_t(unsigned int,
760 addr->service_name_len,
761 NFC_LLCP_MAX_SERVICE_NAME);
762 if (llcp_sock->service_name_len == 0) {
763 llcp_sock->service_name = NULL;
764 } else {
765 llcp_sock->service_name = kmemdup(addr->service_name,
766 llcp_sock->service_name_len,
767 GFP_KERNEL);
768 if (!llcp_sock->service_name) {
769 ret = -ENOMEM;
770 goto sock_llcp_release;
771 }
772 }
773
774 nfc_llcp_sock_link(&local->connecting_sockets, sk);
775
776 ret = nfc_llcp_send_connect(llcp_sock);
777 if (ret)
778 goto sock_unlink;
779
780 sk->sk_state = LLCP_CONNECTING;
781
782 ret = sock_wait_state(sk, LLCP_CONNECTED,
783 sock_sndtimeo(sk, flags & O_NONBLOCK));
784 if (ret && ret != -EINPROGRESS)
785 goto sock_unlink;
786
787 release_sock(sk);
788
789 return ret;
790
791sock_unlink:
792 nfc_llcp_sock_unlink(&local->connecting_sockets, sk);
793 kfree(llcp_sock->service_name);
794 llcp_sock->service_name = NULL;
795
796sock_llcp_release:
797 nfc_llcp_put_ssap(local, llcp_sock->ssap);
798
799sock_llcp_nullify:
800 llcp_sock->local = NULL;
801 llcp_sock->dev = NULL;
802
803sock_llcp_put_local:
804 nfc_llcp_local_put(local);
805
806put_dev:
807 nfc_put_device(dev);
808
809error:
810 release_sock(sk);
811 return ret;
812}
813
814static int llcp_sock_sendmsg(struct socket *sock, struct msghdr *msg,
815 size_t len)
816{
817 struct sock *sk = sock->sk;
818 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
819 int ret;
820
821 pr_debug("sock %p sk %p", sock, sk);
822
823 ret = sock_error(sk);
824 if (ret)
825 return ret;
826
827 if (msg->msg_flags & MSG_OOB)
828 return -EOPNOTSUPP;
829
830 lock_sock(sk);
831
832 if (!llcp_sock->local) {
833 release_sock(sk);
834 return -ENODEV;
835 }
836
837 if (sk->sk_type == SOCK_DGRAM) {
838 if (sk->sk_state != LLCP_BOUND) {
839 release_sock(sk);
840 return -ENOTCONN;
841 }
842
843 DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, addr,
844 msg->msg_name);
845
846 if (msg->msg_namelen < sizeof(*addr)) {
847 release_sock(sk);
848 return -EINVAL;
849 }
850
851 release_sock(sk);
852
853 return nfc_llcp_send_ui_frame(llcp_sock, addr->dsap, addr->ssap,
854 msg, len);
855 }
856
857 if (sk->sk_state != LLCP_CONNECTED) {
858 release_sock(sk);
859 return -ENOTCONN;
860 }
861
862 release_sock(sk);
863
864 return nfc_llcp_send_i_frame(llcp_sock, msg, len);
865}
866
867static int llcp_sock_recvmsg(struct socket *sock, struct msghdr *msg,
868 size_t len, int flags)
869{
870 struct sock *sk = sock->sk;
871 unsigned int copied, rlen;
872 struct sk_buff *skb, *cskb;
873 int err = 0;
874
875 pr_debug("%p %zu\n", sk, len);
876
877 lock_sock(sk);
878
879 if (sk->sk_state == LLCP_CLOSED &&
880 skb_queue_empty(&sk->sk_receive_queue)) {
881 release_sock(sk);
882 return 0;
883 }
884
885 release_sock(sk);
886
887 if (flags & (MSG_OOB))
888 return -EOPNOTSUPP;
889
890 skb = skb_recv_datagram(sk, flags, &err);
891 if (!skb) {
892 pr_err("Recv datagram failed state %d %d %d",
893 sk->sk_state, err, sock_error(sk));
894
895 if (sk->sk_shutdown & RCV_SHUTDOWN)
896 return 0;
897
898 return err;
899 }
900
901 rlen = skb->len; /* real length of skb */
902 copied = min_t(unsigned int, rlen, len);
903
904 cskb = skb;
905 if (skb_copy_datagram_msg(cskb, 0, msg, copied)) {
906 if (!(flags & MSG_PEEK))
907 skb_queue_head(&sk->sk_receive_queue, skb);
908 return -EFAULT;
909 }
910
911 sock_recv_timestamp(msg, sk, skb);
912
913 if (sk->sk_type == SOCK_DGRAM && msg->msg_name) {
914 struct nfc_llcp_ui_cb *ui_cb = nfc_llcp_ui_skb_cb(skb);
915 DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, sockaddr,
916 msg->msg_name);
917
918 msg->msg_namelen = sizeof(struct sockaddr_nfc_llcp);
919
920 pr_debug("Datagram socket %d %d\n", ui_cb->dsap, ui_cb->ssap);
921
922 memset(sockaddr, 0, sizeof(*sockaddr));
923 sockaddr->sa_family = AF_NFC;
924 sockaddr->nfc_protocol = NFC_PROTO_NFC_DEP;
925 sockaddr->dsap = ui_cb->dsap;
926 sockaddr->ssap = ui_cb->ssap;
927 }
928
929 /* Mark read part of skb as used */
930 if (!(flags & MSG_PEEK)) {
931
932 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
933 if (sk->sk_type == SOCK_STREAM ||
934 sk->sk_type == SOCK_DGRAM ||
935 sk->sk_type == SOCK_RAW) {
936 skb_pull(skb, copied);
937 if (skb->len) {
938 skb_queue_head(&sk->sk_receive_queue, skb);
939 goto done;
940 }
941 }
942
943 kfree_skb(skb);
944 }
945
946 /* XXX Queue backlogged skbs */
947
948done:
949 /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
950 if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
951 copied = rlen;
952
953 return copied;
954}
955
956static const struct proto_ops llcp_sock_ops = {
957 .family = PF_NFC,
958 .owner = THIS_MODULE,
959 .bind = llcp_sock_bind,
960 .connect = llcp_sock_connect,
961 .release = llcp_sock_release,
962 .socketpair = sock_no_socketpair,
963 .accept = llcp_sock_accept,
964 .getname = llcp_sock_getname,
965 .poll = llcp_sock_poll,
966 .ioctl = sock_no_ioctl,
967 .listen = llcp_sock_listen,
968 .shutdown = sock_no_shutdown,
969 .setsockopt = nfc_llcp_setsockopt,
970 .getsockopt = nfc_llcp_getsockopt,
971 .sendmsg = llcp_sock_sendmsg,
972 .recvmsg = llcp_sock_recvmsg,
973 .mmap = sock_no_mmap,
974};
975
976static const struct proto_ops llcp_rawsock_ops = {
977 .family = PF_NFC,
978 .owner = THIS_MODULE,
979 .bind = llcp_raw_sock_bind,
980 .connect = sock_no_connect,
981 .release = llcp_sock_release,
982 .socketpair = sock_no_socketpair,
983 .accept = sock_no_accept,
984 .getname = llcp_sock_getname,
985 .poll = llcp_sock_poll,
986 .ioctl = sock_no_ioctl,
987 .listen = sock_no_listen,
988 .shutdown = sock_no_shutdown,
989 .sendmsg = sock_no_sendmsg,
990 .recvmsg = llcp_sock_recvmsg,
991 .mmap = sock_no_mmap,
992};
993
994static void llcp_sock_destruct(struct sock *sk)
995{
996 struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
997
998 pr_debug("%p\n", sk);
999
1000 if (sk->sk_state == LLCP_CONNECTED)
1001 nfc_put_device(llcp_sock->dev);
1002
1003 skb_queue_purge(&sk->sk_receive_queue);
1004
1005 nfc_llcp_sock_free(llcp_sock);
1006
1007 if (!sock_flag(sk, SOCK_DEAD)) {
1008 pr_err("Freeing alive NFC LLCP socket %p\n", sk);
1009 return;
1010 }
1011}
1012
1013struct sock *nfc_llcp_sock_alloc(struct socket *sock, int type, gfp_t gfp, int kern)
1014{
1015 struct sock *sk;
1016 struct nfc_llcp_sock *llcp_sock;
1017
1018 sk = sk_alloc(&init_net, PF_NFC, gfp, &llcp_sock_proto, kern);
1019 if (!sk)
1020 return NULL;
1021
1022 llcp_sock = nfc_llcp_sock(sk);
1023
1024 sock_init_data(sock, sk);
1025 sk->sk_state = LLCP_CLOSED;
1026 sk->sk_protocol = NFC_SOCKPROTO_LLCP;
1027 sk->sk_type = type;
1028 sk->sk_destruct = llcp_sock_destruct;
1029
1030 llcp_sock->ssap = 0;
1031 llcp_sock->dsap = LLCP_SAP_SDP;
1032 llcp_sock->rw = LLCP_MAX_RW + 1;
1033 llcp_sock->miux = cpu_to_be16(LLCP_MAX_MIUX + 1);
1034 llcp_sock->send_n = llcp_sock->send_ack_n = 0;
1035 llcp_sock->recv_n = llcp_sock->recv_ack_n = 0;
1036 llcp_sock->remote_ready = 1;
1037 llcp_sock->reserved_ssap = LLCP_SAP_MAX;
1038 nfc_llcp_socket_remote_param_init(llcp_sock);
1039 skb_queue_head_init(&llcp_sock->tx_queue);
1040 skb_queue_head_init(&llcp_sock->tx_pending_queue);
1041 INIT_LIST_HEAD(&llcp_sock->accept_queue);
1042
1043 if (sock != NULL)
1044 sock->state = SS_UNCONNECTED;
1045
1046 return sk;
1047}
1048
1049void nfc_llcp_sock_free(struct nfc_llcp_sock *sock)
1050{
1051 kfree(sock->service_name);
1052
1053 skb_queue_purge(&sock->tx_queue);
1054 skb_queue_purge(&sock->tx_pending_queue);
1055
1056 list_del_init(&sock->accept_queue);
1057
1058 sock->parent = NULL;
1059
1060 nfc_llcp_local_put(sock->local);
1061}
1062
1063static int llcp_sock_create(struct net *net, struct socket *sock,
1064 const struct nfc_protocol *nfc_proto, int kern)
1065{
1066 struct sock *sk;
1067
1068 pr_debug("%p\n", sock);
1069
1070 if (sock->type != SOCK_STREAM &&
1071 sock->type != SOCK_DGRAM &&
1072 sock->type != SOCK_RAW)
1073 return -ESOCKTNOSUPPORT;
1074
1075 if (sock->type == SOCK_RAW) {
1076 if (!capable(CAP_NET_RAW))
1077 return -EPERM;
1078 sock->ops = &llcp_rawsock_ops;
1079 } else {
1080 sock->ops = &llcp_sock_ops;
1081 }
1082
1083 sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC, kern);
1084 if (sk == NULL)
1085 return -ENOMEM;
1086
1087 return 0;
1088}
1089
1090static const struct nfc_protocol llcp_nfc_proto = {
1091 .id = NFC_SOCKPROTO_LLCP,
1092 .proto = &llcp_sock_proto,
1093 .owner = THIS_MODULE,
1094 .create = llcp_sock_create
1095};
1096
1097int __init nfc_llcp_sock_init(void)
1098{
1099 return nfc_proto_register(&llcp_nfc_proto);
1100}
1101
1102void nfc_llcp_sock_exit(void)
1103{
1104 nfc_proto_unregister(&llcp_nfc_proto);
1105}