net/nfc/rawsock.c

   1 /*
   2  * Copyright (C) 2011 Instituto Nokia de Tecnologia
   3  *
   4  * Authors:
   5  *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
   6  *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the
  20  * Free Software Foundation, Inc.,
  21  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <net/tcp_states.h>
  25 #include <linux/nfc.h>
  26
  27 #include "nfc.h"
  28
  29 static void rawsock_write_queue_purge(struct sock *sk)
  30 {
  31         nfc_dbg("sk=%p", sk);
  32
  33         spin_lock_bh(&sk->sk_write_queue.lock);
  34         __skb_queue_purge(&sk->sk_write_queue);
  35         nfc_rawsock(sk)->tx_work_scheduled = false;
  36         spin_unlock_bh(&sk->sk_write_queue.lock);
  37 }
  38
  39 static void rawsock_report_error(struct sock *sk, int err)
  40 {
  41         nfc_dbg("sk=%p err=%d", sk, err);
  42
  43         sk->sk_shutdown = SHUTDOWN_MASK;
  44         sk->sk_err = -err;
  45         sk->sk_error_report(sk);
  46
  47         rawsock_write_queue_purge(sk);
  48 }
  49
  50 static int rawsock_release(struct socket *sock)
  51 {
  52         struct sock *sk = sock->sk;
  53
  54         nfc_dbg("sock=%p", sock);
  55
  56         sock_orphan(sk);
  57         sock_put(sk);
  58
  59         return 0;
  60 }
  61
  62 static int rawsock_connect(struct socket *sock, struct sockaddr *_addr,
  63                                                         int len, int flags)
  64 {
  65         struct sock *sk = sock->sk;
  66         struct sockaddr_nfc *addr = (struct sockaddr_nfc *)_addr;
  67         struct nfc_dev *dev;
  68         int rc = 0;
  69
  70         nfc_dbg("sock=%p sk=%p flags=%d", sock, sk, flags);
  71
  72         if (!addr || len < sizeof(struct sockaddr_nfc) ||
  73                 addr->sa_family != AF_NFC)
  74                 return -EINVAL;
  75
  76         nfc_dbg("addr dev_idx=%u target_idx=%u protocol=%u", addr->dev_idx,
  77                                         addr->target_idx, addr->nfc_protocol);
  78
  79         lock_sock(sk);
  80
  81         if (sock->state == SS_CONNECTED) {
  82                 rc = -EISCONN;
  83                 goto error;
  84         }
  85
  86         dev = nfc_get_device(addr->dev_idx);
  87         if (!dev) {
  88                 rc = -ENODEV;
  89                 goto error;
  90         }
  91
  92         if (addr->target_idx > dev->target_idx - 1 ||
  93                 addr->target_idx < dev->target_idx - dev->n_targets) {
  94                 rc = -EINVAL;
  95                 goto error;
  96         }
  97
  98         if (addr->target_idx > dev->target_idx - 1 ||
  99                 addr->target_idx < dev->target_idx - dev->n_targets) {
 100                 rc = -EINVAL;
 101                 goto error;
 102         }
 103
 104         rc = nfc_activate_target(dev, addr->target_idx, addr->nfc_protocol);
 105         if (rc)
 106                 goto put_dev;
 107
 108         nfc_rawsock(sk)->dev = dev;
 109         nfc_rawsock(sk)->target_idx = addr->target_idx;
 110         sock->state = SS_CONNECTED;
 111         sk->sk_state = TCP_ESTABLISHED;
 112         sk->sk_state_change(sk);
 113
 114         release_sock(sk);
 115         return 0;
 116
 117 put_dev:
 118         nfc_put_device(dev);
 119 error:
 120         release_sock(sk);
 121         return rc;
 122 }
 123
 124 static int rawsock_add_header(struct sk_buff *skb)
 125 {
 126         *skb_push(skb, NFC_HEADER_SIZE) = 0;
 127
 128         return 0;
 129 }
 130
 131 static void rawsock_data_exchange_complete(void *context, struct sk_buff *skb,
 132                                                                 int err)
 133 {
 134         struct sock *sk = (struct sock *) context;
 135
 136         BUG_ON(in_irq());
 137
 138         nfc_dbg("sk=%p err=%d", sk, err);
 139
 140         if (err)
 141                 goto error;
 142
 143         err = rawsock_add_header(skb);
 144         if (err)
 145                 goto error;
 146
 147         err = sock_queue_rcv_skb(sk, skb);
 148         if (err)
 149                 goto error;
 150
 151         spin_lock_bh(&sk->sk_write_queue.lock);
 152         if (!skb_queue_empty(&sk->sk_write_queue))
 153                 schedule_work(&nfc_rawsock(sk)->tx_work);
 154         else
 155                 nfc_rawsock(sk)->tx_work_scheduled = false;
 156         spin_unlock_bh(&sk->sk_write_queue.lock);
 157
 158         sock_put(sk);
 159         return;
 160
 161 error:
 162         rawsock_report_error(sk, err);
 163         sock_put(sk);
 164 }
 165
 166 static void rawsock_tx_work(struct work_struct *work)
 167 {
 168         struct sock *sk = to_rawsock_sk(work);
 169         struct nfc_dev *dev = nfc_rawsock(sk)->dev;
 170         u32 target_idx = nfc_rawsock(sk)->target_idx;
 171         struct sk_buff *skb;
 172         int rc;
 173
 174         nfc_dbg("sk=%p target_idx=%u", sk, target_idx);
 175
 176         if (sk->sk_shutdown & SEND_SHUTDOWN) {
 177                 rawsock_write_queue_purge(sk);
 178                 return;
 179         }
 180
 181         skb = skb_dequeue(&sk->sk_write_queue);
 182
 183         sock_hold(sk);
 184         rc = nfc_data_exchange(dev, target_idx, skb,
 185                                 rawsock_data_exchange_complete, sk);
 186         if (rc) {
 187                 rawsock_report_error(sk, rc);
 188                 sock_put(sk);
 189         }
 190 }
 191
 192 static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
 193                                         struct msghdr *msg, size_t len)
 194 {
 195         struct sock *sk = sock->sk;
 196         struct nfc_dev *dev = nfc_rawsock(sk)->dev;
 197         struct sk_buff *skb;
 198         int rc;
 199
 200         nfc_dbg("sock=%p sk=%p len=%zu", sock, sk, len);
 201
 202         if (msg->msg_namelen)
 203                 return -EOPNOTSUPP;
 204
 205         if (sock->state != SS_CONNECTED)
 206                 return -ENOTCONN;
 207
 208         skb = sock_alloc_send_skb(sk, len + dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE,
 209                                         msg->msg_flags & MSG_DONTWAIT, &rc);
 210         if (!skb)
 211                 return rc;
 212
 213         skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
 214
 215         rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
 216         if (rc < 0) {
 217                 kfree_skb(skb);
 218                 return rc;
 219         }
 220
 221         spin_lock_bh(&sk->sk_write_queue.lock);
 222         __skb_queue_tail(&sk->sk_write_queue, skb);
 223         if (!nfc_rawsock(sk)->tx_work_scheduled) {
 224                 schedule_work(&nfc_rawsock(sk)->tx_work);
 225                 nfc_rawsock(sk)->tx_work_scheduled = true;
 226         }
 227         spin_unlock_bh(&sk->sk_write_queue.lock);
 228
 229         return len;
 230 }
 231
 232 static int rawsock_recvmsg(struct kiocb *iocb, struct socket *sock,
 233                                 struct msghdr *msg, size_t len, int flags)
 234 {
 235         int noblock = flags & MSG_DONTWAIT;
 236         struct sock *sk = sock->sk;
 237         struct sk_buff *skb;
 238         int copied;
 239         int rc;
 240
 241         nfc_dbg("sock=%p sk=%p len=%zu flags=%d", sock, sk, len, flags);
 242
 243         skb = skb_recv_datagram(sk, flags, noblock, &rc);
 244         if (!skb)
 245                 return rc;
 246
 247         msg->msg_namelen = 0;
 248
 249         copied = skb->len;
 250         if (len < copied) {
 251                 msg->msg_flags |= MSG_TRUNC;
 252                 copied = len;
 253         }
 254
 255         rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 256
 257         skb_free_datagram(sk, skb);
 258
 259         return rc ? : copied;
 260 }
 261
 262
 263 static const struct proto_ops rawsock_ops = {
 264         .family         = PF_NFC,
 265         .owner          = THIS_MODULE,
 266         .release        = rawsock_release,
 267         .bind           = sock_no_bind,
 268         .connect        = rawsock_connect,
 269         .socketpair     = sock_no_socketpair,
 270         .accept         = sock_no_accept,
 271         .getname        = sock_no_getname,
 272         .poll           = datagram_poll,
 273         .ioctl          = sock_no_ioctl,
 274         .listen         = sock_no_listen,
 275         .shutdown       = sock_no_shutdown,
 276         .setsockopt     = sock_no_setsockopt,
 277         .getsockopt     = sock_no_getsockopt,
 278         .sendmsg        = rawsock_sendmsg,
 279         .recvmsg        = rawsock_recvmsg,
 280         .mmap           = sock_no_mmap,
 281 };
 282
 283 static void rawsock_destruct(struct sock *sk)
 284 {
 285         nfc_dbg("sk=%p", sk);
 286
 287         if (sk->sk_state == TCP_ESTABLISHED) {
 288                 nfc_deactivate_target(nfc_rawsock(sk)->dev,
 289                                         nfc_rawsock(sk)->target_idx);
 290                 nfc_put_device(nfc_rawsock(sk)->dev);
 291         }
 292
 293         skb_queue_purge(&sk->sk_receive_queue);
 294
 295         if (!sock_flag(sk, SOCK_DEAD)) {
 296                 nfc_err("Freeing alive NFC raw socket %p", sk);
 297                 return;
 298         }
 299 }
 300
 301 static int rawsock_create(struct net *net, struct socket *sock,
 302                                 const struct nfc_protocol *nfc_proto)
 303 {
 304         struct sock *sk;
 305
 306         nfc_dbg("sock=%p", sock);
 307
 308         if (sock->type != SOCK_SEQPACKET)
 309                 return -ESOCKTNOSUPPORT;
 310
 311         sock->ops = &rawsock_ops;
 312
 313         sk = sk_alloc(net, PF_NFC, GFP_KERNEL, nfc_proto->proto);
 314         if (!sk)
 315                 return -ENOMEM;
 316
 317         sock_init_data(sock, sk);
 318         sk->sk_protocol = nfc_proto->id;
 319         sk->sk_destruct = rawsock_destruct;
 320         sock->state = SS_UNCONNECTED;
 321
 322         INIT_WORK(&nfc_rawsock(sk)->tx_work, rawsock_tx_work);
 323         nfc_rawsock(sk)->tx_work_scheduled = false;
 324
 325         return 0;
 326 }
 327
 328 static struct proto rawsock_proto = {
 329         .name     = "NFC_RAW",
 330         .owner    = THIS_MODULE,
 331         .obj_size = sizeof(struct nfc_rawsock),
 332 };
 333
 334 static const struct nfc_protocol rawsock_nfc_proto = {
 335         .id       = NFC_SOCKPROTO_RAW,
 336         .proto    = &rawsock_proto,
 337         .owner    = THIS_MODULE,
 338         .create   = rawsock_create
 339 };
 340
 341 int __init rawsock_init(void)
 342 {
 343         int rc;
 344
 345         rc = nfc_proto_register(&rawsock_nfc_proto);
 346
 347         return rc;
 348 }
 349
 350 void rawsock_exit(void)
 351 {
 352         nfc_proto_unregister(&rawsock_nfc_proto);
 353 }