projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
myri10ge: check fragmentation in LRO get_frag_header()
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / rfcomm / sock.c
CommitLineData
8e87d142 1/*
1da177e4
LT		 2 RFCOMM implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
4 Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation;
9
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142
YH		 14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4
LT		 17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
8e87d142
YH		 19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 21 SOFTWARE IS DISCLAIMED.
22*/
23
24/*
25 * RFCOMM sockets.
1da177e4
LT		 26 */
27
1da177e4
LT		 28#include <linux/module.h>
29
30#include <linux/types.h>
31#include <linux/errno.h>
32#include <linux/kernel.h>
1da177e4
LT		 33#include <linux/sched.h>
34#include <linux/slab.h>
35#include <linux/poll.h>
36#include <linux/fcntl.h>
37#include <linux/init.h>
38#include <linux/interrupt.h>
39#include <linux/socket.h>
40#include <linux/skbuff.h>
41#include <linux/list.h>
be9d1227 42#include <linux/device.h>
1da177e4
LT		 43#include <net/sock.h>
44
45#include <asm/system.h>
46#include <asm/uaccess.h>
47
48#include <net/bluetooth/bluetooth.h>
49#include <net/bluetooth/hci_core.h>
50#include <net/bluetooth/l2cap.h>
51#include <net/bluetooth/rfcomm.h>
52
90ddc4f0 53static const struct proto_ops rfcomm_sock_ops;
1da177e4
LT		 54
55static struct bt_sock_list rfcomm_sk_list = {
d5fb2962 56 .lock = __RW_LOCK_UNLOCKED(rfcomm_sk_list.lock)
1da177e4
LT		 57};
58
59static void rfcomm_sock_close(struct sock *sk);
60static void rfcomm_sock_kill(struct sock *sk);
61
62/* ---- DLC callbacks ----
63 *
64 * called under rfcomm_dlc_lock()
65 */
66static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
67{
68 struct sock *sk = d->owner;
69 if (!sk)
70 return;
71
72 atomic_add(skb->len, &sk->sk_rmem_alloc);
73 skb_queue_tail(&sk->sk_receive_queue, skb);
74 sk->sk_data_ready(sk, skb->len);
75
76 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
77 rfcomm_dlc_throttle(d);
78}
79
80static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
81{
82 struct sock *sk = d->owner, *parent;
83 if (!sk)
84 return;
85
86 BT_DBG("dlc %p state %ld err %d", d, d->state, err);
87
88 bh_lock_sock(sk);
89
90 if (err)
91 sk->sk_err = err;
92
93 sk->sk_state = d->state;
94
95 parent = bt_sk(sk)->parent;
96 if (parent) {
97 if (d->state == BT_CLOSED) {
98 sock_set_flag(sk, SOCK_ZAPPED);
99 bt_accept_unlink(sk);
100 }
101 parent->sk_data_ready(parent, 0);
102 } else {
103 if (d->state == BT_CONNECTED)
104 rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
105 sk->sk_state_change(sk);
106 }
107
108 bh_unlock_sock(sk);
109
110 if (parent && sock_flag(sk, SOCK_ZAPPED)) {
111 /* We have to drop DLC lock here, otherwise
112 * rfcomm_sock_destruct() will dead lock. */
113 rfcomm_dlc_unlock(d);
114 rfcomm_sock_kill(sk);
115 rfcomm_dlc_lock(d);
116 }
117}
118
119/* ---- Socket functions ---- */
120static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
121{
122 struct sock *sk = NULL;
123 struct hlist_node *node;
124
125 sk_for_each(sk, node, &rfcomm_sk_list.head) {
8e87d142 126 if (rfcomm_pi(sk)->channel == channel &&
1da177e4
LT		 127 !bacmp(&bt_sk(sk)->src, src))
128 break;
129 }
130
131 return node ? sk : NULL;
132}
133
134/* Find socket with channel and source bdaddr.
135 * Returns closest match.
136 */
137static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
138{
139 struct sock *sk = NULL, *sk1 = NULL;
140 struct hlist_node *node;
141
142 sk_for_each(sk, node, &rfcomm_sk_list.head) {
143 if (state && sk->sk_state != state)
144 continue;
145
146 if (rfcomm_pi(sk)->channel == channel) {
147 /* Exact match. */
148 if (!bacmp(&bt_sk(sk)->src, src))
149 break;
150
151 /* Closest match */
152 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
153 sk1 = sk;
154 }
155 }
156 return node ? sk : sk1;
157}
158
159/* Find socket with given address (channel, src).
160 * Returns locked socket */
161static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
162{
163 struct sock *s;
164 read_lock(&rfcomm_sk_list.lock);
165 s = __rfcomm_get_sock_by_channel(state, channel, src);
166 if (s) bh_lock_sock(s);
167 read_unlock(&rfcomm_sk_list.lock);
168 return s;
169}
170
171static void rfcomm_sock_destruct(struct sock *sk)
172{
173 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
174
175 BT_DBG("sk %p dlc %p", sk, d);
176
177 skb_queue_purge(&sk->sk_receive_queue);
178 skb_queue_purge(&sk->sk_write_queue);
179
180 rfcomm_dlc_lock(d);
181 rfcomm_pi(sk)->dlc = NULL;
182
183 /* Detach DLC if it's owned by this socket */
184 if (d->owner == sk)
185 d->owner = NULL;
186 rfcomm_dlc_unlock(d);
187
188 rfcomm_dlc_put(d);
189}
190
191static void rfcomm_sock_cleanup_listen(struct sock *parent)
192{
193 struct sock *sk;
194
195 BT_DBG("parent %p", parent);
196
197 /* Close not yet accepted dlcs */
198 while ((sk = bt_accept_dequeue(parent, NULL))) {
199 rfcomm_sock_close(sk);
200 rfcomm_sock_kill(sk);
201 }
202
203 parent->sk_state = BT_CLOSED;
204 sock_set_flag(parent, SOCK_ZAPPED);
205}
206
207/* Kill socket (only if zapped and orphan)
208 * Must be called on unlocked socket.
209 */
210static void rfcomm_sock_kill(struct sock *sk)
211{
212 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
213 return;
214
215 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
216
217 /* Kill poor orphan */
218 bt_sock_unlink(&rfcomm_sk_list, sk);
219 sock_set_flag(sk, SOCK_DEAD);
220 sock_put(sk);
221}
222
223static void __rfcomm_sock_close(struct sock *sk)
224{
225 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
226
227 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
228
229 switch (sk->sk_state) {
230 case BT_LISTEN:
231 rfcomm_sock_cleanup_listen(sk);
232 break;
233
234 case BT_CONNECT:
235 case BT_CONNECT2:
236 case BT_CONFIG:
237 case BT_CONNECTED:
238 rfcomm_dlc_close(d, 0);
239
240 default:
241 sock_set_flag(sk, SOCK_ZAPPED);
242 break;
243 }
244}
245
246/* Close socket.
247 * Must be called on unlocked socket.
248 */
249static void rfcomm_sock_close(struct sock *sk)
250{
251 lock_sock(sk);
252 __rfcomm_sock_close(sk);
253 release_sock(sk);
254}
255
256static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
257{
258 struct rfcomm_pinfo *pi = rfcomm_pi(sk);
259
260 BT_DBG("sk %p", sk);
261
262 if (parent) {
263 sk->sk_type = parent->sk_type;
264 pi->link_mode = rfcomm_pi(parent)->link_mode;
265 } else {
266 pi->link_mode = 0;
267 }
268
269 pi->dlc->link_mode = pi->link_mode;
270}
271
272static struct proto rfcomm_proto = {
273 .name = "RFCOMM",
274 .owner = THIS_MODULE,
275 .obj_size = sizeof(struct rfcomm_pinfo)
276};
277
1b8d7ae4 278static struct sock *rfcomm_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1da177e4
LT		 279{
280 struct rfcomm_dlc *d;
281 struct sock *sk;
282
6257ff21 283 sk = sk_alloc(net, PF_BLUETOOTH, prio, &rfcomm_proto);
1da177e4
LT		 284 if (!sk)
285 return NULL;
286
287 sock_init_data(sock, sk);
288 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
289
290 d = rfcomm_dlc_alloc(prio);
291 if (!d) {
292 sk_free(sk);
293 return NULL;
294 }
295
296 d->data_ready = rfcomm_sk_data_ready;
297 d->state_change = rfcomm_sk_state_change;
298
299 rfcomm_pi(sk)->dlc = d;
300 d->owner = sk;
301
302 sk->sk_destruct = rfcomm_sock_destruct;
303 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
304
77db1980
MH		 305 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
306 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
1da177e4
LT		 307
308 sock_reset_flag(sk, SOCK_ZAPPED);
309
310 sk->sk_protocol = proto;
77db1980 311 sk->sk_state = BT_OPEN;
1da177e4
LT		 312
313 bt_sock_link(&rfcomm_sk_list, sk);
314
315 BT_DBG("sk %p", sk);
316 return sk;
317}
318
1b8d7ae4 319static int rfcomm_sock_create(struct net *net, struct socket *sock, int protocol)
1da177e4
LT		 320{
321 struct sock *sk;
322
323 BT_DBG("sock %p", sock);
324
325 sock->state = SS_UNCONNECTED;
326
327 if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
328 return -ESOCKTNOSUPPORT;
329
330 sock->ops = &rfcomm_sock_ops;
331
1b8d7ae4 332 sk = rfcomm_sock_alloc(net, sock, protocol, GFP_ATOMIC);
74da626a 333 if (!sk)
1da177e4
LT		 334 return -ENOMEM;
335
336 rfcomm_sock_init(sk, NULL);
337 return 0;
338}
339
340static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
341{
342 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
343 struct sock *sk = sock->sk;
344 int err = 0;
345
346 BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
347
348 if (!addr || addr->sa_family != AF_BLUETOOTH)
349 return -EINVAL;
350
351 lock_sock(sk);
352
353 if (sk->sk_state != BT_OPEN) {
354 err = -EBADFD;
355 goto done;
356 }
357
354d28d5
MH		 358 if (sk->sk_type != SOCK_STREAM) {
359 err = -EINVAL;
360 goto done;
361 }
362
1da177e4
LT		 363 write_lock_bh(&rfcomm_sk_list.lock);
364
365 if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
366 err = -EADDRINUSE;
367 } else {
368 /* Save source address */
369 bacpy(&bt_sk(sk)->src, &sa->rc_bdaddr);
370 rfcomm_pi(sk)->channel = sa->rc_channel;
371 sk->sk_state = BT_BOUND;
372 }
373
374 write_unlock_bh(&rfcomm_sk_list.lock);
375
376done:
377 release_sock(sk);
378 return err;
379}
380
381static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
382{
383 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
384 struct sock *sk = sock->sk;
385 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
386 int err = 0;
387
388 BT_DBG("sk %p", sk);
389
390 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
391 return -EINVAL;
392
354d28d5 393 lock_sock(sk);
1da177e4 394
354d28d5
MH		 395 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
396 err = -EBADFD;
397 goto done;
398 }
1da177e4 399
354d28d5
MH		 400 if (sk->sk_type != SOCK_STREAM) {
401 err = -EINVAL;
402 goto done;
403 }
1da177e4
LT		 404
405 sk->sk_state = BT_CONNECT;
406 bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
407 rfcomm_pi(sk)->channel = sa->rc_channel;
408
77db1980
MH		 409 d->link_mode = rfcomm_pi(sk)->link_mode;
410
1da177e4
LT		 411 err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
412 if (!err)
413 err = bt_sock_wait_state(sk, BT_CONNECTED,
414 sock_sndtimeo(sk, flags & O_NONBLOCK));
415
354d28d5 416done:
1da177e4
LT		 417 release_sock(sk);
418 return err;
419}
420
421static int rfcomm_sock_listen(struct socket *sock, int backlog)
422{
423 struct sock *sk = sock->sk;
424 int err = 0;
425
426 BT_DBG("sk %p backlog %d", sk, backlog);
427
428 lock_sock(sk);
429
430 if (sk->sk_state != BT_BOUND) {
431 err = -EBADFD;
432 goto done;
433 }
434
354d28d5
MH		 435 if (sk->sk_type != SOCK_STREAM) {
436 err = -EINVAL;
437 goto done;
438 }
439
1da177e4
LT		 440 if (!rfcomm_pi(sk)->channel) {
441 bdaddr_t *src = &bt_sk(sk)->src;
442 u8 channel;
443
444 err = -EINVAL;
445
446 write_lock_bh(&rfcomm_sk_list.lock);
447
448 for (channel = 1; channel < 31; channel++)
449 if (!__rfcomm_get_sock_by_addr(channel, src)) {
450 rfcomm_pi(sk)->channel = channel;
451 err = 0;
452 break;
453 }
454
455 write_unlock_bh(&rfcomm_sk_list.lock);
456
457 if (err < 0)
458 goto done;
459 }
460
461 sk->sk_max_ack_backlog = backlog;
462 sk->sk_ack_backlog = 0;
463 sk->sk_state = BT_LISTEN;
464
465done:
466 release_sock(sk);
467 return err;
468}
469
470static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
471{
472 DECLARE_WAITQUEUE(wait, current);
473 struct sock *sk = sock->sk, *nsk;
474 long timeo;
475 int err = 0;
476
477 lock_sock(sk);
478
479 if (sk->sk_state != BT_LISTEN) {
480 err = -EBADFD;
481 goto done;
482 }
483
354d28d5
MH		 484 if (sk->sk_type != SOCK_STREAM) {
485 err = -EINVAL;
486 goto done;
487 }
488
1da177e4
LT		 489 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
490
491 BT_DBG("sk %p timeo %ld", sk, timeo);
492
493 /* Wait for an incoming connection. (wake-one). */
494 add_wait_queue_exclusive(sk->sk_sleep, &wait);
495 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
496 set_current_state(TASK_INTERRUPTIBLE);
497 if (!timeo) {
498 err = -EAGAIN;
499 break;
500 }
501
502 release_sock(sk);
503 timeo = schedule_timeout(timeo);
504 lock_sock(sk);
505
506 if (sk->sk_state != BT_LISTEN) {
507 err = -EBADFD;
508 break;
509 }
510
511 if (signal_pending(current)) {
512 err = sock_intr_errno(timeo);
513 break;
514 }
515 }
516 set_current_state(TASK_RUNNING);
517 remove_wait_queue(sk->sk_sleep, &wait);
518
519 if (err)
520 goto done;
521
522 newsock->state = SS_CONNECTED;
523
524 BT_DBG("new socket %p", nsk);
525
526done:
527 release_sock(sk);
528 return err;
529}
530
531static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
532{
533 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
534 struct sock *sk = sock->sk;
535
536 BT_DBG("sock %p, sk %p", sock, sk);
537
538 sa->rc_family = AF_BLUETOOTH;
539 sa->rc_channel = rfcomm_pi(sk)->channel;
540 if (peer)
541 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
542 else
543 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
544
545 *len = sizeof(struct sockaddr_rc);
546 return 0;
547}
548
549static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
550 struct msghdr *msg, size_t len)
551{
552 struct sock *sk = sock->sk;
553 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
554 struct sk_buff *skb;
1da177e4
LT		 555 int sent = 0;
556
557 if (msg->msg_flags & MSG_OOB)
558 return -EOPNOTSUPP;
559
560 if (sk->sk_shutdown & SEND_SHUTDOWN)
561 return -EPIPE;
562
563 BT_DBG("sock %p, sk %p", sock, sk);
564
565 lock_sock(sk);
566
567 while (len) {
568 size_t size = min_t(size_t, len, d->mtu);
4d6a2188 569 int err;
8e87d142 570
1da177e4
LT		 571 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
572 msg->msg_flags & MSG_DONTWAIT, &err);
573 if (!skb)
574 break;
575 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
576
577 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
578 if (err) {
579 kfree_skb(skb);
4d6a2188
MH		 580 if (sent == 0)
581 sent = err;
1da177e4
LT		 582 break;
583 }
584
585 err = rfcomm_dlc_send(d, skb);
586 if (err < 0) {
587 kfree_skb(skb);
4d6a2188
MH		 588 if (sent == 0)
589 sent = err;
1da177e4
LT		 590 break;
591 }
592
593 sent += size;
594 len -= size;
595 }
596
597 release_sock(sk);
598
4d6a2188 599 return sent;
1da177e4
LT		 600}
601
602static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
603{
604 DECLARE_WAITQUEUE(wait, current);
605
606 add_wait_queue(sk->sk_sleep, &wait);
607 for (;;) {
608 set_current_state(TASK_INTERRUPTIBLE);
609
b03efcfb
DM		 610 if (!skb_queue_empty(&sk->sk_receive_queue) ||
611 sk->sk_err ||
612 (sk->sk_shutdown & RCV_SHUTDOWN) ||
613 signal_pending(current) ||
614 !timeo)
1da177e4
LT		 615 break;
616
617 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
618 release_sock(sk);
619 timeo = schedule_timeout(timeo);
620 lock_sock(sk);
621 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
622 }
623
624 __set_current_state(TASK_RUNNING);
625 remove_wait_queue(sk->sk_sleep, &wait);
626 return timeo;
627}
628
629static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
630 struct msghdr *msg, size_t size, int flags)
631{
632 struct sock *sk = sock->sk;
633 int err = 0;
634 size_t target, copied = 0;
635 long timeo;
636
637 if (flags & MSG_OOB)
638 return -EOPNOTSUPP;
639
640 msg->msg_namelen = 0;
641
a418b893 642 BT_DBG("sk %p size %zu", sk, size);
1da177e4
LT		 643
644 lock_sock(sk);
645
646 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
647 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
648
649 do {
650 struct sk_buff *skb;
651 int chunk;
652
653 skb = skb_dequeue(&sk->sk_receive_queue);
654 if (!skb) {
655 if (copied >= target)
656 break;
657
658 if ((err = sock_error(sk)) != 0)
659 break;
660 if (sk->sk_shutdown & RCV_SHUTDOWN)
661 break;
662
663 err = -EAGAIN;
664 if (!timeo)
665 break;
666
667 timeo = rfcomm_sock_data_wait(sk, timeo);
668
669 if (signal_pending(current)) {
670 err = sock_intr_errno(timeo);
671 goto out;
672 }
673 continue;
674 }
675
676 chunk = min_t(unsigned int, skb->len, size);
677 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
678 skb_queue_head(&sk->sk_receive_queue, skb);
679 if (!copied)
680 copied = -EFAULT;
681 break;
682 }
683 copied += chunk;
684 size -= chunk;
685
3241ad82
MH		 686 sock_recv_timestamp(msg, sk, skb);
687
1da177e4
LT		 688 if (!(flags & MSG_PEEK)) {
689 atomic_sub(chunk, &sk->sk_rmem_alloc);
690
691 skb_pull(skb, chunk);
692 if (skb->len) {
693 skb_queue_head(&sk->sk_receive_queue, skb);
694 break;
695 }
696 kfree_skb(skb);
697
698 } else {
699 /* put message back and return */
700 skb_queue_head(&sk->sk_receive_queue, skb);
701 break;
702 }
703 } while (size);
704
705out:
706 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
707 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
708
709 release_sock(sk);
710 return copied ? : err;
711}
712
713static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
714{
715 struct sock *sk = sock->sk;
716 int err = 0;
717 u32 opt;
718
719 BT_DBG("sk %p", sk);
720
721 lock_sock(sk);
722
723 switch (optname) {
724 case RFCOMM_LM:
725 if (get_user(opt, (u32 __user *) optval)) {
726 err = -EFAULT;
727 break;
728 }
729
730 rfcomm_pi(sk)->link_mode = opt;
731 break;
732
733 default:
734 err = -ENOPROTOOPT;
735 break;
736 }
737
738 release_sock(sk);
739 return err;
740}
741
742static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
743{
744 struct sock *sk = sock->sk;
745 struct sock *l2cap_sk;
746 struct rfcomm_conninfo cinfo;
747 int len, err = 0;
748
749 BT_DBG("sk %p", sk);
750
751 if (get_user(len, optlen))
752 return -EFAULT;
753
754 lock_sock(sk);
755
756 switch (optname) {
757 case RFCOMM_LM:
758 if (put_user(rfcomm_pi(sk)->link_mode, (u32 __user *) optval))
759 err = -EFAULT;
760 break;
761
762 case RFCOMM_CONNINFO:
763 if (sk->sk_state != BT_CONNECTED) {
764 err = -ENOTCONN;
765 break;
766 }
767
768 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
769
770 cinfo.hci_handle = l2cap_pi(l2cap_sk)->conn->hcon->handle;
771 memcpy(cinfo.dev_class, l2cap_pi(l2cap_sk)->conn->hcon->dev_class, 3);
772
773 len = min_t(unsigned int, len, sizeof(cinfo));
774 if (copy_to_user(optval, (char *) &cinfo, len))
775 err = -EFAULT;
776
777 break;
778
779 default:
780 err = -ENOPROTOOPT;
781 break;
782 }
783
784 release_sock(sk);
785 return err;
786}
787
788static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
789{
45555c0e 790#if defined(CONFIG_BT_RFCOMM_TTY) || defined(CONFIG_BT_RFCOMM_DEBUG)
1da177e4 791 struct sock *sk = sock->sk;
45555c0e 792#endif
1da177e4
LT		 793 int err;
794
6cf1a0f8 795 BT_DBG("sk %p cmd %x arg %lx", sock, cmd, arg);
1da177e4 796
3241ad82 797 err = bt_sock_ioctl(sock, cmd, arg);
1da177e4 798
3241ad82 799 if (err == -ENOIOCTLCMD) {
1da177e4 800#ifdef CONFIG_BT_RFCOMM_TTY
3241ad82
MH		 801 lock_sock(sk);
802 err = rfcomm_dev_ioctl(sk, cmd, (void __user *) arg);
803 release_sock(sk);
1da177e4 804#else
3241ad82 805 err = -EOPNOTSUPP;
1da177e4 806#endif
3241ad82 807 }
1da177e4 808
1da177e4
LT		 809 return err;
810}
811
812static int rfcomm_sock_shutdown(struct socket *sock, int how)
813{
814 struct sock *sk = sock->sk;
815 int err = 0;
816
817 BT_DBG("sock %p, sk %p", sock, sk);
818
819 if (!sk) return 0;
820
821 lock_sock(sk);
822 if (!sk->sk_shutdown) {
823 sk->sk_shutdown = SHUTDOWN_MASK;
824 __rfcomm_sock_close(sk);
825
826 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
827 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
828 }
829 release_sock(sk);
830 return err;
831}
832
833static int rfcomm_sock_release(struct socket *sock)
834{
835 struct sock *sk = sock->sk;
836 int err;
837
838 BT_DBG("sock %p, sk %p", sock, sk);
839
840 if (!sk)
841 return 0;
842
843 err = rfcomm_sock_shutdown(sock, 2);
844
845 sock_orphan(sk);
846 rfcomm_sock_kill(sk);
847 return err;
848}
849
8e87d142 850/* ---- RFCOMM core layer callbacks ----
1da177e4
LT		 851 *
852 * called under rfcomm_lock()
853 */
854int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
855{
856 struct sock *sk, *parent;
857 bdaddr_t src, dst;
858 int result = 0;
859
860 BT_DBG("session %p channel %d", s, channel);
861
862 rfcomm_session_getaddr(s, &src, &dst);
863
864 /* Check if we have socket listening on channel */
865 parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
866 if (!parent)
867 return 0;
868
869 /* Check for backlog size */
870 if (sk_acceptq_is_full(parent)) {
8e87d142 871 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1da177e4
LT		 872 goto done;
873 }
874
3b1e0a65 875 sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
1da177e4
LT		 876 if (!sk)
877 goto done;
878
879 rfcomm_sock_init(sk, parent);
880 bacpy(&bt_sk(sk)->src, &src);
881 bacpy(&bt_sk(sk)->dst, &dst);
882 rfcomm_pi(sk)->channel = channel;
883
884 sk->sk_state = BT_CONFIG;
885 bt_accept_enqueue(parent, sk);
886
887 /* Accept connection and return socket DLC */
888 *d = rfcomm_pi(sk)->dlc;
889 result = 1;
890
891done:
892 bh_unlock_sock(parent);
893 return result;
894}
895
be9d1227 896static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf)
1da177e4
LT		 897{
898 struct sock *sk;
899 struct hlist_node *node;
be9d1227 900 char *str = buf;
1da177e4
LT		 901
902 read_lock_bh(&rfcomm_sk_list.lock);
903
be9d1227
MH		 904 sk_for_each(sk, node, &rfcomm_sk_list.head) {
905 str += sprintf(str, "%s %s %d %d\n",
906 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
907 sk->sk_state, rfcomm_pi(sk)->channel);
908 }
1da177e4 909
1da177e4 910 read_unlock_bh(&rfcomm_sk_list.lock);
1da177e4 911
be9d1227 912 return (str - buf);
1da177e4
LT		 913}
914
be9d1227 915static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL);
1da177e4 916
90ddc4f0 917static const struct proto_ops rfcomm_sock_ops = {
1da177e4
LT		 918 .family = PF_BLUETOOTH,
919 .owner = THIS_MODULE,
920 .release = rfcomm_sock_release,
921 .bind = rfcomm_sock_bind,
922 .connect = rfcomm_sock_connect,
923 .listen = rfcomm_sock_listen,
924 .accept = rfcomm_sock_accept,
925 .getname = rfcomm_sock_getname,
926 .sendmsg = rfcomm_sock_sendmsg,
927 .recvmsg = rfcomm_sock_recvmsg,
928 .shutdown = rfcomm_sock_shutdown,
929 .setsockopt = rfcomm_sock_setsockopt,
930 .getsockopt = rfcomm_sock_getsockopt,
931 .ioctl = rfcomm_sock_ioctl,
932 .poll = bt_sock_poll,
933 .socketpair = sock_no_socketpair,
934 .mmap = sock_no_mmap
935};
936
937static struct net_proto_family rfcomm_sock_family_ops = {
938 .family = PF_BLUETOOTH,
939 .owner = THIS_MODULE,
940 .create = rfcomm_sock_create
941};
942
be9d1227 943int __init rfcomm_init_sockets(void)
1da177e4
LT		 944{
945 int err;
946
947 err = proto_register(&rfcomm_proto, 0);
948 if (err < 0)
949 return err;
950
951 err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
952 if (err < 0)
953 goto error;
954
df5c37ea
MH		 955 if (class_create_file(bt_class, &class_attr_rfcomm) < 0)
956 BT_ERR("Failed to create RFCOMM info file");
1da177e4
LT		 957
958 BT_INFO("RFCOMM socket layer initialized");
959
960 return 0;
961
962error:
963 BT_ERR("RFCOMM socket layer registration failed");
964 proto_unregister(&rfcomm_proto);
965 return err;
966}
967
968void __exit rfcomm_cleanup_sockets(void)
969{
a91f2e39 970 class_remove_file(bt_class, &class_attr_rfcomm);
1da177e4
LT		 971
972 if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
973 BT_ERR("RFCOMM socket layer unregistration failed");
974
975 proto_unregister(&rfcomm_proto);
976}
kernel source for telekom puls (alcatel/mediatek)