2 * Copyright (C) 2011 Instituto Nokia de Tecnologia
5 * Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
6 * Lauro Ramos Venancio <lauro.venancio@openbossa.org>
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.
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.
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.
24 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
26 #include <net/tcp_states.h>
27 #include <linux/nfc.h>
28 #include <linux/export.h>
32 static void rawsock_write_queue_purge(struct sock
*sk
)
34 pr_debug("sk=%p\n", sk
);
36 spin_lock_bh(&sk
->sk_write_queue
.lock
);
37 __skb_queue_purge(&sk
->sk_write_queue
);
38 nfc_rawsock(sk
)->tx_work_scheduled
= false;
39 spin_unlock_bh(&sk
->sk_write_queue
.lock
);
42 static void rawsock_report_error(struct sock
*sk
, int err
)
44 pr_debug("sk=%p err=%d\n", sk
, err
);
46 sk
->sk_shutdown
= SHUTDOWN_MASK
;
48 sk
->sk_error_report(sk
);
50 rawsock_write_queue_purge(sk
);
53 static int rawsock_release(struct socket
*sock
)
55 struct sock
*sk
= sock
->sk
;
57 pr_debug("sock=%p\n", sock
);
65 static int rawsock_connect(struct socket
*sock
, struct sockaddr
*_addr
,
68 struct sock
*sk
= sock
->sk
;
69 struct sockaddr_nfc
*addr
= (struct sockaddr_nfc
*)_addr
;
73 pr_debug("sock=%p sk=%p flags=%d\n", sock
, sk
, flags
);
75 if (!addr
|| len
< sizeof(struct sockaddr_nfc
) ||
76 addr
->sa_family
!= AF_NFC
)
79 pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n",
80 addr
->dev_idx
, addr
->target_idx
, addr
->nfc_protocol
);
84 if (sock
->state
== SS_CONNECTED
) {
89 dev
= nfc_get_device(addr
->dev_idx
);
95 if (addr
->target_idx
> dev
->target_idx
- 1 ||
96 addr
->target_idx
< dev
->target_idx
- dev
->n_targets
) {
101 if (addr
->target_idx
> dev
->target_idx
- 1 ||
102 addr
->target_idx
< dev
->target_idx
- dev
->n_targets
) {
107 rc
= nfc_activate_target(dev
, addr
->target_idx
, addr
->nfc_protocol
);
111 nfc_rawsock(sk
)->dev
= dev
;
112 nfc_rawsock(sk
)->target_idx
= addr
->target_idx
;
113 sock
->state
= SS_CONNECTED
;
114 sk
->sk_state
= TCP_ESTABLISHED
;
115 sk
->sk_state_change(sk
);
127 static int rawsock_add_header(struct sk_buff
*skb
)
129 *skb_push(skb
, NFC_HEADER_SIZE
) = 0;
134 static void rawsock_data_exchange_complete(void *context
, struct sk_buff
*skb
,
137 struct sock
*sk
= (struct sock
*) context
;
141 pr_debug("sk=%p err=%d\n", sk
, err
);
146 err
= rawsock_add_header(skb
);
150 err
= sock_queue_rcv_skb(sk
, skb
);
154 spin_lock_bh(&sk
->sk_write_queue
.lock
);
155 if (!skb_queue_empty(&sk
->sk_write_queue
))
156 schedule_work(&nfc_rawsock(sk
)->tx_work
);
158 nfc_rawsock(sk
)->tx_work_scheduled
= false;
159 spin_unlock_bh(&sk
->sk_write_queue
.lock
);
165 rawsock_report_error(sk
, err
);
169 static void rawsock_tx_work(struct work_struct
*work
)
171 struct sock
*sk
= to_rawsock_sk(work
);
172 struct nfc_dev
*dev
= nfc_rawsock(sk
)->dev
;
173 u32 target_idx
= nfc_rawsock(sk
)->target_idx
;
177 pr_debug("sk=%p target_idx=%u\n", sk
, target_idx
);
179 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
180 rawsock_write_queue_purge(sk
);
184 skb
= skb_dequeue(&sk
->sk_write_queue
);
187 rc
= nfc_data_exchange(dev
, target_idx
, skb
,
188 rawsock_data_exchange_complete
, sk
);
190 rawsock_report_error(sk
, rc
);
195 static int rawsock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
196 struct msghdr
*msg
, size_t len
)
198 struct sock
*sk
= sock
->sk
;
199 struct nfc_dev
*dev
= nfc_rawsock(sk
)->dev
;
203 pr_debug("sock=%p sk=%p len=%zu\n", sock
, sk
, len
);
205 if (msg
->msg_namelen
)
208 if (sock
->state
!= SS_CONNECTED
)
211 skb
= sock_alloc_send_skb(sk
, len
+ dev
->tx_headroom
+ dev
->tx_tailroom
+ NFC_HEADER_SIZE
,
212 msg
->msg_flags
& MSG_DONTWAIT
, &rc
);
216 skb_reserve(skb
, dev
->tx_headroom
+ NFC_HEADER_SIZE
);
218 rc
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
224 spin_lock_bh(&sk
->sk_write_queue
.lock
);
225 __skb_queue_tail(&sk
->sk_write_queue
, skb
);
226 if (!nfc_rawsock(sk
)->tx_work_scheduled
) {
227 schedule_work(&nfc_rawsock(sk
)->tx_work
);
228 nfc_rawsock(sk
)->tx_work_scheduled
= true;
230 spin_unlock_bh(&sk
->sk_write_queue
.lock
);
235 static int rawsock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
236 struct msghdr
*msg
, size_t len
, int flags
)
238 int noblock
= flags
& MSG_DONTWAIT
;
239 struct sock
*sk
= sock
->sk
;
244 pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock
, sk
, len
, flags
);
246 skb
= skb_recv_datagram(sk
, flags
, noblock
, &rc
);
250 msg
->msg_namelen
= 0;
254 msg
->msg_flags
|= MSG_TRUNC
;
258 rc
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
260 skb_free_datagram(sk
, skb
);
262 return rc
? : copied
;
266 static const struct proto_ops rawsock_ops
= {
268 .owner
= THIS_MODULE
,
269 .release
= rawsock_release
,
270 .bind
= sock_no_bind
,
271 .connect
= rawsock_connect
,
272 .socketpair
= sock_no_socketpair
,
273 .accept
= sock_no_accept
,
274 .getname
= sock_no_getname
,
275 .poll
= datagram_poll
,
276 .ioctl
= sock_no_ioctl
,
277 .listen
= sock_no_listen
,
278 .shutdown
= sock_no_shutdown
,
279 .setsockopt
= sock_no_setsockopt
,
280 .getsockopt
= sock_no_getsockopt
,
281 .sendmsg
= rawsock_sendmsg
,
282 .recvmsg
= rawsock_recvmsg
,
283 .mmap
= sock_no_mmap
,
286 static void rawsock_destruct(struct sock
*sk
)
288 pr_debug("sk=%p\n", sk
);
290 if (sk
->sk_state
== TCP_ESTABLISHED
) {
291 nfc_deactivate_target(nfc_rawsock(sk
)->dev
,
292 nfc_rawsock(sk
)->target_idx
);
293 nfc_put_device(nfc_rawsock(sk
)->dev
);
296 skb_queue_purge(&sk
->sk_receive_queue
);
298 if (!sock_flag(sk
, SOCK_DEAD
)) {
299 pr_err("Freeing alive NFC raw socket %p\n", sk
);
304 static int rawsock_create(struct net
*net
, struct socket
*sock
,
305 const struct nfc_protocol
*nfc_proto
)
309 pr_debug("sock=%p\n", sock
);
311 if (sock
->type
!= SOCK_SEQPACKET
)
312 return -ESOCKTNOSUPPORT
;
314 sock
->ops
= &rawsock_ops
;
316 sk
= sk_alloc(net
, PF_NFC
, GFP_KERNEL
, nfc_proto
->proto
);
320 sock_init_data(sock
, sk
);
321 sk
->sk_protocol
= nfc_proto
->id
;
322 sk
->sk_destruct
= rawsock_destruct
;
323 sock
->state
= SS_UNCONNECTED
;
325 INIT_WORK(&nfc_rawsock(sk
)->tx_work
, rawsock_tx_work
);
326 nfc_rawsock(sk
)->tx_work_scheduled
= false;
331 static struct proto rawsock_proto
= {
333 .owner
= THIS_MODULE
,
334 .obj_size
= sizeof(struct nfc_rawsock
),
337 static const struct nfc_protocol rawsock_nfc_proto
= {
338 .id
= NFC_SOCKPROTO_RAW
,
339 .proto
= &rawsock_proto
,
340 .owner
= THIS_MODULE
,
341 .create
= rawsock_create
344 int __init
rawsock_init(void)
348 rc
= nfc_proto_register(&rawsock_nfc_proto
);
353 void rawsock_exit(void)
355 nfc_proto_unregister(&rawsock_nfc_proto
);