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.
6 Copyright (C) 2011 ProFUSION Embedded Systems
8 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License version 2 as
12 published by the Free Software Foundation;
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
17 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
18 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
24 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
25 SOFTWARE IS DISCLAIMED.
28 /* Bluetooth L2CAP sockets. */
30 #include <linux/module.h>
31 #include <linux/export.h>
32 #include <linux/filter.h>
33 #include <linux/sched/signal.h>
35 #include <net/bluetooth/bluetooth.h>
36 #include <net/bluetooth/hci_core.h>
37 #include <net/bluetooth/l2cap.h>
41 static struct bt_sock_list l2cap_sk_list = {
42 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
45 static const struct proto_ops l2cap_sock_ops;
46 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
47 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
48 int proto, gfp_t prio, int kern);
49 static void l2cap_sock_cleanup_listen(struct sock *parent);
51 bool l2cap_is_socket(struct socket *sock)
53 return sock && sock->ops == &l2cap_sock_ops;
55 EXPORT_SYMBOL(l2cap_is_socket);
57 static int l2cap_validate_bredr_psm(u16 psm)
59 /* PSM must be odd and lsb of upper byte must be 0 */
60 if ((psm & 0x0101) != 0x0001)
63 /* Restrict usage of well-known PSMs */
64 if (psm < L2CAP_PSM_DYN_START && !capable(CAP_NET_BIND_SERVICE))
70 static int l2cap_validate_le_psm(u16 psm)
72 /* Valid LE_PSM ranges are defined only until 0x00ff */
73 if (psm > L2CAP_PSM_LE_DYN_END)
76 /* Restrict fixed, SIG assigned PSM values to CAP_NET_BIND_SERVICE */
77 if (psm < L2CAP_PSM_LE_DYN_START && !capable(CAP_NET_BIND_SERVICE))
83 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
85 struct sock *sk = sock->sk;
86 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
87 struct sockaddr_l2 la;
92 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
93 addr->sa_family != AF_BLUETOOTH)
96 memset(&la, 0, sizeof(la));
97 len = min_t(unsigned int, sizeof(la), alen);
98 memcpy(&la, addr, len);
100 if (la.l2_cid && la.l2_psm)
103 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
106 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
107 /* We only allow ATT user space socket */
109 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
115 if (sk->sk_state != BT_OPEN) {
121 __u16 psm = __le16_to_cpu(la.l2_psm);
123 if (la.l2_bdaddr_type == BDADDR_BREDR)
124 err = l2cap_validate_bredr_psm(psm);
126 err = l2cap_validate_le_psm(psm);
132 bacpy(&chan->src, &la.l2_bdaddr);
133 chan->src_type = la.l2_bdaddr_type;
136 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
138 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
143 switch (chan->chan_type) {
144 case L2CAP_CHAN_CONN_LESS:
145 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
146 chan->sec_level = BT_SECURITY_SDP;
148 case L2CAP_CHAN_CONN_ORIENTED:
149 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
150 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
151 chan->sec_level = BT_SECURITY_SDP;
154 chan->sec_level = BT_SECURITY_SDP;
156 case L2CAP_CHAN_FIXED:
157 /* Fixed channels default to the L2CAP core not holding a
158 * hci_conn reference for them. For fixed channels mapping to
159 * L2CAP sockets we do want to hold a reference so set the
160 * appropriate flag to request it.
162 set_bit(FLAG_HOLD_HCI_CONN, &chan->flags);
166 /* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
167 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
169 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
170 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
171 chan->mode = L2CAP_MODE_LE_FLOWCTL;
173 chan->state = BT_BOUND;
174 sk->sk_state = BT_BOUND;
181 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
184 struct sock *sk = sock->sk;
185 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
186 struct sockaddr_l2 la;
193 zapped = sock_flag(sk, SOCK_ZAPPED);
199 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
200 addr->sa_family != AF_BLUETOOTH)
203 memset(&la, 0, sizeof(la));
204 len = min_t(unsigned int, sizeof(la), alen);
205 memcpy(&la, addr, len);
207 if (la.l2_cid && la.l2_psm)
210 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
213 /* Check that the socket wasn't bound to something that
214 * conflicts with the address given to connect(). If chan->src
215 * is BDADDR_ANY it means bind() was never used, in which case
216 * chan->src_type and la.l2_bdaddr_type do not need to match.
218 if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
219 bdaddr_type_is_le(la.l2_bdaddr_type)) {
220 /* Old user space versions will try to incorrectly bind
221 * the ATT socket using BDADDR_BREDR. We need to accept
222 * this and fix up the source address type only when
223 * both the source CID and destination CID indicate
224 * ATT. Anything else is an invalid combination.
226 if (chan->scid != L2CAP_CID_ATT ||
227 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
230 /* We don't have the hdev available here to make a
231 * better decision on random vs public, but since all
232 * user space versions that exhibit this issue anyway do
233 * not support random local addresses assuming public
234 * here is good enough.
236 chan->src_type = BDADDR_LE_PUBLIC;
239 if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
242 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
243 /* We only allow ATT user space socket */
245 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
249 /* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
250 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
252 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
253 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
254 chan->mode = L2CAP_MODE_LE_FLOWCTL;
256 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
257 &la.l2_bdaddr, la.l2_bdaddr_type,
264 err = bt_sock_wait_state(sk, BT_CONNECTED,
265 sock_sndtimeo(sk, flags & O_NONBLOCK));
272 static int l2cap_sock_listen(struct socket *sock, int backlog)
274 struct sock *sk = sock->sk;
275 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
278 BT_DBG("sk %p backlog %d", sk, backlog);
282 if (sk->sk_state != BT_BOUND) {
287 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
292 switch (chan->mode) {
293 case L2CAP_MODE_BASIC:
294 case L2CAP_MODE_LE_FLOWCTL:
296 case L2CAP_MODE_EXT_FLOWCTL:
302 case L2CAP_MODE_ERTM:
303 case L2CAP_MODE_STREAMING:
312 sk->sk_max_ack_backlog = backlog;
313 sk->sk_ack_backlog = 0;
315 /* Listening channels need to use nested locking in order not to
316 * cause lockdep warnings when the created child channels end up
317 * being locked in the same thread as the parent channel.
319 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
321 chan->state = BT_LISTEN;
322 sk->sk_state = BT_LISTEN;
329 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
330 int flags, bool kern)
332 DEFINE_WAIT_FUNC(wait, woken_wake_function);
333 struct sock *sk = sock->sk, *nsk;
337 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
339 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
341 BT_DBG("sk %p timeo %ld", sk, timeo);
343 /* Wait for an incoming connection. (wake-one). */
344 add_wait_queue_exclusive(sk_sleep(sk), &wait);
346 if (sk->sk_state != BT_LISTEN) {
351 nsk = bt_accept_dequeue(sk, newsock);
360 if (signal_pending(current)) {
361 err = sock_intr_errno(timeo);
367 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
369 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
371 remove_wait_queue(sk_sleep(sk), &wait);
376 newsock->state = SS_CONNECTED;
378 BT_DBG("new socket %p", nsk);
385 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
388 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
389 struct sock *sk = sock->sk;
390 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
392 BT_DBG("sock %p, sk %p", sock, sk);
394 if (peer && sk->sk_state != BT_CONNECTED &&
395 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2 &&
396 sk->sk_state != BT_CONFIG)
399 memset(la, 0, sizeof(struct sockaddr_l2));
400 addr->sa_family = AF_BLUETOOTH;
402 la->l2_psm = chan->psm;
405 bacpy(&la->l2_bdaddr, &chan->dst);
406 la->l2_cid = cpu_to_le16(chan->dcid);
407 la->l2_bdaddr_type = chan->dst_type;
409 bacpy(&la->l2_bdaddr, &chan->src);
410 la->l2_cid = cpu_to_le16(chan->scid);
411 la->l2_bdaddr_type = chan->src_type;
414 return sizeof(struct sockaddr_l2);
417 static int l2cap_get_mode(struct l2cap_chan *chan)
419 switch (chan->mode) {
420 case L2CAP_MODE_BASIC:
421 return BT_MODE_BASIC;
422 case L2CAP_MODE_ERTM:
424 case L2CAP_MODE_STREAMING:
425 return BT_MODE_STREAMING;
426 case L2CAP_MODE_LE_FLOWCTL:
427 return BT_MODE_LE_FLOWCTL;
428 case L2CAP_MODE_EXT_FLOWCTL:
429 return BT_MODE_EXT_FLOWCTL;
435 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
436 char __user *optval, int __user *optlen)
438 struct sock *sk = sock->sk;
439 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
440 struct l2cap_options opts;
441 struct l2cap_conninfo cinfo;
447 if (get_user(len, optlen))
454 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
455 * legacy ATT code depends on getsockopt for
456 * L2CAP_OPTIONS we need to let this pass.
458 if (bdaddr_type_is_le(chan->src_type) &&
459 chan->scid != L2CAP_CID_ATT) {
464 /* Only BR/EDR modes are supported here */
465 switch (chan->mode) {
466 case L2CAP_MODE_BASIC:
467 case L2CAP_MODE_ERTM:
468 case L2CAP_MODE_STREAMING:
478 memset(&opts, 0, sizeof(opts));
479 opts.imtu = chan->imtu;
480 opts.omtu = chan->omtu;
481 opts.flush_to = chan->flush_to;
482 opts.mode = chan->mode;
483 opts.fcs = chan->fcs;
484 opts.max_tx = chan->max_tx;
485 opts.txwin_size = chan->tx_win;
487 BT_DBG("mode 0x%2.2x", chan->mode);
489 len = min_t(unsigned int, len, sizeof(opts));
490 if (copy_to_user(optval, (char *) &opts, len))
496 switch (chan->sec_level) {
497 case BT_SECURITY_LOW:
500 case BT_SECURITY_MEDIUM:
501 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
503 case BT_SECURITY_HIGH:
504 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
507 case BT_SECURITY_FIPS:
508 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
509 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
516 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
517 opt |= L2CAP_LM_MASTER;
519 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
520 opt |= L2CAP_LM_RELIABLE;
522 if (put_user(opt, (u32 __user *) optval))
528 if (sk->sk_state != BT_CONNECTED &&
529 !(sk->sk_state == BT_CONNECT2 &&
530 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
535 memset(&cinfo, 0, sizeof(cinfo));
536 cinfo.hci_handle = chan->conn->hcon->handle;
537 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
539 len = min_t(unsigned int, len, sizeof(cinfo));
540 if (copy_to_user(optval, (char *) &cinfo, len))
554 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
555 char __user *optval, int __user *optlen)
557 struct sock *sk = sock->sk;
558 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
559 struct bt_security sec;
562 int len, mode, err = 0;
566 if (level == SOL_L2CAP)
567 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
569 if (level != SOL_BLUETOOTH)
572 if (get_user(len, optlen))
579 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
580 chan->chan_type != L2CAP_CHAN_FIXED &&
581 chan->chan_type != L2CAP_CHAN_RAW) {
586 memset(&sec, 0, sizeof(sec));
588 sec.level = chan->conn->hcon->sec_level;
590 if (sk->sk_state == BT_CONNECTED)
591 sec.key_size = chan->conn->hcon->enc_key_size;
593 sec.level = chan->sec_level;
596 len = min_t(unsigned int, len, sizeof(sec));
597 if (copy_to_user(optval, (char *) &sec, len))
603 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
608 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
609 (u32 __user *) optval))
615 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
616 (u32 __user *) optval))
622 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
623 && sk->sk_type != SOCK_RAW) {
628 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
630 len = min_t(unsigned int, len, sizeof(pwr));
631 if (copy_to_user(optval, (char *) &pwr, len))
636 case BT_CHANNEL_POLICY:
637 if (put_user(chan->chan_policy, (u32 __user *) optval))
642 if (!bdaddr_type_is_le(chan->src_type)) {
647 if (sk->sk_state != BT_CONNECTED) {
652 if (put_user(chan->omtu, (u16 __user *) optval))
657 if (!bdaddr_type_is_le(chan->src_type)) {
662 if (put_user(chan->imtu, (u16 __user *) optval))
667 if (sk->sk_state != BT_CONNECTED) {
672 phys = hci_conn_get_phy(chan->conn->hcon);
674 if (put_user(phys, (u32 __user *) optval))
684 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
689 mode = l2cap_get_mode(chan);
695 if (put_user(mode, (u8 __user *) optval))
708 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
710 switch (chan->scid) {
712 if (mtu < L2CAP_LE_MIN_MTU)
717 if (mtu < L2CAP_DEFAULT_MIN_MTU)
724 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
725 sockptr_t optval, unsigned int optlen)
727 struct sock *sk = sock->sk;
728 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
729 struct l2cap_options opts;
739 if (bdaddr_type_is_le(chan->src_type)) {
744 if (sk->sk_state == BT_CONNECTED) {
749 opts.imtu = chan->imtu;
750 opts.omtu = chan->omtu;
751 opts.flush_to = chan->flush_to;
752 opts.mode = chan->mode;
753 opts.fcs = chan->fcs;
754 opts.max_tx = chan->max_tx;
755 opts.txwin_size = chan->tx_win;
757 len = min_t(unsigned int, sizeof(opts), optlen);
758 if (copy_from_sockptr(&opts, optval, len)) {
763 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
768 if (!l2cap_valid_mtu(chan, opts.imtu)) {
773 /* Only BR/EDR modes are supported here */
775 case L2CAP_MODE_BASIC:
776 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
778 case L2CAP_MODE_ERTM:
779 case L2CAP_MODE_STREAMING:
791 chan->mode = opts.mode;
793 BT_DBG("mode 0x%2.2x", chan->mode);
795 chan->imtu = opts.imtu;
796 chan->omtu = opts.omtu;
797 chan->fcs = opts.fcs;
798 chan->max_tx = opts.max_tx;
799 chan->tx_win = opts.txwin_size;
800 chan->flush_to = opts.flush_to;
804 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
809 if (opt & L2CAP_LM_FIPS) {
814 if (opt & L2CAP_LM_AUTH)
815 chan->sec_level = BT_SECURITY_LOW;
816 if (opt & L2CAP_LM_ENCRYPT)
817 chan->sec_level = BT_SECURITY_MEDIUM;
818 if (opt & L2CAP_LM_SECURE)
819 chan->sec_level = BT_SECURITY_HIGH;
821 if (opt & L2CAP_LM_MASTER)
822 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
824 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
826 if (opt & L2CAP_LM_RELIABLE)
827 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
829 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
841 static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
845 if (bdaddr_type_is_le(chan->src_type))
847 mode = L2CAP_MODE_BASIC;
848 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
851 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
853 mode = L2CAP_MODE_ERTM;
855 case BT_MODE_STREAMING:
856 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
858 mode = L2CAP_MODE_STREAMING;
860 case BT_MODE_LE_FLOWCTL:
861 if (!bdaddr_type_is_le(chan->src_type))
863 mode = L2CAP_MODE_LE_FLOWCTL;
865 case BT_MODE_EXT_FLOWCTL:
866 /* TODO: Add support for ECRED PDUs to BR/EDR */
867 if (!bdaddr_type_is_le(chan->src_type))
869 mode = L2CAP_MODE_EXT_FLOWCTL;
880 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
881 sockptr_t optval, unsigned int optlen)
883 struct sock *sk = sock->sk;
884 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
885 struct bt_security sec;
887 struct l2cap_conn *conn;
895 if (level == SOL_L2CAP)
896 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
898 if (level != SOL_BLUETOOTH)
905 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
906 chan->chan_type != L2CAP_CHAN_FIXED &&
907 chan->chan_type != L2CAP_CHAN_RAW) {
912 sec.level = BT_SECURITY_LOW;
914 len = min_t(unsigned int, sizeof(sec), optlen);
915 if (copy_from_sockptr(&sec, optval, len)) {
920 if (sec.level < BT_SECURITY_LOW ||
921 sec.level > BT_SECURITY_FIPS) {
926 chan->sec_level = sec.level;
933 /* change security for LE channels */
934 if (chan->scid == L2CAP_CID_ATT) {
935 if (smp_conn_security(conn->hcon, sec.level)) {
940 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
941 sk->sk_state = BT_CONFIG;
942 chan->state = BT_CONFIG;
944 /* or for ACL link */
945 } else if ((sk->sk_state == BT_CONNECT2 &&
946 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
947 sk->sk_state == BT_CONNECTED) {
948 if (!l2cap_chan_check_security(chan, true))
949 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
951 sk->sk_state_change(sk);
958 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
963 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
969 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
970 set_bit(FLAG_DEFER_SETUP, &chan->flags);
972 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
973 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
978 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
983 if (opt > BT_FLUSHABLE_ON) {
988 if (opt == BT_FLUSHABLE_OFF) {
990 /* proceed further only when we have l2cap_conn and
991 No Flush support in the LM */
992 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
999 set_bit(FLAG_FLUSHABLE, &chan->flags);
1001 clear_bit(FLAG_FLUSHABLE, &chan->flags);
1005 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
1006 chan->chan_type != L2CAP_CHAN_RAW) {
1011 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1013 len = min_t(unsigned int, sizeof(pwr), optlen);
1014 if (copy_from_sockptr(&pwr, optval, len)) {
1019 if (pwr.force_active)
1020 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1022 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1025 case BT_CHANNEL_POLICY:
1026 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1035 if (!bdaddr_type_is_le(chan->src_type)) {
1040 /* Setting is not supported as it's the remote side that
1047 if (!bdaddr_type_is_le(chan->src_type)) {
1052 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1053 sk->sk_state == BT_CONNECTED) {
1058 if (copy_from_sockptr(&mtu, optval, sizeof(u16))) {
1063 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1064 sk->sk_state == BT_CONNECTED)
1065 err = l2cap_chan_reconfigure(chan, mtu);
1072 if (!enable_ecred) {
1077 BT_DBG("sk->sk_state %u", sk->sk_state);
1079 if (sk->sk_state != BT_BOUND) {
1084 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1089 if (copy_from_sockptr(&mode, optval, sizeof(u8))) {
1094 BT_DBG("mode %u", mode);
1096 err = l2cap_set_mode(chan, mode);
1100 BT_DBG("mode 0x%2.2x", chan->mode);
1113 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1116 struct sock *sk = sock->sk;
1117 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1120 BT_DBG("sock %p, sk %p", sock, sk);
1122 err = sock_error(sk);
1126 if (msg->msg_flags & MSG_OOB)
1129 if (sk->sk_state != BT_CONNECTED)
1133 err = bt_sock_wait_ready(sk, msg->msg_flags);
1138 l2cap_chan_lock(chan);
1139 err = l2cap_chan_send(chan, msg, len);
1140 l2cap_chan_unlock(chan);
1145 static int l2cap_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1146 size_t len, int flags)
1148 struct sock *sk = sock->sk;
1149 struct l2cap_pinfo *pi = l2cap_pi(sk);
1154 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1155 &bt_sk(sk)->flags)) {
1156 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1157 sk->sk_state = BT_CONNECTED;
1158 pi->chan->state = BT_CONNECTED;
1159 __l2cap_ecred_conn_rsp_defer(pi->chan);
1160 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1161 sk->sk_state = BT_CONNECTED;
1162 pi->chan->state = BT_CONNECTED;
1163 __l2cap_le_connect_rsp_defer(pi->chan);
1165 sk->sk_state = BT_CONFIG;
1166 pi->chan->state = BT_CONFIG;
1167 __l2cap_connect_rsp_defer(pi->chan);
1176 if (sock->type == SOCK_STREAM)
1177 err = bt_sock_stream_recvmsg(sock, msg, len, flags);
1179 err = bt_sock_recvmsg(sock, msg, len, flags);
1181 if (pi->chan->mode != L2CAP_MODE_ERTM)
1184 /* Attempt to put pending rx data in the socket buffer */
1188 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1191 if (pi->rx_busy_skb) {
1192 if (!__sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1193 pi->rx_busy_skb = NULL;
1198 /* Restore data flow when half of the receive buffer is
1199 * available. This avoids resending large numbers of
1202 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1203 l2cap_chan_busy(pi->chan, 0);
1210 /* Kill socket (only if zapped and orphan)
1211 * Must be called on unlocked socket, with l2cap channel lock.
1213 static void l2cap_sock_kill(struct sock *sk)
1215 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1218 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1220 /* Kill poor orphan */
1222 l2cap_chan_put(l2cap_pi(sk)->chan);
1223 sock_set_flag(sk, SOCK_DEAD);
1227 static int __l2cap_wait_ack(struct sock *sk, struct l2cap_chan *chan)
1229 DECLARE_WAITQUEUE(wait, current);
1231 int timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1232 /* Timeout to prevent infinite loop */
1233 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1235 add_wait_queue(sk_sleep(sk), &wait);
1236 set_current_state(TASK_INTERRUPTIBLE);
1238 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1239 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1240 jiffies_to_msecs(timeout - jiffies));
1243 timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1245 if (signal_pending(current)) {
1246 err = sock_intr_errno(timeo);
1251 timeo = schedule_timeout(timeo);
1253 set_current_state(TASK_INTERRUPTIBLE);
1255 err = sock_error(sk);
1259 if (time_after(jiffies, timeout)) {
1264 } while (chan->unacked_frames > 0 &&
1265 chan->state == BT_CONNECTED);
1267 set_current_state(TASK_RUNNING);
1268 remove_wait_queue(sk_sleep(sk), &wait);
1272 static int l2cap_sock_shutdown(struct socket *sock, int how)
1274 struct sock *sk = sock->sk;
1275 struct l2cap_chan *chan;
1276 struct l2cap_conn *conn;
1279 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1281 /* 'how' parameter is mapped to sk_shutdown as follows:
1282 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1283 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1284 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1293 if ((sk->sk_shutdown & how) == how)
1294 goto shutdown_already;
1296 BT_DBG("Handling sock shutdown");
1298 /* prevent sk structure from being freed whilst unlocked */
1301 chan = l2cap_pi(sk)->chan;
1302 /* prevent chan structure from being freed whilst unlocked */
1303 l2cap_chan_hold(chan);
1305 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1307 if (chan->mode == L2CAP_MODE_ERTM &&
1308 chan->unacked_frames > 0 &&
1309 chan->state == BT_CONNECTED) {
1310 err = __l2cap_wait_ack(sk, chan);
1312 /* After waiting for ACKs, check whether shutdown
1313 * has already been actioned to close the L2CAP
1314 * link such as by l2cap_disconnection_req().
1316 if ((sk->sk_shutdown & how) == how)
1317 goto shutdown_matched;
1320 /* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1323 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1324 sk->sk_shutdown |= RCV_SHUTDOWN;
1325 if ((sk->sk_shutdown & how) == how)
1326 goto shutdown_matched;
1329 sk->sk_shutdown |= SEND_SHUTDOWN;
1332 l2cap_chan_lock(chan);
1335 /* prevent conn structure from being freed */
1336 l2cap_conn_get(conn);
1337 l2cap_chan_unlock(chan);
1340 /* mutex lock must be taken before l2cap_chan_lock() */
1341 mutex_lock(&conn->chan_lock);
1343 l2cap_chan_lock(chan);
1344 l2cap_chan_close(chan, 0);
1345 l2cap_chan_unlock(chan);
1348 mutex_unlock(&conn->chan_lock);
1349 l2cap_conn_put(conn);
1354 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1355 !(current->flags & PF_EXITING))
1356 err = bt_sock_wait_state(sk, BT_CLOSED,
1360 l2cap_chan_put(chan);
1364 if (!err && sk->sk_err)
1369 BT_DBG("Sock shutdown complete err: %d", err);
1374 static int l2cap_sock_release(struct socket *sock)
1376 struct sock *sk = sock->sk;
1378 struct l2cap_chan *chan;
1380 BT_DBG("sock %p, sk %p", sock, sk);
1385 l2cap_sock_cleanup_listen(sk);
1386 bt_sock_unlink(&l2cap_sk_list, sk);
1388 err = l2cap_sock_shutdown(sock, SHUT_RDWR);
1389 chan = l2cap_pi(sk)->chan;
1391 l2cap_chan_hold(chan);
1392 l2cap_chan_lock(chan);
1395 l2cap_sock_kill(sk);
1397 l2cap_chan_unlock(chan);
1398 l2cap_chan_put(chan);
1403 static void l2cap_sock_cleanup_listen(struct sock *parent)
1407 BT_DBG("parent %p state %s", parent,
1408 state_to_string(parent->sk_state));
1410 /* Close not yet accepted channels */
1411 while ((sk = bt_accept_dequeue(parent, NULL))) {
1412 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1414 BT_DBG("child chan %p state %s", chan,
1415 state_to_string(chan->state));
1417 l2cap_chan_hold(chan);
1418 l2cap_chan_lock(chan);
1420 __clear_chan_timer(chan);
1421 l2cap_chan_close(chan, ECONNRESET);
1422 l2cap_sock_kill(sk);
1424 l2cap_chan_unlock(chan);
1425 l2cap_chan_put(chan);
1429 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1431 struct sock *sk, *parent = chan->data;
1435 /* Check for backlog size */
1436 if (sk_acceptq_is_full(parent)) {
1437 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1438 release_sock(parent);
1442 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1445 release_sock(parent);
1449 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1451 l2cap_sock_init(sk, parent);
1453 bt_accept_enqueue(parent, sk, false);
1455 release_sock(parent);
1457 return l2cap_pi(sk)->chan;
1460 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1462 struct sock *sk = chan->data;
1467 if (l2cap_pi(sk)->rx_busy_skb) {
1472 if (chan->mode != L2CAP_MODE_ERTM &&
1473 chan->mode != L2CAP_MODE_STREAMING) {
1474 /* Even if no filter is attached, we could potentially
1475 * get errors from security modules, etc.
1477 err = sk_filter(sk, skb);
1482 err = __sock_queue_rcv_skb(sk, skb);
1484 /* For ERTM, handle one skb that doesn't fit into the recv
1485 * buffer. This is important to do because the data frames
1486 * have already been acked, so the skb cannot be discarded.
1488 * Notify the l2cap core that the buffer is full, so the
1489 * LOCAL_BUSY state is entered and no more frames are
1490 * acked and reassembled until there is buffer space
1493 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1494 l2cap_pi(sk)->rx_busy_skb = skb;
1495 l2cap_chan_busy(chan, 1);
1505 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1507 struct sock *sk = chan->data;
1512 l2cap_sock_kill(sk);
1515 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1517 struct sock *sk = chan->data;
1518 struct sock *parent;
1523 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1525 /* This callback can be called both for server (BT_LISTEN)
1526 * sockets as well as "normal" ones. To avoid lockdep warnings
1527 * with child socket locking (through l2cap_sock_cleanup_listen)
1528 * we need separation into separate nesting levels. The simplest
1529 * way to accomplish this is to inherit the nesting level used
1532 lock_sock_nested(sk, atomic_read(&chan->nesting));
1534 parent = bt_sk(sk)->parent;
1536 switch (chan->state) {
1542 l2cap_sock_cleanup_listen(sk);
1543 sk->sk_state = BT_CLOSED;
1544 chan->state = BT_CLOSED;
1548 sk->sk_state = BT_CLOSED;
1549 chan->state = BT_CLOSED;
1554 bt_accept_unlink(sk);
1555 parent->sk_data_ready(parent);
1557 sk->sk_state_change(sk);
1564 /* Only zap after cleanup to avoid use after free race */
1565 sock_set_flag(sk, SOCK_ZAPPED);
1569 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1572 struct sock *sk = chan->data;
1574 sk->sk_state = state;
1580 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1581 unsigned long hdr_len,
1582 unsigned long len, int nb)
1584 struct sock *sk = chan->data;
1585 struct sk_buff *skb;
1588 l2cap_chan_unlock(chan);
1589 skb = bt_skb_send_alloc(sk, hdr_len + len, nb, &err);
1590 l2cap_chan_lock(chan);
1593 return ERR_PTR(err);
1595 /* Channel lock is released before requesting new skb and then
1596 * reacquired thus we need to recheck channel state.
1598 if (chan->state != BT_CONNECTED) {
1600 return ERR_PTR(-ENOTCONN);
1603 skb->priority = READ_ONCE(sk->sk_priority);
1605 bt_cb(skb)->l2cap.chan = chan;
1610 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1612 struct sock *sk = chan->data;
1613 struct sock *parent;
1617 parent = bt_sk(sk)->parent;
1619 BT_DBG("sk %p, parent %p", sk, parent);
1621 sk->sk_state = BT_CONNECTED;
1622 sk->sk_state_change(sk);
1625 parent->sk_data_ready(parent);
1630 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1632 struct sock *parent, *sk = chan->data;
1636 parent = bt_sk(sk)->parent;
1638 parent->sk_data_ready(parent);
1643 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1645 struct sock *sk = chan->data;
1647 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1648 sk->sk_state = BT_CONNECTED;
1649 chan->state = BT_CONNECTED;
1652 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1653 sk->sk_state_change(sk);
1656 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1658 struct sock *sk = chan->data;
1661 sk->sk_shutdown = SHUTDOWN_MASK;
1665 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1667 struct sock *sk = chan->data;
1669 return sk->sk_sndtimeo;
1672 static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1674 struct sock *sk = chan->data;
1676 return sk->sk_peer_pid;
1679 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1681 struct sock *sk = chan->data;
1683 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1684 sk->sk_state_change(sk);
1687 static int l2cap_sock_filter(struct l2cap_chan *chan, struct sk_buff *skb)
1689 struct sock *sk = chan->data;
1691 switch (chan->mode) {
1692 case L2CAP_MODE_ERTM:
1693 case L2CAP_MODE_STREAMING:
1694 return sk_filter(sk, skb);
1700 static const struct l2cap_ops l2cap_chan_ops = {
1701 .name = "L2CAP Socket Interface",
1702 .new_connection = l2cap_sock_new_connection_cb,
1703 .recv = l2cap_sock_recv_cb,
1704 .close = l2cap_sock_close_cb,
1705 .teardown = l2cap_sock_teardown_cb,
1706 .state_change = l2cap_sock_state_change_cb,
1707 .ready = l2cap_sock_ready_cb,
1708 .defer = l2cap_sock_defer_cb,
1709 .resume = l2cap_sock_resume_cb,
1710 .suspend = l2cap_sock_suspend_cb,
1711 .set_shutdown = l2cap_sock_set_shutdown_cb,
1712 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
1713 .get_peer_pid = l2cap_sock_get_peer_pid_cb,
1714 .alloc_skb = l2cap_sock_alloc_skb_cb,
1715 .filter = l2cap_sock_filter,
1718 static void l2cap_sock_destruct(struct sock *sk)
1720 BT_DBG("sk %p", sk);
1722 if (l2cap_pi(sk)->chan) {
1723 l2cap_pi(sk)->chan->data = NULL;
1724 l2cap_chan_put(l2cap_pi(sk)->chan);
1727 if (l2cap_pi(sk)->rx_busy_skb) {
1728 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1729 l2cap_pi(sk)->rx_busy_skb = NULL;
1732 skb_queue_purge(&sk->sk_receive_queue);
1733 skb_queue_purge(&sk->sk_write_queue);
1736 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1739 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
1741 memset(la, 0, sizeof(struct sockaddr_l2));
1742 la->l2_family = AF_BLUETOOTH;
1743 la->l2_psm = bt_cb(skb)->l2cap.psm;
1744 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1746 *msg_namelen = sizeof(struct sockaddr_l2);
1749 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1751 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1753 BT_DBG("sk %p", sk);
1756 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1758 sk->sk_type = parent->sk_type;
1759 bt_sk(sk)->flags = bt_sk(parent)->flags;
1761 chan->chan_type = pchan->chan_type;
1762 chan->imtu = pchan->imtu;
1763 chan->omtu = pchan->omtu;
1764 chan->conf_state = pchan->conf_state;
1765 chan->mode = pchan->mode;
1766 chan->fcs = pchan->fcs;
1767 chan->max_tx = pchan->max_tx;
1768 chan->tx_win = pchan->tx_win;
1769 chan->tx_win_max = pchan->tx_win_max;
1770 chan->sec_level = pchan->sec_level;
1771 chan->flags = pchan->flags;
1772 chan->tx_credits = pchan->tx_credits;
1773 chan->rx_credits = pchan->rx_credits;
1775 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1776 chan->scid = pchan->scid;
1777 chan->dcid = pchan->scid;
1780 security_sk_clone(parent, sk);
1782 switch (sk->sk_type) {
1784 chan->chan_type = L2CAP_CHAN_RAW;
1787 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1788 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1790 case SOCK_SEQPACKET:
1792 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1796 chan->imtu = L2CAP_DEFAULT_MTU;
1798 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1799 chan->mode = L2CAP_MODE_ERTM;
1800 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1802 chan->mode = L2CAP_MODE_BASIC;
1805 l2cap_chan_set_defaults(chan);
1808 /* Default config options */
1809 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1812 chan->ops = &l2cap_chan_ops;
1815 static struct proto l2cap_proto = {
1817 .owner = THIS_MODULE,
1818 .obj_size = sizeof(struct l2cap_pinfo)
1821 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1822 int proto, gfp_t prio, int kern)
1825 struct l2cap_chan *chan;
1827 sk = bt_sock_alloc(net, sock, &l2cap_proto, proto, prio, kern);
1831 sk->sk_destruct = l2cap_sock_destruct;
1832 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1834 chan = l2cap_chan_create();
1840 l2cap_chan_hold(chan);
1842 l2cap_pi(sk)->chan = chan;
1847 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1852 BT_DBG("sock %p", sock);
1854 sock->state = SS_UNCONNECTED;
1856 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1857 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1858 return -ESOCKTNOSUPPORT;
1860 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1863 sock->ops = &l2cap_sock_ops;
1865 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1869 l2cap_sock_init(sk, NULL);
1870 bt_sock_link(&l2cap_sk_list, sk);
1874 static const struct proto_ops l2cap_sock_ops = {
1875 .family = PF_BLUETOOTH,
1876 .owner = THIS_MODULE,
1877 .release = l2cap_sock_release,
1878 .bind = l2cap_sock_bind,
1879 .connect = l2cap_sock_connect,
1880 .listen = l2cap_sock_listen,
1881 .accept = l2cap_sock_accept,
1882 .getname = l2cap_sock_getname,
1883 .sendmsg = l2cap_sock_sendmsg,
1884 .recvmsg = l2cap_sock_recvmsg,
1885 .poll = bt_sock_poll,
1886 .ioctl = bt_sock_ioctl,
1887 .gettstamp = sock_gettstamp,
1888 .mmap = sock_no_mmap,
1889 .socketpair = sock_no_socketpair,
1890 .shutdown = l2cap_sock_shutdown,
1891 .setsockopt = l2cap_sock_setsockopt,
1892 .getsockopt = l2cap_sock_getsockopt
1895 static const struct net_proto_family l2cap_sock_family_ops = {
1896 .family = PF_BLUETOOTH,
1897 .owner = THIS_MODULE,
1898 .create = l2cap_sock_create,
1901 int __init l2cap_init_sockets(void)
1905 BUILD_BUG_ON(sizeof(struct sockaddr_l2) > sizeof(struct sockaddr));
1907 err = proto_register(&l2cap_proto, 0);
1911 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1913 BT_ERR("L2CAP socket registration failed");
1917 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1920 BT_ERR("Failed to create L2CAP proc file");
1921 bt_sock_unregister(BTPROTO_L2CAP);
1925 BT_INFO("L2CAP socket layer initialized");
1930 proto_unregister(&l2cap_proto);
1934 void l2cap_cleanup_sockets(void)
1936 bt_procfs_cleanup(&init_net, "l2cap");
1937 bt_sock_unregister(BTPROTO_L2CAP);
1938 proto_unregister(&l2cap_proto);