2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4 Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
5 Copyright (C) 2010 Google Inc.
7 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 2 as
11 published by the Free Software Foundation;
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
16 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
17 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
18 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
23 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
24 SOFTWARE IS DISCLAIMED.
27 /* Bluetooth L2CAP sockets. */
29 #include <net/bluetooth/bluetooth.h>
30 #include <net/bluetooth/hci_core.h>
31 #include <net/bluetooth/l2cap.h>
33 /* ---- L2CAP timers ---- */
34 static void l2cap_sock_timeout(unsigned long arg
)
36 struct sock
*sk
= (struct sock
*) arg
;
39 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
43 if (sock_owned_by_user(sk
)) {
44 /* sk is owned by user. Try again later */
45 l2cap_sock_set_timer(sk
, HZ
/ 5);
51 if (sk
->sk_state
== BT_CONNECTED
|| sk
->sk_state
== BT_CONFIG
)
52 reason
= ECONNREFUSED
;
53 else if (sk
->sk_state
== BT_CONNECT
&&
54 l2cap_pi(sk
)->chan
->sec_level
!= BT_SECURITY_SDP
)
55 reason
= ECONNREFUSED
;
59 __l2cap_sock_close(sk
, reason
);
67 void l2cap_sock_set_timer(struct sock
*sk
, long timeout
)
69 BT_DBG("sk %p state %d timeout %ld", sk
, sk
->sk_state
, timeout
);
70 sk_reset_timer(sk
, &sk
->sk_timer
, jiffies
+ timeout
);
73 void l2cap_sock_clear_timer(struct sock
*sk
)
75 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
76 sk_stop_timer(sk
, &sk
->sk_timer
);
79 static struct sock
*__l2cap_get_sock_by_addr(__le16 psm
, bdaddr_t
*src
)
82 struct hlist_node
*node
;
83 sk_for_each(sk
, node
, &l2cap_sk_list
.head
)
84 if (l2cap_pi(sk
)->sport
== psm
&& !bacmp(&bt_sk(sk
)->src
, src
))
91 static int l2cap_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int alen
)
93 struct sock
*sk
= sock
->sk
;
94 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
95 struct sockaddr_l2 la
;
100 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
103 memset(&la
, 0, sizeof(la
));
104 len
= min_t(unsigned int, sizeof(la
), alen
);
105 memcpy(&la
, addr
, len
);
107 if (la
.l2_cid
&& la
.l2_psm
)
112 if (sk
->sk_state
!= BT_OPEN
) {
118 __u16 psm
= __le16_to_cpu(la
.l2_psm
);
120 /* PSM must be odd and lsb of upper byte must be 0 */
121 if ((psm
& 0x0101) != 0x0001) {
126 /* Restrict usage of well-known PSMs */
127 if (psm
< 0x1001 && !capable(CAP_NET_BIND_SERVICE
)) {
133 write_lock_bh(&l2cap_sk_list
.lock
);
135 if (la
.l2_psm
&& __l2cap_get_sock_by_addr(la
.l2_psm
, &la
.l2_bdaddr
)) {
138 /* Save source address */
139 bacpy(&bt_sk(sk
)->src
, &la
.l2_bdaddr
);
140 l2cap_pi(sk
)->psm
= la
.l2_psm
;
141 l2cap_pi(sk
)->sport
= la
.l2_psm
;
142 sk
->sk_state
= BT_BOUND
;
144 if (__le16_to_cpu(la
.l2_psm
) == 0x0001 ||
145 __le16_to_cpu(la
.l2_psm
) == 0x0003)
146 chan
->sec_level
= BT_SECURITY_SDP
;
150 l2cap_pi(sk
)->scid
= la
.l2_cid
;
152 write_unlock_bh(&l2cap_sk_list
.lock
);
159 static int l2cap_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
161 struct sock
*sk
= sock
->sk
;
162 struct sockaddr_l2 la
;
167 if (!addr
|| alen
< sizeof(addr
->sa_family
) ||
168 addr
->sa_family
!= AF_BLUETOOTH
)
171 memset(&la
, 0, sizeof(la
));
172 len
= min_t(unsigned int, sizeof(la
), alen
);
173 memcpy(&la
, addr
, len
);
175 if (la
.l2_cid
&& la
.l2_psm
)
180 if ((sk
->sk_type
== SOCK_SEQPACKET
|| sk
->sk_type
== SOCK_STREAM
)
181 && !(la
.l2_psm
|| la
.l2_cid
)) {
186 switch (l2cap_pi(sk
)->mode
) {
187 case L2CAP_MODE_BASIC
:
189 case L2CAP_MODE_ERTM
:
190 case L2CAP_MODE_STREAMING
:
199 switch (sk
->sk_state
) {
203 /* Already connecting */
207 /* Already connected */
221 /* PSM must be odd and lsb of upper byte must be 0 */
222 if ((__le16_to_cpu(la
.l2_psm
) & 0x0101) != 0x0001 &&
223 sk
->sk_type
!= SOCK_RAW
&& !la
.l2_cid
) {
228 /* Set destination address and psm */
229 bacpy(&bt_sk(sk
)->dst
, &la
.l2_bdaddr
);
230 l2cap_pi(sk
)->psm
= la
.l2_psm
;
231 l2cap_pi(sk
)->dcid
= la
.l2_cid
;
233 err
= l2cap_chan_connect(l2cap_pi(sk
)->chan
);
238 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
239 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
245 static int l2cap_sock_listen(struct socket
*sock
, int backlog
)
247 struct sock
*sk
= sock
->sk
;
250 BT_DBG("sk %p backlog %d", sk
, backlog
);
254 if ((sock
->type
!= SOCK_SEQPACKET
&& sock
->type
!= SOCK_STREAM
)
255 || sk
->sk_state
!= BT_BOUND
) {
260 switch (l2cap_pi(sk
)->mode
) {
261 case L2CAP_MODE_BASIC
:
263 case L2CAP_MODE_ERTM
:
264 case L2CAP_MODE_STREAMING
:
273 if (!l2cap_pi(sk
)->psm
&& !l2cap_pi(sk
)->scid
) {
274 bdaddr_t
*src
= &bt_sk(sk
)->src
;
279 write_lock_bh(&l2cap_sk_list
.lock
);
281 for (psm
= 0x1001; psm
< 0x1100; psm
+= 2)
282 if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm
), src
)) {
283 l2cap_pi(sk
)->psm
= cpu_to_le16(psm
);
284 l2cap_pi(sk
)->sport
= cpu_to_le16(psm
);
289 write_unlock_bh(&l2cap_sk_list
.lock
);
295 sk
->sk_max_ack_backlog
= backlog
;
296 sk
->sk_ack_backlog
= 0;
297 sk
->sk_state
= BT_LISTEN
;
304 static int l2cap_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
306 DECLARE_WAITQUEUE(wait
, current
);
307 struct sock
*sk
= sock
->sk
, *nsk
;
311 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
313 if (sk
->sk_state
!= BT_LISTEN
) {
318 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
320 BT_DBG("sk %p timeo %ld", sk
, timeo
);
322 /* Wait for an incoming connection. (wake-one). */
323 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
324 while (!(nsk
= bt_accept_dequeue(sk
, newsock
))) {
325 set_current_state(TASK_INTERRUPTIBLE
);
332 timeo
= schedule_timeout(timeo
);
333 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
335 if (sk
->sk_state
!= BT_LISTEN
) {
340 if (signal_pending(current
)) {
341 err
= sock_intr_errno(timeo
);
345 set_current_state(TASK_RUNNING
);
346 remove_wait_queue(sk_sleep(sk
), &wait
);
351 newsock
->state
= SS_CONNECTED
;
353 BT_DBG("new socket %p", nsk
);
360 static int l2cap_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
362 struct sockaddr_l2
*la
= (struct sockaddr_l2
*) addr
;
363 struct sock
*sk
= sock
->sk
;
365 BT_DBG("sock %p, sk %p", sock
, sk
);
367 addr
->sa_family
= AF_BLUETOOTH
;
368 *len
= sizeof(struct sockaddr_l2
);
371 la
->l2_psm
= l2cap_pi(sk
)->psm
;
372 bacpy(&la
->l2_bdaddr
, &bt_sk(sk
)->dst
);
373 la
->l2_cid
= cpu_to_le16(l2cap_pi(sk
)->dcid
);
375 la
->l2_psm
= l2cap_pi(sk
)->sport
;
376 bacpy(&la
->l2_bdaddr
, &bt_sk(sk
)->src
);
377 la
->l2_cid
= cpu_to_le16(l2cap_pi(sk
)->scid
);
383 static int l2cap_sock_getsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, int __user
*optlen
)
385 struct sock
*sk
= sock
->sk
;
386 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
387 struct l2cap_options opts
;
388 struct l2cap_conninfo cinfo
;
394 if (get_user(len
, optlen
))
401 memset(&opts
, 0, sizeof(opts
));
402 opts
.imtu
= l2cap_pi(sk
)->imtu
;
403 opts
.omtu
= l2cap_pi(sk
)->omtu
;
404 opts
.flush_to
= l2cap_pi(sk
)->flush_to
;
405 opts
.mode
= l2cap_pi(sk
)->mode
;
406 opts
.fcs
= l2cap_pi(sk
)->fcs
;
407 opts
.max_tx
= l2cap_pi(sk
)->max_tx
;
408 opts
.txwin_size
= (__u16
)l2cap_pi(sk
)->tx_win
;
410 len
= min_t(unsigned int, len
, sizeof(opts
));
411 if (copy_to_user(optval
, (char *) &opts
, len
))
417 switch (chan
->sec_level
) {
418 case BT_SECURITY_LOW
:
421 case BT_SECURITY_MEDIUM
:
422 opt
= L2CAP_LM_AUTH
| L2CAP_LM_ENCRYPT
;
424 case BT_SECURITY_HIGH
:
425 opt
= L2CAP_LM_AUTH
| L2CAP_LM_ENCRYPT
|
433 if (chan
->role_switch
)
434 opt
|= L2CAP_LM_MASTER
;
436 if (chan
->force_reliable
)
437 opt
|= L2CAP_LM_RELIABLE
;
439 if (put_user(opt
, (u32 __user
*) optval
))
444 if (sk
->sk_state
!= BT_CONNECTED
&&
445 !(sk
->sk_state
== BT_CONNECT2
&&
446 bt_sk(sk
)->defer_setup
)) {
451 cinfo
.hci_handle
= l2cap_pi(sk
)->conn
->hcon
->handle
;
452 memcpy(cinfo
.dev_class
, l2cap_pi(sk
)->conn
->hcon
->dev_class
, 3);
454 len
= min_t(unsigned int, len
, sizeof(cinfo
));
455 if (copy_to_user(optval
, (char *) &cinfo
, len
))
469 static int l2cap_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
471 struct sock
*sk
= sock
->sk
;
472 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
473 struct bt_security sec
;
478 if (level
== SOL_L2CAP
)
479 return l2cap_sock_getsockopt_old(sock
, optname
, optval
, optlen
);
481 if (level
!= SOL_BLUETOOTH
)
484 if (get_user(len
, optlen
))
491 if (sk
->sk_type
!= SOCK_SEQPACKET
&& sk
->sk_type
!= SOCK_STREAM
492 && sk
->sk_type
!= SOCK_RAW
) {
497 sec
.level
= chan
->sec_level
;
499 len
= min_t(unsigned int, len
, sizeof(sec
));
500 if (copy_to_user(optval
, (char *) &sec
, len
))
506 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
511 if (put_user(bt_sk(sk
)->defer_setup
, (u32 __user
*) optval
))
517 if (put_user(chan
->flushable
, (u32 __user
*) optval
))
531 static int l2cap_sock_setsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, unsigned int optlen
)
533 struct sock
*sk
= sock
->sk
;
534 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
535 struct l2cap_options opts
;
545 if (sk
->sk_state
== BT_CONNECTED
) {
550 opts
.imtu
= l2cap_pi(sk
)->imtu
;
551 opts
.omtu
= l2cap_pi(sk
)->omtu
;
552 opts
.flush_to
= l2cap_pi(sk
)->flush_to
;
553 opts
.mode
= l2cap_pi(sk
)->mode
;
554 opts
.fcs
= l2cap_pi(sk
)->fcs
;
555 opts
.max_tx
= l2cap_pi(sk
)->max_tx
;
556 opts
.txwin_size
= (__u16
)l2cap_pi(sk
)->tx_win
;
558 len
= min_t(unsigned int, sizeof(opts
), optlen
);
559 if (copy_from_user((char *) &opts
, optval
, len
)) {
564 if (opts
.txwin_size
> L2CAP_DEFAULT_TX_WINDOW
) {
569 l2cap_pi(sk
)->mode
= opts
.mode
;
570 switch (l2cap_pi(sk
)->mode
) {
571 case L2CAP_MODE_BASIC
:
572 chan
->conf_state
&= ~L2CAP_CONF_STATE2_DEVICE
;
574 case L2CAP_MODE_ERTM
:
575 case L2CAP_MODE_STREAMING
:
584 l2cap_pi(sk
)->imtu
= opts
.imtu
;
585 l2cap_pi(sk
)->omtu
= opts
.omtu
;
586 l2cap_pi(sk
)->fcs
= opts
.fcs
;
587 l2cap_pi(sk
)->max_tx
= opts
.max_tx
;
588 l2cap_pi(sk
)->tx_win
= (__u8
)opts
.txwin_size
;
592 if (get_user(opt
, (u32 __user
*) optval
)) {
597 if (opt
& L2CAP_LM_AUTH
)
598 chan
->sec_level
= BT_SECURITY_LOW
;
599 if (opt
& L2CAP_LM_ENCRYPT
)
600 chan
->sec_level
= BT_SECURITY_MEDIUM
;
601 if (opt
& L2CAP_LM_SECURE
)
602 chan
->sec_level
= BT_SECURITY_HIGH
;
604 chan
->role_switch
= (opt
& L2CAP_LM_MASTER
);
605 chan
->force_reliable
= (opt
& L2CAP_LM_RELIABLE
);
617 static int l2cap_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int optlen
)
619 struct sock
*sk
= sock
->sk
;
620 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
621 struct bt_security sec
;
627 if (level
== SOL_L2CAP
)
628 return l2cap_sock_setsockopt_old(sock
, optname
, optval
, optlen
);
630 if (level
!= SOL_BLUETOOTH
)
637 if (sk
->sk_type
!= SOCK_SEQPACKET
&& sk
->sk_type
!= SOCK_STREAM
638 && sk
->sk_type
!= SOCK_RAW
) {
643 sec
.level
= BT_SECURITY_LOW
;
645 len
= min_t(unsigned int, sizeof(sec
), optlen
);
646 if (copy_from_user((char *) &sec
, optval
, len
)) {
651 if (sec
.level
< BT_SECURITY_LOW
||
652 sec
.level
> BT_SECURITY_HIGH
) {
657 chan
->sec_level
= sec
.level
;
661 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
666 if (get_user(opt
, (u32 __user
*) optval
)) {
671 bt_sk(sk
)->defer_setup
= opt
;
675 if (get_user(opt
, (u32 __user
*) optval
)) {
680 if (opt
> BT_FLUSHABLE_ON
) {
685 if (opt
== BT_FLUSHABLE_OFF
) {
686 struct l2cap_conn
*conn
= l2cap_pi(sk
)->conn
;
687 /* proceed futher only when we have l2cap_conn and
688 No Flush support in the LM */
689 if (!conn
|| !lmp_no_flush_capable(conn
->hcon
->hdev
)) {
695 chan
->flushable
= opt
;
707 static int l2cap_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
, size_t len
)
709 struct sock
*sk
= sock
->sk
;
710 struct l2cap_pinfo
*pi
= l2cap_pi(sk
);
715 BT_DBG("sock %p, sk %p", sock
, sk
);
717 err
= sock_error(sk
);
721 if (msg
->msg_flags
& MSG_OOB
)
726 if (sk
->sk_state
!= BT_CONNECTED
) {
731 /* Connectionless channel */
732 if (sk
->sk_type
== SOCK_DGRAM
) {
733 skb
= l2cap_create_connless_pdu(sk
, msg
, len
);
737 l2cap_do_send(pi
->chan
, skb
);
744 case L2CAP_MODE_BASIC
:
745 /* Check outgoing MTU */
746 if (len
> pi
->omtu
) {
751 /* Create a basic PDU */
752 skb
= l2cap_create_basic_pdu(sk
, msg
, len
);
758 l2cap_do_send(pi
->chan
, skb
);
762 case L2CAP_MODE_ERTM
:
763 case L2CAP_MODE_STREAMING
:
764 /* Entire SDU fits into one PDU */
765 if (len
<= pi
->chan
->remote_mps
) {
766 control
= L2CAP_SDU_UNSEGMENTED
;
767 skb
= l2cap_create_iframe_pdu(sk
, msg
, len
, control
, 0);
772 __skb_queue_tail(&pi
->chan
->tx_q
, skb
);
774 if (pi
->chan
->tx_send_head
== NULL
)
775 pi
->chan
->tx_send_head
= skb
;
778 /* Segment SDU into multiples PDUs */
779 err
= l2cap_sar_segment_sdu(pi
->chan
, msg
, len
);
784 if (pi
->mode
== L2CAP_MODE_STREAMING
) {
785 l2cap_streaming_send(pi
->chan
);
790 if ((pi
->chan
->conn_state
& L2CAP_CONN_REMOTE_BUSY
) &&
791 (pi
->chan
->conn_state
& L2CAP_CONN_WAIT_F
)) {
795 err
= l2cap_ertm_send(pi
->chan
);
802 BT_DBG("bad state %1.1x", pi
->mode
);
811 static int l2cap_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
, size_t len
, int flags
)
813 struct sock
*sk
= sock
->sk
;
817 if (sk
->sk_state
== BT_CONNECT2
&& bt_sk(sk
)->defer_setup
) {
818 __l2cap_connect_rsp_defer(sk
);
825 if (sock
->type
== SOCK_STREAM
)
826 return bt_sock_stream_recvmsg(iocb
, sock
, msg
, len
, flags
);
828 return bt_sock_recvmsg(iocb
, sock
, msg
, len
, flags
);
831 /* Kill socket (only if zapped and orphan)
832 * Must be called on unlocked socket.
834 void l2cap_sock_kill(struct sock
*sk
)
836 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
839 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
841 /* Kill poor orphan */
842 bt_sock_unlink(&l2cap_sk_list
, sk
);
843 sock_set_flag(sk
, SOCK_DEAD
);
847 /* Must be called on unlocked socket. */
848 static void l2cap_sock_close(struct sock
*sk
)
850 l2cap_sock_clear_timer(sk
);
852 __l2cap_sock_close(sk
, ECONNRESET
);
857 static void l2cap_sock_cleanup_listen(struct sock
*parent
)
861 BT_DBG("parent %p", parent
);
863 /* Close not yet accepted channels */
864 while ((sk
= bt_accept_dequeue(parent
, NULL
)))
865 l2cap_sock_close(sk
);
867 parent
->sk_state
= BT_CLOSED
;
868 sock_set_flag(parent
, SOCK_ZAPPED
);
871 void __l2cap_sock_close(struct sock
*sk
, int reason
)
873 struct l2cap_conn
*conn
= l2cap_pi(sk
)->conn
;
874 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
876 BT_DBG("sk %p state %d socket %p", sk
, sk
->sk_state
, sk
->sk_socket
);
878 switch (sk
->sk_state
) {
880 l2cap_sock_cleanup_listen(sk
);
885 if ((sk
->sk_type
== SOCK_SEQPACKET
||
886 sk
->sk_type
== SOCK_STREAM
) &&
887 conn
->hcon
->type
== ACL_LINK
) {
888 l2cap_sock_set_timer(sk
, sk
->sk_sndtimeo
);
889 l2cap_send_disconn_req(conn
, chan
, reason
);
891 l2cap_chan_del(chan
, reason
);
895 if ((sk
->sk_type
== SOCK_SEQPACKET
||
896 sk
->sk_type
== SOCK_STREAM
) &&
897 conn
->hcon
->type
== ACL_LINK
) {
898 struct l2cap_conn_rsp rsp
;
901 if (bt_sk(sk
)->defer_setup
)
902 result
= L2CAP_CR_SEC_BLOCK
;
904 result
= L2CAP_CR_BAD_PSM
;
906 rsp
.scid
= cpu_to_le16(l2cap_pi(sk
)->dcid
);
907 rsp
.dcid
= cpu_to_le16(l2cap_pi(sk
)->scid
);
908 rsp
.result
= cpu_to_le16(result
);
909 rsp
.status
= cpu_to_le16(L2CAP_CS_NO_INFO
);
910 l2cap_send_cmd(conn
, chan
->ident
, L2CAP_CONN_RSP
,
914 l2cap_chan_del(chan
, reason
);
919 l2cap_chan_del(chan
, reason
);
923 sock_set_flag(sk
, SOCK_ZAPPED
);
928 static int l2cap_sock_shutdown(struct socket
*sock
, int how
)
930 struct sock
*sk
= sock
->sk
;
933 BT_DBG("sock %p, sk %p", sock
, sk
);
939 if (!sk
->sk_shutdown
) {
940 if (l2cap_pi(sk
)->mode
== L2CAP_MODE_ERTM
)
941 err
= __l2cap_wait_ack(sk
);
943 sk
->sk_shutdown
= SHUTDOWN_MASK
;
944 l2cap_sock_clear_timer(sk
);
945 __l2cap_sock_close(sk
, 0);
947 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
948 err
= bt_sock_wait_state(sk
, BT_CLOSED
,
952 if (!err
&& sk
->sk_err
)
959 static int l2cap_sock_release(struct socket
*sock
)
961 struct sock
*sk
= sock
->sk
;
964 BT_DBG("sock %p, sk %p", sock
, sk
);
969 err
= l2cap_sock_shutdown(sock
, 2);
976 static void l2cap_sock_destruct(struct sock
*sk
)
980 skb_queue_purge(&sk
->sk_receive_queue
);
981 skb_queue_purge(&sk
->sk_write_queue
);
984 void l2cap_sock_init(struct sock
*sk
, struct sock
*parent
)
986 struct l2cap_pinfo
*pi
= l2cap_pi(sk
);
987 struct l2cap_chan
*chan
= pi
->chan
;
992 struct l2cap_chan
*pchan
= l2cap_pi(parent
)->chan
;
994 sk
->sk_type
= parent
->sk_type
;
995 bt_sk(sk
)->defer_setup
= bt_sk(parent
)->defer_setup
;
997 pi
->imtu
= l2cap_pi(parent
)->imtu
;
998 pi
->omtu
= l2cap_pi(parent
)->omtu
;
999 chan
->conf_state
= pchan
->conf_state
;
1000 pi
->mode
= l2cap_pi(parent
)->mode
;
1001 pi
->fcs
= l2cap_pi(parent
)->fcs
;
1002 pi
->max_tx
= l2cap_pi(parent
)->max_tx
;
1003 pi
->tx_win
= l2cap_pi(parent
)->tx_win
;
1004 chan
->sec_level
= pchan
->sec_level
;
1005 chan
->role_switch
= pchan
->role_switch
;
1006 chan
->force_reliable
= pchan
->force_reliable
;
1007 chan
->flushable
= pchan
->flushable
;
1009 pi
->imtu
= L2CAP_DEFAULT_MTU
;
1011 if (!disable_ertm
&& sk
->sk_type
== SOCK_STREAM
) {
1012 pi
->mode
= L2CAP_MODE_ERTM
;
1013 chan
->conf_state
|= L2CAP_CONF_STATE2_DEVICE
;
1015 pi
->mode
= L2CAP_MODE_BASIC
;
1017 pi
->max_tx
= L2CAP_DEFAULT_MAX_TX
;
1018 pi
->fcs
= L2CAP_FCS_CRC16
;
1019 pi
->tx_win
= L2CAP_DEFAULT_TX_WINDOW
;
1020 chan
->sec_level
= BT_SECURITY_LOW
;
1021 chan
->role_switch
= 0;
1022 chan
->force_reliable
= 0;
1023 chan
->flushable
= BT_FLUSHABLE_OFF
;
1026 /* Default config options */
1027 pi
->flush_to
= L2CAP_DEFAULT_FLUSH_TO
;
1030 static struct proto l2cap_proto
= {
1032 .owner
= THIS_MODULE
,
1033 .obj_size
= sizeof(struct l2cap_pinfo
)
1036 struct sock
*l2cap_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
)
1040 sk
= sk_alloc(net
, PF_BLUETOOTH
, prio
, &l2cap_proto
);
1044 sock_init_data(sock
, sk
);
1045 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
1047 sk
->sk_destruct
= l2cap_sock_destruct
;
1048 sk
->sk_sndtimeo
= msecs_to_jiffies(L2CAP_CONN_TIMEOUT
);
1050 sock_reset_flag(sk
, SOCK_ZAPPED
);
1052 sk
->sk_protocol
= proto
;
1053 sk
->sk_state
= BT_OPEN
;
1055 setup_timer(&sk
->sk_timer
, l2cap_sock_timeout
, (unsigned long) sk
);
1057 bt_sock_link(&l2cap_sk_list
, sk
);
1061 static int l2cap_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
1065 struct l2cap_chan
*chan
;
1067 BT_DBG("sock %p", sock
);
1069 sock
->state
= SS_UNCONNECTED
;
1071 if (sock
->type
!= SOCK_SEQPACKET
&& sock
->type
!= SOCK_STREAM
&&
1072 sock
->type
!= SOCK_DGRAM
&& sock
->type
!= SOCK_RAW
)
1073 return -ESOCKTNOSUPPORT
;
1075 if (sock
->type
== SOCK_RAW
&& !kern
&& !capable(CAP_NET_RAW
))
1078 sock
->ops
= &l2cap_sock_ops
;
1080 sk
= l2cap_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
);
1084 chan
= l2cap_chan_alloc(sk
);
1086 l2cap_sock_kill(sk
);
1090 l2cap_pi(sk
)->chan
= chan
;
1092 l2cap_sock_init(sk
, NULL
);
1096 const struct proto_ops l2cap_sock_ops
= {
1097 .family
= PF_BLUETOOTH
,
1098 .owner
= THIS_MODULE
,
1099 .release
= l2cap_sock_release
,
1100 .bind
= l2cap_sock_bind
,
1101 .connect
= l2cap_sock_connect
,
1102 .listen
= l2cap_sock_listen
,
1103 .accept
= l2cap_sock_accept
,
1104 .getname
= l2cap_sock_getname
,
1105 .sendmsg
= l2cap_sock_sendmsg
,
1106 .recvmsg
= l2cap_sock_recvmsg
,
1107 .poll
= bt_sock_poll
,
1108 .ioctl
= bt_sock_ioctl
,
1109 .mmap
= sock_no_mmap
,
1110 .socketpair
= sock_no_socketpair
,
1111 .shutdown
= l2cap_sock_shutdown
,
1112 .setsockopt
= l2cap_sock_setsockopt
,
1113 .getsockopt
= l2cap_sock_getsockopt
1116 static const struct net_proto_family l2cap_sock_family_ops
= {
1117 .family
= PF_BLUETOOTH
,
1118 .owner
= THIS_MODULE
,
1119 .create
= l2cap_sock_create
,
1122 int __init
l2cap_init_sockets(void)
1126 err
= proto_register(&l2cap_proto
, 0);
1130 err
= bt_sock_register(BTPROTO_L2CAP
, &l2cap_sock_family_ops
);
1134 BT_INFO("L2CAP socket layer initialized");
1139 BT_ERR("L2CAP socket registration failed");
1140 proto_unregister(&l2cap_proto
);
1144 void l2cap_cleanup_sockets(void)
1146 if (bt_sock_unregister(BTPROTO_L2CAP
) < 0)
1147 BT_ERR("L2CAP socket unregistration failed");
1149 proto_unregister(&l2cap_proto
);