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);
263 err = bt_sock_wait_state(sk, BT_CONNECTED,
264 sock_sndtimeo(sk, flags & O_NONBLOCK));
271 static int l2cap_sock_listen(struct socket *sock, int backlog)
273 struct sock *sk = sock->sk;
274 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
277 BT_DBG("sk %p backlog %d", sk, backlog);
281 if (sk->sk_state != BT_BOUND) {
286 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
291 switch (chan->mode) {
292 case L2CAP_MODE_BASIC:
293 case L2CAP_MODE_LE_FLOWCTL:
295 case L2CAP_MODE_EXT_FLOWCTL:
301 case L2CAP_MODE_ERTM:
302 case L2CAP_MODE_STREAMING:
311 sk->sk_max_ack_backlog = backlog;
312 sk->sk_ack_backlog = 0;
314 /* Listening channels need to use nested locking in order not to
315 * cause lockdep warnings when the created child channels end up
316 * being locked in the same thread as the parent channel.
318 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
320 chan->state = BT_LISTEN;
321 sk->sk_state = BT_LISTEN;
328 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
329 int flags, bool kern)
331 DEFINE_WAIT_FUNC(wait, woken_wake_function);
332 struct sock *sk = sock->sk, *nsk;
336 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
338 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
340 BT_DBG("sk %p timeo %ld", sk, timeo);
342 /* Wait for an incoming connection. (wake-one). */
343 add_wait_queue_exclusive(sk_sleep(sk), &wait);
345 if (sk->sk_state != BT_LISTEN) {
350 nsk = bt_accept_dequeue(sk, newsock);
359 if (signal_pending(current)) {
360 err = sock_intr_errno(timeo);
366 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
368 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
370 remove_wait_queue(sk_sleep(sk), &wait);
375 newsock->state = SS_CONNECTED;
377 BT_DBG("new socket %p", nsk);
384 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
387 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
388 struct sock *sk = sock->sk;
389 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
391 BT_DBG("sock %p, sk %p", sock, sk);
393 if (peer && sk->sk_state != BT_CONNECTED &&
394 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2 &&
395 sk->sk_state != BT_CONFIG)
398 memset(la, 0, sizeof(struct sockaddr_l2));
399 addr->sa_family = AF_BLUETOOTH;
401 la->l2_psm = chan->psm;
404 bacpy(&la->l2_bdaddr, &chan->dst);
405 la->l2_cid = cpu_to_le16(chan->dcid);
406 la->l2_bdaddr_type = chan->dst_type;
408 bacpy(&la->l2_bdaddr, &chan->src);
409 la->l2_cid = cpu_to_le16(chan->scid);
410 la->l2_bdaddr_type = chan->src_type;
413 return sizeof(struct sockaddr_l2);
416 static int l2cap_get_mode(struct l2cap_chan *chan)
418 switch (chan->mode) {
419 case L2CAP_MODE_BASIC:
420 return BT_MODE_BASIC;
421 case L2CAP_MODE_ERTM:
423 case L2CAP_MODE_STREAMING:
424 return BT_MODE_STREAMING;
425 case L2CAP_MODE_LE_FLOWCTL:
426 return BT_MODE_LE_FLOWCTL;
427 case L2CAP_MODE_EXT_FLOWCTL:
428 return BT_MODE_EXT_FLOWCTL;
434 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
435 char __user *optval, int __user *optlen)
437 struct sock *sk = sock->sk;
438 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
439 struct l2cap_options opts;
440 struct l2cap_conninfo cinfo;
446 if (get_user(len, optlen))
453 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
454 * legacy ATT code depends on getsockopt for
455 * L2CAP_OPTIONS we need to let this pass.
457 if (bdaddr_type_is_le(chan->src_type) &&
458 chan->scid != L2CAP_CID_ATT) {
463 /* Only BR/EDR modes are supported here */
464 switch (chan->mode) {
465 case L2CAP_MODE_BASIC:
466 case L2CAP_MODE_ERTM:
467 case L2CAP_MODE_STREAMING:
477 memset(&opts, 0, sizeof(opts));
478 opts.imtu = chan->imtu;
479 opts.omtu = chan->omtu;
480 opts.flush_to = chan->flush_to;
481 opts.mode = chan->mode;
482 opts.fcs = chan->fcs;
483 opts.max_tx = chan->max_tx;
484 opts.txwin_size = chan->tx_win;
486 BT_DBG("mode 0x%2.2x", chan->mode);
488 len = min_t(unsigned int, len, sizeof(opts));
489 if (copy_to_user(optval, (char *) &opts, len))
495 switch (chan->sec_level) {
496 case BT_SECURITY_LOW:
499 case BT_SECURITY_MEDIUM:
500 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
502 case BT_SECURITY_HIGH:
503 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
506 case BT_SECURITY_FIPS:
507 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
508 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
515 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
516 opt |= L2CAP_LM_MASTER;
518 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
519 opt |= L2CAP_LM_RELIABLE;
521 if (put_user(opt, (u32 __user *) optval))
527 if (sk->sk_state != BT_CONNECTED &&
528 !(sk->sk_state == BT_CONNECT2 &&
529 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
534 memset(&cinfo, 0, sizeof(cinfo));
535 cinfo.hci_handle = chan->conn->hcon->handle;
536 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
538 len = min_t(unsigned int, len, sizeof(cinfo));
539 if (copy_to_user(optval, (char *) &cinfo, len))
553 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
554 char __user *optval, int __user *optlen)
556 struct sock *sk = sock->sk;
557 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
558 struct bt_security sec;
561 int len, mode, err = 0;
565 if (level == SOL_L2CAP)
566 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
568 if (level != SOL_BLUETOOTH)
571 if (get_user(len, optlen))
578 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
579 chan->chan_type != L2CAP_CHAN_FIXED &&
580 chan->chan_type != L2CAP_CHAN_RAW) {
585 memset(&sec, 0, sizeof(sec));
587 sec.level = chan->conn->hcon->sec_level;
589 if (sk->sk_state == BT_CONNECTED)
590 sec.key_size = chan->conn->hcon->enc_key_size;
592 sec.level = chan->sec_level;
595 len = min_t(unsigned int, len, sizeof(sec));
596 if (copy_to_user(optval, (char *) &sec, len))
602 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
607 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
608 (u32 __user *) optval))
614 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
615 (u32 __user *) optval))
621 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
622 && sk->sk_type != SOCK_RAW) {
627 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
629 len = min_t(unsigned int, len, sizeof(pwr));
630 if (copy_to_user(optval, (char *) &pwr, len))
635 case BT_CHANNEL_POLICY:
636 if (put_user(chan->chan_policy, (u32 __user *) optval))
641 if (!bdaddr_type_is_le(chan->src_type)) {
646 if (sk->sk_state != BT_CONNECTED) {
651 if (put_user(chan->omtu, (u16 __user *) optval))
656 if (!bdaddr_type_is_le(chan->src_type)) {
661 if (put_user(chan->imtu, (u16 __user *) optval))
666 if (sk->sk_state != BT_CONNECTED) {
671 phys = hci_conn_get_phy(chan->conn->hcon);
673 if (put_user(phys, (u32 __user *) optval))
683 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
688 mode = l2cap_get_mode(chan);
694 if (put_user(mode, (u8 __user *) optval))
707 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
709 switch (chan->scid) {
711 if (mtu < L2CAP_LE_MIN_MTU)
716 if (mtu < L2CAP_DEFAULT_MIN_MTU)
723 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
724 sockptr_t optval, unsigned int optlen)
726 struct sock *sk = sock->sk;
727 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
728 struct l2cap_options opts;
738 if (bdaddr_type_is_le(chan->src_type)) {
743 if (sk->sk_state == BT_CONNECTED) {
748 opts.imtu = chan->imtu;
749 opts.omtu = chan->omtu;
750 opts.flush_to = chan->flush_to;
751 opts.mode = chan->mode;
752 opts.fcs = chan->fcs;
753 opts.max_tx = chan->max_tx;
754 opts.txwin_size = chan->tx_win;
756 err = bt_copy_from_sockptr(&opts, sizeof(opts), optval, optlen);
760 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
765 if (!l2cap_valid_mtu(chan, opts.imtu)) {
770 /* Only BR/EDR modes are supported here */
772 case L2CAP_MODE_BASIC:
773 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
775 case L2CAP_MODE_ERTM:
776 case L2CAP_MODE_STREAMING:
788 chan->mode = opts.mode;
790 BT_DBG("mode 0x%2.2x", chan->mode);
792 chan->imtu = opts.imtu;
793 chan->omtu = opts.omtu;
794 chan->fcs = opts.fcs;
795 chan->max_tx = opts.max_tx;
796 chan->tx_win = opts.txwin_size;
797 chan->flush_to = opts.flush_to;
801 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
805 if (opt & L2CAP_LM_FIPS) {
810 if (opt & L2CAP_LM_AUTH)
811 chan->sec_level = BT_SECURITY_LOW;
812 if (opt & L2CAP_LM_ENCRYPT)
813 chan->sec_level = BT_SECURITY_MEDIUM;
814 if (opt & L2CAP_LM_SECURE)
815 chan->sec_level = BT_SECURITY_HIGH;
817 if (opt & L2CAP_LM_MASTER)
818 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
820 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
822 if (opt & L2CAP_LM_RELIABLE)
823 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
825 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
837 static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
841 if (bdaddr_type_is_le(chan->src_type))
843 mode = L2CAP_MODE_BASIC;
844 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
847 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
849 mode = L2CAP_MODE_ERTM;
851 case BT_MODE_STREAMING:
852 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
854 mode = L2CAP_MODE_STREAMING;
856 case BT_MODE_LE_FLOWCTL:
857 if (!bdaddr_type_is_le(chan->src_type))
859 mode = L2CAP_MODE_LE_FLOWCTL;
861 case BT_MODE_EXT_FLOWCTL:
862 /* TODO: Add support for ECRED PDUs to BR/EDR */
863 if (!bdaddr_type_is_le(chan->src_type))
865 mode = L2CAP_MODE_EXT_FLOWCTL;
876 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
877 sockptr_t optval, unsigned int optlen)
879 struct sock *sk = sock->sk;
880 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
881 struct bt_security sec;
883 struct l2cap_conn *conn;
891 if (level == SOL_L2CAP)
892 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
894 if (level != SOL_BLUETOOTH)
901 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
902 chan->chan_type != L2CAP_CHAN_FIXED &&
903 chan->chan_type != L2CAP_CHAN_RAW) {
908 sec.level = BT_SECURITY_LOW;
910 err = bt_copy_from_sockptr(&sec, sizeof(sec), optval, optlen);
914 if (sec.level < BT_SECURITY_LOW ||
915 sec.level > BT_SECURITY_FIPS) {
920 chan->sec_level = sec.level;
927 /* change security for LE channels */
928 if (chan->scid == L2CAP_CID_ATT) {
929 if (smp_conn_security(conn->hcon, sec.level)) {
934 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
935 sk->sk_state = BT_CONFIG;
936 chan->state = BT_CONFIG;
938 /* or for ACL link */
939 } else if ((sk->sk_state == BT_CONNECT2 &&
940 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
941 sk->sk_state == BT_CONNECTED) {
942 if (!l2cap_chan_check_security(chan, true))
943 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
945 sk->sk_state_change(sk);
952 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
957 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
962 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
963 set_bit(FLAG_DEFER_SETUP, &chan->flags);
965 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
966 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
971 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
975 if (opt > BT_FLUSHABLE_ON) {
980 if (opt == BT_FLUSHABLE_OFF) {
982 /* proceed further only when we have l2cap_conn and
983 No Flush support in the LM */
984 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
991 set_bit(FLAG_FLUSHABLE, &chan->flags);
993 clear_bit(FLAG_FLUSHABLE, &chan->flags);
997 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
998 chan->chan_type != L2CAP_CHAN_RAW) {
1003 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1005 err = bt_copy_from_sockptr(&pwr, sizeof(pwr), optval, optlen);
1009 if (pwr.force_active)
1010 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1012 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1015 case BT_CHANNEL_POLICY:
1016 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
1024 if (!bdaddr_type_is_le(chan->src_type)) {
1029 /* Setting is not supported as it's the remote side that
1036 if (!bdaddr_type_is_le(chan->src_type)) {
1041 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1042 sk->sk_state == BT_CONNECTED) {
1047 err = bt_copy_from_sockptr(&mtu, sizeof(mtu), optval, optlen);
1051 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1052 sk->sk_state == BT_CONNECTED)
1053 err = l2cap_chan_reconfigure(chan, mtu);
1060 if (!enable_ecred) {
1065 BT_DBG("sk->sk_state %u", sk->sk_state);
1067 if (sk->sk_state != BT_BOUND) {
1072 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1077 err = bt_copy_from_sockptr(&mode, sizeof(mode), optval, optlen);
1081 BT_DBG("mode %u", mode);
1083 err = l2cap_set_mode(chan, mode);
1087 BT_DBG("mode 0x%2.2x", chan->mode);
1100 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1103 struct sock *sk = sock->sk;
1104 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1107 BT_DBG("sock %p, sk %p", sock, sk);
1109 err = sock_error(sk);
1113 if (msg->msg_flags & MSG_OOB)
1116 if (sk->sk_state != BT_CONNECTED)
1120 err = bt_sock_wait_ready(sk, msg->msg_flags);
1125 l2cap_chan_lock(chan);
1126 err = l2cap_chan_send(chan, msg, len);
1127 l2cap_chan_unlock(chan);
1132 static int l2cap_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1133 size_t len, int flags)
1135 struct sock *sk = sock->sk;
1136 struct l2cap_pinfo *pi = l2cap_pi(sk);
1141 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1142 &bt_sk(sk)->flags)) {
1143 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1144 sk->sk_state = BT_CONNECTED;
1145 pi->chan->state = BT_CONNECTED;
1146 __l2cap_ecred_conn_rsp_defer(pi->chan);
1147 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1148 sk->sk_state = BT_CONNECTED;
1149 pi->chan->state = BT_CONNECTED;
1150 __l2cap_le_connect_rsp_defer(pi->chan);
1152 sk->sk_state = BT_CONFIG;
1153 pi->chan->state = BT_CONFIG;
1154 __l2cap_connect_rsp_defer(pi->chan);
1163 if (sock->type == SOCK_STREAM)
1164 err = bt_sock_stream_recvmsg(sock, msg, len, flags);
1166 err = bt_sock_recvmsg(sock, msg, len, flags);
1168 if (pi->chan->mode != L2CAP_MODE_ERTM)
1171 /* Attempt to put pending rx data in the socket buffer */
1175 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1178 if (pi->rx_busy_skb) {
1179 if (!__sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1180 pi->rx_busy_skb = NULL;
1185 /* Restore data flow when half of the receive buffer is
1186 * available. This avoids resending large numbers of
1189 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1190 l2cap_chan_busy(pi->chan, 0);
1197 /* Kill socket (only if zapped and orphan)
1198 * Must be called on unlocked socket, with l2cap channel lock.
1200 static void l2cap_sock_kill(struct sock *sk)
1202 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1205 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1207 /* Kill poor orphan */
1209 l2cap_chan_put(l2cap_pi(sk)->chan);
1210 sock_set_flag(sk, SOCK_DEAD);
1214 static int __l2cap_wait_ack(struct sock *sk, struct l2cap_chan *chan)
1216 DECLARE_WAITQUEUE(wait, current);
1218 int timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1219 /* Timeout to prevent infinite loop */
1220 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1222 add_wait_queue(sk_sleep(sk), &wait);
1223 set_current_state(TASK_INTERRUPTIBLE);
1225 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1226 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1227 jiffies_to_msecs(timeout - jiffies));
1230 timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1232 if (signal_pending(current)) {
1233 err = sock_intr_errno(timeo);
1238 timeo = schedule_timeout(timeo);
1240 set_current_state(TASK_INTERRUPTIBLE);
1242 err = sock_error(sk);
1246 if (time_after(jiffies, timeout)) {
1251 } while (chan->unacked_frames > 0 &&
1252 chan->state == BT_CONNECTED);
1254 set_current_state(TASK_RUNNING);
1255 remove_wait_queue(sk_sleep(sk), &wait);
1259 static int l2cap_sock_shutdown(struct socket *sock, int how)
1261 struct sock *sk = sock->sk;
1262 struct l2cap_chan *chan;
1263 struct l2cap_conn *conn;
1266 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1268 /* 'how' parameter is mapped to sk_shutdown as follows:
1269 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1270 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1271 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1280 if ((sk->sk_shutdown & how) == how)
1281 goto shutdown_already;
1283 BT_DBG("Handling sock shutdown");
1285 /* prevent sk structure from being freed whilst unlocked */
1288 chan = l2cap_pi(sk)->chan;
1289 /* prevent chan structure from being freed whilst unlocked */
1290 l2cap_chan_hold(chan);
1292 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1294 if (chan->mode == L2CAP_MODE_ERTM &&
1295 chan->unacked_frames > 0 &&
1296 chan->state == BT_CONNECTED) {
1297 err = __l2cap_wait_ack(sk, chan);
1299 /* After waiting for ACKs, check whether shutdown
1300 * has already been actioned to close the L2CAP
1301 * link such as by l2cap_disconnection_req().
1303 if ((sk->sk_shutdown & how) == how)
1304 goto shutdown_matched;
1307 /* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1310 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1311 sk->sk_shutdown |= RCV_SHUTDOWN;
1312 if ((sk->sk_shutdown & how) == how)
1313 goto shutdown_matched;
1316 sk->sk_shutdown |= SEND_SHUTDOWN;
1319 l2cap_chan_lock(chan);
1322 /* prevent conn structure from being freed */
1323 l2cap_conn_get(conn);
1324 l2cap_chan_unlock(chan);
1327 /* mutex lock must be taken before l2cap_chan_lock() */
1328 mutex_lock(&conn->chan_lock);
1330 l2cap_chan_lock(chan);
1331 l2cap_chan_close(chan, 0);
1332 l2cap_chan_unlock(chan);
1335 mutex_unlock(&conn->chan_lock);
1336 l2cap_conn_put(conn);
1341 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1342 !(current->flags & PF_EXITING))
1343 err = bt_sock_wait_state(sk, BT_CLOSED,
1347 l2cap_chan_put(chan);
1351 if (!err && sk->sk_err)
1356 BT_DBG("Sock shutdown complete err: %d", err);
1361 static int l2cap_sock_release(struct socket *sock)
1363 struct sock *sk = sock->sk;
1365 struct l2cap_chan *chan;
1367 BT_DBG("sock %p, sk %p", sock, sk);
1372 l2cap_sock_cleanup_listen(sk);
1373 bt_sock_unlink(&l2cap_sk_list, sk);
1375 err = l2cap_sock_shutdown(sock, SHUT_RDWR);
1376 chan = l2cap_pi(sk)->chan;
1378 l2cap_chan_hold(chan);
1379 l2cap_chan_lock(chan);
1382 l2cap_sock_kill(sk);
1384 l2cap_chan_unlock(chan);
1385 l2cap_chan_put(chan);
1390 static void l2cap_sock_cleanup_listen(struct sock *parent)
1394 BT_DBG("parent %p state %s", parent,
1395 state_to_string(parent->sk_state));
1397 /* Close not yet accepted channels */
1398 while ((sk = bt_accept_dequeue(parent, NULL))) {
1399 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1401 BT_DBG("child chan %p state %s", chan,
1402 state_to_string(chan->state));
1404 l2cap_chan_hold(chan);
1405 l2cap_chan_lock(chan);
1407 __clear_chan_timer(chan);
1408 l2cap_chan_close(chan, ECONNRESET);
1409 l2cap_sock_kill(sk);
1411 l2cap_chan_unlock(chan);
1412 l2cap_chan_put(chan);
1416 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1418 struct sock *sk, *parent = chan->data;
1422 /* Check for backlog size */
1423 if (sk_acceptq_is_full(parent)) {
1424 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1425 release_sock(parent);
1429 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1432 release_sock(parent);
1436 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1438 l2cap_sock_init(sk, parent);
1440 bt_accept_enqueue(parent, sk, false);
1442 release_sock(parent);
1444 return l2cap_pi(sk)->chan;
1447 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1449 struct sock *sk = chan->data;
1454 if (l2cap_pi(sk)->rx_busy_skb) {
1459 if (chan->mode != L2CAP_MODE_ERTM &&
1460 chan->mode != L2CAP_MODE_STREAMING) {
1461 /* Even if no filter is attached, we could potentially
1462 * get errors from security modules, etc.
1464 err = sk_filter(sk, skb);
1469 err = __sock_queue_rcv_skb(sk, skb);
1471 /* For ERTM, handle one skb that doesn't fit into the recv
1472 * buffer. This is important to do because the data frames
1473 * have already been acked, so the skb cannot be discarded.
1475 * Notify the l2cap core that the buffer is full, so the
1476 * LOCAL_BUSY state is entered and no more frames are
1477 * acked and reassembled until there is buffer space
1480 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1481 l2cap_pi(sk)->rx_busy_skb = skb;
1482 l2cap_chan_busy(chan, 1);
1492 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1494 struct sock *sk = chan->data;
1499 l2cap_sock_kill(sk);
1502 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1504 struct sock *sk = chan->data;
1505 struct sock *parent;
1510 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1512 /* This callback can be called both for server (BT_LISTEN)
1513 * sockets as well as "normal" ones. To avoid lockdep warnings
1514 * with child socket locking (through l2cap_sock_cleanup_listen)
1515 * we need separation into separate nesting levels. The simplest
1516 * way to accomplish this is to inherit the nesting level used
1519 lock_sock_nested(sk, atomic_read(&chan->nesting));
1521 parent = bt_sk(sk)->parent;
1523 switch (chan->state) {
1529 l2cap_sock_cleanup_listen(sk);
1530 sk->sk_state = BT_CLOSED;
1531 chan->state = BT_CLOSED;
1535 sk->sk_state = BT_CLOSED;
1536 chan->state = BT_CLOSED;
1541 bt_accept_unlink(sk);
1542 parent->sk_data_ready(parent);
1544 sk->sk_state_change(sk);
1551 /* Only zap after cleanup to avoid use after free race */
1552 sock_set_flag(sk, SOCK_ZAPPED);
1556 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1559 struct sock *sk = chan->data;
1561 sk->sk_state = state;
1567 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1568 unsigned long hdr_len,
1569 unsigned long len, int nb)
1571 struct sock *sk = chan->data;
1572 struct sk_buff *skb;
1575 l2cap_chan_unlock(chan);
1576 skb = bt_skb_send_alloc(sk, hdr_len + len, nb, &err);
1577 l2cap_chan_lock(chan);
1580 return ERR_PTR(err);
1582 /* Channel lock is released before requesting new skb and then
1583 * reacquired thus we need to recheck channel state.
1585 if (chan->state != BT_CONNECTED) {
1587 return ERR_PTR(-ENOTCONN);
1590 skb->priority = READ_ONCE(sk->sk_priority);
1592 bt_cb(skb)->l2cap.chan = chan;
1597 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1599 struct sock *sk = chan->data;
1600 struct sock *parent;
1604 parent = bt_sk(sk)->parent;
1606 BT_DBG("sk %p, parent %p", sk, parent);
1608 sk->sk_state = BT_CONNECTED;
1609 sk->sk_state_change(sk);
1612 parent->sk_data_ready(parent);
1617 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1619 struct sock *parent, *sk = chan->data;
1623 parent = bt_sk(sk)->parent;
1625 parent->sk_data_ready(parent);
1630 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1632 struct sock *sk = chan->data;
1634 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1635 sk->sk_state = BT_CONNECTED;
1636 chan->state = BT_CONNECTED;
1639 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1640 sk->sk_state_change(sk);
1643 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1645 struct sock *sk = chan->data;
1648 sk->sk_shutdown = SHUTDOWN_MASK;
1652 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1654 struct sock *sk = chan->data;
1656 return sk->sk_sndtimeo;
1659 static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1661 struct sock *sk = chan->data;
1663 return sk->sk_peer_pid;
1666 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1668 struct sock *sk = chan->data;
1670 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1671 sk->sk_state_change(sk);
1674 static int l2cap_sock_filter(struct l2cap_chan *chan, struct sk_buff *skb)
1676 struct sock *sk = chan->data;
1678 switch (chan->mode) {
1679 case L2CAP_MODE_ERTM:
1680 case L2CAP_MODE_STREAMING:
1681 return sk_filter(sk, skb);
1687 static const struct l2cap_ops l2cap_chan_ops = {
1688 .name = "L2CAP Socket Interface",
1689 .new_connection = l2cap_sock_new_connection_cb,
1690 .recv = l2cap_sock_recv_cb,
1691 .close = l2cap_sock_close_cb,
1692 .teardown = l2cap_sock_teardown_cb,
1693 .state_change = l2cap_sock_state_change_cb,
1694 .ready = l2cap_sock_ready_cb,
1695 .defer = l2cap_sock_defer_cb,
1696 .resume = l2cap_sock_resume_cb,
1697 .suspend = l2cap_sock_suspend_cb,
1698 .set_shutdown = l2cap_sock_set_shutdown_cb,
1699 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
1700 .get_peer_pid = l2cap_sock_get_peer_pid_cb,
1701 .alloc_skb = l2cap_sock_alloc_skb_cb,
1702 .filter = l2cap_sock_filter,
1705 static void l2cap_sock_destruct(struct sock *sk)
1707 BT_DBG("sk %p", sk);
1709 if (l2cap_pi(sk)->chan) {
1710 l2cap_pi(sk)->chan->data = NULL;
1711 l2cap_chan_put(l2cap_pi(sk)->chan);
1714 if (l2cap_pi(sk)->rx_busy_skb) {
1715 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1716 l2cap_pi(sk)->rx_busy_skb = NULL;
1719 skb_queue_purge(&sk->sk_receive_queue);
1720 skb_queue_purge(&sk->sk_write_queue);
1723 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1726 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
1728 memset(la, 0, sizeof(struct sockaddr_l2));
1729 la->l2_family = AF_BLUETOOTH;
1730 la->l2_psm = bt_cb(skb)->l2cap.psm;
1731 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1733 *msg_namelen = sizeof(struct sockaddr_l2);
1736 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1738 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1740 BT_DBG("sk %p", sk);
1743 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1745 sk->sk_type = parent->sk_type;
1746 bt_sk(sk)->flags = bt_sk(parent)->flags;
1748 chan->chan_type = pchan->chan_type;
1749 chan->imtu = pchan->imtu;
1750 chan->omtu = pchan->omtu;
1751 chan->conf_state = pchan->conf_state;
1752 chan->mode = pchan->mode;
1753 chan->fcs = pchan->fcs;
1754 chan->max_tx = pchan->max_tx;
1755 chan->tx_win = pchan->tx_win;
1756 chan->tx_win_max = pchan->tx_win_max;
1757 chan->sec_level = pchan->sec_level;
1758 chan->flags = pchan->flags;
1759 chan->tx_credits = pchan->tx_credits;
1760 chan->rx_credits = pchan->rx_credits;
1762 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1763 chan->scid = pchan->scid;
1764 chan->dcid = pchan->scid;
1767 security_sk_clone(parent, sk);
1769 switch (sk->sk_type) {
1771 chan->chan_type = L2CAP_CHAN_RAW;
1774 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1775 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1777 case SOCK_SEQPACKET:
1779 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1783 chan->imtu = L2CAP_DEFAULT_MTU;
1785 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1786 chan->mode = L2CAP_MODE_ERTM;
1787 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1789 chan->mode = L2CAP_MODE_BASIC;
1792 l2cap_chan_set_defaults(chan);
1795 /* Default config options */
1796 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1799 chan->ops = &l2cap_chan_ops;
1802 static struct proto l2cap_proto = {
1804 .owner = THIS_MODULE,
1805 .obj_size = sizeof(struct l2cap_pinfo)
1808 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1809 int proto, gfp_t prio, int kern)
1812 struct l2cap_chan *chan;
1814 sk = bt_sock_alloc(net, sock, &l2cap_proto, proto, prio, kern);
1818 sk->sk_destruct = l2cap_sock_destruct;
1819 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1821 chan = l2cap_chan_create();
1827 l2cap_chan_hold(chan);
1829 l2cap_pi(sk)->chan = chan;
1834 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1839 BT_DBG("sock %p", sock);
1841 sock->state = SS_UNCONNECTED;
1843 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1844 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1845 return -ESOCKTNOSUPPORT;
1847 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1850 sock->ops = &l2cap_sock_ops;
1852 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1856 l2cap_sock_init(sk, NULL);
1857 bt_sock_link(&l2cap_sk_list, sk);
1861 static const struct proto_ops l2cap_sock_ops = {
1862 .family = PF_BLUETOOTH,
1863 .owner = THIS_MODULE,
1864 .release = l2cap_sock_release,
1865 .bind = l2cap_sock_bind,
1866 .connect = l2cap_sock_connect,
1867 .listen = l2cap_sock_listen,
1868 .accept = l2cap_sock_accept,
1869 .getname = l2cap_sock_getname,
1870 .sendmsg = l2cap_sock_sendmsg,
1871 .recvmsg = l2cap_sock_recvmsg,
1872 .poll = bt_sock_poll,
1873 .ioctl = bt_sock_ioctl,
1874 .gettstamp = sock_gettstamp,
1875 .mmap = sock_no_mmap,
1876 .socketpair = sock_no_socketpair,
1877 .shutdown = l2cap_sock_shutdown,
1878 .setsockopt = l2cap_sock_setsockopt,
1879 .getsockopt = l2cap_sock_getsockopt
1882 static const struct net_proto_family l2cap_sock_family_ops = {
1883 .family = PF_BLUETOOTH,
1884 .owner = THIS_MODULE,
1885 .create = l2cap_sock_create,
1888 int __init l2cap_init_sockets(void)
1892 BUILD_BUG_ON(sizeof(struct sockaddr_l2) > sizeof(struct sockaddr));
1894 err = proto_register(&l2cap_proto, 0);
1898 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1900 BT_ERR("L2CAP socket registration failed");
1904 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1907 BT_ERR("Failed to create L2CAP proc file");
1908 bt_sock_unregister(BTPROTO_L2CAP);
1912 BT_INFO("L2CAP socket layer initialized");
1917 proto_unregister(&l2cap_proto);
1921 void l2cap_cleanup_sockets(void)
1923 bt_procfs_cleanup(&init_net, "l2cap");
1924 bt_sock_unregister(BTPROTO_L2CAP);
1925 proto_unregister(&l2cap_proto);