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/export.h>
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/l2cap.h>
35 #include <net/bluetooth/smp.h>
37 static struct bt_sock_list l2cap_sk_list = {
38 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
41 static const struct proto_ops l2cap_sock_ops;
42 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
43 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
45 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
47 struct sock *sk = sock->sk;
48 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
49 struct sockaddr_l2 la;
54 if (!addr || addr->sa_family != AF_BLUETOOTH)
57 memset(&la, 0, sizeof(la));
58 len = min_t(unsigned int, sizeof(la), alen);
59 memcpy(&la, addr, len);
61 if (la.l2_cid && la.l2_psm)
66 if (sk->sk_state != BT_OPEN) {
72 __u16 psm = __le16_to_cpu(la.l2_psm);
74 /* PSM must be odd and lsb of upper byte must be 0 */
75 if ((psm & 0x0101) != 0x0001) {
80 /* Restrict usage of well-known PSMs */
81 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
88 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
90 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
95 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
96 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
97 chan->sec_level = BT_SECURITY_SDP;
99 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
101 chan->state = BT_BOUND;
102 sk->sk_state = BT_BOUND;
109 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
111 struct sock *sk = sock->sk;
112 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
113 struct sockaddr_l2 la;
118 if (!addr || alen < sizeof(addr->sa_family) ||
119 addr->sa_family != AF_BLUETOOTH)
122 memset(&la, 0, sizeof(la));
123 len = min_t(unsigned int, sizeof(la), alen);
124 memcpy(&la, addr, len);
126 if (la.l2_cid && la.l2_psm)
129 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
130 &la.l2_bdaddr, la.l2_bdaddr_type);
136 err = bt_sock_wait_state(sk, BT_CONNECTED,
137 sock_sndtimeo(sk, flags & O_NONBLOCK));
144 static int l2cap_sock_listen(struct socket *sock, int backlog)
146 struct sock *sk = sock->sk;
147 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
150 BT_DBG("sk %p backlog %d", sk, backlog);
154 if (sk->sk_state != BT_BOUND) {
159 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
164 switch (chan->mode) {
165 case L2CAP_MODE_BASIC:
167 case L2CAP_MODE_ERTM:
168 case L2CAP_MODE_STREAMING:
177 sk->sk_max_ack_backlog = backlog;
178 sk->sk_ack_backlog = 0;
180 chan->state = BT_LISTEN;
181 sk->sk_state = BT_LISTEN;
188 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
190 DECLARE_WAITQUEUE(wait, current);
191 struct sock *sk = sock->sk, *nsk;
195 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
197 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
199 BT_DBG("sk %p timeo %ld", sk, timeo);
201 /* Wait for an incoming connection. (wake-one). */
202 add_wait_queue_exclusive(sk_sleep(sk), &wait);
204 set_current_state(TASK_INTERRUPTIBLE);
206 if (sk->sk_state != BT_LISTEN) {
211 nsk = bt_accept_dequeue(sk, newsock);
220 if (signal_pending(current)) {
221 err = sock_intr_errno(timeo);
226 timeo = schedule_timeout(timeo);
227 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
229 __set_current_state(TASK_RUNNING);
230 remove_wait_queue(sk_sleep(sk), &wait);
235 newsock->state = SS_CONNECTED;
237 BT_DBG("new socket %p", nsk);
244 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
246 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
247 struct sock *sk = sock->sk;
248 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
250 BT_DBG("sock %p, sk %p", sock, sk);
252 memset(la, 0, sizeof(struct sockaddr_l2));
253 addr->sa_family = AF_BLUETOOTH;
254 *len = sizeof(struct sockaddr_l2);
257 la->l2_psm = chan->psm;
258 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
259 la->l2_cid = cpu_to_le16(chan->dcid);
261 la->l2_psm = chan->sport;
262 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
263 la->l2_cid = cpu_to_le16(chan->scid);
269 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
271 struct sock *sk = sock->sk;
272 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
273 struct l2cap_options opts;
274 struct l2cap_conninfo cinfo;
280 if (get_user(len, optlen))
287 memset(&opts, 0, sizeof(opts));
288 opts.imtu = chan->imtu;
289 opts.omtu = chan->omtu;
290 opts.flush_to = chan->flush_to;
291 opts.mode = chan->mode;
292 opts.fcs = chan->fcs;
293 opts.max_tx = chan->max_tx;
294 opts.txwin_size = chan->tx_win;
296 len = min_t(unsigned int, len, sizeof(opts));
297 if (copy_to_user(optval, (char *) &opts, len))
303 switch (chan->sec_level) {
304 case BT_SECURITY_LOW:
307 case BT_SECURITY_MEDIUM:
308 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
310 case BT_SECURITY_HIGH:
311 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
319 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
320 opt |= L2CAP_LM_MASTER;
322 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
323 opt |= L2CAP_LM_RELIABLE;
325 if (put_user(opt, (u32 __user *) optval))
330 if (sk->sk_state != BT_CONNECTED &&
331 !(sk->sk_state == BT_CONNECT2 &&
332 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
337 memset(&cinfo, 0, sizeof(cinfo));
338 cinfo.hci_handle = chan->conn->hcon->handle;
339 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
341 len = min_t(unsigned int, len, sizeof(cinfo));
342 if (copy_to_user(optval, (char *) &cinfo, len))
356 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
358 struct sock *sk = sock->sk;
359 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
360 struct bt_security sec;
366 if (level == SOL_L2CAP)
367 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
369 if (level != SOL_BLUETOOTH)
372 if (get_user(len, optlen))
379 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
380 chan->chan_type != L2CAP_CHAN_RAW) {
385 memset(&sec, 0, sizeof(sec));
387 sec.level = chan->conn->hcon->sec_level;
389 sec.level = chan->sec_level;
391 if (sk->sk_state == BT_CONNECTED)
392 sec.key_size = chan->conn->hcon->enc_key_size;
394 len = min_t(unsigned int, len, sizeof(sec));
395 if (copy_to_user(optval, (char *) &sec, len))
401 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
406 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
407 (u32 __user *) optval))
413 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
414 (u32 __user *) optval))
420 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
421 && sk->sk_type != SOCK_RAW) {
426 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
428 len = min_t(unsigned int, len, sizeof(pwr));
429 if (copy_to_user(optval, (char *) &pwr, len))
434 case BT_CHANNEL_POLICY:
440 if (put_user(chan->chan_policy, (u32 __user *) optval))
453 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
455 switch (chan->scid) {
456 case L2CAP_CID_LE_DATA:
457 if (mtu < L2CAP_LE_MIN_MTU)
462 if (mtu < L2CAP_DEFAULT_MIN_MTU)
469 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
471 struct sock *sk = sock->sk;
472 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
473 struct l2cap_options opts;
483 if (sk->sk_state == BT_CONNECTED) {
488 opts.imtu = chan->imtu;
489 opts.omtu = chan->omtu;
490 opts.flush_to = chan->flush_to;
491 opts.mode = chan->mode;
492 opts.fcs = chan->fcs;
493 opts.max_tx = chan->max_tx;
494 opts.txwin_size = chan->tx_win;
496 len = min_t(unsigned int, sizeof(opts), optlen);
497 if (copy_from_user((char *) &opts, optval, len)) {
502 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
507 if (!l2cap_valid_mtu(chan, opts.imtu)) {
512 chan->mode = opts.mode;
513 switch (chan->mode) {
514 case L2CAP_MODE_BASIC:
515 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
517 case L2CAP_MODE_ERTM:
518 case L2CAP_MODE_STREAMING:
527 chan->imtu = opts.imtu;
528 chan->omtu = opts.omtu;
529 chan->fcs = opts.fcs;
530 chan->max_tx = opts.max_tx;
531 chan->tx_win = opts.txwin_size;
535 if (get_user(opt, (u32 __user *) optval)) {
540 if (opt & L2CAP_LM_AUTH)
541 chan->sec_level = BT_SECURITY_LOW;
542 if (opt & L2CAP_LM_ENCRYPT)
543 chan->sec_level = BT_SECURITY_MEDIUM;
544 if (opt & L2CAP_LM_SECURE)
545 chan->sec_level = BT_SECURITY_HIGH;
547 if (opt & L2CAP_LM_MASTER)
548 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
550 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
552 if (opt & L2CAP_LM_RELIABLE)
553 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
555 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
567 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
569 struct sock *sk = sock->sk;
570 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
571 struct bt_security sec;
573 struct l2cap_conn *conn;
579 if (level == SOL_L2CAP)
580 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
582 if (level != SOL_BLUETOOTH)
589 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
590 chan->chan_type != L2CAP_CHAN_RAW) {
595 sec.level = BT_SECURITY_LOW;
597 len = min_t(unsigned int, sizeof(sec), optlen);
598 if (copy_from_user((char *) &sec, optval, len)) {
603 if (sec.level < BT_SECURITY_LOW ||
604 sec.level > BT_SECURITY_HIGH) {
609 chan->sec_level = sec.level;
616 /*change security for LE channels */
617 if (chan->scid == L2CAP_CID_LE_DATA) {
618 if (!conn->hcon->out) {
623 if (smp_conn_security(conn->hcon, sec.level))
625 sk->sk_state = BT_CONFIG;
626 chan->state = BT_CONFIG;
628 /* or for ACL link */
629 } else if ((sk->sk_state == BT_CONNECT2 &&
630 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
631 sk->sk_state == BT_CONNECTED) {
632 if (!l2cap_chan_check_security(chan))
633 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
635 sk->sk_state_change(sk);
642 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
647 if (get_user(opt, (u32 __user *) optval)) {
653 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
655 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
659 if (get_user(opt, (u32 __user *) optval)) {
664 if (opt > BT_FLUSHABLE_ON) {
669 if (opt == BT_FLUSHABLE_OFF) {
670 struct l2cap_conn *conn = chan->conn;
671 /* proceed further only when we have l2cap_conn and
672 No Flush support in the LM */
673 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
680 set_bit(FLAG_FLUSHABLE, &chan->flags);
682 clear_bit(FLAG_FLUSHABLE, &chan->flags);
686 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
687 chan->chan_type != L2CAP_CHAN_RAW) {
692 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
694 len = min_t(unsigned int, sizeof(pwr), optlen);
695 if (copy_from_user((char *) &pwr, optval, len)) {
700 if (pwr.force_active)
701 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
703 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
706 case BT_CHANNEL_POLICY:
712 if (get_user(opt, (u32 __user *) optval)) {
717 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
722 if (chan->mode != L2CAP_MODE_ERTM &&
723 chan->mode != L2CAP_MODE_STREAMING) {
728 chan->chan_policy = (u8) opt;
740 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
742 struct sock *sk = sock->sk;
743 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
746 BT_DBG("sock %p, sk %p", sock, sk);
748 err = sock_error(sk);
752 if (msg->msg_flags & MSG_OOB)
755 if (sk->sk_state != BT_CONNECTED)
758 l2cap_chan_lock(chan);
759 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
760 l2cap_chan_unlock(chan);
765 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
767 struct sock *sk = sock->sk;
768 struct l2cap_pinfo *pi = l2cap_pi(sk);
773 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
774 &bt_sk(sk)->flags)) {
775 sk->sk_state = BT_CONFIG;
776 pi->chan->state = BT_CONFIG;
778 __l2cap_connect_rsp_defer(pi->chan);
785 if (sock->type == SOCK_STREAM)
786 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
788 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
790 if (pi->chan->mode != L2CAP_MODE_ERTM)
793 /* Attempt to put pending rx data in the socket buffer */
797 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
800 if (pi->rx_busy_skb) {
801 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
802 pi->rx_busy_skb = NULL;
807 /* Restore data flow when half of the receive buffer is
808 * available. This avoids resending large numbers of
811 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
812 l2cap_chan_busy(pi->chan, 0);
819 /* Kill socket (only if zapped and orphan)
820 * Must be called on unlocked socket.
822 static void l2cap_sock_kill(struct sock *sk)
824 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
827 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
829 /* Kill poor orphan */
831 l2cap_chan_put(l2cap_pi(sk)->chan);
832 sock_set_flag(sk, SOCK_DEAD);
836 static int l2cap_sock_shutdown(struct socket *sock, int how)
838 struct sock *sk = sock->sk;
839 struct l2cap_chan *chan;
840 struct l2cap_conn *conn;
843 BT_DBG("sock %p, sk %p", sock, sk);
848 chan = l2cap_pi(sk)->chan;
852 mutex_lock(&conn->chan_lock);
854 l2cap_chan_lock(chan);
857 if (!sk->sk_shutdown) {
858 if (chan->mode == L2CAP_MODE_ERTM)
859 err = __l2cap_wait_ack(sk);
861 sk->sk_shutdown = SHUTDOWN_MASK;
864 l2cap_chan_close(chan, 0);
867 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
868 err = bt_sock_wait_state(sk, BT_CLOSED,
872 if (!err && sk->sk_err)
876 l2cap_chan_unlock(chan);
879 mutex_unlock(&conn->chan_lock);
884 static int l2cap_sock_release(struct socket *sock)
886 struct sock *sk = sock->sk;
889 BT_DBG("sock %p, sk %p", sock, sk);
894 bt_sock_unlink(&l2cap_sk_list, sk);
896 err = l2cap_sock_shutdown(sock, 2);
903 static void l2cap_sock_cleanup_listen(struct sock *parent)
907 BT_DBG("parent %p", parent);
909 /* Close not yet accepted channels */
910 while ((sk = bt_accept_dequeue(parent, NULL))) {
911 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
913 l2cap_chan_lock(chan);
914 __clear_chan_timer(chan);
915 l2cap_chan_close(chan, ECONNRESET);
916 l2cap_chan_unlock(chan);
922 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
924 struct sock *sk, *parent = chan->data;
926 /* Check for backlog size */
927 if (sk_acceptq_is_full(parent)) {
928 BT_DBG("backlog full %d", parent->sk_ack_backlog);
932 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
937 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
939 l2cap_sock_init(sk, parent);
941 return l2cap_pi(sk)->chan;
944 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
947 struct sock *sk = chan->data;
948 struct l2cap_pinfo *pi = l2cap_pi(sk);
952 if (pi->rx_busy_skb) {
957 err = sock_queue_rcv_skb(sk, skb);
959 /* For ERTM, handle one skb that doesn't fit into the recv
960 * buffer. This is important to do because the data frames
961 * have already been acked, so the skb cannot be discarded.
963 * Notify the l2cap core that the buffer is full, so the
964 * LOCAL_BUSY state is entered and no more frames are
965 * acked and reassembled until there is buffer space
968 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
969 pi->rx_busy_skb = skb;
970 l2cap_chan_busy(pi->chan, 1);
980 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
982 struct sock *sk = chan->data;
987 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
989 struct sock *sk = chan->data;
994 parent = bt_sk(sk)->parent;
996 sock_set_flag(sk, SOCK_ZAPPED);
998 switch (chan->state) {
1004 l2cap_sock_cleanup_listen(sk);
1005 sk->sk_state = BT_CLOSED;
1006 chan->state = BT_CLOSED;
1010 sk->sk_state = BT_CLOSED;
1011 chan->state = BT_CLOSED;
1016 bt_accept_unlink(sk);
1017 parent->sk_data_ready(parent, 0);
1019 sk->sk_state_change(sk);
1028 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state)
1030 struct sock *sk = chan->data;
1032 sk->sk_state = state;
1035 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1036 unsigned long len, int nb)
1038 struct sk_buff *skb;
1041 l2cap_chan_unlock(chan);
1042 skb = bt_skb_send_alloc(chan->sk, len, nb, &err);
1043 l2cap_chan_lock(chan);
1046 return ERR_PTR(err);
1051 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1053 struct sock *sk = chan->data;
1054 struct sock *parent;
1058 parent = bt_sk(sk)->parent;
1060 BT_DBG("sk %p, parent %p", sk, parent);
1062 sk->sk_state = BT_CONNECTED;
1063 sk->sk_state_change(sk);
1066 parent->sk_data_ready(parent, 0);
1071 static struct l2cap_ops l2cap_chan_ops = {
1072 .name = "L2CAP Socket Interface",
1073 .new_connection = l2cap_sock_new_connection_cb,
1074 .recv = l2cap_sock_recv_cb,
1075 .close = l2cap_sock_close_cb,
1076 .teardown = l2cap_sock_teardown_cb,
1077 .state_change = l2cap_sock_state_change_cb,
1078 .ready = l2cap_sock_ready_cb,
1079 .alloc_skb = l2cap_sock_alloc_skb_cb,
1082 static void l2cap_sock_destruct(struct sock *sk)
1084 BT_DBG("sk %p", sk);
1086 l2cap_chan_put(l2cap_pi(sk)->chan);
1087 if (l2cap_pi(sk)->rx_busy_skb) {
1088 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1089 l2cap_pi(sk)->rx_busy_skb = NULL;
1092 skb_queue_purge(&sk->sk_receive_queue);
1093 skb_queue_purge(&sk->sk_write_queue);
1096 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1098 struct l2cap_pinfo *pi = l2cap_pi(sk);
1099 struct l2cap_chan *chan = pi->chan;
1101 BT_DBG("sk %p", sk);
1104 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1106 sk->sk_type = parent->sk_type;
1107 bt_sk(sk)->flags = bt_sk(parent)->flags;
1109 chan->chan_type = pchan->chan_type;
1110 chan->imtu = pchan->imtu;
1111 chan->omtu = pchan->omtu;
1112 chan->conf_state = pchan->conf_state;
1113 chan->mode = pchan->mode;
1114 chan->fcs = pchan->fcs;
1115 chan->max_tx = pchan->max_tx;
1116 chan->tx_win = pchan->tx_win;
1117 chan->tx_win_max = pchan->tx_win_max;
1118 chan->sec_level = pchan->sec_level;
1119 chan->flags = pchan->flags;
1121 security_sk_clone(parent, sk);
1124 switch (sk->sk_type) {
1126 chan->chan_type = L2CAP_CHAN_RAW;
1129 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1131 case SOCK_SEQPACKET:
1133 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1137 chan->imtu = L2CAP_DEFAULT_MTU;
1139 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1140 chan->mode = L2CAP_MODE_ERTM;
1141 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1143 chan->mode = L2CAP_MODE_BASIC;
1146 l2cap_chan_set_defaults(chan);
1149 /* Default config options */
1150 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1153 chan->ops = &l2cap_chan_ops;
1156 static struct proto l2cap_proto = {
1158 .owner = THIS_MODULE,
1159 .obj_size = sizeof(struct l2cap_pinfo)
1162 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1165 struct l2cap_chan *chan;
1167 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1171 sock_init_data(sock, sk);
1172 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1174 sk->sk_destruct = l2cap_sock_destruct;
1175 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1177 sock_reset_flag(sk, SOCK_ZAPPED);
1179 sk->sk_protocol = proto;
1180 sk->sk_state = BT_OPEN;
1182 chan = l2cap_chan_create();
1188 l2cap_chan_hold(chan);
1192 l2cap_pi(sk)->chan = chan;
1197 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1202 BT_DBG("sock %p", sock);
1204 sock->state = SS_UNCONNECTED;
1206 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1207 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1208 return -ESOCKTNOSUPPORT;
1210 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1213 sock->ops = &l2cap_sock_ops;
1215 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1219 l2cap_sock_init(sk, NULL);
1220 bt_sock_link(&l2cap_sk_list, sk);
1224 static const struct proto_ops l2cap_sock_ops = {
1225 .family = PF_BLUETOOTH,
1226 .owner = THIS_MODULE,
1227 .release = l2cap_sock_release,
1228 .bind = l2cap_sock_bind,
1229 .connect = l2cap_sock_connect,
1230 .listen = l2cap_sock_listen,
1231 .accept = l2cap_sock_accept,
1232 .getname = l2cap_sock_getname,
1233 .sendmsg = l2cap_sock_sendmsg,
1234 .recvmsg = l2cap_sock_recvmsg,
1235 .poll = bt_sock_poll,
1236 .ioctl = bt_sock_ioctl,
1237 .mmap = sock_no_mmap,
1238 .socketpair = sock_no_socketpair,
1239 .shutdown = l2cap_sock_shutdown,
1240 .setsockopt = l2cap_sock_setsockopt,
1241 .getsockopt = l2cap_sock_getsockopt
1244 static const struct net_proto_family l2cap_sock_family_ops = {
1245 .family = PF_BLUETOOTH,
1246 .owner = THIS_MODULE,
1247 .create = l2cap_sock_create,
1250 int __init l2cap_init_sockets(void)
1254 err = proto_register(&l2cap_proto, 0);
1258 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1260 BT_ERR("L2CAP socket registration failed");
1264 err = bt_procfs_init(THIS_MODULE, &init_net, "l2cap", &l2cap_sk_list, NULL);
1266 BT_ERR("Failed to create L2CAP proc file");
1267 bt_sock_unregister(BTPROTO_L2CAP);
1271 BT_INFO("L2CAP socket layer initialized");
1276 proto_unregister(&l2cap_proto);
1280 void l2cap_cleanup_sockets(void)
1282 bt_procfs_cleanup(&init_net, "l2cap");
1283 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1284 BT_ERR("L2CAP socket unregistration failed");
1286 proto_unregister(&l2cap_proto);