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;
448 if (get_user(len, optlen))
455 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
456 * legacy ATT code depends on getsockopt for
457 * L2CAP_OPTIONS we need to let this pass.
459 if (bdaddr_type_is_le(chan->src_type) &&
460 chan->scid != L2CAP_CID_ATT) {
465 /* Only BR/EDR modes are supported here */
466 switch (chan->mode) {
467 case L2CAP_MODE_BASIC:
468 case L2CAP_MODE_ERTM:
469 case L2CAP_MODE_STREAMING:
479 memset(&opts, 0, sizeof(opts));
480 opts.imtu = chan->imtu;
481 opts.omtu = chan->omtu;
482 opts.flush_to = chan->flush_to;
483 opts.mode = chan->mode;
484 opts.fcs = chan->fcs;
485 opts.max_tx = chan->max_tx;
486 opts.txwin_size = chan->tx_win;
488 BT_DBG("mode 0x%2.2x", chan->mode);
490 len = min(len, sizeof(opts));
491 if (copy_to_user(optval, (char *) &opts, len))
497 switch (chan->sec_level) {
498 case BT_SECURITY_LOW:
501 case BT_SECURITY_MEDIUM:
502 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
504 case BT_SECURITY_HIGH:
505 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
508 case BT_SECURITY_FIPS:
509 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
510 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
517 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
518 opt |= L2CAP_LM_MASTER;
520 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
521 opt |= L2CAP_LM_RELIABLE;
523 if (put_user(opt, (u32 __user *) optval))
529 if (sk->sk_state != BT_CONNECTED &&
530 !(sk->sk_state == BT_CONNECT2 &&
531 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
536 memset(&cinfo, 0, sizeof(cinfo));
537 cinfo.hci_handle = chan->conn->hcon->handle;
538 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
540 len = min(len, sizeof(cinfo));
541 if (copy_to_user(optval, (char *) &cinfo, len))
555 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
556 char __user *optval, int __user *optlen)
558 struct sock *sk = sock->sk;
559 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
560 struct bt_security sec;
563 int len, mode, err = 0;
567 if (level == SOL_L2CAP)
568 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
570 if (level != SOL_BLUETOOTH)
573 if (get_user(len, optlen))
580 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
581 chan->chan_type != L2CAP_CHAN_FIXED &&
582 chan->chan_type != L2CAP_CHAN_RAW) {
587 memset(&sec, 0, sizeof(sec));
589 sec.level = chan->conn->hcon->sec_level;
591 if (sk->sk_state == BT_CONNECTED)
592 sec.key_size = chan->conn->hcon->enc_key_size;
594 sec.level = chan->sec_level;
597 len = min_t(unsigned int, len, sizeof(sec));
598 if (copy_to_user(optval, (char *) &sec, len))
604 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
609 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
610 (u32 __user *) optval))
616 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
617 (u32 __user *) optval))
623 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
624 && sk->sk_type != SOCK_RAW) {
629 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
631 len = min_t(unsigned int, len, sizeof(pwr));
632 if (copy_to_user(optval, (char *) &pwr, len))
637 case BT_CHANNEL_POLICY:
638 if (put_user(chan->chan_policy, (u32 __user *) optval))
643 if (!bdaddr_type_is_le(chan->src_type)) {
648 if (sk->sk_state != BT_CONNECTED) {
653 if (put_user(chan->omtu, (u16 __user *) optval))
658 if (!bdaddr_type_is_le(chan->src_type)) {
663 if (put_user(chan->imtu, (u16 __user *) optval))
668 if (sk->sk_state != BT_CONNECTED) {
673 phys = hci_conn_get_phy(chan->conn->hcon);
675 if (put_user(phys, (u32 __user *) optval))
685 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
690 mode = l2cap_get_mode(chan);
696 if (put_user(mode, (u8 __user *) optval))
709 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
711 switch (chan->scid) {
713 if (mtu < L2CAP_LE_MIN_MTU)
718 if (mtu < L2CAP_DEFAULT_MIN_MTU)
725 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
726 sockptr_t optval, unsigned int optlen)
728 struct sock *sk = sock->sk;
729 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
730 struct l2cap_options opts;
740 if (bdaddr_type_is_le(chan->src_type)) {
745 if (sk->sk_state == BT_CONNECTED) {
750 opts.imtu = chan->imtu;
751 opts.omtu = chan->omtu;
752 opts.flush_to = chan->flush_to;
753 opts.mode = chan->mode;
754 opts.fcs = chan->fcs;
755 opts.max_tx = chan->max_tx;
756 opts.txwin_size = chan->tx_win;
758 err = bt_copy_from_sockptr(&opts, sizeof(opts), optval, optlen);
762 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
767 if (!l2cap_valid_mtu(chan, opts.imtu)) {
772 /* Only BR/EDR modes are supported here */
774 case L2CAP_MODE_BASIC:
775 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
777 case L2CAP_MODE_ERTM:
778 case L2CAP_MODE_STREAMING:
790 chan->mode = opts.mode;
792 BT_DBG("mode 0x%2.2x", chan->mode);
794 chan->imtu = opts.imtu;
795 chan->omtu = opts.omtu;
796 chan->fcs = opts.fcs;
797 chan->max_tx = opts.max_tx;
798 chan->tx_win = opts.txwin_size;
799 chan->flush_to = opts.flush_to;
803 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
807 if (opt & L2CAP_LM_FIPS) {
812 if (opt & L2CAP_LM_AUTH)
813 chan->sec_level = BT_SECURITY_LOW;
814 if (opt & L2CAP_LM_ENCRYPT)
815 chan->sec_level = BT_SECURITY_MEDIUM;
816 if (opt & L2CAP_LM_SECURE)
817 chan->sec_level = BT_SECURITY_HIGH;
819 if (opt & L2CAP_LM_MASTER)
820 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
822 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
824 if (opt & L2CAP_LM_RELIABLE)
825 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
827 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
839 static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
843 if (bdaddr_type_is_le(chan->src_type))
845 mode = L2CAP_MODE_BASIC;
846 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
849 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
851 mode = L2CAP_MODE_ERTM;
853 case BT_MODE_STREAMING:
854 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
856 mode = L2CAP_MODE_STREAMING;
858 case BT_MODE_LE_FLOWCTL:
859 if (!bdaddr_type_is_le(chan->src_type))
861 mode = L2CAP_MODE_LE_FLOWCTL;
863 case BT_MODE_EXT_FLOWCTL:
864 /* TODO: Add support for ECRED PDUs to BR/EDR */
865 if (!bdaddr_type_is_le(chan->src_type))
867 mode = L2CAP_MODE_EXT_FLOWCTL;
878 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
879 sockptr_t optval, unsigned int optlen)
881 struct sock *sk = sock->sk;
882 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
883 struct bt_security sec;
885 struct l2cap_conn *conn;
893 if (level == SOL_L2CAP)
894 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
896 if (level != SOL_BLUETOOTH)
903 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
904 chan->chan_type != L2CAP_CHAN_FIXED &&
905 chan->chan_type != L2CAP_CHAN_RAW) {
910 sec.level = BT_SECURITY_LOW;
912 err = bt_copy_from_sockptr(&sec, sizeof(sec), optval, optlen);
916 if (sec.level < BT_SECURITY_LOW ||
917 sec.level > BT_SECURITY_FIPS) {
922 chan->sec_level = sec.level;
929 /* change security for LE channels */
930 if (chan->scid == L2CAP_CID_ATT) {
931 if (smp_conn_security(conn->hcon, sec.level)) {
936 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
937 sk->sk_state = BT_CONFIG;
938 chan->state = BT_CONFIG;
940 /* or for ACL link */
941 } else if ((sk->sk_state == BT_CONNECT2 &&
942 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
943 sk->sk_state == BT_CONNECTED) {
944 if (!l2cap_chan_check_security(chan, true))
945 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
947 sk->sk_state_change(sk);
954 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
959 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
964 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
965 set_bit(FLAG_DEFER_SETUP, &chan->flags);
967 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
968 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
973 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
977 if (opt > BT_FLUSHABLE_ON) {
982 if (opt == BT_FLUSHABLE_OFF) {
984 /* proceed further only when we have l2cap_conn and
985 No Flush support in the LM */
986 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
993 set_bit(FLAG_FLUSHABLE, &chan->flags);
995 clear_bit(FLAG_FLUSHABLE, &chan->flags);
999 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
1000 chan->chan_type != L2CAP_CHAN_RAW) {
1005 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1007 err = bt_copy_from_sockptr(&pwr, sizeof(pwr), optval, optlen);
1011 if (pwr.force_active)
1012 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1014 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1017 case BT_CHANNEL_POLICY:
1018 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
1026 if (!bdaddr_type_is_le(chan->src_type)) {
1031 /* Setting is not supported as it's the remote side that
1038 if (!bdaddr_type_is_le(chan->src_type)) {
1043 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1044 sk->sk_state == BT_CONNECTED) {
1049 err = bt_copy_from_sockptr(&mtu, sizeof(mtu), optval, optlen);
1053 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1054 sk->sk_state == BT_CONNECTED)
1055 err = l2cap_chan_reconfigure(chan, mtu);
1062 if (!enable_ecred) {
1067 BT_DBG("sk->sk_state %u", sk->sk_state);
1069 if (sk->sk_state != BT_BOUND) {
1074 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1079 err = bt_copy_from_sockptr(&mode, sizeof(mode), optval, optlen);
1083 BT_DBG("mode %u", mode);
1085 err = l2cap_set_mode(chan, mode);
1089 BT_DBG("mode 0x%2.2x", chan->mode);
1102 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1105 struct sock *sk = sock->sk;
1106 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1109 BT_DBG("sock %p, sk %p", sock, sk);
1111 err = sock_error(sk);
1115 if (msg->msg_flags & MSG_OOB)
1118 if (sk->sk_state != BT_CONNECTED)
1122 err = bt_sock_wait_ready(sk, msg->msg_flags);
1127 l2cap_chan_lock(chan);
1128 err = l2cap_chan_send(chan, msg, len);
1129 l2cap_chan_unlock(chan);
1134 static int l2cap_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1135 size_t len, int flags)
1137 struct sock *sk = sock->sk;
1138 struct l2cap_pinfo *pi = l2cap_pi(sk);
1143 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1144 &bt_sk(sk)->flags)) {
1145 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1146 sk->sk_state = BT_CONNECTED;
1147 pi->chan->state = BT_CONNECTED;
1148 __l2cap_ecred_conn_rsp_defer(pi->chan);
1149 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1150 sk->sk_state = BT_CONNECTED;
1151 pi->chan->state = BT_CONNECTED;
1152 __l2cap_le_connect_rsp_defer(pi->chan);
1154 sk->sk_state = BT_CONFIG;
1155 pi->chan->state = BT_CONFIG;
1156 __l2cap_connect_rsp_defer(pi->chan);
1165 if (sock->type == SOCK_STREAM)
1166 err = bt_sock_stream_recvmsg(sock, msg, len, flags);
1168 err = bt_sock_recvmsg(sock, msg, len, flags);
1170 if (pi->chan->mode != L2CAP_MODE_ERTM)
1173 /* Attempt to put pending rx data in the socket buffer */
1177 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1180 if (pi->rx_busy_skb) {
1181 if (!__sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1182 pi->rx_busy_skb = NULL;
1187 /* Restore data flow when half of the receive buffer is
1188 * available. This avoids resending large numbers of
1191 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1192 l2cap_chan_busy(pi->chan, 0);
1199 /* Kill socket (only if zapped and orphan)
1200 * Must be called on unlocked socket, with l2cap channel lock.
1202 static void l2cap_sock_kill(struct sock *sk)
1204 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1207 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1209 /* Kill poor orphan */
1211 l2cap_chan_put(l2cap_pi(sk)->chan);
1212 sock_set_flag(sk, SOCK_DEAD);
1216 static int __l2cap_wait_ack(struct sock *sk, struct l2cap_chan *chan)
1218 DECLARE_WAITQUEUE(wait, current);
1220 int timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1221 /* Timeout to prevent infinite loop */
1222 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1224 add_wait_queue(sk_sleep(sk), &wait);
1225 set_current_state(TASK_INTERRUPTIBLE);
1227 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1228 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1229 jiffies_to_msecs(timeout - jiffies));
1232 timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1234 if (signal_pending(current)) {
1235 err = sock_intr_errno(timeo);
1240 timeo = schedule_timeout(timeo);
1242 set_current_state(TASK_INTERRUPTIBLE);
1244 err = sock_error(sk);
1248 if (time_after(jiffies, timeout)) {
1253 } while (chan->unacked_frames > 0 &&
1254 chan->state == BT_CONNECTED);
1256 set_current_state(TASK_RUNNING);
1257 remove_wait_queue(sk_sleep(sk), &wait);
1261 static int l2cap_sock_shutdown(struct socket *sock, int how)
1263 struct sock *sk = sock->sk;
1264 struct l2cap_chan *chan;
1265 struct l2cap_conn *conn;
1268 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1270 /* 'how' parameter is mapped to sk_shutdown as follows:
1271 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1272 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1273 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1282 if ((sk->sk_shutdown & how) == how)
1283 goto shutdown_already;
1285 BT_DBG("Handling sock shutdown");
1287 /* prevent sk structure from being freed whilst unlocked */
1290 chan = l2cap_pi(sk)->chan;
1291 /* prevent chan structure from being freed whilst unlocked */
1292 l2cap_chan_hold(chan);
1294 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1296 if (chan->mode == L2CAP_MODE_ERTM &&
1297 chan->unacked_frames > 0 &&
1298 chan->state == BT_CONNECTED) {
1299 err = __l2cap_wait_ack(sk, chan);
1301 /* After waiting for ACKs, check whether shutdown
1302 * has already been actioned to close the L2CAP
1303 * link such as by l2cap_disconnection_req().
1305 if ((sk->sk_shutdown & how) == how)
1306 goto shutdown_matched;
1309 /* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1312 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1313 sk->sk_shutdown |= RCV_SHUTDOWN;
1314 if ((sk->sk_shutdown & how) == how)
1315 goto shutdown_matched;
1318 sk->sk_shutdown |= SEND_SHUTDOWN;
1321 l2cap_chan_lock(chan);
1324 /* prevent conn structure from being freed */
1325 l2cap_conn_get(conn);
1326 l2cap_chan_unlock(chan);
1329 /* mutex lock must be taken before l2cap_chan_lock() */
1330 mutex_lock(&conn->chan_lock);
1332 l2cap_chan_lock(chan);
1333 l2cap_chan_close(chan, 0);
1334 l2cap_chan_unlock(chan);
1337 mutex_unlock(&conn->chan_lock);
1338 l2cap_conn_put(conn);
1343 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1344 !(current->flags & PF_EXITING))
1345 err = bt_sock_wait_state(sk, BT_CLOSED,
1349 l2cap_chan_put(chan);
1353 if (!err && sk->sk_err)
1358 BT_DBG("Sock shutdown complete err: %d", err);
1363 static int l2cap_sock_release(struct socket *sock)
1365 struct sock *sk = sock->sk;
1367 struct l2cap_chan *chan;
1369 BT_DBG("sock %p, sk %p", sock, sk);
1374 l2cap_sock_cleanup_listen(sk);
1375 bt_sock_unlink(&l2cap_sk_list, sk);
1377 err = l2cap_sock_shutdown(sock, SHUT_RDWR);
1378 chan = l2cap_pi(sk)->chan;
1380 l2cap_chan_hold(chan);
1381 l2cap_chan_lock(chan);
1384 l2cap_sock_kill(sk);
1386 l2cap_chan_unlock(chan);
1387 l2cap_chan_put(chan);
1392 static void l2cap_sock_cleanup_listen(struct sock *parent)
1396 BT_DBG("parent %p state %s", parent,
1397 state_to_string(parent->sk_state));
1399 /* Close not yet accepted channels */
1400 while ((sk = bt_accept_dequeue(parent, NULL))) {
1401 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1403 BT_DBG("child chan %p state %s", chan,
1404 state_to_string(chan->state));
1406 l2cap_chan_hold(chan);
1407 l2cap_chan_lock(chan);
1409 __clear_chan_timer(chan);
1410 l2cap_chan_close(chan, ECONNRESET);
1411 l2cap_sock_kill(sk);
1413 l2cap_chan_unlock(chan);
1414 l2cap_chan_put(chan);
1418 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1420 struct sock *sk, *parent = chan->data;
1424 /* Check for backlog size */
1425 if (sk_acceptq_is_full(parent)) {
1426 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1427 release_sock(parent);
1431 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1434 release_sock(parent);
1438 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1440 l2cap_sock_init(sk, parent);
1442 bt_accept_enqueue(parent, sk, false);
1444 release_sock(parent);
1446 return l2cap_pi(sk)->chan;
1449 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1451 struct sock *sk = chan->data;
1456 if (l2cap_pi(sk)->rx_busy_skb) {
1461 if (chan->mode != L2CAP_MODE_ERTM &&
1462 chan->mode != L2CAP_MODE_STREAMING) {
1463 /* Even if no filter is attached, we could potentially
1464 * get errors from security modules, etc.
1466 err = sk_filter(sk, skb);
1471 err = __sock_queue_rcv_skb(sk, skb);
1473 /* For ERTM, handle one skb that doesn't fit into the recv
1474 * buffer. This is important to do because the data frames
1475 * have already been acked, so the skb cannot be discarded.
1477 * Notify the l2cap core that the buffer is full, so the
1478 * LOCAL_BUSY state is entered and no more frames are
1479 * acked and reassembled until there is buffer space
1482 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1483 l2cap_pi(sk)->rx_busy_skb = skb;
1484 l2cap_chan_busy(chan, 1);
1494 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1496 struct sock *sk = chan->data;
1501 l2cap_sock_kill(sk);
1504 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1506 struct sock *sk = chan->data;
1507 struct sock *parent;
1512 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1514 /* This callback can be called both for server (BT_LISTEN)
1515 * sockets as well as "normal" ones. To avoid lockdep warnings
1516 * with child socket locking (through l2cap_sock_cleanup_listen)
1517 * we need separation into separate nesting levels. The simplest
1518 * way to accomplish this is to inherit the nesting level used
1521 lock_sock_nested(sk, atomic_read(&chan->nesting));
1523 parent = bt_sk(sk)->parent;
1525 switch (chan->state) {
1531 l2cap_sock_cleanup_listen(sk);
1532 sk->sk_state = BT_CLOSED;
1533 chan->state = BT_CLOSED;
1537 sk->sk_state = BT_CLOSED;
1538 chan->state = BT_CLOSED;
1543 bt_accept_unlink(sk);
1544 parent->sk_data_ready(parent);
1546 sk->sk_state_change(sk);
1553 /* Only zap after cleanup to avoid use after free race */
1554 sock_set_flag(sk, SOCK_ZAPPED);
1558 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1561 struct sock *sk = chan->data;
1563 sk->sk_state = state;
1569 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1570 unsigned long hdr_len,
1571 unsigned long len, int nb)
1573 struct sock *sk = chan->data;
1574 struct sk_buff *skb;
1577 l2cap_chan_unlock(chan);
1578 skb = bt_skb_send_alloc(sk, hdr_len + len, nb, &err);
1579 l2cap_chan_lock(chan);
1582 return ERR_PTR(err);
1584 /* Channel lock is released before requesting new skb and then
1585 * reacquired thus we need to recheck channel state.
1587 if (chan->state != BT_CONNECTED) {
1589 return ERR_PTR(-ENOTCONN);
1592 skb->priority = READ_ONCE(sk->sk_priority);
1594 bt_cb(skb)->l2cap.chan = chan;
1599 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1601 struct sock *sk = chan->data;
1602 struct sock *parent;
1606 parent = bt_sk(sk)->parent;
1608 BT_DBG("sk %p, parent %p", sk, parent);
1610 sk->sk_state = BT_CONNECTED;
1611 sk->sk_state_change(sk);
1614 parent->sk_data_ready(parent);
1619 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1621 struct sock *parent, *sk = chan->data;
1625 parent = bt_sk(sk)->parent;
1627 parent->sk_data_ready(parent);
1632 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1634 struct sock *sk = chan->data;
1636 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1637 sk->sk_state = BT_CONNECTED;
1638 chan->state = BT_CONNECTED;
1641 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1642 sk->sk_state_change(sk);
1645 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1647 struct sock *sk = chan->data;
1650 sk->sk_shutdown = SHUTDOWN_MASK;
1654 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1656 struct sock *sk = chan->data;
1658 return sk->sk_sndtimeo;
1661 static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1663 struct sock *sk = chan->data;
1665 return sk->sk_peer_pid;
1668 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1670 struct sock *sk = chan->data;
1672 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1673 sk->sk_state_change(sk);
1676 static int l2cap_sock_filter(struct l2cap_chan *chan, struct sk_buff *skb)
1678 struct sock *sk = chan->data;
1680 switch (chan->mode) {
1681 case L2CAP_MODE_ERTM:
1682 case L2CAP_MODE_STREAMING:
1683 return sk_filter(sk, skb);
1689 static const struct l2cap_ops l2cap_chan_ops = {
1690 .name = "L2CAP Socket Interface",
1691 .new_connection = l2cap_sock_new_connection_cb,
1692 .recv = l2cap_sock_recv_cb,
1693 .close = l2cap_sock_close_cb,
1694 .teardown = l2cap_sock_teardown_cb,
1695 .state_change = l2cap_sock_state_change_cb,
1696 .ready = l2cap_sock_ready_cb,
1697 .defer = l2cap_sock_defer_cb,
1698 .resume = l2cap_sock_resume_cb,
1699 .suspend = l2cap_sock_suspend_cb,
1700 .set_shutdown = l2cap_sock_set_shutdown_cb,
1701 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
1702 .get_peer_pid = l2cap_sock_get_peer_pid_cb,
1703 .alloc_skb = l2cap_sock_alloc_skb_cb,
1704 .filter = l2cap_sock_filter,
1707 static void l2cap_sock_destruct(struct sock *sk)
1709 BT_DBG("sk %p", sk);
1711 if (l2cap_pi(sk)->chan) {
1712 l2cap_pi(sk)->chan->data = NULL;
1713 l2cap_chan_put(l2cap_pi(sk)->chan);
1716 if (l2cap_pi(sk)->rx_busy_skb) {
1717 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1718 l2cap_pi(sk)->rx_busy_skb = NULL;
1721 skb_queue_purge(&sk->sk_receive_queue);
1722 skb_queue_purge(&sk->sk_write_queue);
1725 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1728 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
1730 memset(la, 0, sizeof(struct sockaddr_l2));
1731 la->l2_family = AF_BLUETOOTH;
1732 la->l2_psm = bt_cb(skb)->l2cap.psm;
1733 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1735 *msg_namelen = sizeof(struct sockaddr_l2);
1738 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1740 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1742 BT_DBG("sk %p", sk);
1745 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1747 sk->sk_type = parent->sk_type;
1748 bt_sk(sk)->flags = bt_sk(parent)->flags;
1750 chan->chan_type = pchan->chan_type;
1751 chan->imtu = pchan->imtu;
1752 chan->omtu = pchan->omtu;
1753 chan->conf_state = pchan->conf_state;
1754 chan->mode = pchan->mode;
1755 chan->fcs = pchan->fcs;
1756 chan->max_tx = pchan->max_tx;
1757 chan->tx_win = pchan->tx_win;
1758 chan->tx_win_max = pchan->tx_win_max;
1759 chan->sec_level = pchan->sec_level;
1760 chan->flags = pchan->flags;
1761 chan->tx_credits = pchan->tx_credits;
1762 chan->rx_credits = pchan->rx_credits;
1764 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1765 chan->scid = pchan->scid;
1766 chan->dcid = pchan->scid;
1769 security_sk_clone(parent, sk);
1771 switch (sk->sk_type) {
1773 chan->chan_type = L2CAP_CHAN_RAW;
1776 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1777 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1779 case SOCK_SEQPACKET:
1781 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1785 chan->imtu = L2CAP_DEFAULT_MTU;
1787 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1788 chan->mode = L2CAP_MODE_ERTM;
1789 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1791 chan->mode = L2CAP_MODE_BASIC;
1794 l2cap_chan_set_defaults(chan);
1797 /* Default config options */
1798 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1801 chan->ops = &l2cap_chan_ops;
1804 static struct proto l2cap_proto = {
1806 .owner = THIS_MODULE,
1807 .obj_size = sizeof(struct l2cap_pinfo)
1810 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1811 int proto, gfp_t prio, int kern)
1814 struct l2cap_chan *chan;
1816 sk = bt_sock_alloc(net, sock, &l2cap_proto, proto, prio, kern);
1820 sk->sk_destruct = l2cap_sock_destruct;
1821 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1823 chan = l2cap_chan_create();
1829 l2cap_chan_hold(chan);
1831 l2cap_pi(sk)->chan = chan;
1836 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1841 BT_DBG("sock %p", sock);
1843 sock->state = SS_UNCONNECTED;
1845 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1846 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1847 return -ESOCKTNOSUPPORT;
1849 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1852 sock->ops = &l2cap_sock_ops;
1854 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1858 l2cap_sock_init(sk, NULL);
1859 bt_sock_link(&l2cap_sk_list, sk);
1863 static const struct proto_ops l2cap_sock_ops = {
1864 .family = PF_BLUETOOTH,
1865 .owner = THIS_MODULE,
1866 .release = l2cap_sock_release,
1867 .bind = l2cap_sock_bind,
1868 .connect = l2cap_sock_connect,
1869 .listen = l2cap_sock_listen,
1870 .accept = l2cap_sock_accept,
1871 .getname = l2cap_sock_getname,
1872 .sendmsg = l2cap_sock_sendmsg,
1873 .recvmsg = l2cap_sock_recvmsg,
1874 .poll = bt_sock_poll,
1875 .ioctl = bt_sock_ioctl,
1876 .gettstamp = sock_gettstamp,
1877 .mmap = sock_no_mmap,
1878 .socketpair = sock_no_socketpair,
1879 .shutdown = l2cap_sock_shutdown,
1880 .setsockopt = l2cap_sock_setsockopt,
1881 .getsockopt = l2cap_sock_getsockopt
1884 static const struct net_proto_family l2cap_sock_family_ops = {
1885 .family = PF_BLUETOOTH,
1886 .owner = THIS_MODULE,
1887 .create = l2cap_sock_create,
1890 int __init l2cap_init_sockets(void)
1894 BUILD_BUG_ON(sizeof(struct sockaddr_l2) > sizeof(struct sockaddr));
1896 err = proto_register(&l2cap_proto, 0);
1900 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1902 BT_ERR("L2CAP socket registration failed");
1906 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1909 BT_ERR("Failed to create L2CAP proc file");
1910 bt_sock_unregister(BTPROTO_L2CAP);
1914 BT_INFO("L2CAP socket layer initialized");
1919 proto_unregister(&l2cap_proto);
1923 void l2cap_cleanup_sockets(void)
1925 bt_procfs_cleanup(&init_net, "l2cap");
1926 bt_sock_unregister(BTPROTO_L2CAP);
1927 proto_unregister(&l2cap_proto);