net/nfc/llcp_sock.c

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