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;
465 if (get_user(len, optlen))
472 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
473 * legacy ATT code depends on getsockopt for
474 * L2CAP_OPTIONS we need to let this pass.
476 if (bdaddr_type_is_le(chan->src_type) &&
477 chan->scid != L2CAP_CID_ATT) {
482 /* Only BR/EDR modes are supported here */
483 switch (chan->mode) {
484 case L2CAP_MODE_BASIC:
485 case L2CAP_MODE_ERTM:
486 case L2CAP_MODE_STREAMING:
496 memset(&opts, 0, sizeof(opts));
497 opts.imtu = chan->imtu;
498 opts.omtu = chan->omtu;
499 opts.flush_to = chan->flush_to;
500 opts.mode = chan->mode;
501 opts.fcs = chan->fcs;
502 opts.max_tx = chan->max_tx;
503 opts.txwin_size = chan->tx_win;
505 BT_DBG("mode 0x%2.2x", chan->mode);
507 len = min(len, sizeof(opts));
508 if (copy_to_user(optval, (char *) &opts, len))
514 switch (chan->sec_level) {
515 case BT_SECURITY_LOW:
518 case BT_SECURITY_MEDIUM:
519 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
521 case BT_SECURITY_HIGH:
522 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
525 case BT_SECURITY_FIPS:
526 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
527 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
534 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
535 opt |= L2CAP_LM_MASTER;
537 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
538 opt |= L2CAP_LM_RELIABLE;
540 if (put_user(opt, (u32 __user *) optval))
546 if (sk->sk_state != BT_CONNECTED &&
547 !(sk->sk_state == BT_CONNECT2 &&
548 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
553 memset(&cinfo, 0, sizeof(cinfo));
554 cinfo.hci_handle = chan->conn->hcon->handle;
555 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
557 len = min(len, sizeof(cinfo));
558 if (copy_to_user(optval, (char *) &cinfo, len))
572 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
573 char __user *optval, int __user *optlen)
575 struct sock *sk = sock->sk;
576 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
577 struct bt_security sec;
580 int len, mode, err = 0;
584 if (level == SOL_L2CAP)
585 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
587 if (level != SOL_BLUETOOTH)
590 if (get_user(len, optlen))
597 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
598 chan->chan_type != L2CAP_CHAN_FIXED &&
599 chan->chan_type != L2CAP_CHAN_RAW) {
604 memset(&sec, 0, sizeof(sec));
606 sec.level = chan->conn->hcon->sec_level;
608 if (sk->sk_state == BT_CONNECTED)
609 sec.key_size = chan->conn->hcon->enc_key_size;
611 sec.level = chan->sec_level;
614 len = min_t(unsigned int, len, sizeof(sec));
615 if (copy_to_user(optval, (char *) &sec, len))
621 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
626 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
627 (u32 __user *) optval))
633 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
634 (u32 __user *) optval))
640 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
641 && sk->sk_type != SOCK_RAW) {
646 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
648 len = min_t(unsigned int, len, sizeof(pwr));
649 if (copy_to_user(optval, (char *) &pwr, len))
654 case BT_CHANNEL_POLICY:
655 if (put_user(chan->chan_policy, (u32 __user *) optval))
660 if (!bdaddr_type_is_le(chan->src_type)) {
665 if (sk->sk_state != BT_CONNECTED) {
670 if (put_user(chan->omtu, (u16 __user *) optval))
675 if (!bdaddr_type_is_le(chan->src_type)) {
680 if (put_user(chan->imtu, (u16 __user *) optval))
685 if (sk->sk_state != BT_CONNECTED) {
690 phys = hci_conn_get_phy(chan->conn->hcon);
692 if (put_user(phys, (u32 __user *) optval))
702 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
707 mode = l2cap_get_mode(chan);
713 if (put_user(mode, (u8 __user *) optval))
726 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
728 switch (chan->scid) {
730 if (mtu < L2CAP_LE_MIN_MTU)
735 if (mtu < L2CAP_DEFAULT_MIN_MTU)
742 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
743 sockptr_t optval, unsigned int optlen)
745 struct sock *sk = sock->sk;
746 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
747 struct l2cap_options opts;
757 if (bdaddr_type_is_le(chan->src_type)) {
762 if (sk->sk_state == BT_CONNECTED) {
767 opts.imtu = chan->imtu;
768 opts.omtu = chan->omtu;
769 opts.flush_to = chan->flush_to;
770 opts.mode = chan->mode;
771 opts.fcs = chan->fcs;
772 opts.max_tx = chan->max_tx;
773 opts.txwin_size = chan->tx_win;
775 len = min_t(unsigned int, sizeof(opts), optlen);
776 if (copy_from_sockptr(&opts, optval, len)) {
781 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
786 if (!l2cap_valid_mtu(chan, opts.imtu)) {
791 /* Only BR/EDR modes are supported here */
793 case L2CAP_MODE_BASIC:
794 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
796 case L2CAP_MODE_ERTM:
797 case L2CAP_MODE_STREAMING:
809 chan->mode = opts.mode;
811 BT_DBG("mode 0x%2.2x", chan->mode);
813 chan->imtu = opts.imtu;
814 chan->omtu = opts.omtu;
815 chan->fcs = opts.fcs;
816 chan->max_tx = opts.max_tx;
817 chan->tx_win = opts.txwin_size;
818 chan->flush_to = opts.flush_to;
822 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
827 if (opt & L2CAP_LM_FIPS) {
832 if (opt & L2CAP_LM_AUTH)
833 chan->sec_level = BT_SECURITY_LOW;
834 if (opt & L2CAP_LM_ENCRYPT)
835 chan->sec_level = BT_SECURITY_MEDIUM;
836 if (opt & L2CAP_LM_SECURE)
837 chan->sec_level = BT_SECURITY_HIGH;
839 if (opt & L2CAP_LM_MASTER)
840 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
842 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
844 if (opt & L2CAP_LM_RELIABLE)
845 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
847 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
859 static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
863 if (bdaddr_type_is_le(chan->src_type))
865 mode = L2CAP_MODE_BASIC;
866 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
869 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
871 mode = L2CAP_MODE_ERTM;
873 case BT_MODE_STREAMING:
874 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
876 mode = L2CAP_MODE_STREAMING;
878 case BT_MODE_LE_FLOWCTL:
879 if (!bdaddr_type_is_le(chan->src_type))
881 mode = L2CAP_MODE_LE_FLOWCTL;
883 case BT_MODE_EXT_FLOWCTL:
884 /* TODO: Add support for ECRED PDUs to BR/EDR */
885 if (!bdaddr_type_is_le(chan->src_type))
887 mode = L2CAP_MODE_EXT_FLOWCTL;
898 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
899 sockptr_t optval, unsigned int optlen)
901 struct sock *sk = sock->sk;
902 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
903 struct bt_security sec;
905 struct l2cap_conn *conn;
913 if (level == SOL_L2CAP)
914 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
916 if (level != SOL_BLUETOOTH)
923 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
924 chan->chan_type != L2CAP_CHAN_FIXED &&
925 chan->chan_type != L2CAP_CHAN_RAW) {
930 sec.level = BT_SECURITY_LOW;
932 len = min_t(unsigned int, sizeof(sec), optlen);
933 if (copy_from_sockptr(&sec, optval, len)) {
938 if (sec.level < BT_SECURITY_LOW ||
939 sec.level > BT_SECURITY_FIPS) {
944 chan->sec_level = sec.level;
951 /* change security for LE channels */
952 if (chan->scid == L2CAP_CID_ATT) {
953 if (smp_conn_security(conn->hcon, sec.level)) {
958 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
959 sk->sk_state = BT_CONFIG;
960 chan->state = BT_CONFIG;
962 /* or for ACL link */
963 } else if ((sk->sk_state == BT_CONNECT2 &&
964 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
965 sk->sk_state == BT_CONNECTED) {
966 if (!l2cap_chan_check_security(chan, true))
967 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
969 sk->sk_state_change(sk);
976 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
981 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
987 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
988 set_bit(FLAG_DEFER_SETUP, &chan->flags);
990 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
991 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
996 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1001 if (opt > BT_FLUSHABLE_ON) {
1006 if (opt == BT_FLUSHABLE_OFF) {
1008 /* proceed further only when we have l2cap_conn and
1009 No Flush support in the LM */
1010 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
1017 set_bit(FLAG_FLUSHABLE, &chan->flags);
1019 clear_bit(FLAG_FLUSHABLE, &chan->flags);
1023 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
1024 chan->chan_type != L2CAP_CHAN_RAW) {
1029 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1031 len = min_t(unsigned int, sizeof(pwr), optlen);
1032 if (copy_from_sockptr(&pwr, optval, len)) {
1037 if (pwr.force_active)
1038 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1040 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1043 case BT_CHANNEL_POLICY:
1044 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1049 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
1054 if (chan->mode != L2CAP_MODE_ERTM &&
1055 chan->mode != L2CAP_MODE_STREAMING) {
1060 chan->chan_policy = (u8) opt;
1062 if (sk->sk_state == BT_CONNECTED &&
1063 chan->move_role == L2CAP_MOVE_ROLE_NONE)
1064 l2cap_move_start(chan);
1069 if (!bdaddr_type_is_le(chan->src_type)) {
1074 /* Setting is not supported as it's the remote side that
1081 if (!bdaddr_type_is_le(chan->src_type)) {
1086 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1087 sk->sk_state == BT_CONNECTED) {
1092 if (copy_from_sockptr(&mtu, optval, sizeof(u16))) {
1097 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1098 sk->sk_state == BT_CONNECTED)
1099 err = l2cap_chan_reconfigure(chan, mtu);
1106 if (!enable_ecred) {
1111 BT_DBG("sk->sk_state %u", sk->sk_state);
1113 if (sk->sk_state != BT_BOUND) {
1118 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1123 if (copy_from_sockptr(&mode, optval, sizeof(u8))) {
1128 BT_DBG("mode %u", mode);
1130 err = l2cap_set_mode(chan, mode);
1134 BT_DBG("mode 0x%2.2x", chan->mode);
1147 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1150 struct sock *sk = sock->sk;
1151 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1154 BT_DBG("sock %p, sk %p", sock, sk);
1156 err = sock_error(sk);
1160 if (msg->msg_flags & MSG_OOB)
1163 if (sk->sk_state != BT_CONNECTED)
1167 err = bt_sock_wait_ready(sk, msg->msg_flags);
1172 l2cap_chan_lock(chan);
1173 err = l2cap_chan_send(chan, msg, len);
1174 l2cap_chan_unlock(chan);
1179 static int l2cap_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1180 size_t len, int flags)
1182 struct sock *sk = sock->sk;
1183 struct l2cap_pinfo *pi = l2cap_pi(sk);
1188 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1189 &bt_sk(sk)->flags)) {
1190 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1191 sk->sk_state = BT_CONNECTED;
1192 pi->chan->state = BT_CONNECTED;
1193 __l2cap_ecred_conn_rsp_defer(pi->chan);
1194 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1195 sk->sk_state = BT_CONNECTED;
1196 pi->chan->state = BT_CONNECTED;
1197 __l2cap_le_connect_rsp_defer(pi->chan);
1199 sk->sk_state = BT_CONFIG;
1200 pi->chan->state = BT_CONFIG;
1201 __l2cap_connect_rsp_defer(pi->chan);
1210 if (sock->type == SOCK_STREAM)
1211 err = bt_sock_stream_recvmsg(sock, msg, len, flags);
1213 err = bt_sock_recvmsg(sock, msg, len, flags);
1215 if (pi->chan->mode != L2CAP_MODE_ERTM)
1218 /* Attempt to put pending rx data in the socket buffer */
1222 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1225 if (pi->rx_busy_skb) {
1226 if (!__sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1227 pi->rx_busy_skb = NULL;
1232 /* Restore data flow when half of the receive buffer is
1233 * available. This avoids resending large numbers of
1236 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1237 l2cap_chan_busy(pi->chan, 0);
1244 /* Kill socket (only if zapped and orphan)
1245 * Must be called on unlocked socket, with l2cap channel lock.
1247 static void l2cap_sock_kill(struct sock *sk)
1249 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1252 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1254 /* Kill poor orphan */
1256 l2cap_chan_put(l2cap_pi(sk)->chan);
1257 sock_set_flag(sk, SOCK_DEAD);
1261 static int __l2cap_wait_ack(struct sock *sk, struct l2cap_chan *chan)
1263 DECLARE_WAITQUEUE(wait, current);
1265 int timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1266 /* Timeout to prevent infinite loop */
1267 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1269 add_wait_queue(sk_sleep(sk), &wait);
1270 set_current_state(TASK_INTERRUPTIBLE);
1272 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1273 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1274 jiffies_to_msecs(timeout - jiffies));
1277 timeo = L2CAP_WAIT_ACK_POLL_PERIOD;
1279 if (signal_pending(current)) {
1280 err = sock_intr_errno(timeo);
1285 timeo = schedule_timeout(timeo);
1287 set_current_state(TASK_INTERRUPTIBLE);
1289 err = sock_error(sk);
1293 if (time_after(jiffies, timeout)) {
1298 } while (chan->unacked_frames > 0 &&
1299 chan->state == BT_CONNECTED);
1301 set_current_state(TASK_RUNNING);
1302 remove_wait_queue(sk_sleep(sk), &wait);
1306 static int l2cap_sock_shutdown(struct socket *sock, int how)
1308 struct sock *sk = sock->sk;
1309 struct l2cap_chan *chan;
1310 struct l2cap_conn *conn;
1313 BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1315 /* 'how' parameter is mapped to sk_shutdown as follows:
1316 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1317 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1318 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1327 if ((sk->sk_shutdown & how) == how)
1328 goto shutdown_already;
1330 BT_DBG("Handling sock shutdown");
1332 /* prevent sk structure from being freed whilst unlocked */
1335 chan = l2cap_pi(sk)->chan;
1336 /* prevent chan structure from being freed whilst unlocked */
1337 l2cap_chan_hold(chan);
1339 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1341 if (chan->mode == L2CAP_MODE_ERTM &&
1342 chan->unacked_frames > 0 &&
1343 chan->state == BT_CONNECTED) {
1344 err = __l2cap_wait_ack(sk, chan);
1346 /* After waiting for ACKs, check whether shutdown
1347 * has already been actioned to close the L2CAP
1348 * link such as by l2cap_disconnection_req().
1350 if ((sk->sk_shutdown & how) == how)
1351 goto shutdown_matched;
1354 /* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1357 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1358 sk->sk_shutdown |= RCV_SHUTDOWN;
1359 if ((sk->sk_shutdown & how) == how)
1360 goto shutdown_matched;
1363 sk->sk_shutdown |= SEND_SHUTDOWN;
1366 l2cap_chan_lock(chan);
1369 /* prevent conn structure from being freed */
1370 l2cap_conn_get(conn);
1371 l2cap_chan_unlock(chan);
1374 /* mutex lock must be taken before l2cap_chan_lock() */
1375 mutex_lock(&conn->chan_lock);
1377 l2cap_chan_lock(chan);
1378 l2cap_chan_close(chan, 0);
1379 l2cap_chan_unlock(chan);
1382 mutex_unlock(&conn->chan_lock);
1383 l2cap_conn_put(conn);
1388 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1389 !(current->flags & PF_EXITING))
1390 err = bt_sock_wait_state(sk, BT_CLOSED,
1394 l2cap_chan_put(chan);
1398 if (!err && sk->sk_err)
1403 BT_DBG("Sock shutdown complete err: %d", err);
1408 static int l2cap_sock_release(struct socket *sock)
1410 struct sock *sk = sock->sk;
1412 struct l2cap_chan *chan;
1414 BT_DBG("sock %p, sk %p", sock, sk);
1419 l2cap_sock_cleanup_listen(sk);
1420 bt_sock_unlink(&l2cap_sk_list, sk);
1422 err = l2cap_sock_shutdown(sock, SHUT_RDWR);
1423 chan = l2cap_pi(sk)->chan;
1425 l2cap_chan_hold(chan);
1426 l2cap_chan_lock(chan);
1429 l2cap_sock_kill(sk);
1431 l2cap_chan_unlock(chan);
1432 l2cap_chan_put(chan);
1437 static void l2cap_sock_cleanup_listen(struct sock *parent)
1441 BT_DBG("parent %p state %s", parent,
1442 state_to_string(parent->sk_state));
1444 /* Close not yet accepted channels */
1445 while ((sk = bt_accept_dequeue(parent, NULL))) {
1446 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1448 BT_DBG("child chan %p state %s", chan,
1449 state_to_string(chan->state));
1451 l2cap_chan_hold(chan);
1452 l2cap_chan_lock(chan);
1454 __clear_chan_timer(chan);
1455 l2cap_chan_close(chan, ECONNRESET);
1456 l2cap_sock_kill(sk);
1458 l2cap_chan_unlock(chan);
1459 l2cap_chan_put(chan);
1463 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1465 struct sock *sk, *parent = chan->data;
1469 /* Check for backlog size */
1470 if (sk_acceptq_is_full(parent)) {
1471 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1472 release_sock(parent);
1476 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1479 release_sock(parent);
1483 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1485 l2cap_sock_init(sk, parent);
1487 bt_accept_enqueue(parent, sk, false);
1489 release_sock(parent);
1491 return l2cap_pi(sk)->chan;
1494 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1496 struct sock *sk = chan->data;
1501 if (l2cap_pi(sk)->rx_busy_skb) {
1506 if (chan->mode != L2CAP_MODE_ERTM &&
1507 chan->mode != L2CAP_MODE_STREAMING) {
1508 /* Even if no filter is attached, we could potentially
1509 * get errors from security modules, etc.
1511 err = sk_filter(sk, skb);
1516 err = __sock_queue_rcv_skb(sk, skb);
1518 /* For ERTM, handle one skb that doesn't fit into the recv
1519 * buffer. This is important to do because the data frames
1520 * have already been acked, so the skb cannot be discarded.
1522 * Notify the l2cap core that the buffer is full, so the
1523 * LOCAL_BUSY state is entered and no more frames are
1524 * acked and reassembled until there is buffer space
1527 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1528 l2cap_pi(sk)->rx_busy_skb = skb;
1529 l2cap_chan_busy(chan, 1);
1539 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1541 struct sock *sk = chan->data;
1546 l2cap_sock_kill(sk);
1549 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1551 struct sock *sk = chan->data;
1552 struct sock *parent;
1557 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1559 /* This callback can be called both for server (BT_LISTEN)
1560 * sockets as well as "normal" ones. To avoid lockdep warnings
1561 * with child socket locking (through l2cap_sock_cleanup_listen)
1562 * we need separation into separate nesting levels. The simplest
1563 * way to accomplish this is to inherit the nesting level used
1566 lock_sock_nested(sk, atomic_read(&chan->nesting));
1568 parent = bt_sk(sk)->parent;
1570 switch (chan->state) {
1576 l2cap_sock_cleanup_listen(sk);
1577 sk->sk_state = BT_CLOSED;
1578 chan->state = BT_CLOSED;
1582 sk->sk_state = BT_CLOSED;
1583 chan->state = BT_CLOSED;
1588 bt_accept_unlink(sk);
1589 parent->sk_data_ready(parent);
1591 sk->sk_state_change(sk);
1598 /* Only zap after cleanup to avoid use after free race */
1599 sock_set_flag(sk, SOCK_ZAPPED);
1603 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1606 struct sock *sk = chan->data;
1608 sk->sk_state = state;
1614 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1615 unsigned long hdr_len,
1616 unsigned long len, int nb)
1618 struct sock *sk = chan->data;
1619 struct sk_buff *skb;
1622 l2cap_chan_unlock(chan);
1623 skb = bt_skb_send_alloc(sk, hdr_len + len, nb, &err);
1624 l2cap_chan_lock(chan);
1627 return ERR_PTR(err);
1629 /* Channel lock is released before requesting new skb and then
1630 * reacquired thus we need to recheck channel state.
1632 if (chan->state != BT_CONNECTED) {
1634 return ERR_PTR(-ENOTCONN);
1637 skb->priority = sk->sk_priority;
1639 bt_cb(skb)->l2cap.chan = chan;
1644 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1646 struct sock *sk = chan->data;
1647 struct sock *parent;
1651 parent = bt_sk(sk)->parent;
1653 BT_DBG("sk %p, parent %p", sk, parent);
1655 sk->sk_state = BT_CONNECTED;
1656 sk->sk_state_change(sk);
1659 parent->sk_data_ready(parent);
1664 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1666 struct sock *parent, *sk = chan->data;
1670 parent = bt_sk(sk)->parent;
1672 parent->sk_data_ready(parent);
1677 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1679 struct sock *sk = chan->data;
1681 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1682 sk->sk_state = BT_CONNECTED;
1683 chan->state = BT_CONNECTED;
1686 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1687 sk->sk_state_change(sk);
1690 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1692 struct sock *sk = chan->data;
1695 sk->sk_shutdown = SHUTDOWN_MASK;
1699 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1701 struct sock *sk = chan->data;
1703 return sk->sk_sndtimeo;
1706 static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1708 struct sock *sk = chan->data;
1710 return sk->sk_peer_pid;
1713 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1715 struct sock *sk = chan->data;
1717 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1718 sk->sk_state_change(sk);
1721 static int l2cap_sock_filter(struct l2cap_chan *chan, struct sk_buff *skb)
1723 struct sock *sk = chan->data;
1725 switch (chan->mode) {
1726 case L2CAP_MODE_ERTM:
1727 case L2CAP_MODE_STREAMING:
1728 return sk_filter(sk, skb);
1734 static const struct l2cap_ops l2cap_chan_ops = {
1735 .name = "L2CAP Socket Interface",
1736 .new_connection = l2cap_sock_new_connection_cb,
1737 .recv = l2cap_sock_recv_cb,
1738 .close = l2cap_sock_close_cb,
1739 .teardown = l2cap_sock_teardown_cb,
1740 .state_change = l2cap_sock_state_change_cb,
1741 .ready = l2cap_sock_ready_cb,
1742 .defer = l2cap_sock_defer_cb,
1743 .resume = l2cap_sock_resume_cb,
1744 .suspend = l2cap_sock_suspend_cb,
1745 .set_shutdown = l2cap_sock_set_shutdown_cb,
1746 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
1747 .get_peer_pid = l2cap_sock_get_peer_pid_cb,
1748 .alloc_skb = l2cap_sock_alloc_skb_cb,
1749 .filter = l2cap_sock_filter,
1752 static void l2cap_sock_destruct(struct sock *sk)
1754 BT_DBG("sk %p", sk);
1756 if (l2cap_pi(sk)->chan) {
1757 l2cap_pi(sk)->chan->data = NULL;
1758 l2cap_chan_put(l2cap_pi(sk)->chan);
1761 if (l2cap_pi(sk)->rx_busy_skb) {
1762 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1763 l2cap_pi(sk)->rx_busy_skb = NULL;
1766 skb_queue_purge(&sk->sk_receive_queue);
1767 skb_queue_purge(&sk->sk_write_queue);
1770 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1773 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
1775 memset(la, 0, sizeof(struct sockaddr_l2));
1776 la->l2_family = AF_BLUETOOTH;
1777 la->l2_psm = bt_cb(skb)->l2cap.psm;
1778 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1780 *msg_namelen = sizeof(struct sockaddr_l2);
1783 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1785 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1787 BT_DBG("sk %p", sk);
1790 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1792 sk->sk_type = parent->sk_type;
1793 bt_sk(sk)->flags = bt_sk(parent)->flags;
1795 chan->chan_type = pchan->chan_type;
1796 chan->imtu = pchan->imtu;
1797 chan->omtu = pchan->omtu;
1798 chan->conf_state = pchan->conf_state;
1799 chan->mode = pchan->mode;
1800 chan->fcs = pchan->fcs;
1801 chan->max_tx = pchan->max_tx;
1802 chan->tx_win = pchan->tx_win;
1803 chan->tx_win_max = pchan->tx_win_max;
1804 chan->sec_level = pchan->sec_level;
1805 chan->flags = pchan->flags;
1806 chan->tx_credits = pchan->tx_credits;
1807 chan->rx_credits = pchan->rx_credits;
1809 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1810 chan->scid = pchan->scid;
1811 chan->dcid = pchan->scid;
1814 security_sk_clone(parent, sk);
1816 switch (sk->sk_type) {
1818 chan->chan_type = L2CAP_CHAN_RAW;
1821 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1822 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1824 case SOCK_SEQPACKET:
1826 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1830 chan->imtu = L2CAP_DEFAULT_MTU;
1832 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1833 chan->mode = L2CAP_MODE_ERTM;
1834 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1836 chan->mode = L2CAP_MODE_BASIC;
1839 l2cap_chan_set_defaults(chan);
1842 /* Default config options */
1843 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1846 chan->ops = &l2cap_chan_ops;
1849 static struct proto l2cap_proto = {
1851 .owner = THIS_MODULE,
1852 .obj_size = sizeof(struct l2cap_pinfo)
1855 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1856 int proto, gfp_t prio, int kern)
1859 struct l2cap_chan *chan;
1861 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto, kern);
1865 sock_init_data(sock, sk);
1866 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1868 sk->sk_destruct = l2cap_sock_destruct;
1869 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1871 sock_reset_flag(sk, SOCK_ZAPPED);
1873 sk->sk_protocol = proto;
1874 sk->sk_state = BT_OPEN;
1876 chan = l2cap_chan_create();
1882 l2cap_chan_hold(chan);
1884 l2cap_pi(sk)->chan = chan;
1889 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1894 BT_DBG("sock %p", sock);
1896 sock->state = SS_UNCONNECTED;
1898 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1899 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1900 return -ESOCKTNOSUPPORT;
1902 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1905 sock->ops = &l2cap_sock_ops;
1907 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
1911 l2cap_sock_init(sk, NULL);
1912 bt_sock_link(&l2cap_sk_list, sk);
1916 static const struct proto_ops l2cap_sock_ops = {
1917 .family = PF_BLUETOOTH,
1918 .owner = THIS_MODULE,
1919 .release = l2cap_sock_release,
1920 .bind = l2cap_sock_bind,
1921 .connect = l2cap_sock_connect,
1922 .listen = l2cap_sock_listen,
1923 .accept = l2cap_sock_accept,
1924 .getname = l2cap_sock_getname,
1925 .sendmsg = l2cap_sock_sendmsg,
1926 .recvmsg = l2cap_sock_recvmsg,
1927 .poll = bt_sock_poll,
1928 .ioctl = bt_sock_ioctl,
1929 .gettstamp = sock_gettstamp,
1930 .mmap = sock_no_mmap,
1931 .socketpair = sock_no_socketpair,
1932 .shutdown = l2cap_sock_shutdown,
1933 .setsockopt = l2cap_sock_setsockopt,
1934 .getsockopt = l2cap_sock_getsockopt
1937 static const struct net_proto_family l2cap_sock_family_ops = {
1938 .family = PF_BLUETOOTH,
1939 .owner = THIS_MODULE,
1940 .create = l2cap_sock_create,
1943 int __init l2cap_init_sockets(void)
1947 BUILD_BUG_ON(sizeof(struct sockaddr_l2) > sizeof(struct sockaddr));
1949 err = proto_register(&l2cap_proto, 0);
1953 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1955 BT_ERR("L2CAP socket registration failed");
1959 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1962 BT_ERR("Failed to create L2CAP proc file");
1963 bt_sock_unregister(BTPROTO_L2CAP);
1967 BT_INFO("L2CAP socket layer initialized");
1972 proto_unregister(&l2cap_proto);
1976 void l2cap_cleanup_sockets(void)
1978 bt_procfs_cleanup(&init_net, "l2cap");
1979 bt_sock_unregister(BTPROTO_L2CAP);
1980 proto_unregister(&l2cap_proto);