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         lock_sock(sk);
 513         if (!llcp_sock->dev) {
 514                 release_sock(sk);
 515                 return -EBADFD;
 516         }
 517         llcp_addr->sa_family = AF_NFC;
 518         llcp_addr->dev_idx = llcp_sock->dev->idx;
 519         llcp_addr->target_idx = llcp_sock->target_idx;
 520         llcp_addr->nfc_protocol = llcp_sock->nfc_protocol;
 521         llcp_addr->dsap = llcp_sock->dsap;
 522         llcp_addr->ssap = llcp_sock->ssap;
 523         llcp_addr->service_name_len = llcp_sock->service_name_len;
 524         memcpy(llcp_addr->service_name, llcp_sock->service_name,
 525                llcp_addr->service_name_len);
 526         release_sock(sk);
 527
 528         return 0;
 529 }
 530
 531 static inline unsigned int llcp_accept_poll(struct sock *parent)
 532 {
 533         struct nfc_llcp_sock *llcp_sock, *parent_sock;
 534         struct sock *sk;
 535
 536         parent_sock = nfc_llcp_sock(parent);
 537
 538         list_for_each_entry(llcp_sock, &parent_sock->accept_queue,
 539                             accept_queue) {
 540                 sk = &llcp_sock->sk;
 541
 542                 if (sk->sk_state == LLCP_CONNECTED)
 543                         return POLLIN | POLLRDNORM;
 544         }
 545
 546         return 0;
 547 }
 548
 549 static unsigned int llcp_sock_poll(struct file *file, struct socket *sock,
 550                                    poll_table *wait)
 551 {
 552         struct sock *sk = sock->sk;
 553         unsigned int mask = 0;
 554
 555         pr_debug("%p\n", sk);
 556
 557         sock_poll_wait(file, sk_sleep(sk), wait);
 558
 559         if (sk->sk_state == LLCP_LISTEN)
 560                 return llcp_accept_poll(sk);
 561
 562         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 563                 mask |= POLLERR |
 564                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
 565
 566         if (!skb_queue_empty(&sk->sk_receive_queue))
 567                 mask |= POLLIN | POLLRDNORM;
 568
 569         if (sk->sk_state == LLCP_CLOSED)
 570                 mask |= POLLHUP;
 571
 572         if (sk->sk_shutdown & RCV_SHUTDOWN)
 573                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 574
 575         if (sk->sk_shutdown == SHUTDOWN_MASK)
 576                 mask |= POLLHUP;
 577
 578         if (sock_writeable(sk) && sk->sk_state == LLCP_CONNECTED)
 579                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 580         else
 581                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 582
 583         pr_debug("mask 0x%x\n", mask);
 584
 585         return mask;
 586 }
 587
 588 static int llcp_sock_release(struct socket *sock)
 589 {
 590         struct sock *sk = sock->sk;
 591         struct nfc_llcp_local *local;
 592         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 593         int err = 0;
 594
 595         if (!sk)
 596                 return 0;
 597
 598         pr_debug("%p\n", sk);
 599
 600         local = llcp_sock->local;
 601         if (local == NULL) {
 602                 err = -ENODEV;
 603                 goto out;
 604         }
 605
 606         lock_sock(sk);
 607
 608         /* Send a DISC */
 609         if (sk->sk_state == LLCP_CONNECTED)
 610                 nfc_llcp_send_disconnect(llcp_sock);
 611
 612         if (sk->sk_state == LLCP_LISTEN) {
 613                 struct nfc_llcp_sock *lsk, *n;
 614                 struct sock *accept_sk;
 615
 616                 list_for_each_entry_safe(lsk, n, &llcp_sock->accept_queue,
 617                                          accept_queue) {
 618                         accept_sk = &lsk->sk;
 619                         lock_sock(accept_sk);
 620
 621                         nfc_llcp_send_disconnect(lsk);
 622                         nfc_llcp_accept_unlink(accept_sk);
 623
 624                         release_sock(accept_sk);
 625                 }
 626         }
 627
 628         if (llcp_sock->reserved_ssap < LLCP_SAP_MAX)
 629                 nfc_llcp_put_ssap(llcp_sock->local, llcp_sock->ssap);
 630
 631         release_sock(sk);
 632
 633         /* Keep this sock alive and therefore do not remove it from the sockets
 634          * list until the DISC PDU has been actually sent. Otherwise we would
 635          * reply with DM PDUs before sending the DISC one.
 636          */
 637         if (sk->sk_state == LLCP_DISCONNECTING)
 638                 return err;
 639
 640         if (sock->type == SOCK_RAW)
 641                 nfc_llcp_sock_unlink(&local->raw_sockets, sk);
 642         else
 643                 nfc_llcp_sock_unlink(&local->sockets, sk);
 644
 645 out:
 646         sock_orphan(sk);
 647         sock_put(sk);
 648
 649         return err;
 650 }
 651
 652 static int llcp_sock_connect(struct socket *sock, struct sockaddr *_addr,
 653                              int len, int flags)
 654 {
 655         struct sock *sk = sock->sk;
 656         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 657         struct sockaddr_nfc_llcp *addr = (struct sockaddr_nfc_llcp *)_addr;
 658         struct nfc_dev *dev;
 659         struct nfc_llcp_local *local;
 660         int ret = 0;
 661
 662         pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags);
 663
 664         if (!addr || len < sizeof(struct sockaddr_nfc) ||
 665             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
 681         dev = nfc_get_device(addr->dev_idx);
 682         if (dev == NULL) {
 683                 ret = -ENODEV;
 684                 goto error;
 685         }
 686
 687         local = nfc_llcp_find_local(dev);
 688         if (local == NULL) {
 689                 ret = -ENODEV;
 690                 goto put_dev;
 691         }
 692
 693         device_lock(&dev->dev);
 694         if (dev->dep_link_up == false) {
 695                 ret = -ENOLINK;
 696                 device_unlock(&dev->dev);
 697                 goto put_dev;
 698         }
 699         device_unlock(&dev->dev);
 700
 701         if (local->rf_mode == NFC_RF_INITIATOR &&
 702             addr->target_idx != local->target_idx) {
 703                 ret = -ENOLINK;
 704                 goto put_dev;
 705         }
 706
 707         llcp_sock->dev = dev;
 708         llcp_sock->local = nfc_llcp_local_get(local);
 709         llcp_sock->ssap = nfc_llcp_get_local_ssap(local);
 710         if (llcp_sock->ssap == LLCP_SAP_MAX) {
 711                 ret = -ENOMEM;
 712                 goto put_dev;
 713         }
 714
 715         llcp_sock->reserved_ssap = llcp_sock->ssap;
 716
 717         if (addr->service_name_len == 0)
 718                 llcp_sock->dsap = addr->dsap;
 719         else
 720                 llcp_sock->dsap = LLCP_SAP_SDP;
 721         llcp_sock->nfc_protocol = addr->nfc_protocol;
 722         llcp_sock->service_name_len = min_t(unsigned int,
 723                                             addr->service_name_len,
 724                                             NFC_LLCP_MAX_SERVICE_NAME);
 725         llcp_sock->service_name = kmemdup(addr->service_name,
 726                                           llcp_sock->service_name_len,
 727                                           GFP_KERNEL);
 728
 729         nfc_llcp_sock_link(&local->connecting_sockets, sk);
 730
 731         ret = nfc_llcp_send_connect(llcp_sock);
 732         if (ret)
 733                 goto sock_unlink;
 734
 735         sk->sk_state = LLCP_CONNECTING;
 736
 737         ret = sock_wait_state(sk, LLCP_CONNECTED,
 738                               sock_sndtimeo(sk, flags & O_NONBLOCK));
 739         if (ret && ret != -EINPROGRESS)
 740                 goto sock_unlink;
 741
 742         release_sock(sk);
 743
 744         return ret;
 745
 746 sock_unlink:
 747         nfc_llcp_put_ssap(local, llcp_sock->ssap);
 748
 749         nfc_llcp_sock_unlink(&local->connecting_sockets, sk);
 750
 751 put_dev:
 752         nfc_put_device(dev);
 753
 754 error:
 755         release_sock(sk);
 756         return ret;
 757 }
 758
 759 static int llcp_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 760                              size_t len)
 761 {
 762         struct sock *sk = sock->sk;
 763         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 764         int ret;
 765
 766         pr_debug("sock %p sk %p", sock, sk);
 767
 768         ret = sock_error(sk);
 769         if (ret)
 770                 return ret;
 771
 772         if (msg->msg_flags & MSG_OOB)
 773                 return -EOPNOTSUPP;
 774
 775         lock_sock(sk);
 776
 777         if (sk->sk_type == SOCK_DGRAM) {
 778                 DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, addr,
 779                                  msg->msg_name);
 780
 781                 if (msg->msg_namelen < sizeof(*addr)) {
 782                         release_sock(sk);
 783                         return -EINVAL;
 784                 }
 785
 786                 release_sock(sk);
 787
 788                 return nfc_llcp_send_ui_frame(llcp_sock, addr->dsap, addr->ssap,
 789                                               msg, len);
 790         }
 791
 792         if (sk->sk_state != LLCP_CONNECTED) {
 793                 release_sock(sk);
 794                 return -ENOTCONN;
 795         }
 796
 797         release_sock(sk);
 798
 799         return nfc_llcp_send_i_frame(llcp_sock, msg, len);
 800 }
 801
 802 static int llcp_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 803                              size_t len, int flags)
 804 {
 805         int noblock = flags & MSG_DONTWAIT;
 806         struct sock *sk = sock->sk;
 807         unsigned int copied, rlen;
 808         struct sk_buff *skb, *cskb;
 809         int err = 0;
 810
 811         pr_debug("%p %zu\n", sk, len);
 812
 813         lock_sock(sk);
 814
 815         if (sk->sk_state == LLCP_CLOSED &&
 816             skb_queue_empty(&sk->sk_receive_queue)) {
 817                 release_sock(sk);
 818                 return 0;
 819         }
 820
 821         release_sock(sk);
 822
 823         if (flags & (MSG_OOB))
 824                 return -EOPNOTSUPP;
 825
 826         skb = skb_recv_datagram(sk, flags, noblock, &err);
 827         if (!skb) {
 828                 pr_err("Recv datagram failed state %d %d %d",
 829                        sk->sk_state, err, sock_error(sk));
 830
 831                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 832                         return 0;
 833
 834                 return err;
 835         }
 836
 837         rlen = skb->len;                /* real length of skb */
 838         copied = min_t(unsigned int, rlen, len);
 839
 840         cskb = skb;
 841         if (skb_copy_datagram_msg(cskb, 0, msg, copied)) {
 842                 if (!(flags & MSG_PEEK))
 843                         skb_queue_head(&sk->sk_receive_queue, skb);
 844                 return -EFAULT;
 845         }
 846
 847         sock_recv_timestamp(msg, sk, skb);
 848
 849         if (sk->sk_type == SOCK_DGRAM && msg->msg_name) {
 850                 struct nfc_llcp_ui_cb *ui_cb = nfc_llcp_ui_skb_cb(skb);
 851                 DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, sockaddr,
 852                                  msg->msg_name);
 853
 854                 msg->msg_namelen = sizeof(struct sockaddr_nfc_llcp);
 855
 856                 pr_debug("Datagram socket %d %d\n", ui_cb->dsap, ui_cb->ssap);
 857
 858                 memset(sockaddr, 0, sizeof(*sockaddr));
 859                 sockaddr->sa_family = AF_NFC;
 860                 sockaddr->nfc_protocol = NFC_PROTO_NFC_DEP;
 861                 sockaddr->dsap = ui_cb->dsap;
 862                 sockaddr->ssap = ui_cb->ssap;
 863         }
 864
 865         /* Mark read part of skb as used */
 866         if (!(flags & MSG_PEEK)) {
 867
 868                 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
 869                 if (sk->sk_type == SOCK_STREAM ||
 870                     sk->sk_type == SOCK_DGRAM ||
 871                     sk->sk_type == SOCK_RAW) {
 872                         skb_pull(skb, copied);
 873                         if (skb->len) {
 874                                 skb_queue_head(&sk->sk_receive_queue, skb);
 875                                 goto done;
 876                         }
 877                 }
 878
 879                 kfree_skb(skb);
 880         }
 881
 882         /* XXX Queue backlogged skbs */
 883
 884 done:
 885         /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
 886         if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
 887                 copied = rlen;
 888
 889         return copied;
 890 }
 891
 892 static const struct proto_ops llcp_sock_ops = {
 893         .family         = PF_NFC,
 894         .owner          = THIS_MODULE,
 895         .bind           = llcp_sock_bind,
 896         .connect        = llcp_sock_connect,
 897         .release        = llcp_sock_release,
 898         .socketpair     = sock_no_socketpair,
 899         .accept         = llcp_sock_accept,
 900         .getname        = llcp_sock_getname,
 901         .poll           = llcp_sock_poll,
 902         .ioctl          = sock_no_ioctl,
 903         .listen         = llcp_sock_listen,
 904         .shutdown       = sock_no_shutdown,
 905         .setsockopt     = nfc_llcp_setsockopt,
 906         .getsockopt     = nfc_llcp_getsockopt,
 907         .sendmsg        = llcp_sock_sendmsg,
 908         .recvmsg        = llcp_sock_recvmsg,
 909         .mmap           = sock_no_mmap,
 910 };
 911
 912 static const struct proto_ops llcp_rawsock_ops = {
 913         .family         = PF_NFC,
 914         .owner          = THIS_MODULE,
 915         .bind           = llcp_raw_sock_bind,
 916         .connect        = sock_no_connect,
 917         .release        = llcp_sock_release,
 918         .socketpair     = sock_no_socketpair,
 919         .accept         = sock_no_accept,
 920         .getname        = llcp_sock_getname,
 921         .poll           = llcp_sock_poll,
 922         .ioctl          = sock_no_ioctl,
 923         .listen         = sock_no_listen,
 924         .shutdown       = sock_no_shutdown,
 925         .setsockopt     = sock_no_setsockopt,
 926         .getsockopt     = sock_no_getsockopt,
 927         .sendmsg        = sock_no_sendmsg,
 928         .recvmsg        = llcp_sock_recvmsg,
 929         .mmap           = sock_no_mmap,
 930 };
 931
 932 static void llcp_sock_destruct(struct sock *sk)
 933 {
 934         struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
 935
 936         pr_debug("%p\n", sk);
 937
 938         if (sk->sk_state == LLCP_CONNECTED)
 939                 nfc_put_device(llcp_sock->dev);
 940
 941         skb_queue_purge(&sk->sk_receive_queue);
 942
 943         nfc_llcp_sock_free(llcp_sock);
 944
 945         if (!sock_flag(sk, SOCK_DEAD)) {
 946                 pr_err("Freeing alive NFC LLCP socket %p\n", sk);
 947                 return;
 948         }
 949 }
 950
 951 struct sock *nfc_llcp_sock_alloc(struct socket *sock, int type, gfp_t gfp, int kern)
 952 {
 953         struct sock *sk;
 954         struct nfc_llcp_sock *llcp_sock;
 955
 956         sk = sk_alloc(&init_net, PF_NFC, gfp, &llcp_sock_proto, kern);
 957         if (!sk)
 958                 return NULL;
 959
 960         llcp_sock = nfc_llcp_sock(sk);
 961
 962         sock_init_data(sock, sk);
 963         sk->sk_state = LLCP_CLOSED;
 964         sk->sk_protocol = NFC_SOCKPROTO_LLCP;
 965         sk->sk_type = type;
 966         sk->sk_destruct = llcp_sock_destruct;
 967
 968         llcp_sock->ssap = 0;
 969         llcp_sock->dsap = LLCP_SAP_SDP;
 970         llcp_sock->rw = LLCP_MAX_RW + 1;
 971         llcp_sock->miux = cpu_to_be16(LLCP_MAX_MIUX + 1);
 972         llcp_sock->send_n = llcp_sock->send_ack_n = 0;
 973         llcp_sock->recv_n = llcp_sock->recv_ack_n = 0;
 974         llcp_sock->remote_ready = 1;
 975         llcp_sock->reserved_ssap = LLCP_SAP_MAX;
 976         nfc_llcp_socket_remote_param_init(llcp_sock);
 977         skb_queue_head_init(&llcp_sock->tx_queue);
 978         skb_queue_head_init(&llcp_sock->tx_pending_queue);
 979         INIT_LIST_HEAD(&llcp_sock->accept_queue);
 980
 981         if (sock != NULL)
 982                 sock->state = SS_UNCONNECTED;
 983
 984         return sk;
 985 }
 986
 987 void nfc_llcp_sock_free(struct nfc_llcp_sock *sock)
 988 {
 989         kfree(sock->service_name);
 990
 991         skb_queue_purge(&sock->tx_queue);
 992         skb_queue_purge(&sock->tx_pending_queue);
 993
 994         list_del_init(&sock->accept_queue);
 995
 996         sock->parent = NULL;
 997
 998         nfc_llcp_local_put(sock->local);
 999 }
1000
1001 static int llcp_sock_create(struct net *net, struct socket *sock,
1002                             const struct nfc_protocol *nfc_proto, int kern)
1003 {
1004         struct sock *sk;
1005
1006         pr_debug("%p\n", sock);
1007
1008         if (sock->type != SOCK_STREAM &&
1009             sock->type != SOCK_DGRAM &&
1010             sock->type != SOCK_RAW)
1011                 return -ESOCKTNOSUPPORT;
1012
1013         if (sock->type == SOCK_RAW)
1014                 sock->ops = &llcp_rawsock_ops;
1015         else
1016                 sock->ops = &llcp_sock_ops;
1017
1018         sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC, kern);
1019         if (sk == NULL)
1020                 return -ENOMEM;
1021
1022         return 0;
1023 }
1024
1025 static const struct nfc_protocol llcp_nfc_proto = {
1026         .id       = NFC_SOCKPROTO_LLCP,
1027         .proto    = &llcp_sock_proto,
1028         .owner    = THIS_MODULE,
1029         .create   = llcp_sock_create
1030 };
1031
1032 int __init nfc_llcp_sock_init(void)
1033 {
1034         return nfc_proto_register(&llcp_nfc_proto);
1035 }
1036
1037 void nfc_llcp_sock_exit(void)
1038 {
1039         nfc_proto_unregister(&llcp_nfc_proto);
1040 }