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 17 static 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 53 static struct proto llcp_sock_proto = { 54 .name = "NFC_LLCP", 55 .owner = THIS_MODULE, 56 .obj_size = sizeof(struct nfc_llcp_sock), 57 }; 58 59 static 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 132 free_service_name: 133 kfree(llcp_sock->service_name); 134 llcp_sock->service_name = NULL; 135 136 sock_llcp_put_local: 137 nfc_llcp_local_put(llcp_sock->local); 138 llcp_sock->local = NULL; 139 llcp_sock->dev = NULL; 140 141 put_dev: 142 nfc_put_device(dev); 143 144 error: 145 release_sock(sk); 146 return ret; 147 } 148 149 static 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 196 put_dev: 197 nfc_put_device(dev); 198 199 error: 200 release_sock(sk); 201 return ret; 202 } 203 204 static 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 225 error: 226 release_sock(sk); 227 228 return ret; 229 } 230 231 static 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 304 static 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 389 void 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 403 void 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 417 struct 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 466 static 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 519 error: 520 release_sock(sk); 521 522 return ret; 523 } 524 525 static 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 559 static 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 577 static __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 616 static 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 679 out: 680 sock_orphan(sk); 681 sock_put(sk); 682 683 return err; 684 } 685 686 static 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 791 sock_unlink: 792 nfc_llcp_sock_unlink(&local->connecting_sockets, sk); 793 kfree(llcp_sock->service_name); 794 llcp_sock->service_name = NULL; 795 796 sock_llcp_release: 797 nfc_llcp_put_ssap(local, llcp_sock->ssap); 798 799 sock_llcp_nullify: 800 llcp_sock->local = NULL; 801 llcp_sock->dev = NULL; 802 803 sock_llcp_put_local: 804 nfc_llcp_local_put(local); 805 806 put_dev: 807 nfc_put_device(dev); 808 809 error: 810 release_sock(sk); 811 return ret; 812 } 813 814 static 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 867 static 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 948 done: 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 956 static 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 976 static 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 994 static 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 1013 struct 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 1049 void 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 1063 static 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 1090 static 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 1097 int __init nfc_llcp_sock_init(void) 1098 { 1099 return nfc_proto_register(&llcp_nfc_proto); 1100 } 1101 1102 void nfc_llcp_sock_exit(void) 1103 { 1104 nfc_proto_unregister(&llcp_nfc_proto); 1105 } 1106