Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2011  Intel Corporation. All rights reserved.
0004  */
0005 
0006 #define pr_fmt(fmt) "llcp: %s: " fmt, __func__
0007 
0008 #include <linux/init.h>
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/nfc.h>
0012 #include <linux/sched/signal.h>
0013 
0014 #include "nfc.h"
0015 #include "llcp.h"
0016 
0017 static int sock_wait_state(struct sock *sk, int state, unsigned long timeo)
0018 {
0019     DECLARE_WAITQUEUE(wait, current);
0020     int err = 0;
0021 
0022     pr_debug("sk %p", sk);
0023 
0024     add_wait_queue(sk_sleep(sk), &wait);
0025     set_current_state(TASK_INTERRUPTIBLE);
0026 
0027     while (sk->sk_state != state) {
0028         if (!timeo) {
0029             err = -EINPROGRESS;
0030             break;
0031         }
0032 
0033         if (signal_pending(current)) {
0034             err = sock_intr_errno(timeo);
0035             break;
0036         }
0037 
0038         release_sock(sk);
0039         timeo = schedule_timeout(timeo);
0040         lock_sock(sk);
0041         set_current_state(TASK_INTERRUPTIBLE);
0042 
0043         err = sock_error(sk);
0044         if (err)
0045             break;
0046     }
0047 
0048     __set_current_state(TASK_RUNNING);
0049     remove_wait_queue(sk_sleep(sk), &wait);
0050     return err;
0051 }
0052 
0053 static struct proto llcp_sock_proto = {
0054     .name     = "NFC_LLCP",
0055     .owner    = THIS_MODULE,
0056     .obj_size = sizeof(struct nfc_llcp_sock),
0057 };
0058 
0059 static int llcp_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
0060 {
0061     struct sock *sk = sock->sk;
0062     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0063     struct nfc_llcp_local *local;
0064     struct nfc_dev *dev;
0065     struct sockaddr_nfc_llcp llcp_addr;
0066     int len, ret = 0;
0067 
0068     if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
0069         addr->sa_family != AF_NFC)
0070         return -EINVAL;
0071 
0072     pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
0073 
0074     memset(&llcp_addr, 0, sizeof(llcp_addr));
0075     len = min_t(unsigned int, sizeof(llcp_addr), alen);
0076     memcpy(&llcp_addr, addr, len);
0077 
0078     /* This is going to be a listening socket, dsap must be 0 */
0079     if (llcp_addr.dsap != 0)
0080         return -EINVAL;
0081 
0082     lock_sock(sk);
0083 
0084     if (sk->sk_state != LLCP_CLOSED) {
0085         ret = -EBADFD;
0086         goto error;
0087     }
0088 
0089     dev = nfc_get_device(llcp_addr.dev_idx);
0090     if (dev == NULL) {
0091         ret = -ENODEV;
0092         goto error;
0093     }
0094 
0095     local = nfc_llcp_find_local(dev);
0096     if (local == NULL) {
0097         ret = -ENODEV;
0098         goto put_dev;
0099     }
0100 
0101     llcp_sock->dev = dev;
0102     llcp_sock->local = nfc_llcp_local_get(local);
0103     llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
0104     llcp_sock->service_name_len = min_t(unsigned int,
0105                         llcp_addr.service_name_len,
0106                         NFC_LLCP_MAX_SERVICE_NAME);
0107     llcp_sock->service_name = kmemdup(llcp_addr.service_name,
0108                       llcp_sock->service_name_len,
0109                       GFP_KERNEL);
0110     if (!llcp_sock->service_name) {
0111         ret = -ENOMEM;
0112         goto sock_llcp_put_local;
0113     }
0114     llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);
0115     if (llcp_sock->ssap == LLCP_SAP_MAX) {
0116         ret = -EADDRINUSE;
0117         goto free_service_name;
0118     }
0119 
0120     llcp_sock->reserved_ssap = llcp_sock->ssap;
0121 
0122     nfc_llcp_sock_link(&local->sockets, sk);
0123 
0124     pr_debug("Socket bound to SAP %d\n", llcp_sock->ssap);
0125 
0126     sk->sk_state = LLCP_BOUND;
0127     nfc_put_device(dev);
0128     release_sock(sk);
0129 
0130     return 0;
0131 
0132 free_service_name:
0133     kfree(llcp_sock->service_name);
0134     llcp_sock->service_name = NULL;
0135 
0136 sock_llcp_put_local:
0137     nfc_llcp_local_put(llcp_sock->local);
0138     llcp_sock->local = NULL;
0139     llcp_sock->dev = NULL;
0140 
0141 put_dev:
0142     nfc_put_device(dev);
0143 
0144 error:
0145     release_sock(sk);
0146     return ret;
0147 }
0148 
0149 static int llcp_raw_sock_bind(struct socket *sock, struct sockaddr *addr,
0150                   int alen)
0151 {
0152     struct sock *sk = sock->sk;
0153     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0154     struct nfc_llcp_local *local;
0155     struct nfc_dev *dev;
0156     struct sockaddr_nfc_llcp llcp_addr;
0157     int len, ret = 0;
0158 
0159     if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
0160         addr->sa_family != AF_NFC)
0161         return -EINVAL;
0162 
0163     pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
0164 
0165     memset(&llcp_addr, 0, sizeof(llcp_addr));
0166     len = min_t(unsigned int, sizeof(llcp_addr), alen);
0167     memcpy(&llcp_addr, addr, len);
0168 
0169     lock_sock(sk);
0170 
0171     if (sk->sk_state != LLCP_CLOSED) {
0172         ret = -EBADFD;
0173         goto error;
0174     }
0175 
0176     dev = nfc_get_device(llcp_addr.dev_idx);
0177     if (dev == NULL) {
0178         ret = -ENODEV;
0179         goto error;
0180     }
0181 
0182     local = nfc_llcp_find_local(dev);
0183     if (local == NULL) {
0184         ret = -ENODEV;
0185         goto put_dev;
0186     }
0187 
0188     llcp_sock->dev = dev;
0189     llcp_sock->local = nfc_llcp_local_get(local);
0190     llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
0191 
0192     nfc_llcp_sock_link(&local->raw_sockets, sk);
0193 
0194     sk->sk_state = LLCP_BOUND;
0195 
0196 put_dev:
0197     nfc_put_device(dev);
0198 
0199 error:
0200     release_sock(sk);
0201     return ret;
0202 }
0203 
0204 static int llcp_sock_listen(struct socket *sock, int backlog)
0205 {
0206     struct sock *sk = sock->sk;
0207     int ret = 0;
0208 
0209     pr_debug("sk %p backlog %d\n", sk, backlog);
0210 
0211     lock_sock(sk);
0212 
0213     if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM) ||
0214         sk->sk_state != LLCP_BOUND) {
0215         ret = -EBADFD;
0216         goto error;
0217     }
0218 
0219     sk->sk_max_ack_backlog = backlog;
0220     sk->sk_ack_backlog = 0;
0221 
0222     pr_debug("Socket listening\n");
0223     sk->sk_state = LLCP_LISTEN;
0224 
0225 error:
0226     release_sock(sk);
0227 
0228     return ret;
0229 }
0230 
0231 static int nfc_llcp_setsockopt(struct socket *sock, int level, int optname,
0232                    sockptr_t optval, unsigned int optlen)
0233 {
0234     struct sock *sk = sock->sk;
0235     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0236     u32 opt;
0237     int err = 0;
0238 
0239     pr_debug("%p optname %d\n", sk, optname);
0240 
0241     if (level != SOL_NFC)
0242         return -ENOPROTOOPT;
0243 
0244     lock_sock(sk);
0245 
0246     switch (optname) {
0247     case NFC_LLCP_RW:
0248         if (sk->sk_state == LLCP_CONNECTED ||
0249             sk->sk_state == LLCP_BOUND ||
0250             sk->sk_state == LLCP_LISTEN) {
0251             err = -EINVAL;
0252             break;
0253         }
0254 
0255         if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
0256             err = -EFAULT;
0257             break;
0258         }
0259 
0260         if (opt > LLCP_MAX_RW) {
0261             err = -EINVAL;
0262             break;
0263         }
0264 
0265         llcp_sock->rw = (u8) opt;
0266 
0267         break;
0268 
0269     case NFC_LLCP_MIUX:
0270         if (sk->sk_state == LLCP_CONNECTED ||
0271             sk->sk_state == LLCP_BOUND ||
0272             sk->sk_state == LLCP_LISTEN) {
0273             err = -EINVAL;
0274             break;
0275         }
0276 
0277         if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
0278             err = -EFAULT;
0279             break;
0280         }
0281 
0282         if (opt > LLCP_MAX_MIUX) {
0283             err = -EINVAL;
0284             break;
0285         }
0286 
0287         llcp_sock->miux = cpu_to_be16((u16) opt);
0288 
0289         break;
0290 
0291     default:
0292         err = -ENOPROTOOPT;
0293         break;
0294     }
0295 
0296     release_sock(sk);
0297 
0298     pr_debug("%p rw %d miux %d\n", llcp_sock,
0299          llcp_sock->rw, llcp_sock->miux);
0300 
0301     return err;
0302 }
0303 
0304 static int nfc_llcp_getsockopt(struct socket *sock, int level, int optname,
0305                    char __user *optval, int __user *optlen)
0306 {
0307     struct nfc_llcp_local *local;
0308     struct sock *sk = sock->sk;
0309     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0310     int len, err = 0;
0311     u16 miux, remote_miu;
0312     u8 rw;
0313 
0314     pr_debug("%p optname %d\n", sk, optname);
0315 
0316     if (level != SOL_NFC)
0317         return -ENOPROTOOPT;
0318 
0319     if (get_user(len, optlen))
0320         return -EFAULT;
0321 
0322     local = llcp_sock->local;
0323     if (!local)
0324         return -ENODEV;
0325 
0326     len = min_t(u32, len, sizeof(u32));
0327 
0328     lock_sock(sk);
0329 
0330     switch (optname) {
0331     case NFC_LLCP_RW:
0332         rw = llcp_sock->rw > LLCP_MAX_RW ? local->rw : llcp_sock->rw;
0333         if (put_user(rw, (u32 __user *) optval))
0334             err = -EFAULT;
0335 
0336         break;
0337 
0338     case NFC_LLCP_MIUX:
0339         miux = be16_to_cpu(llcp_sock->miux) > LLCP_MAX_MIUX ?
0340             be16_to_cpu(local->miux) : be16_to_cpu(llcp_sock->miux);
0341 
0342         if (put_user(miux, (u32 __user *) optval))
0343             err = -EFAULT;
0344 
0345         break;
0346 
0347     case NFC_LLCP_REMOTE_MIU:
0348         remote_miu = llcp_sock->remote_miu > LLCP_MAX_MIU ?
0349                 local->remote_miu : llcp_sock->remote_miu;
0350 
0351         if (put_user(remote_miu, (u32 __user *) optval))
0352             err = -EFAULT;
0353 
0354         break;
0355 
0356     case NFC_LLCP_REMOTE_LTO:
0357         if (put_user(local->remote_lto / 10, (u32 __user *) optval))
0358             err = -EFAULT;
0359 
0360         break;
0361 
0362     case NFC_LLCP_REMOTE_RW:
0363         if (put_user(llcp_sock->remote_rw, (u32 __user *) optval))
0364             err = -EFAULT;
0365 
0366         break;
0367 
0368     default:
0369         err = -ENOPROTOOPT;
0370         break;
0371     }
0372 
0373     release_sock(sk);
0374 
0375     if (put_user(len, optlen))
0376         return -EFAULT;
0377 
0378     return err;
0379 }
0380 
0381 void nfc_llcp_accept_unlink(struct sock *sk)
0382 {
0383     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0384 
0385     pr_debug("state %d\n", sk->sk_state);
0386 
0387     list_del_init(&llcp_sock->accept_queue);
0388     sk_acceptq_removed(llcp_sock->parent);
0389     llcp_sock->parent = NULL;
0390 
0391     sock_put(sk);
0392 }
0393 
0394 void nfc_llcp_accept_enqueue(struct sock *parent, struct sock *sk)
0395 {
0396     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0397     struct nfc_llcp_sock *llcp_sock_parent = nfc_llcp_sock(parent);
0398 
0399     /* Lock will be free from unlink */
0400     sock_hold(sk);
0401 
0402     list_add_tail(&llcp_sock->accept_queue,
0403               &llcp_sock_parent->accept_queue);
0404     llcp_sock->parent = parent;
0405     sk_acceptq_added(parent);
0406 }
0407 
0408 struct sock *nfc_llcp_accept_dequeue(struct sock *parent,
0409                      struct socket *newsock)
0410 {
0411     struct nfc_llcp_sock *lsk, *n, *llcp_parent;
0412     struct sock *sk;
0413 
0414     llcp_parent = nfc_llcp_sock(parent);
0415 
0416     list_for_each_entry_safe(lsk, n, &llcp_parent->accept_queue,
0417                  accept_queue) {
0418         sk = &lsk->sk;
0419         lock_sock(sk);
0420 
0421         if (sk->sk_state == LLCP_CLOSED) {
0422             release_sock(sk);
0423             nfc_llcp_accept_unlink(sk);
0424             continue;
0425         }
0426 
0427         if (sk->sk_state == LLCP_CONNECTED || !newsock) {
0428             list_del_init(&lsk->accept_queue);
0429             sock_put(sk);
0430 
0431             if (newsock)
0432                 sock_graft(sk, newsock);
0433 
0434             release_sock(sk);
0435 
0436             pr_debug("Returning sk state %d\n", sk->sk_state);
0437 
0438             sk_acceptq_removed(parent);
0439 
0440             return sk;
0441         }
0442 
0443         release_sock(sk);
0444     }
0445 
0446     return NULL;
0447 }
0448 
0449 static int llcp_sock_accept(struct socket *sock, struct socket *newsock,
0450                 int flags, bool kern)
0451 {
0452     DECLARE_WAITQUEUE(wait, current);
0453     struct sock *sk = sock->sk, *new_sk;
0454     long timeo;
0455     int ret = 0;
0456 
0457     pr_debug("parent %p\n", sk);
0458 
0459     lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
0460 
0461     if (sk->sk_state != LLCP_LISTEN) {
0462         ret = -EBADFD;
0463         goto error;
0464     }
0465 
0466     timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
0467 
0468     /* Wait for an incoming connection. */
0469     add_wait_queue_exclusive(sk_sleep(sk), &wait);
0470     while (!(new_sk = nfc_llcp_accept_dequeue(sk, newsock))) {
0471         set_current_state(TASK_INTERRUPTIBLE);
0472 
0473         if (!timeo) {
0474             ret = -EAGAIN;
0475             break;
0476         }
0477 
0478         if (signal_pending(current)) {
0479             ret = sock_intr_errno(timeo);
0480             break;
0481         }
0482 
0483         release_sock(sk);
0484         timeo = schedule_timeout(timeo);
0485         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
0486     }
0487     __set_current_state(TASK_RUNNING);
0488     remove_wait_queue(sk_sleep(sk), &wait);
0489 
0490     if (ret)
0491         goto error;
0492 
0493     newsock->state = SS_CONNECTED;
0494 
0495     pr_debug("new socket %p\n", new_sk);
0496 
0497 error:
0498     release_sock(sk);
0499 
0500     return ret;
0501 }
0502 
0503 static int llcp_sock_getname(struct socket *sock, struct sockaddr *uaddr,
0504                  int peer)
0505 {
0506     struct sock *sk = sock->sk;
0507     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0508     DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, llcp_addr, uaddr);
0509 
0510     if (llcp_sock == NULL || llcp_sock->dev == NULL)
0511         return -EBADFD;
0512 
0513     pr_debug("%p %d %d %d\n", sk, llcp_sock->target_idx,
0514          llcp_sock->dsap, llcp_sock->ssap);
0515 
0516     memset(llcp_addr, 0, sizeof(*llcp_addr));
0517 
0518     lock_sock(sk);
0519     if (!llcp_sock->dev) {
0520         release_sock(sk);
0521         return -EBADFD;
0522     }
0523     llcp_addr->sa_family = AF_NFC;
0524     llcp_addr->dev_idx = llcp_sock->dev->idx;
0525     llcp_addr->target_idx = llcp_sock->target_idx;
0526     llcp_addr->nfc_protocol = llcp_sock->nfc_protocol;
0527     llcp_addr->dsap = llcp_sock->dsap;
0528     llcp_addr->ssap = llcp_sock->ssap;
0529     llcp_addr->service_name_len = llcp_sock->service_name_len;
0530     memcpy(llcp_addr->service_name, llcp_sock->service_name,
0531            llcp_addr->service_name_len);
0532     release_sock(sk);
0533 
0534     return sizeof(struct sockaddr_nfc_llcp);
0535 }
0536 
0537 static inline __poll_t llcp_accept_poll(struct sock *parent)
0538 {
0539     struct nfc_llcp_sock *llcp_sock, *parent_sock;
0540     struct sock *sk;
0541 
0542     parent_sock = nfc_llcp_sock(parent);
0543 
0544     list_for_each_entry(llcp_sock, &parent_sock->accept_queue,
0545                 accept_queue) {
0546         sk = &llcp_sock->sk;
0547 
0548         if (sk->sk_state == LLCP_CONNECTED)
0549             return EPOLLIN | EPOLLRDNORM;
0550     }
0551 
0552     return 0;
0553 }
0554 
0555 static __poll_t llcp_sock_poll(struct file *file, struct socket *sock,
0556                    poll_table *wait)
0557 {
0558     struct sock *sk = sock->sk;
0559     __poll_t mask = 0;
0560 
0561     pr_debug("%p\n", sk);
0562 
0563     sock_poll_wait(file, sock, wait);
0564 
0565     if (sk->sk_state == LLCP_LISTEN)
0566         return llcp_accept_poll(sk);
0567 
0568     if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
0569         mask |= EPOLLERR |
0570             (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
0571 
0572     if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
0573         mask |= EPOLLIN | EPOLLRDNORM;
0574 
0575     if (sk->sk_state == LLCP_CLOSED)
0576         mask |= EPOLLHUP;
0577 
0578     if (sk->sk_shutdown & RCV_SHUTDOWN)
0579         mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
0580 
0581     if (sk->sk_shutdown == SHUTDOWN_MASK)
0582         mask |= EPOLLHUP;
0583 
0584     if (sock_writeable(sk) && sk->sk_state == LLCP_CONNECTED)
0585         mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
0586     else
0587         sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
0588 
0589     pr_debug("mask 0x%x\n", mask);
0590 
0591     return mask;
0592 }
0593 
0594 static int llcp_sock_release(struct socket *sock)
0595 {
0596     struct sock *sk = sock->sk;
0597     struct nfc_llcp_local *local;
0598     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0599     int err = 0;
0600 
0601     if (!sk)
0602         return 0;
0603 
0604     pr_debug("%p\n", sk);
0605 
0606     local = llcp_sock->local;
0607     if (local == NULL) {
0608         err = -ENODEV;
0609         goto out;
0610     }
0611 
0612     lock_sock(sk);
0613 
0614     /* Send a DISC */
0615     if (sk->sk_state == LLCP_CONNECTED)
0616         nfc_llcp_send_disconnect(llcp_sock);
0617 
0618     if (sk->sk_state == LLCP_LISTEN) {
0619         struct nfc_llcp_sock *lsk, *n;
0620         struct sock *accept_sk;
0621 
0622         list_for_each_entry_safe(lsk, n, &llcp_sock->accept_queue,
0623                      accept_queue) {
0624             accept_sk = &lsk->sk;
0625             lock_sock(accept_sk);
0626 
0627             nfc_llcp_send_disconnect(lsk);
0628             nfc_llcp_accept_unlink(accept_sk);
0629 
0630             release_sock(accept_sk);
0631         }
0632     }
0633 
0634     if (sock->type == SOCK_RAW)
0635         nfc_llcp_sock_unlink(&local->raw_sockets, sk);
0636     else
0637         nfc_llcp_sock_unlink(&local->sockets, sk);
0638 
0639     if (llcp_sock->reserved_ssap < LLCP_SAP_MAX)
0640         nfc_llcp_put_ssap(llcp_sock->local, llcp_sock->ssap);
0641 
0642     release_sock(sk);
0643 
0644 out:
0645     sock_orphan(sk);
0646     sock_put(sk);
0647 
0648     return err;
0649 }
0650 
0651 static int llcp_sock_connect(struct socket *sock, struct sockaddr *_addr,
0652                  int len, int flags)
0653 {
0654     struct sock *sk = sock->sk;
0655     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0656     struct sockaddr_nfc_llcp *addr = (struct sockaddr_nfc_llcp *)_addr;
0657     struct nfc_dev *dev;
0658     struct nfc_llcp_local *local;
0659     int ret = 0;
0660 
0661     pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags);
0662 
0663     if (!addr || len < sizeof(*addr) || addr->sa_family != AF_NFC)
0664         return -EINVAL;
0665 
0666     if (addr->service_name_len == 0 && addr->dsap == 0)
0667         return -EINVAL;
0668 
0669     pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n", addr->dev_idx,
0670          addr->target_idx, addr->nfc_protocol);
0671 
0672     lock_sock(sk);
0673 
0674     if (sk->sk_state == LLCP_CONNECTED) {
0675         ret = -EISCONN;
0676         goto error;
0677     }
0678     if (sk->sk_state == LLCP_CONNECTING) {
0679         ret = -EINPROGRESS;
0680         goto error;
0681     }
0682 
0683     dev = nfc_get_device(addr->dev_idx);
0684     if (dev == NULL) {
0685         ret = -ENODEV;
0686         goto error;
0687     }
0688 
0689     local = nfc_llcp_find_local(dev);
0690     if (local == NULL) {
0691         ret = -ENODEV;
0692         goto put_dev;
0693     }
0694 
0695     device_lock(&dev->dev);
0696     if (dev->dep_link_up == false) {
0697         ret = -ENOLINK;
0698         device_unlock(&dev->dev);
0699         goto put_dev;
0700     }
0701     device_unlock(&dev->dev);
0702 
0703     if (local->rf_mode == NFC_RF_INITIATOR &&
0704         addr->target_idx != local->target_idx) {
0705         ret = -ENOLINK;
0706         goto put_dev;
0707     }
0708 
0709     llcp_sock->dev = dev;
0710     llcp_sock->local = nfc_llcp_local_get(local);
0711     llcp_sock->ssap = nfc_llcp_get_local_ssap(local);
0712     if (llcp_sock->ssap == LLCP_SAP_MAX) {
0713         ret = -ENOMEM;
0714         goto sock_llcp_put_local;
0715     }
0716 
0717     llcp_sock->reserved_ssap = llcp_sock->ssap;
0718 
0719     if (addr->service_name_len == 0)
0720         llcp_sock->dsap = addr->dsap;
0721     else
0722         llcp_sock->dsap = LLCP_SAP_SDP;
0723     llcp_sock->nfc_protocol = addr->nfc_protocol;
0724     llcp_sock->service_name_len = min_t(unsigned int,
0725                         addr->service_name_len,
0726                         NFC_LLCP_MAX_SERVICE_NAME);
0727     llcp_sock->service_name = kmemdup(addr->service_name,
0728                       llcp_sock->service_name_len,
0729                       GFP_KERNEL);
0730     if (!llcp_sock->service_name) {
0731         ret = -ENOMEM;
0732         goto sock_llcp_release;
0733     }
0734 
0735     nfc_llcp_sock_link(&local->connecting_sockets, sk);
0736 
0737     ret = nfc_llcp_send_connect(llcp_sock);
0738     if (ret)
0739         goto sock_unlink;
0740 
0741     sk->sk_state = LLCP_CONNECTING;
0742 
0743     ret = sock_wait_state(sk, LLCP_CONNECTED,
0744                   sock_sndtimeo(sk, flags & O_NONBLOCK));
0745     if (ret && ret != -EINPROGRESS)
0746         goto sock_unlink;
0747 
0748     release_sock(sk);
0749 
0750     return ret;
0751 
0752 sock_unlink:
0753     nfc_llcp_sock_unlink(&local->connecting_sockets, sk);
0754     kfree(llcp_sock->service_name);
0755     llcp_sock->service_name = NULL;
0756 
0757 sock_llcp_release:
0758     nfc_llcp_put_ssap(local, llcp_sock->ssap);
0759 
0760 sock_llcp_put_local:
0761     nfc_llcp_local_put(llcp_sock->local);
0762     llcp_sock->local = NULL;
0763     llcp_sock->dev = NULL;
0764 
0765 put_dev:
0766     nfc_put_device(dev);
0767 
0768 error:
0769     release_sock(sk);
0770     return ret;
0771 }
0772 
0773 static int llcp_sock_sendmsg(struct socket *sock, struct msghdr *msg,
0774                  size_t len)
0775 {
0776     struct sock *sk = sock->sk;
0777     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0778     int ret;
0779 
0780     pr_debug("sock %p sk %p", sock, sk);
0781 
0782     ret = sock_error(sk);
0783     if (ret)
0784         return ret;
0785 
0786     if (msg->msg_flags & MSG_OOB)
0787         return -EOPNOTSUPP;
0788 
0789     lock_sock(sk);
0790 
0791     if (!llcp_sock->local) {
0792         release_sock(sk);
0793         return -ENODEV;
0794     }
0795 
0796     if (sk->sk_type == SOCK_DGRAM) {
0797         DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, addr,
0798                  msg->msg_name);
0799 
0800         if (msg->msg_namelen < sizeof(*addr)) {
0801             release_sock(sk);
0802             return -EINVAL;
0803         }
0804 
0805         release_sock(sk);
0806 
0807         return nfc_llcp_send_ui_frame(llcp_sock, addr->dsap, addr->ssap,
0808                           msg, len);
0809     }
0810 
0811     if (sk->sk_state != LLCP_CONNECTED) {
0812         release_sock(sk);
0813         return -ENOTCONN;
0814     }
0815 
0816     release_sock(sk);
0817 
0818     return nfc_llcp_send_i_frame(llcp_sock, msg, len);
0819 }
0820 
0821 static int llcp_sock_recvmsg(struct socket *sock, struct msghdr *msg,
0822                  size_t len, int flags)
0823 {
0824     struct sock *sk = sock->sk;
0825     unsigned int copied, rlen;
0826     struct sk_buff *skb, *cskb;
0827     int err = 0;
0828 
0829     pr_debug("%p %zu\n", sk, len);
0830 
0831     lock_sock(sk);
0832 
0833     if (sk->sk_state == LLCP_CLOSED &&
0834         skb_queue_empty(&sk->sk_receive_queue)) {
0835         release_sock(sk);
0836         return 0;
0837     }
0838 
0839     release_sock(sk);
0840 
0841     if (flags & (MSG_OOB))
0842         return -EOPNOTSUPP;
0843 
0844     skb = skb_recv_datagram(sk, flags, &err);
0845     if (!skb) {
0846         pr_err("Recv datagram failed state %d %d %d",
0847                sk->sk_state, err, sock_error(sk));
0848 
0849         if (sk->sk_shutdown & RCV_SHUTDOWN)
0850             return 0;
0851 
0852         return err;
0853     }
0854 
0855     rlen = skb->len;        /* real length of skb */
0856     copied = min_t(unsigned int, rlen, len);
0857 
0858     cskb = skb;
0859     if (skb_copy_datagram_msg(cskb, 0, msg, copied)) {
0860         if (!(flags & MSG_PEEK))
0861             skb_queue_head(&sk->sk_receive_queue, skb);
0862         return -EFAULT;
0863     }
0864 
0865     sock_recv_timestamp(msg, sk, skb);
0866 
0867     if (sk->sk_type == SOCK_DGRAM && msg->msg_name) {
0868         struct nfc_llcp_ui_cb *ui_cb = nfc_llcp_ui_skb_cb(skb);
0869         DECLARE_SOCKADDR(struct sockaddr_nfc_llcp *, sockaddr,
0870                  msg->msg_name);
0871 
0872         msg->msg_namelen = sizeof(struct sockaddr_nfc_llcp);
0873 
0874         pr_debug("Datagram socket %d %d\n", ui_cb->dsap, ui_cb->ssap);
0875 
0876         memset(sockaddr, 0, sizeof(*sockaddr));
0877         sockaddr->sa_family = AF_NFC;
0878         sockaddr->nfc_protocol = NFC_PROTO_NFC_DEP;
0879         sockaddr->dsap = ui_cb->dsap;
0880         sockaddr->ssap = ui_cb->ssap;
0881     }
0882 
0883     /* Mark read part of skb as used */
0884     if (!(flags & MSG_PEEK)) {
0885 
0886         /* SOCK_STREAM: re-queue skb if it contains unreceived data */
0887         if (sk->sk_type == SOCK_STREAM ||
0888             sk->sk_type == SOCK_DGRAM ||
0889             sk->sk_type == SOCK_RAW) {
0890             skb_pull(skb, copied);
0891             if (skb->len) {
0892                 skb_queue_head(&sk->sk_receive_queue, skb);
0893                 goto done;
0894             }
0895         }
0896 
0897         kfree_skb(skb);
0898     }
0899 
0900     /* XXX Queue backlogged skbs */
0901 
0902 done:
0903     /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
0904     if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
0905         copied = rlen;
0906 
0907     return copied;
0908 }
0909 
0910 static const struct proto_ops llcp_sock_ops = {
0911     .family         = PF_NFC,
0912     .owner          = THIS_MODULE,
0913     .bind           = llcp_sock_bind,
0914     .connect        = llcp_sock_connect,
0915     .release        = llcp_sock_release,
0916     .socketpair     = sock_no_socketpair,
0917     .accept         = llcp_sock_accept,
0918     .getname        = llcp_sock_getname,
0919     .poll           = llcp_sock_poll,
0920     .ioctl          = sock_no_ioctl,
0921     .listen         = llcp_sock_listen,
0922     .shutdown       = sock_no_shutdown,
0923     .setsockopt     = nfc_llcp_setsockopt,
0924     .getsockopt     = nfc_llcp_getsockopt,
0925     .sendmsg        = llcp_sock_sendmsg,
0926     .recvmsg        = llcp_sock_recvmsg,
0927     .mmap           = sock_no_mmap,
0928 };
0929 
0930 static const struct proto_ops llcp_rawsock_ops = {
0931     .family         = PF_NFC,
0932     .owner          = THIS_MODULE,
0933     .bind           = llcp_raw_sock_bind,
0934     .connect        = sock_no_connect,
0935     .release        = llcp_sock_release,
0936     .socketpair     = sock_no_socketpair,
0937     .accept         = sock_no_accept,
0938     .getname        = llcp_sock_getname,
0939     .poll           = llcp_sock_poll,
0940     .ioctl          = sock_no_ioctl,
0941     .listen         = sock_no_listen,
0942     .shutdown       = sock_no_shutdown,
0943     .sendmsg        = sock_no_sendmsg,
0944     .recvmsg        = llcp_sock_recvmsg,
0945     .mmap           = sock_no_mmap,
0946 };
0947 
0948 static void llcp_sock_destruct(struct sock *sk)
0949 {
0950     struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
0951 
0952     pr_debug("%p\n", sk);
0953 
0954     if (sk->sk_state == LLCP_CONNECTED)
0955         nfc_put_device(llcp_sock->dev);
0956 
0957     skb_queue_purge(&sk->sk_receive_queue);
0958 
0959     nfc_llcp_sock_free(llcp_sock);
0960 
0961     if (!sock_flag(sk, SOCK_DEAD)) {
0962         pr_err("Freeing alive NFC LLCP socket %p\n", sk);
0963         return;
0964     }
0965 }
0966 
0967 struct sock *nfc_llcp_sock_alloc(struct socket *sock, int type, gfp_t gfp, int kern)
0968 {
0969     struct sock *sk;
0970     struct nfc_llcp_sock *llcp_sock;
0971 
0972     sk = sk_alloc(&init_net, PF_NFC, gfp, &llcp_sock_proto, kern);
0973     if (!sk)
0974         return NULL;
0975 
0976     llcp_sock = nfc_llcp_sock(sk);
0977 
0978     sock_init_data(sock, sk);
0979     sk->sk_state = LLCP_CLOSED;
0980     sk->sk_protocol = NFC_SOCKPROTO_LLCP;
0981     sk->sk_type = type;
0982     sk->sk_destruct = llcp_sock_destruct;
0983 
0984     llcp_sock->ssap = 0;
0985     llcp_sock->dsap = LLCP_SAP_SDP;
0986     llcp_sock->rw = LLCP_MAX_RW + 1;
0987     llcp_sock->miux = cpu_to_be16(LLCP_MAX_MIUX + 1);
0988     llcp_sock->send_n = llcp_sock->send_ack_n = 0;
0989     llcp_sock->recv_n = llcp_sock->recv_ack_n = 0;
0990     llcp_sock->remote_ready = 1;
0991     llcp_sock->reserved_ssap = LLCP_SAP_MAX;
0992     nfc_llcp_socket_remote_param_init(llcp_sock);
0993     skb_queue_head_init(&llcp_sock->tx_queue);
0994     skb_queue_head_init(&llcp_sock->tx_pending_queue);
0995     INIT_LIST_HEAD(&llcp_sock->accept_queue);
0996 
0997     if (sock != NULL)
0998         sock->state = SS_UNCONNECTED;
0999 
1000     return sk;
1001 }
1002 
1003 void nfc_llcp_sock_free(struct nfc_llcp_sock *sock)
1004 {
1005     kfree(sock->service_name);
1006 
1007     skb_queue_purge(&sock->tx_queue);
1008     skb_queue_purge(&sock->tx_pending_queue);
1009 
1010     list_del_init(&sock->accept_queue);
1011 
1012     sock->parent = NULL;
1013 
1014     nfc_llcp_local_put(sock->local);
1015 }
1016 
1017 static int llcp_sock_create(struct net *net, struct socket *sock,
1018                 const struct nfc_protocol *nfc_proto, int kern)
1019 {
1020     struct sock *sk;
1021 
1022     pr_debug("%p\n", sock);
1023 
1024     if (sock->type != SOCK_STREAM &&
1025         sock->type != SOCK_DGRAM &&
1026         sock->type != SOCK_RAW)
1027         return -ESOCKTNOSUPPORT;
1028 
1029     if (sock->type == SOCK_RAW) {
1030         if (!capable(CAP_NET_RAW))
1031             return -EPERM;
1032         sock->ops = &llcp_rawsock_ops;
1033     } else {
1034         sock->ops = &llcp_sock_ops;
1035     }
1036 
1037     sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC, kern);
1038     if (sk == NULL)
1039         return -ENOMEM;
1040 
1041     return 0;
1042 }
1043 
1044 static const struct nfc_protocol llcp_nfc_proto = {
1045     .id   = NFC_SOCKPROTO_LLCP,
1046     .proto    = &llcp_sock_proto,
1047     .owner    = THIS_MODULE,
1048     .create   = llcp_sock_create
1049 };
1050 
1051 int __init nfc_llcp_sock_init(void)
1052 {
1053     return nfc_proto_register(&llcp_nfc_proto);
1054 }
1055 
1056 void nfc_llcp_sock_exit(void)
1057 {
1058     nfc_proto_unregister(&llcp_nfc_proto);
1059 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!