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>
32 #include <net/bluetooth/smp.h>
34 static const struct proto_ops l2cap_sock_ops
;
35 static void l2cap_sock_init(struct sock
*sk
, struct sock
*parent
);
36 static struct sock
*l2cap_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
);
38 static int l2cap_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int alen
)
40 struct sock
*sk
= sock
->sk
;
41 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
42 struct sockaddr_l2 la
;
47 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
50 memset(&la
, 0, sizeof(la
));
51 len
= min_t(unsigned int, sizeof(la
), alen
);
52 memcpy(&la
, addr
, len
);
54 if (la
.l2_cid
&& la
.l2_psm
)
59 if (sk
->sk_state
!= BT_OPEN
) {
65 __u16 psm
= __le16_to_cpu(la
.l2_psm
);
67 /* PSM must be odd and lsb of upper byte must be 0 */
68 if ((psm
& 0x0101) != 0x0001) {
73 /* Restrict usage of well-known PSMs */
74 if (psm
< 0x1001 && !capable(CAP_NET_BIND_SERVICE
)) {
81 err
= l2cap_add_scid(chan
, la
.l2_cid
);
83 err
= l2cap_add_psm(chan
, &la
.l2_bdaddr
, la
.l2_psm
);
88 if (__le16_to_cpu(la
.l2_psm
) == 0x0001 ||
89 __le16_to_cpu(la
.l2_psm
) == 0x0003)
90 chan
->sec_level
= BT_SECURITY_SDP
;
92 bacpy(&bt_sk(sk
)->src
, &la
.l2_bdaddr
);
94 chan
->state
= BT_BOUND
;
95 sk
->sk_state
= BT_BOUND
;
102 static int l2cap_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
104 struct sock
*sk
= sock
->sk
;
105 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
106 struct sockaddr_l2 la
;
111 if (!addr
|| alen
< sizeof(addr
->sa_family
) ||
112 addr
->sa_family
!= AF_BLUETOOTH
)
115 memset(&la
, 0, sizeof(la
));
116 len
= min_t(unsigned int, sizeof(la
), alen
);
117 memcpy(&la
, addr
, len
);
119 if (la
.l2_cid
&& la
.l2_psm
)
124 if (chan
->chan_type
== L2CAP_CHAN_CONN_ORIENTED
125 && !(la
.l2_psm
|| la
.l2_cid
)) {
130 switch (chan
->mode
) {
131 case L2CAP_MODE_BASIC
:
133 case L2CAP_MODE_ERTM
:
134 case L2CAP_MODE_STREAMING
:
143 switch (sk
->sk_state
) {
147 /* Already connecting */
151 /* Already connected */
165 /* PSM must be odd and lsb of upper byte must be 0 */
166 if ((__le16_to_cpu(la
.l2_psm
) & 0x0101) != 0x0001 && !la
.l2_cid
&&
167 chan
->chan_type
!= L2CAP_CHAN_RAW
) {
172 /* Set destination address and psm */
173 bacpy(&bt_sk(sk
)->dst
, &la
.l2_bdaddr
);
174 chan
->psm
= la
.l2_psm
;
175 chan
->dcid
= la
.l2_cid
;
177 err
= l2cap_chan_connect(l2cap_pi(sk
)->chan
);
182 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
183 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
189 static int l2cap_sock_listen(struct socket
*sock
, int backlog
)
191 struct sock
*sk
= sock
->sk
;
192 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
195 BT_DBG("sk %p backlog %d", sk
, backlog
);
199 if ((sock
->type
!= SOCK_SEQPACKET
&& sock
->type
!= SOCK_STREAM
)
200 || sk
->sk_state
!= BT_BOUND
) {
205 switch (chan
->mode
) {
206 case L2CAP_MODE_BASIC
:
208 case L2CAP_MODE_ERTM
:
209 case L2CAP_MODE_STREAMING
:
218 sk
->sk_max_ack_backlog
= backlog
;
219 sk
->sk_ack_backlog
= 0;
221 chan
->state
= BT_LISTEN
;
222 sk
->sk_state
= BT_LISTEN
;
229 static int l2cap_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
231 DECLARE_WAITQUEUE(wait
, current
);
232 struct sock
*sk
= sock
->sk
, *nsk
;
236 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
238 if (sk
->sk_state
!= BT_LISTEN
) {
243 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
245 BT_DBG("sk %p timeo %ld", sk
, timeo
);
247 /* Wait for an incoming connection. (wake-one). */
248 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
249 while (!(nsk
= bt_accept_dequeue(sk
, newsock
))) {
250 set_current_state(TASK_INTERRUPTIBLE
);
257 timeo
= schedule_timeout(timeo
);
258 lock_sock_nested(sk
, SINGLE_DEPTH_NESTING
);
260 if (sk
->sk_state
!= BT_LISTEN
) {
265 if (signal_pending(current
)) {
266 err
= sock_intr_errno(timeo
);
270 set_current_state(TASK_RUNNING
);
271 remove_wait_queue(sk_sleep(sk
), &wait
);
276 newsock
->state
= SS_CONNECTED
;
278 BT_DBG("new socket %p", nsk
);
285 static int l2cap_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
287 struct sockaddr_l2
*la
= (struct sockaddr_l2
*) addr
;
288 struct sock
*sk
= sock
->sk
;
289 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
291 BT_DBG("sock %p, sk %p", sock
, sk
);
293 addr
->sa_family
= AF_BLUETOOTH
;
294 *len
= sizeof(struct sockaddr_l2
);
297 la
->l2_psm
= chan
->psm
;
298 bacpy(&la
->l2_bdaddr
, &bt_sk(sk
)->dst
);
299 la
->l2_cid
= cpu_to_le16(chan
->dcid
);
301 la
->l2_psm
= chan
->sport
;
302 bacpy(&la
->l2_bdaddr
, &bt_sk(sk
)->src
);
303 la
->l2_cid
= cpu_to_le16(chan
->scid
);
309 static int l2cap_sock_getsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, int __user
*optlen
)
311 struct sock
*sk
= sock
->sk
;
312 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
313 struct l2cap_options opts
;
314 struct l2cap_conninfo cinfo
;
320 if (get_user(len
, optlen
))
327 memset(&opts
, 0, sizeof(opts
));
328 opts
.imtu
= chan
->imtu
;
329 opts
.omtu
= chan
->omtu
;
330 opts
.flush_to
= chan
->flush_to
;
331 opts
.mode
= chan
->mode
;
332 opts
.fcs
= chan
->fcs
;
333 opts
.max_tx
= chan
->max_tx
;
334 opts
.txwin_size
= (__u16
)chan
->tx_win
;
336 len
= min_t(unsigned int, len
, sizeof(opts
));
337 if (copy_to_user(optval
, (char *) &opts
, len
))
343 switch (chan
->sec_level
) {
344 case BT_SECURITY_LOW
:
347 case BT_SECURITY_MEDIUM
:
348 opt
= L2CAP_LM_AUTH
| L2CAP_LM_ENCRYPT
;
350 case BT_SECURITY_HIGH
:
351 opt
= L2CAP_LM_AUTH
| L2CAP_LM_ENCRYPT
|
359 if (chan
->role_switch
)
360 opt
|= L2CAP_LM_MASTER
;
362 if (chan
->force_reliable
)
363 opt
|= L2CAP_LM_RELIABLE
;
365 if (put_user(opt
, (u32 __user
*) optval
))
370 if (sk
->sk_state
!= BT_CONNECTED
&&
371 !(sk
->sk_state
== BT_CONNECT2
&&
372 bt_sk(sk
)->defer_setup
)) {
377 memset(&cinfo
, 0, sizeof(cinfo
));
378 cinfo
.hci_handle
= chan
->conn
->hcon
->handle
;
379 memcpy(cinfo
.dev_class
, chan
->conn
->hcon
->dev_class
, 3);
381 len
= min_t(unsigned int, len
, sizeof(cinfo
));
382 if (copy_to_user(optval
, (char *) &cinfo
, len
))
396 static int l2cap_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
398 struct sock
*sk
= sock
->sk
;
399 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
400 struct bt_security sec
;
406 if (level
== SOL_L2CAP
)
407 return l2cap_sock_getsockopt_old(sock
, optname
, optval
, optlen
);
409 if (level
!= SOL_BLUETOOTH
)
412 if (get_user(len
, optlen
))
419 if (chan
->chan_type
!= L2CAP_CHAN_CONN_ORIENTED
&&
420 chan
->chan_type
!= L2CAP_CHAN_RAW
) {
425 sec
.level
= chan
->sec_level
;
427 len
= min_t(unsigned int, len
, sizeof(sec
));
428 if (copy_to_user(optval
, (char *) &sec
, len
))
434 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
439 if (put_user(bt_sk(sk
)->defer_setup
, (u32 __user
*) optval
))
445 if (put_user(chan
->flushable
, (u32 __user
*) optval
))
451 if (sk
->sk_type
!= SOCK_SEQPACKET
&& sk
->sk_type
!= SOCK_STREAM
452 && sk
->sk_type
!= SOCK_RAW
) {
457 pwr
.force_active
= chan
->force_active
;
459 len
= min_t(unsigned int, len
, sizeof(pwr
));
460 if (copy_to_user(optval
, (char *) &pwr
, len
))
474 static int l2cap_sock_setsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, unsigned int optlen
)
476 struct sock
*sk
= sock
->sk
;
477 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
478 struct l2cap_options opts
;
488 if (sk
->sk_state
== BT_CONNECTED
) {
493 opts
.imtu
= chan
->imtu
;
494 opts
.omtu
= chan
->omtu
;
495 opts
.flush_to
= chan
->flush_to
;
496 opts
.mode
= chan
->mode
;
497 opts
.fcs
= chan
->fcs
;
498 opts
.max_tx
= chan
->max_tx
;
499 opts
.txwin_size
= (__u16
)chan
->tx_win
;
501 len
= min_t(unsigned int, sizeof(opts
), optlen
);
502 if (copy_from_user((char *) &opts
, optval
, len
)) {
507 if (opts
.txwin_size
> L2CAP_DEFAULT_TX_WINDOW
) {
512 chan
->mode
= opts
.mode
;
513 switch (chan
->mode
) {
514 case L2CAP_MODE_BASIC
:
515 clear_bit(CONF_STATE2_DEVICE
, &chan
->conf_state
);
517 case L2CAP_MODE_ERTM
:
518 case L2CAP_MODE_STREAMING
:
527 chan
->imtu
= opts
.imtu
;
528 chan
->omtu
= opts
.omtu
;
529 chan
->fcs
= opts
.fcs
;
530 chan
->max_tx
= opts
.max_tx
;
531 chan
->tx_win
= (__u8
)opts
.txwin_size
;
535 if (get_user(opt
, (u32 __user
*) optval
)) {
540 if (opt
& L2CAP_LM_AUTH
)
541 chan
->sec_level
= BT_SECURITY_LOW
;
542 if (opt
& L2CAP_LM_ENCRYPT
)
543 chan
->sec_level
= BT_SECURITY_MEDIUM
;
544 if (opt
& L2CAP_LM_SECURE
)
545 chan
->sec_level
= BT_SECURITY_HIGH
;
547 chan
->role_switch
= (opt
& L2CAP_LM_MASTER
);
548 chan
->force_reliable
= (opt
& L2CAP_LM_RELIABLE
);
560 static int l2cap_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int optlen
)
562 struct sock
*sk
= sock
->sk
;
563 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
564 struct bt_security sec
;
566 struct l2cap_conn
*conn
;
572 if (level
== SOL_L2CAP
)
573 return l2cap_sock_setsockopt_old(sock
, optname
, optval
, optlen
);
575 if (level
!= SOL_BLUETOOTH
)
582 if (chan
->chan_type
!= L2CAP_CHAN_CONN_ORIENTED
&&
583 chan
->chan_type
!= L2CAP_CHAN_RAW
) {
588 sec
.level
= BT_SECURITY_LOW
;
590 len
= min_t(unsigned int, sizeof(sec
), optlen
);
591 if (copy_from_user((char *) &sec
, optval
, len
)) {
596 if (sec
.level
< BT_SECURITY_LOW
||
597 sec
.level
> BT_SECURITY_HIGH
) {
602 chan
->sec_level
= sec
.level
;
605 if (conn
&& chan
->scid
== L2CAP_CID_LE_DATA
) {
606 if (!conn
->hcon
->out
) {
611 if (smp_conn_security(conn
, sec
.level
))
615 sk
->sk_state
= BT_CONFIG
;
620 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
625 if (get_user(opt
, (u32 __user
*) optval
)) {
630 bt_sk(sk
)->defer_setup
= opt
;
634 if (get_user(opt
, (u32 __user
*) optval
)) {
639 if (opt
> BT_FLUSHABLE_ON
) {
644 if (opt
== BT_FLUSHABLE_OFF
) {
645 struct l2cap_conn
*conn
= chan
->conn
;
646 /* proceed further only when we have l2cap_conn and
647 No Flush support in the LM */
648 if (!conn
|| !lmp_no_flush_capable(conn
->hcon
->hdev
)) {
654 chan
->flushable
= opt
;
658 if (chan
->chan_type
!= L2CAP_CHAN_CONN_ORIENTED
&&
659 chan
->chan_type
!= L2CAP_CHAN_RAW
) {
664 pwr
.force_active
= BT_POWER_FORCE_ACTIVE_ON
;
666 len
= min_t(unsigned int, sizeof(pwr
), optlen
);
667 if (copy_from_user((char *) &pwr
, optval
, len
)) {
671 chan
->force_active
= pwr
.force_active
;
683 static int l2cap_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
, size_t len
)
685 struct sock
*sk
= sock
->sk
;
686 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
689 BT_DBG("sock %p, sk %p", sock
, sk
);
691 err
= sock_error(sk
);
695 if (msg
->msg_flags
& MSG_OOB
)
700 if (sk
->sk_state
!= BT_CONNECTED
) {
705 err
= l2cap_chan_send(chan
, msg
, len
);
711 static int l2cap_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
, size_t len
, int flags
)
713 struct sock
*sk
= sock
->sk
;
717 if (sk
->sk_state
== BT_CONNECT2
&& bt_sk(sk
)->defer_setup
) {
718 sk
->sk_state
= BT_CONFIG
;
720 __l2cap_connect_rsp_defer(l2cap_pi(sk
)->chan
);
727 if (sock
->type
== SOCK_STREAM
)
728 return bt_sock_stream_recvmsg(iocb
, sock
, msg
, len
, flags
);
730 return bt_sock_recvmsg(iocb
, sock
, msg
, len
, flags
);
733 /* Kill socket (only if zapped and orphan)
734 * Must be called on unlocked socket.
736 static void l2cap_sock_kill(struct sock
*sk
)
738 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
741 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
743 /* Kill poor orphan */
745 l2cap_chan_destroy(l2cap_pi(sk
)->chan
);
746 sock_set_flag(sk
, SOCK_DEAD
);
750 static int l2cap_sock_shutdown(struct socket
*sock
, int how
)
752 struct sock
*sk
= sock
->sk
;
753 struct l2cap_chan
*chan
= l2cap_pi(sk
)->chan
;
756 BT_DBG("sock %p, sk %p", sock
, sk
);
762 if (!sk
->sk_shutdown
) {
763 if (chan
->mode
== L2CAP_MODE_ERTM
)
764 err
= __l2cap_wait_ack(sk
);
766 sk
->sk_shutdown
= SHUTDOWN_MASK
;
767 l2cap_chan_close(chan
, 0);
769 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
770 err
= bt_sock_wait_state(sk
, BT_CLOSED
,
774 if (!err
&& sk
->sk_err
)
781 static int l2cap_sock_release(struct socket
*sock
)
783 struct sock
*sk
= sock
->sk
;
786 BT_DBG("sock %p, sk %p", sock
, sk
);
791 err
= l2cap_sock_shutdown(sock
, 2);
798 static struct l2cap_chan
*l2cap_sock_new_connection_cb(void *data
)
800 struct sock
*sk
, *parent
= data
;
802 sk
= l2cap_sock_alloc(sock_net(parent
), NULL
, BTPROTO_L2CAP
,
807 l2cap_sock_init(sk
, parent
);
809 return l2cap_pi(sk
)->chan
;
812 static int l2cap_sock_recv_cb(void *data
, struct sk_buff
*skb
)
814 struct sock
*sk
= data
;
816 return sock_queue_rcv_skb(sk
, skb
);
819 static void l2cap_sock_close_cb(void *data
)
821 struct sock
*sk
= data
;
826 static void l2cap_sock_state_change_cb(void *data
, int state
)
828 struct sock
*sk
= data
;
830 sk
->sk_state
= state
;
833 static struct l2cap_ops l2cap_chan_ops
= {
834 .name
= "L2CAP Socket Interface",
835 .new_connection
= l2cap_sock_new_connection_cb
,
836 .recv
= l2cap_sock_recv_cb
,
837 .close
= l2cap_sock_close_cb
,
838 .state_change
= l2cap_sock_state_change_cb
,
841 static void l2cap_sock_destruct(struct sock
*sk
)
845 skb_queue_purge(&sk
->sk_receive_queue
);
846 skb_queue_purge(&sk
->sk_write_queue
);
849 static void l2cap_sock_init(struct sock
*sk
, struct sock
*parent
)
851 struct l2cap_pinfo
*pi
= l2cap_pi(sk
);
852 struct l2cap_chan
*chan
= pi
->chan
;
857 struct l2cap_chan
*pchan
= l2cap_pi(parent
)->chan
;
859 sk
->sk_type
= parent
->sk_type
;
860 bt_sk(sk
)->defer_setup
= bt_sk(parent
)->defer_setup
;
862 chan
->chan_type
= pchan
->chan_type
;
863 chan
->imtu
= pchan
->imtu
;
864 chan
->omtu
= pchan
->omtu
;
865 chan
->conf_state
= pchan
->conf_state
;
866 chan
->mode
= pchan
->mode
;
867 chan
->fcs
= pchan
->fcs
;
868 chan
->max_tx
= pchan
->max_tx
;
869 chan
->tx_win
= pchan
->tx_win
;
870 chan
->sec_level
= pchan
->sec_level
;
871 chan
->role_switch
= pchan
->role_switch
;
872 chan
->force_reliable
= pchan
->force_reliable
;
873 chan
->flushable
= pchan
->flushable
;
874 chan
->force_active
= pchan
->force_active
;
877 switch (sk
->sk_type
) {
879 chan
->chan_type
= L2CAP_CHAN_RAW
;
882 chan
->chan_type
= L2CAP_CHAN_CONN_LESS
;
886 chan
->chan_type
= L2CAP_CHAN_CONN_ORIENTED
;
890 chan
->imtu
= L2CAP_DEFAULT_MTU
;
892 if (!disable_ertm
&& sk
->sk_type
== SOCK_STREAM
) {
893 chan
->mode
= L2CAP_MODE_ERTM
;
894 set_bit(CONF_STATE2_DEVICE
, &chan
->conf_state
);
896 chan
->mode
= L2CAP_MODE_BASIC
;
898 chan
->max_tx
= L2CAP_DEFAULT_MAX_TX
;
899 chan
->fcs
= L2CAP_FCS_CRC16
;
900 chan
->tx_win
= L2CAP_DEFAULT_TX_WINDOW
;
901 chan
->sec_level
= BT_SECURITY_LOW
;
902 chan
->role_switch
= 0;
903 chan
->force_reliable
= 0;
904 chan
->flushable
= BT_FLUSHABLE_OFF
;
905 chan
->force_active
= BT_POWER_FORCE_ACTIVE_ON
;
909 /* Default config options */
910 chan
->flush_to
= L2CAP_DEFAULT_FLUSH_TO
;
913 chan
->ops
= &l2cap_chan_ops
;
916 static struct proto l2cap_proto
= {
918 .owner
= THIS_MODULE
,
919 .obj_size
= sizeof(struct l2cap_pinfo
)
922 static struct sock
*l2cap_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
)
925 struct l2cap_chan
*chan
;
927 sk
= sk_alloc(net
, PF_BLUETOOTH
, prio
, &l2cap_proto
);
931 sock_init_data(sock
, sk
);
932 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
934 sk
->sk_destruct
= l2cap_sock_destruct
;
935 sk
->sk_sndtimeo
= msecs_to_jiffies(L2CAP_CONN_TIMEOUT
);
937 sock_reset_flag(sk
, SOCK_ZAPPED
);
939 sk
->sk_protocol
= proto
;
940 sk
->sk_state
= BT_OPEN
;
942 chan
= l2cap_chan_create(sk
);
948 l2cap_pi(sk
)->chan
= chan
;
953 static int l2cap_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
958 BT_DBG("sock %p", sock
);
960 sock
->state
= SS_UNCONNECTED
;
962 if (sock
->type
!= SOCK_SEQPACKET
&& sock
->type
!= SOCK_STREAM
&&
963 sock
->type
!= SOCK_DGRAM
&& sock
->type
!= SOCK_RAW
)
964 return -ESOCKTNOSUPPORT
;
966 if (sock
->type
== SOCK_RAW
&& !kern
&& !capable(CAP_NET_RAW
))
969 sock
->ops
= &l2cap_sock_ops
;
971 sk
= l2cap_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
);
975 l2cap_sock_init(sk
, NULL
);
979 static const struct proto_ops l2cap_sock_ops
= {
980 .family
= PF_BLUETOOTH
,
981 .owner
= THIS_MODULE
,
982 .release
= l2cap_sock_release
,
983 .bind
= l2cap_sock_bind
,
984 .connect
= l2cap_sock_connect
,
985 .listen
= l2cap_sock_listen
,
986 .accept
= l2cap_sock_accept
,
987 .getname
= l2cap_sock_getname
,
988 .sendmsg
= l2cap_sock_sendmsg
,
989 .recvmsg
= l2cap_sock_recvmsg
,
990 .poll
= bt_sock_poll
,
991 .ioctl
= bt_sock_ioctl
,
992 .mmap
= sock_no_mmap
,
993 .socketpair
= sock_no_socketpair
,
994 .shutdown
= l2cap_sock_shutdown
,
995 .setsockopt
= l2cap_sock_setsockopt
,
996 .getsockopt
= l2cap_sock_getsockopt
999 static const struct net_proto_family l2cap_sock_family_ops
= {
1000 .family
= PF_BLUETOOTH
,
1001 .owner
= THIS_MODULE
,
1002 .create
= l2cap_sock_create
,
1005 int __init
l2cap_init_sockets(void)
1009 err
= proto_register(&l2cap_proto
, 0);
1013 err
= bt_sock_register(BTPROTO_L2CAP
, &l2cap_sock_family_ops
);
1017 BT_INFO("L2CAP socket layer initialized");
1022 BT_ERR("L2CAP socket registration failed");
1023 proto_unregister(&l2cap_proto
);
1027 void l2cap_cleanup_sockets(void)
1029 if (bt_sock_unregister(BTPROTO_L2CAP
) < 0)
1030 BT_ERR("L2CAP socket unregistration failed");
1032 proto_unregister(&l2cap_proto
);