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/sched/signal.h>
34 #include <net/bluetooth/bluetooth.h>
35 #include <net/bluetooth/hci_core.h>
36 #include <net/bluetooth/l2cap.h>
40 static struct bt_sock_list l2cap_sk_list = {
41 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
44 static const struct proto_ops l2cap_sock_ops;
45 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
46 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
47 int proto, gfp_t prio, int kern);
48 static void l2cap_sock_cleanup_listen(struct sock *parent);
50 bool l2cap_is_socket(struct socket *sock)
52 return sock && sock->ops == &l2cap_sock_ops;
54 EXPORT_SYMBOL(l2cap_is_socket);
56 static int l2cap_validate_bredr_psm(u16 psm)
58 /* PSM must be odd and lsb of upper byte must be 0 */
59 if ((psm & 0x0101) != 0x0001)
62 /* Restrict usage of well-known PSMs */
63 if (psm < L2CAP_PSM_DYN_START && !capable(CAP_NET_BIND_SERVICE))
69 static int l2cap_validate_le_psm(u16 psm)
71 /* Valid LE_PSM ranges are defined only until 0x00ff */
72 if (psm > L2CAP_PSM_LE_DYN_END)
75 /* Restrict fixed, SIG assigned PSM values to CAP_NET_BIND_SERVICE */
76 if (psm < L2CAP_PSM_LE_DYN_START && !capable(CAP_NET_BIND_SERVICE))
82 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
84 struct sock *sk = sock->sk;
85 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
86 struct sockaddr_l2 la;
91 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
92 addr->sa_family != AF_BLUETOOTH)
95 memset(&la, 0, sizeof(la));
96 len = min_t(unsigned int, sizeof(la), alen);
97 memcpy(&la, addr, len);
99 if (la.l2_cid && la.l2_psm)
102 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
105 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
106 /* We only allow ATT user space socket */
108 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
114 if (sk->sk_state != BT_OPEN) {
120 __u16 psm = __le16_to_cpu(la.l2_psm);
122 if (la.l2_bdaddr_type == BDADDR_BREDR)
123 err = l2cap_validate_bredr_psm(psm);
125 err = l2cap_validate_le_psm(psm);
131 bacpy(&chan->src, &la.l2_bdaddr);
132 chan->src_type = la.l2_bdaddr_type;
135 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
137 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
142 switch (chan->chan_type) {
143 case L2CAP_CHAN_CONN_LESS:
144 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
145 chan->sec_level = BT_SECURITY_SDP;
147 case L2CAP_CHAN_CONN_ORIENTED:
148 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
149 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
150 chan->sec_level = BT_SECURITY_SDP;
153 chan->sec_level = BT_SECURITY_SDP;
155 case L2CAP_CHAN_FIXED:
156 /* Fixed channels default to the L2CAP core not holding a
157 * hci_conn reference for them. For fixed channels mapping to
158 * L2CAP sockets we do want to hold a reference so set the
159 * appropriate flag to request it.
161 set_bit(FLAG_HOLD_HCI_CONN, &chan->flags);
165 /* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
166 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
168 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
169 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
170 chan->mode = L2CAP_MODE_LE_FLOWCTL;
172 chan->state = BT_BOUND;
173 sk->sk_state = BT_BOUND;
180 static void l2cap_sock_init_pid(struct sock *sk)
182 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
184 /* Only L2CAP_MODE_EXT_FLOWCTL ever need to access the PID in order to
185 * group the channels being requested.
187 if (chan->mode != L2CAP_MODE_EXT_FLOWCTL)
190 spin_lock(&sk->sk_peer_lock);
191 sk->sk_peer_pid = get_pid(task_tgid(current));
192 spin_unlock(&sk->sk_peer_lock);
195 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
198 struct sock *sk = sock->sk;
199 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
200 struct sockaddr_l2 la;
207 zapped = sock_flag(sk, SOCK_ZAPPED);
213 if (!addr || alen < offsetofend(struct sockaddr, sa_family) ||
214 addr->sa_family != AF_BLUETOOTH)
217 memset(&la, 0, sizeof(la));
218 len = min_t(unsigned int, sizeof(la), alen);
219 memcpy(&la, addr, len);
221 if (la.l2_cid && la.l2_psm)
224 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
227 /* Check that the socket wasn't bound to something that
228 * conflicts with the address given to connect(). If chan->src
229 * is BDADDR_ANY it means bind() was never used, in which case
230 * chan->src_type and la.l2_bdaddr_type do not need to match.
232 if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
233 bdaddr_type_is_le(la.l2_bdaddr_type)) {
234 /* Old user space versions will try to incorrectly bind
235 * the ATT socket using BDADDR_BREDR. We need to accept
236 * this and fix up the source address type only when
237 * both the source CID and destination CID indicate
238 * ATT. Anything else is an invalid combination.
240 if (chan->scid != L2CAP_CID_ATT ||
241 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
244 /* We don't have the hdev available here to make a
245 * better decision on random vs public, but since all
246 * user space versions that exhibit this issue anyway do
247 * not support random local addresses assuming public
248 * here is good enough.
250 chan->src_type = BDADDR_LE_PUBLIC;
253 if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
256 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
257 /* We only allow ATT user space socket */
259 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
263 /* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
264 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
266 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
267 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
268 chan->mode = L2CAP_MODE_LE_FLOWCTL;
270 l2cap_sock_init_pid(sk);
272 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
273 &la.l2_bdaddr, la.l2_bdaddr_type);
279 err = bt_sock_wait_state(sk, BT_CONNECTED,
280 sock_sndtimeo(sk, flags & O_NONBLOCK));
287 static int l2cap_sock_listen(struct socket *sock, int backlog)
289 struct sock *sk = sock->sk;
290 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
293 BT_DBG("sk %p backlog %d", sk, backlog);
297 if (sk->sk_state != BT_BOUND) {
302 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
307 switch (chan->mode) {
308 case L2CAP_MODE_BASIC:
309 case L2CAP_MODE_LE_FLOWCTL:
311 case L2CAP_MODE_EXT_FLOWCTL:
317 case L2CAP_MODE_ERTM:
318 case L2CAP_MODE_STREAMING:
327 l2cap_sock_init_pid(sk);
329 sk->sk_max_ack_backlog = backlog;
330 sk->sk_ack_backlog = 0;
332 /* Listening channels need to use nested locking in order not to
333 * cause lockdep warnings when the created child channels end up
334 * being locked in the same thread as the parent channel.
336 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
338 chan->state = BT_LISTEN;
339 sk->sk_state = BT_LISTEN;
346 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
347 int flags, bool kern)
349 DEFINE_WAIT_FUNC(wait, woken_wake_function);
350 struct sock *sk = sock->sk, *nsk;
354 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
356 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
358 BT_DBG("sk %p timeo %ld", sk, timeo);
360 /* Wait for an incoming connection. (wake-one). */
361 add_wait_queue_exclusive(sk_sleep(sk), &wait);
363 if (sk->sk_state != BT_LISTEN) {
368 nsk = bt_accept_dequeue(sk, newsock);
377 if (signal_pending(current)) {
378 err = sock_intr_errno(timeo);
384 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
386 lock_sock_nested(sk, L2CAP_NESTING_PARENT);
388 remove_wait_queue(sk_sleep(sk), &wait);
393 newsock->state = SS_CONNECTED;
395 BT_DBG("new socket %p", nsk);
402 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
405 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
406 struct sock *sk = sock->sk;
407 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
409 BT_DBG("sock %p, sk %p", sock, sk);
411 if (peer && sk->sk_state != BT_CONNECTED &&
412 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2 &&
413 sk->sk_state != BT_CONFIG)
416 memset(la, 0, sizeof(struct sockaddr_l2));
417 addr->sa_family = AF_BLUETOOTH;
419 la->l2_psm = chan->psm;
422 bacpy(&la->l2_bdaddr, &chan->dst);
423 la->l2_cid = cpu_to_le16(chan->dcid);
424 la->l2_bdaddr_type = chan->dst_type;
426 bacpy(&la->l2_bdaddr, &chan->src);
427 la->l2_cid = cpu_to_le16(chan->scid);
428 la->l2_bdaddr_type = chan->src_type;
431 return sizeof(struct sockaddr_l2);
434 static int l2cap_get_mode(struct l2cap_chan *chan)
436 switch (chan->mode) {
437 case L2CAP_MODE_BASIC:
438 return BT_MODE_BASIC;
439 case L2CAP_MODE_ERTM:
441 case L2CAP_MODE_STREAMING:
442 return BT_MODE_STREAMING;
443 case L2CAP_MODE_LE_FLOWCTL:
444 return BT_MODE_LE_FLOWCTL;
445 case L2CAP_MODE_EXT_FLOWCTL:
446 return BT_MODE_EXT_FLOWCTL;
452 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
453 char __user *optval, int __user *optlen)
455 struct sock *sk = sock->sk;
456 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
457 struct l2cap_options opts;
458 struct l2cap_conninfo cinfo;
464 if (get_user(len, optlen))
471 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
472 * legacy ATT code depends on getsockopt for
473 * L2CAP_OPTIONS we need to let this pass.
475 if (bdaddr_type_is_le(chan->src_type) &&
476 chan->scid != L2CAP_CID_ATT) {
481 /* Only BR/EDR modes are supported here */
482 switch (chan->mode) {
483 case L2CAP_MODE_BASIC:
484 case L2CAP_MODE_ERTM:
485 case L2CAP_MODE_STREAMING:
495 memset(&opts, 0, sizeof(opts));
496 opts.imtu = chan->imtu;
497 opts.omtu = chan->omtu;
498 opts.flush_to = chan->flush_to;
499 opts.mode = chan->mode;
500 opts.fcs = chan->fcs;
501 opts.max_tx = chan->max_tx;
502 opts.txwin_size = chan->tx_win;
504 BT_DBG("mode 0x%2.2x", chan->mode);
506 len = min_t(unsigned int, len, sizeof(opts));
507 if (copy_to_user(optval, (char *) &opts, len))
513 switch (chan->sec_level) {
514 case BT_SECURITY_LOW:
517 case BT_SECURITY_MEDIUM:
518 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
520 case BT_SECURITY_HIGH:
521 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
524 case BT_SECURITY_FIPS:
525 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
526 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
533 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
534 opt |= L2CAP_LM_MASTER;
536 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
537 opt |= L2CAP_LM_RELIABLE;
539 if (put_user(opt, (u32 __user *) optval))
545 if (sk->sk_state != BT_CONNECTED &&
546 !(sk->sk_state == BT_CONNECT2 &&
547 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
552 memset(&cinfo, 0, sizeof(cinfo));
553 cinfo.hci_handle = chan->conn->hcon->handle;
554 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
556 len = min_t(unsigned int, len, sizeof(cinfo));
557 if (copy_to_user(optval, (char *) &cinfo, len))
571 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
572 char __user *optval, int __user *optlen)
574 struct sock *sk = sock->sk;
575 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
576 struct bt_security sec;
579 int len, mode, err = 0;
583 if (level == SOL_L2CAP)
584 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
586 if (level != SOL_BLUETOOTH)
589 if (get_user(len, optlen))
596 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
597 chan->chan_type != L2CAP_CHAN_FIXED &&
598 chan->chan_type != L2CAP_CHAN_RAW) {
603 memset(&sec, 0, sizeof(sec));
605 sec.level = chan->conn->hcon->sec_level;
607 if (sk->sk_state == BT_CONNECTED)
608 sec.key_size = chan->conn->hcon->enc_key_size;
610 sec.level = chan->sec_level;
613 len = min_t(unsigned int, len, sizeof(sec));
614 if (copy_to_user(optval, (char *) &sec, len))
620 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
625 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
626 (u32 __user *) optval))
632 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
633 (u32 __user *) optval))
639 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
640 && sk->sk_type != SOCK_RAW) {
645 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
647 len = min_t(unsigned int, len, sizeof(pwr));
648 if (copy_to_user(optval, (char *) &pwr, len))
653 case BT_CHANNEL_POLICY:
654 if (put_user(chan->chan_policy, (u32 __user *) optval))
659 if (!bdaddr_type_is_le(chan->src_type)) {
664 if (sk->sk_state != BT_CONNECTED) {
669 if (put_user(chan->omtu, (u16 __user *) optval))
674 if (!bdaddr_type_is_le(chan->src_type)) {
679 if (put_user(chan->imtu, (u16 __user *) optval))
684 if (sk->sk_state != BT_CONNECTED) {
689 phys = hci_conn_get_phy(chan->conn->hcon);
691 if (put_user(phys, (u32 __user *) optval))
701 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
706 mode = l2cap_get_mode(chan);
712 if (put_user(mode, (u8 __user *) optval))
725 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
727 switch (chan->scid) {
729 if (mtu < L2CAP_LE_MIN_MTU)
734 if (mtu < L2CAP_DEFAULT_MIN_MTU)
741 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
742 sockptr_t optval, unsigned int optlen)
744 struct sock *sk = sock->sk;
745 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
746 struct l2cap_options opts;
756 if (bdaddr_type_is_le(chan->src_type)) {
761 if (sk->sk_state == BT_CONNECTED) {
766 opts.imtu = chan->imtu;
767 opts.omtu = chan->omtu;
768 opts.flush_to = chan->flush_to;
769 opts.mode = chan->mode;
770 opts.fcs = chan->fcs;
771 opts.max_tx = chan->max_tx;
772 opts.txwin_size = chan->tx_win;
774 len = min_t(unsigned int, sizeof(opts), optlen);
775 if (copy_from_sockptr(&opts, optval, len)) {
780 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
785 if (!l2cap_valid_mtu(chan, opts.imtu)) {
790 /* Only BR/EDR modes are supported here */
792 case L2CAP_MODE_BASIC:
793 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
795 case L2CAP_MODE_ERTM:
796 case L2CAP_MODE_STREAMING:
808 chan->mode = opts.mode;
810 BT_DBG("mode 0x%2.2x", chan->mode);
812 chan->imtu = opts.imtu;
813 chan->omtu = opts.omtu;
814 chan->fcs = opts.fcs;
815 chan->max_tx = opts.max_tx;
816 chan->tx_win = opts.txwin_size;
817 chan->flush_to = opts.flush_to;
821 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
826 if (opt & L2CAP_LM_FIPS) {
831 if (opt & L2CAP_LM_AUTH)
832 chan->sec_level = BT_SECURITY_LOW;
833 if (opt & L2CAP_LM_ENCRYPT)
834 chan->sec_level = BT_SECURITY_MEDIUM;
835 if (opt & L2CAP_LM_SECURE)
836 chan->sec_level = BT_SECURITY_HIGH;
838 if (opt & L2CAP_LM_MASTER)
839 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
841 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
843 if (opt & L2CAP_LM_RELIABLE)
844 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
846 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
858 static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
862 if (bdaddr_type_is_le(chan->src_type))
864 mode = L2CAP_MODE_BASIC;
865 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
868 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
870 mode = L2CAP_MODE_ERTM;
872 case BT_MODE_STREAMING:
873 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
875 mode = L2CAP_MODE_STREAMING;
877 case BT_MODE_LE_FLOWCTL:
878 if (!bdaddr_type_is_le(chan->src_type))
880 mode = L2CAP_MODE_LE_FLOWCTL;
882 case BT_MODE_EXT_FLOWCTL:
883 /* TODO: Add support for ECRED PDUs to BR/EDR */
884 if (!bdaddr_type_is_le(chan->src_type))
886 mode = L2CAP_MODE_EXT_FLOWCTL;
897 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
898 sockptr_t optval, unsigned int optlen)
900 struct sock *sk = sock->sk;
901 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
902 struct bt_security sec;
904 struct l2cap_conn *conn;
912 if (level == SOL_L2CAP)
913 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
915 if (level != SOL_BLUETOOTH)
922 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
923 chan->chan_type != L2CAP_CHAN_FIXED &&
924 chan->chan_type != L2CAP_CHAN_RAW) {
929 sec.level = BT_SECURITY_LOW;
931 len = min_t(unsigned int, sizeof(sec), optlen);
932 if (copy_from_sockptr(&sec, optval, len)) {
937 if (sec.level < BT_SECURITY_LOW ||
938 sec.level > BT_SECURITY_FIPS) {
943 chan->sec_level = sec.level;
950 /* change security for LE channels */
951 if (chan->scid == L2CAP_CID_ATT) {
952 if (smp_conn_security(conn->hcon, sec.level)) {
957 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
958 sk->sk_state = BT_CONFIG;
959 chan->state = BT_CONFIG;
961 /* or for ACL link */
962 } else if ((sk->sk_state == BT_CONNECT2 &&
963 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
964 sk->sk_state == BT_CONNECTED) {
965 if (!l2cap_chan_check_security(chan, true))
966 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
968 sk->sk_state_change(sk);
975 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
980 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
986 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
987 set_bit(FLAG_DEFER_SETUP, &chan->flags);
989 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
990 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
995 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1000 if (opt > BT_FLUSHABLE_ON) {
1005 if (opt == BT_FLUSHABLE_OFF) {
1007 /* proceed further only when we have l2cap_conn and
1008 No Flush support in the LM */
1009 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
1016 set_bit(FLAG_FLUSHABLE, &chan->flags);
1018 clear_bit(FLAG_FLUSHABLE, &chan->flags);
1022 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
1023 chan->chan_type != L2CAP_CHAN_RAW) {
1028 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1030 len = min_t(unsigned int, sizeof(pwr), optlen);
1031 if (copy_from_sockptr(&pwr, optval, len)) {
1036 if (pwr.force_active)
1037 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1039 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1042 case BT_CHANNEL_POLICY:
1043 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1048 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
1053 if (chan->mode != L2CAP_MODE_ERTM &&
1054 chan->mode != L2CAP_MODE_STREAMING) {
1059 chan->chan_policy = (u8) opt;
1061 if (sk->sk_state == BT_CONNECTED &&
1062 chan->move_role == L2CAP_MOVE_ROLE_NONE)
1063 l2cap_move_start(chan);
1068 if (!bdaddr_type_is_le(chan->src_type)) {
1073 /* Setting is not supported as it's the remote side that
1080 if (!bdaddr_type_is_le(chan->src_type)) {
1085 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1086 sk->sk_state == BT_CONNECTED) {
1091 if (copy_from_sockptr(&mtu, optval, sizeof(u16))) {
1096 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1097 sk->sk_state == BT_CONNECTED)
1098 err = l2cap_chan_reconfigure(chan, mtu);
1105 if (!enable_ecred) {
1110 BT_DBG("sk->sk_state %u", sk->sk_state);
1112 if (sk->sk_state != BT_BOUND) {
1117 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1122 if (copy_from_sockptr(&mode, optval, sizeof(u8))) {
1127 BT_DBG("mode %u", mode);
1129 err = l2cap_set_mode(chan, mode);
1133 BT_DBG("mode 0x%2.2x", chan->mode);
1146 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1149 struct sock *sk = sock->sk;
1150 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1153 BT_DBG("sock %p, sk %p", sock, sk);
1155 err = sock_error(sk);
1159 if (msg->msg_flags & MSG_OOB)
1162 if (sk->sk_state != BT_CONNECTED)
1166 err = bt_sock_wait_ready(sk, msg->msg_flags);
1171 l2cap_chan_lock(chan);
1172 err = l2cap_chan_send(chan, msg, len);
1173 l2cap_chan_unlock(chan);
1178 static int l2cap_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1179 size_t len, int flags)
1181 struct sock *sk = sock->sk;
1182 struct l2cap_pinfo *pi = l2cap_pi(sk);
1187 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1188 &bt_sk(sk)->flags)) {
1189 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1190 sk->sk_state = BT_CONNECTED;
1191 pi->chan->state = BT_CONNECTED;
1192 __l2cap_ecred_conn_rsp_defer(pi->chan);
1193 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1194 sk->sk_state = BT_CONNECTED;
1195 pi->chan->state = BT_CONNECTED;
1196 __l2cap_le_connect_rsp_defer(pi->chan);
1198 sk->sk_state = BT_CONFIG;
1199 pi->chan->state = BT_CONFIG;
1200 __l2cap_connect_rsp_defer(pi->chan);
1209 if (sock->type == SOCK_STREAM)
1210 err = bt_sock_stream_recvmsg(sock, msg, len, flags);
1212 err = bt_sock_recvmsg(sock, msg, len, flags);
1214 if (pi->chan->mode != L2CAP_MODE_ERTM)
1217 /* Attempt to put pending rx data in the socket buffer */
1221 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1224 if (pi->rx_busy_skb) {
1225 if (!__sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1226 pi->rx_busy_skb = NULL;
1231 /* Restore data flow when half of the receive buffer is
1232 * available. This avoids resending large numbers of
1235 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1236 l2cap_chan_busy(pi->chan, 0);
1243 /* Kill socket (only if zapped and orphan)
1244 * Must be called on unlocked socket, with l2cap channel lock.
1246 static void l2cap_sock_kill(struct sock *sk)
1248 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1251 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1253 /* Kill poor orphan */
1255 l2cap_chan_put(l2cap_pi(sk)->chan);
1256 sock_set_flag(sk, SOCK_DEAD);
1260 static int __l2cap_wait_ack(struct sock *sk, struct l2cap_chan *chan)
1262 DECLARE_WAITQUEUE(wait, current);
1264 int timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1265 /* Timeout to prevent infinite loop */
1266 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1268 add_wait_queue(sk_sleep(sk), &wait);
1269 set_current_state(TASK_INTERRUPTIBLE);
1271 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1272 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1273 jiffies_to_msecs(timeout - jiffies));
1276 timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1278 if (signal_pending(current)) {
1279 err = sock_intr_errno(timeo);
1284 timeo = schedule_timeout(timeo);
1286 set_current_state(TASK_INTERRUPTIBLE);
1288 err = sock_error(sk);
1292 if (time_after(jiffies, timeout)) {
1297 } while (chan->unacked_frames > 0 &&
1298 chan->state == BT_CONNECTED);
1300 set_current_state(TASK_RUNNING);
1301 remove_wait_queue(sk_sleep(sk), &wait);
1305 static int l2cap_sock_shutdown(struct socket *sock, int how)
1307 struct sock *sk = sock->sk;
1308 struct l2cap_chan *chan;
1309 struct l2cap_conn *conn;
1312 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1314 /* 'how' parameter is mapped to sk_shutdown as follows:
1315 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1316 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1317 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1326 if ((sk->sk_shutdown & how) == how)
1327 goto shutdown_already;
1329 BT_DBG("Handling sock shutdown");
1331 /* prevent sk structure from being freed whilst unlocked */
1334 chan = l2cap_pi(sk)->chan;
1335 /* prevent chan structure from being freed whilst unlocked */
1336 l2cap_chan_hold(chan);
1338 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1340 if (chan->mode == L2CAP_MODE_ERTM &&
1341 chan->unacked_frames > 0 &&
1342 chan->state == BT_CONNECTED) {
1343 err = __l2cap_wait_ack(sk, chan);
1345 /* After waiting for ACKs, check whether shutdown
1346 * has already been actioned to close the L2CAP
1347 * link such as by l2cap_disconnection_req().
1349 if ((sk->sk_shutdown & how) == how)
1350 goto shutdown_matched;
1353 /* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1356 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1357 sk->sk_shutdown |= RCV_SHUTDOWN;
1358 if ((sk->sk_shutdown & how) == how)
1359 goto shutdown_matched;
1362 sk->sk_shutdown |= SEND_SHUTDOWN;
1365 l2cap_chan_lock(chan);
1368 /* prevent conn structure from being freed */
1369 l2cap_conn_get(conn);
1370 l2cap_chan_unlock(chan);
1373 /* mutex lock must be taken before l2cap_chan_lock() */
1374 mutex_lock(&conn->chan_lock);
1376 l2cap_chan_lock(chan);
1377 l2cap_chan_close(chan, 0);
1378 l2cap_chan_unlock(chan);
1381 mutex_unlock(&conn->chan_lock);
1382 l2cap_conn_put(conn);
1387 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1388 !(current->flags & PF_EXITING))
1389 err = bt_sock_wait_state(sk, BT_CLOSED,
1393 l2cap_chan_put(chan);
1397 if (!err && sk->sk_err)
1402 BT_DBG("Sock shutdown complete err: %d", err);
1407 static int l2cap_sock_release(struct socket *sock)
1409 struct sock *sk = sock->sk;
1411 struct l2cap_chan *chan;
1413 BT_DBG("sock %p, sk %p", sock, sk);
1418 l2cap_sock_cleanup_listen(sk);
1419 bt_sock_unlink(&l2cap_sk_list, sk);
1421 err = l2cap_sock_shutdown(sock, SHUT_RDWR);
1422 chan = l2cap_pi(sk)->chan;
1424 l2cap_chan_hold(chan);
1425 l2cap_chan_lock(chan);
1428 l2cap_sock_kill(sk);
1430 l2cap_chan_unlock(chan);
1431 l2cap_chan_put(chan);
1436 static void l2cap_sock_cleanup_listen(struct sock *parent)
1440 BT_DBG("parent %p state %s", parent,
1441 state_to_string(parent->sk_state));
1443 /* Close not yet accepted channels */
1444 while ((sk = bt_accept_dequeue(parent, NULL))) {
1445 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1447 BT_DBG("child chan %p state %s", chan,
1448 state_to_string(chan->state));
1450 l2cap_chan_hold(chan);
1451 l2cap_chan_lock(chan);
1453 __clear_chan_timer(chan);
1454 l2cap_chan_close(chan, ECONNRESET);
1455 l2cap_sock_kill(sk);
1457 l2cap_chan_unlock(chan);
1458 l2cap_chan_put(chan);
1462 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1464 struct sock *sk, *parent = chan->data;
1468 /* Check for backlog size */
1469 if (sk_acceptq_is_full(parent)) {
1470 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1471 release_sock(parent);
1475 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1478 release_sock(parent);
1482 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1484 l2cap_sock_init(sk, parent);
1486 bt_accept_enqueue(parent, sk, false);
1488 release_sock(parent);
1490 return l2cap_pi(sk)->chan;
1493 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1495 struct sock *sk = chan->data;
1500 if (l2cap_pi(sk)->rx_busy_skb) {
1505 if (chan->mode != L2CAP_MODE_ERTM &&
1506 chan->mode != L2CAP_MODE_STREAMING) {
1507 /* Even if no filter is attached, we could potentially
1508 * get errors from security modules, etc.
1510 err = sk_filter(sk, skb);
1515 err = __sock_queue_rcv_skb(sk, skb);
1517 /* For ERTM, handle one skb that doesn't fit into the recv
1518 * buffer. This is important to do because the data frames
1519 * have already been acked, so the skb cannot be discarded.
1521 * Notify the l2cap core that the buffer is full, so the
1522 * LOCAL_BUSY state is entered and no more frames are
1523 * acked and reassembled until there is buffer space
1526 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1527 l2cap_pi(sk)->rx_busy_skb = skb;
1528 l2cap_chan_busy(chan, 1);
1538 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1540 struct sock *sk = chan->data;
1545 l2cap_sock_kill(sk);
1548 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1550 struct sock *sk = chan->data;
1551 struct sock *parent;
1556 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1558 /* This callback can be called both for server (BT_LISTEN)
1559 * sockets as well as "normal" ones. To avoid lockdep warnings
1560 * with child socket locking (through l2cap_sock_cleanup_listen)
1561 * we need separation into separate nesting levels. The simplest
1562 * way to accomplish this is to inherit the nesting level used
1565 lock_sock_nested(sk, atomic_read(&chan->nesting));
1567 parent = bt_sk(sk)->parent;
1569 switch (chan->state) {
1575 l2cap_sock_cleanup_listen(sk);
1576 sk->sk_state = BT_CLOSED;
1577 chan->state = BT_CLOSED;
1581 sk->sk_state = BT_CLOSED;
1582 chan->state = BT_CLOSED;
1587 bt_accept_unlink(sk);
1588 parent->sk_data_ready(parent);
1590 sk->sk_state_change(sk);
1597 /* Only zap after cleanup to avoid use after free race */
1598 sock_set_flag(sk, SOCK_ZAPPED);
1602 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1605 struct sock *sk = chan->data;
1607 sk->sk_state = state;
1613 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1614 unsigned long hdr_len,
1615 unsigned long len, int nb)
1617 struct sock *sk = chan->data;
1618 struct sk_buff *skb;
1621 l2cap_chan_unlock(chan);
1622 skb = bt_skb_send_alloc(sk, hdr_len + len, nb, &err);
1623 l2cap_chan_lock(chan);
1626 return ERR_PTR(err);
1628 /* Channel lock is released before requesting new skb and then
1629 * reacquired thus we need to recheck channel state.
1631 if (chan->state != BT_CONNECTED) {
1633 return ERR_PTR(-ENOTCONN);
1636 skb->priority = sk->sk_priority;
1638 bt_cb(skb)->l2cap.chan = chan;
1643 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1645 struct sock *sk = chan->data;
1646 struct sock *parent;
1650 parent = bt_sk(sk)->parent;
1652 BT_DBG("sk %p, parent %p", sk, parent);
1654 sk->sk_state = BT_CONNECTED;
1655 sk->sk_state_change(sk);
1658 parent->sk_data_ready(parent);
1663 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1665 struct sock *parent, *sk = chan->data;
1669 parent = bt_sk(sk)->parent;
1671 parent->sk_data_ready(parent);
1676 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1678 struct sock *sk = chan->data;
1680 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1681 sk->sk_state = BT_CONNECTED;
1682 chan->state = BT_CONNECTED;
1685 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1686 sk->sk_state_change(sk);
1689 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1691 struct sock *sk = chan->data;
1694 sk->sk_shutdown = SHUTDOWN_MASK;
1698 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1700 struct sock *sk = chan->data;
1702 return sk->sk_sndtimeo;
1705 static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1707 struct sock *sk = chan->data;
1709 return sk->sk_peer_pid;
1712 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1714 struct sock *sk = chan->data;
1716 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1717 sk->sk_state_change(sk);
1720 static int l2cap_sock_filter(struct l2cap_chan *chan, struct sk_buff *skb)
1722 struct sock *sk = chan->data;
1724 switch (chan->mode) {
1725 case L2CAP_MODE_ERTM:
1726 case L2CAP_MODE_STREAMING:
1727 return sk_filter(sk, skb);
1733 static const struct l2cap_ops l2cap_chan_ops = {
1734 .name = "L2CAP Socket Interface",
1735 .new_connection = l2cap_sock_new_connection_cb,
1736 .recv = l2cap_sock_recv_cb,
1737 .close = l2cap_sock_close_cb,
1738 .teardown = l2cap_sock_teardown_cb,
1739 .state_change = l2cap_sock_state_change_cb,
1740 .ready = l2cap_sock_ready_cb,
1741 .defer = l2cap_sock_defer_cb,
1742 .resume = l2cap_sock_resume_cb,
1743 .suspend = l2cap_sock_suspend_cb,
1744 .set_shutdown = l2cap_sock_set_shutdown_cb,
1745 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
1746 .get_peer_pid = l2cap_sock_get_peer_pid_cb,
1747 .alloc_skb = l2cap_sock_alloc_skb_cb,
1748 .filter = l2cap_sock_filter,
1751 static void l2cap_sock_destruct(struct sock *sk)
1753 BT_DBG("sk %p", sk);
1755 if (l2cap_pi(sk)->chan) {
1756 l2cap_pi(sk)->chan->data = NULL;
1757 l2cap_chan_put(l2cap_pi(sk)->chan);
1760 if (l2cap_pi(sk)->rx_busy_skb) {
1761 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1762 l2cap_pi(sk)->rx_busy_skb = NULL;
1765 skb_queue_purge(&sk->sk_receive_queue);
1766 skb_queue_purge(&sk->sk_write_queue);
1769 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1772 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
1774 memset(la, 0, sizeof(struct sockaddr_l2));
1775 la->l2_family = AF_BLUETOOTH;
1776 la->l2_psm = bt_cb(skb)->l2cap.psm;
1777 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1779 *msg_namelen = sizeof(struct sockaddr_l2);
1782 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1784 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1786 BT_DBG("sk %p", sk);
1789 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1791 sk->sk_type = parent->sk_type;
1792 bt_sk(sk)->flags = bt_sk(parent)->flags;
1794 chan->chan_type = pchan->chan_type;
1795 chan->imtu = pchan->imtu;
1796 chan->omtu = pchan->omtu;
1797 chan->conf_state = pchan->conf_state;
1798 chan->mode = pchan->mode;
1799 chan->fcs = pchan->fcs;
1800 chan->max_tx = pchan->max_tx;
1801 chan->tx_win = pchan->tx_win;
1802 chan->tx_win_max = pchan->tx_win_max;
1803 chan->sec_level = pchan->sec_level;
1804 chan->flags = pchan->flags;
1805 chan->tx_credits = pchan->tx_credits;
1806 chan->rx_credits = pchan->rx_credits;
1808 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1809 chan->scid = pchan->scid;
1810 chan->dcid = pchan->scid;
1813 security_sk_clone(parent, sk);
1815 switch (sk->sk_type) {
1817 chan->chan_type = L2CAP_CHAN_RAW;
1820 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1821 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1823 case SOCK_SEQPACKET:
1825 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1829 chan->imtu = L2CAP_DEFAULT_MTU;
1831 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1832 chan->mode = L2CAP_MODE_ERTM;
1833 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1835 chan->mode = L2CAP_MODE_BASIC;
1838 l2cap_chan_set_defaults(chan);
1841 /* Default config options */
1842 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1845 chan->ops = &l2cap_chan_ops;
1848 static struct proto l2cap_proto = {
1850 .owner = THIS_MODULE,
1851 .obj_size = sizeof(struct l2cap_pinfo)
1854 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1855 int proto, gfp_t prio, int kern)
1858 struct l2cap_chan *chan;
1860 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto, kern);
1864 sock_init_data(sock, sk);
1865 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1867 sk->sk_destruct = l2cap_sock_destruct;
1868 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1870 sock_reset_flag(sk, SOCK_ZAPPED);
1872 sk->sk_protocol = proto;
1873 sk->sk_state = BT_OPEN;
1875 chan = l2cap_chan_create();
1881 l2cap_chan_hold(chan);
1883 l2cap_pi(sk)->chan = chan;
1888 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1893 BT_DBG("sock %p", sock);
1895 sock->state = SS_UNCONNECTED;
1897 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1898 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1899 return -ESOCKTNOSUPPORT;
1901 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1904 sock->ops = &l2cap_sock_ops;
1906 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1910 l2cap_sock_init(sk, NULL);
1911 bt_sock_link(&l2cap_sk_list, sk);
1915 static const struct proto_ops l2cap_sock_ops = {
1916 .family = PF_BLUETOOTH,
1917 .owner = THIS_MODULE,
1918 .release = l2cap_sock_release,
1919 .bind = l2cap_sock_bind,
1920 .connect = l2cap_sock_connect,
1921 .listen = l2cap_sock_listen,
1922 .accept = l2cap_sock_accept,
1923 .getname = l2cap_sock_getname,
1924 .sendmsg = l2cap_sock_sendmsg,
1925 .recvmsg = l2cap_sock_recvmsg,
1926 .poll = bt_sock_poll,
1927 .ioctl = bt_sock_ioctl,
1928 .gettstamp = sock_gettstamp,
1929 .mmap = sock_no_mmap,
1930 .socketpair = sock_no_socketpair,
1931 .shutdown = l2cap_sock_shutdown,
1932 .setsockopt = l2cap_sock_setsockopt,
1933 .getsockopt = l2cap_sock_getsockopt
1936 static const struct net_proto_family l2cap_sock_family_ops = {
1937 .family = PF_BLUETOOTH,
1938 .owner = THIS_MODULE,
1939 .create = l2cap_sock_create,
1942 int __init l2cap_init_sockets(void)
1946 BUILD_BUG_ON(sizeof(struct sockaddr_l2) > sizeof(struct sockaddr));
1948 err = proto_register(&l2cap_proto, 0);
1952 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1954 BT_ERR("L2CAP socket registration failed");
1958 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1961 BT_ERR("Failed to create L2CAP proc file");
1962 bt_sock_unregister(BTPROTO_L2CAP);
1966 BT_INFO("L2CAP socket layer initialized");
1971 proto_unregister(&l2cap_proto);
1975 void l2cap_cleanup_sockets(void)
1977 bt_procfs_cleanup(&init_net, "l2cap");
1978 bt_sock_unregister(BTPROTO_L2CAP);
1979 proto_unregister(&l2cap_proto);