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