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.
7 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 2 as
11 published by the Free Software Foundation;
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
16 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
17 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
18 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
23 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
24 SOFTWARE IS DISCLAIMED.
27 /* Bluetooth L2CAP sockets. */
29 #include <linux/security.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <net/bluetooth/hci_core.h>
33 #include <net/bluetooth/l2cap.h>
34 #include <net/bluetooth/smp.h>
36 static const struct proto_ops l2cap_sock_ops;
37 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
38 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
40 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
42 struct sock *sk = sock->sk;
43 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
44 struct sockaddr_l2 la;
49 if (!addr || addr->sa_family != AF_BLUETOOTH)
52 memset(&la, 0, sizeof(la));
53 len = min_t(unsigned int, sizeof(la), alen);
54 memcpy(&la, addr, len);
56 if (la.l2_cid && la.l2_psm)
61 if (sk->sk_state != BT_OPEN) {
67 __u16 psm = __le16_to_cpu(la.l2_psm);
69 /* PSM must be odd and lsb of upper byte must be 0 */
70 if ((psm & 0x0101) != 0x0001) {
75 /* Restrict usage of well-known PSMs */
76 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
83 err = l2cap_add_scid(chan, la.l2_cid);
85 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
90 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
91 __le16_to_cpu(la.l2_psm) == 0x0003)
92 chan->sec_level = BT_SECURITY_SDP;
94 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
96 chan->state = BT_BOUND;
97 sk->sk_state = BT_BOUND;
104 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
106 struct sock *sk = sock->sk;
107 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
108 struct sockaddr_l2 la;
113 if (!addr || alen < sizeof(addr->sa_family) ||
114 addr->sa_family != AF_BLUETOOTH)
117 memset(&la, 0, sizeof(la));
118 len = min_t(unsigned int, sizeof(la), alen);
119 memcpy(&la, addr, len);
121 if (la.l2_cid && la.l2_psm)
126 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
127 && !(la.l2_psm || la.l2_cid)) {
132 switch (chan->mode) {
133 case L2CAP_MODE_BASIC:
135 case L2CAP_MODE_ERTM:
136 case L2CAP_MODE_STREAMING:
145 switch (sk->sk_state) {
149 /* Already connecting */
153 /* Already connected */
167 /* PSM must be odd and lsb of upper byte must be 0 */
168 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
169 chan->chan_type != L2CAP_CHAN_RAW) {
174 /* Set destination address and psm */
175 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
176 chan->psm = la.l2_psm;
177 chan->dcid = la.l2_cid;
179 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
184 err = bt_sock_wait_state(sk, BT_CONNECTED,
185 sock_sndtimeo(sk, flags & O_NONBLOCK));
191 static int l2cap_sock_listen(struct socket *sock, int backlog)
193 struct sock *sk = sock->sk;
194 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
197 BT_DBG("sk %p backlog %d", sk, backlog);
201 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
202 || sk->sk_state != BT_BOUND) {
207 switch (chan->mode) {
208 case L2CAP_MODE_BASIC:
210 case L2CAP_MODE_ERTM:
211 case L2CAP_MODE_STREAMING:
220 sk->sk_max_ack_backlog = backlog;
221 sk->sk_ack_backlog = 0;
223 chan->state = BT_LISTEN;
224 sk->sk_state = BT_LISTEN;
231 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
233 DECLARE_WAITQUEUE(wait, current);
234 struct sock *sk = sock->sk, *nsk;
238 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
240 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
242 BT_DBG("sk %p timeo %ld", sk, timeo);
244 /* Wait for an incoming connection. (wake-one). */
245 add_wait_queue_exclusive(sk_sleep(sk), &wait);
247 set_current_state(TASK_INTERRUPTIBLE);
249 if (sk->sk_state != BT_LISTEN) {
254 nsk = bt_accept_dequeue(sk, newsock);
263 if (signal_pending(current)) {
264 err = sock_intr_errno(timeo);
269 timeo = schedule_timeout(timeo);
270 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
272 __set_current_state(TASK_RUNNING);
273 remove_wait_queue(sk_sleep(sk), &wait);
278 newsock->state = SS_CONNECTED;
280 BT_DBG("new socket %p", nsk);
287 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
289 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
290 struct sock *sk = sock->sk;
291 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
293 BT_DBG("sock %p, sk %p", sock, sk);
295 addr->sa_family = AF_BLUETOOTH;
296 *len = sizeof(struct sockaddr_l2);
299 la->l2_psm = chan->psm;
300 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
301 la->l2_cid = cpu_to_le16(chan->dcid);
303 la->l2_psm = chan->sport;
304 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
305 la->l2_cid = cpu_to_le16(chan->scid);
311 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
313 struct sock *sk = sock->sk;
314 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
315 struct l2cap_options opts;
316 struct l2cap_conninfo cinfo;
322 if (get_user(len, optlen))
329 memset(&opts, 0, sizeof(opts));
330 opts.imtu = chan->imtu;
331 opts.omtu = chan->omtu;
332 opts.flush_to = chan->flush_to;
333 opts.mode = chan->mode;
334 opts.fcs = chan->fcs;
335 opts.max_tx = chan->max_tx;
336 opts.txwin_size = chan->tx_win;
338 len = min_t(unsigned int, len, sizeof(opts));
339 if (copy_to_user(optval, (char *) &opts, len))
345 switch (chan->sec_level) {
346 case BT_SECURITY_LOW:
349 case BT_SECURITY_MEDIUM:
350 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
352 case BT_SECURITY_HIGH:
353 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
361 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
362 opt |= L2CAP_LM_MASTER;
364 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
365 opt |= L2CAP_LM_RELIABLE;
367 if (put_user(opt, (u32 __user *) optval))
372 if (sk->sk_state != BT_CONNECTED &&
373 !(sk->sk_state == BT_CONNECT2 &&
374 bt_sk(sk)->defer_setup)) {
379 memset(&cinfo, 0, sizeof(cinfo));
380 cinfo.hci_handle = chan->conn->hcon->handle;
381 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
383 len = min_t(unsigned int, len, sizeof(cinfo));
384 if (copy_to_user(optval, (char *) &cinfo, len))
398 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
400 struct sock *sk = sock->sk;
401 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
402 struct bt_security sec;
408 if (level == SOL_L2CAP)
409 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
411 if (level != SOL_BLUETOOTH)
414 if (get_user(len, optlen))
421 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
422 chan->chan_type != L2CAP_CHAN_RAW) {
427 memset(&sec, 0, sizeof(sec));
428 sec.level = chan->sec_level;
430 if (sk->sk_state == BT_CONNECTED)
431 sec.key_size = chan->conn->hcon->enc_key_size;
433 len = min_t(unsigned int, len, sizeof(sec));
434 if (copy_to_user(optval, (char *) &sec, len))
440 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
445 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
451 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
452 (u32 __user *) optval))
458 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
459 && sk->sk_type != SOCK_RAW) {
464 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
466 len = min_t(unsigned int, len, sizeof(pwr));
467 if (copy_to_user(optval, (char *) &pwr, len))
472 case BT_CHANNEL_POLICY:
478 if (put_user(chan->chan_policy, (u32 __user *) optval))
491 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
493 struct sock *sk = sock->sk;
494 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
495 struct l2cap_options opts;
505 if (sk->sk_state == BT_CONNECTED) {
510 opts.imtu = chan->imtu;
511 opts.omtu = chan->omtu;
512 opts.flush_to = chan->flush_to;
513 opts.mode = chan->mode;
514 opts.fcs = chan->fcs;
515 opts.max_tx = chan->max_tx;
516 opts.txwin_size = chan->tx_win;
518 len = min_t(unsigned int, sizeof(opts), optlen);
519 if (copy_from_user((char *) &opts, optval, len)) {
524 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
529 chan->mode = opts.mode;
530 switch (chan->mode) {
531 case L2CAP_MODE_BASIC:
532 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
534 case L2CAP_MODE_ERTM:
535 case L2CAP_MODE_STREAMING:
544 chan->imtu = opts.imtu;
545 chan->omtu = opts.omtu;
546 chan->fcs = opts.fcs;
547 chan->max_tx = opts.max_tx;
548 chan->tx_win = opts.txwin_size;
552 if (get_user(opt, (u32 __user *) optval)) {
557 if (opt & L2CAP_LM_AUTH)
558 chan->sec_level = BT_SECURITY_LOW;
559 if (opt & L2CAP_LM_ENCRYPT)
560 chan->sec_level = BT_SECURITY_MEDIUM;
561 if (opt & L2CAP_LM_SECURE)
562 chan->sec_level = BT_SECURITY_HIGH;
564 if (opt & L2CAP_LM_MASTER)
565 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
567 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
569 if (opt & L2CAP_LM_RELIABLE)
570 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
572 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
584 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
586 struct sock *sk = sock->sk;
587 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
588 struct bt_security sec;
590 struct l2cap_conn *conn;
596 if (level == SOL_L2CAP)
597 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
599 if (level != SOL_BLUETOOTH)
606 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
607 chan->chan_type != L2CAP_CHAN_RAW) {
612 sec.level = BT_SECURITY_LOW;
614 len = min_t(unsigned int, sizeof(sec), optlen);
615 if (copy_from_user((char *) &sec, optval, len)) {
620 if (sec.level < BT_SECURITY_LOW ||
621 sec.level > BT_SECURITY_HIGH) {
626 chan->sec_level = sec.level;
633 /*change security for LE channels */
634 if (chan->scid == L2CAP_CID_LE_DATA) {
635 if (!conn->hcon->out) {
640 if (smp_conn_security(conn, sec.level))
642 sk->sk_state = BT_CONFIG;
644 /* or for ACL link, under defer_setup time */
645 } else if (sk->sk_state == BT_CONNECT2 &&
646 bt_sk(sk)->defer_setup) {
647 err = l2cap_chan_check_security(chan);
654 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
659 if (get_user(opt, (u32 __user *) optval)) {
664 bt_sk(sk)->defer_setup = opt;
668 if (get_user(opt, (u32 __user *) optval)) {
673 if (opt > BT_FLUSHABLE_ON) {
678 if (opt == BT_FLUSHABLE_OFF) {
679 struct l2cap_conn *conn = chan->conn;
680 /* proceed further only when we have l2cap_conn and
681 No Flush support in the LM */
682 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
689 set_bit(FLAG_FLUSHABLE, &chan->flags);
691 clear_bit(FLAG_FLUSHABLE, &chan->flags);
695 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
696 chan->chan_type != L2CAP_CHAN_RAW) {
701 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
703 len = min_t(unsigned int, sizeof(pwr), optlen);
704 if (copy_from_user((char *) &pwr, optval, len)) {
709 if (pwr.force_active)
710 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
712 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
715 case BT_CHANNEL_POLICY:
721 if (get_user(opt, (u32 __user *) optval)) {
726 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
731 if (chan->mode != L2CAP_MODE_ERTM &&
732 chan->mode != L2CAP_MODE_STREAMING) {
737 chan->chan_policy = (u8) opt;
749 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
751 struct sock *sk = sock->sk;
752 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
755 BT_DBG("sock %p, sk %p", sock, sk);
757 err = sock_error(sk);
761 if (msg->msg_flags & MSG_OOB)
766 if (sk->sk_state != BT_CONNECTED) {
771 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
777 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
779 struct sock *sk = sock->sk;
780 struct l2cap_pinfo *pi = l2cap_pi(sk);
785 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
786 sk->sk_state = BT_CONFIG;
788 __l2cap_connect_rsp_defer(pi->chan);
795 if (sock->type == SOCK_STREAM)
796 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
798 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
800 if (pi->chan->mode != L2CAP_MODE_ERTM)
803 /* Attempt to put pending rx data in the socket buffer */
807 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
810 if (pi->rx_busy_skb) {
811 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
812 pi->rx_busy_skb = NULL;
817 /* Restore data flow when half of the receive buffer is
818 * available. This avoids resending large numbers of
821 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
822 l2cap_chan_busy(pi->chan, 0);
829 /* Kill socket (only if zapped and orphan)
830 * Must be called on unlocked socket.
832 static void l2cap_sock_kill(struct sock *sk)
834 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
837 BT_DBG("sk %p state %d", sk, sk->sk_state);
839 /* Kill poor orphan */
841 l2cap_chan_destroy(l2cap_pi(sk)->chan);
842 sock_set_flag(sk, SOCK_DEAD);
846 static int l2cap_sock_shutdown(struct socket *sock, int how)
848 struct sock *sk = sock->sk;
849 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
852 BT_DBG("sock %p, sk %p", sock, sk);
858 if (!sk->sk_shutdown) {
859 if (chan->mode == L2CAP_MODE_ERTM)
860 err = __l2cap_wait_ack(sk);
862 sk->sk_shutdown = SHUTDOWN_MASK;
863 l2cap_chan_close(chan, 0);
865 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
866 err = bt_sock_wait_state(sk, BT_CLOSED,
870 if (!err && sk->sk_err)
877 static int l2cap_sock_release(struct socket *sock)
879 struct sock *sk = sock->sk;
882 BT_DBG("sock %p, sk %p", sock, sk);
887 err = l2cap_sock_shutdown(sock, 2);
894 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
896 struct sock *sk, *parent = data;
898 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
903 l2cap_sock_init(sk, parent);
905 return l2cap_pi(sk)->chan;
908 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
911 struct sock *sk = data;
912 struct l2cap_pinfo *pi = l2cap_pi(sk);
917 err = sock_queue_rcv_skb(sk, skb);
919 /* For ERTM, handle one skb that doesn't fit into the recv
920 * buffer. This is important to do because the data frames
921 * have already been acked, so the skb cannot be discarded.
923 * Notify the l2cap core that the buffer is full, so the
924 * LOCAL_BUSY state is entered and no more frames are
925 * acked and reassembled until there is buffer space
928 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
929 pi->rx_busy_skb = skb;
930 l2cap_chan_busy(pi->chan, 1);
937 static void l2cap_sock_close_cb(void *data)
939 struct sock *sk = data;
944 static void l2cap_sock_state_change_cb(void *data, int state)
946 struct sock *sk = data;
948 sk->sk_state = state;
951 static struct l2cap_ops l2cap_chan_ops = {
952 .name = "L2CAP Socket Interface",
953 .new_connection = l2cap_sock_new_connection_cb,
954 .recv = l2cap_sock_recv_cb,
955 .close = l2cap_sock_close_cb,
956 .state_change = l2cap_sock_state_change_cb,
959 static void l2cap_sock_destruct(struct sock *sk)
963 if (l2cap_pi(sk)->rx_busy_skb) {
964 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
965 l2cap_pi(sk)->rx_busy_skb = NULL;
968 skb_queue_purge(&sk->sk_receive_queue);
969 skb_queue_purge(&sk->sk_write_queue);
972 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
974 struct l2cap_pinfo *pi = l2cap_pi(sk);
975 struct l2cap_chan *chan = pi->chan;
980 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
982 sk->sk_type = parent->sk_type;
983 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
985 chan->chan_type = pchan->chan_type;
986 chan->imtu = pchan->imtu;
987 chan->omtu = pchan->omtu;
988 chan->conf_state = pchan->conf_state;
989 chan->mode = pchan->mode;
990 chan->fcs = pchan->fcs;
991 chan->max_tx = pchan->max_tx;
992 chan->tx_win = pchan->tx_win;
993 chan->tx_win_max = pchan->tx_win_max;
994 chan->sec_level = pchan->sec_level;
995 chan->flags = pchan->flags;
997 security_sk_clone(parent, sk);
1000 switch (sk->sk_type) {
1002 chan->chan_type = L2CAP_CHAN_RAW;
1005 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1007 case SOCK_SEQPACKET:
1009 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1013 chan->imtu = L2CAP_DEFAULT_MTU;
1015 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1016 chan->mode = L2CAP_MODE_ERTM;
1017 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1019 chan->mode = L2CAP_MODE_BASIC;
1021 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
1022 chan->fcs = L2CAP_FCS_CRC16;
1023 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1024 chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
1025 chan->sec_level = BT_SECURITY_LOW;
1027 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1030 /* Default config options */
1031 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1034 chan->ops = &l2cap_chan_ops;
1037 static struct proto l2cap_proto = {
1039 .owner = THIS_MODULE,
1040 .obj_size = sizeof(struct l2cap_pinfo)
1043 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1046 struct l2cap_chan *chan;
1048 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1052 sock_init_data(sock, sk);
1053 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1055 sk->sk_destruct = l2cap_sock_destruct;
1056 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1058 sock_reset_flag(sk, SOCK_ZAPPED);
1060 sk->sk_protocol = proto;
1061 sk->sk_state = BT_OPEN;
1063 chan = l2cap_chan_create(sk);
1065 l2cap_sock_kill(sk);
1069 l2cap_pi(sk)->chan = chan;
1074 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1079 BT_DBG("sock %p", sock);
1081 sock->state = SS_UNCONNECTED;
1083 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1084 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1085 return -ESOCKTNOSUPPORT;
1087 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1090 sock->ops = &l2cap_sock_ops;
1092 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1096 l2cap_sock_init(sk, NULL);
1100 static const struct proto_ops l2cap_sock_ops = {
1101 .family = PF_BLUETOOTH,
1102 .owner = THIS_MODULE,
1103 .release = l2cap_sock_release,
1104 .bind = l2cap_sock_bind,
1105 .connect = l2cap_sock_connect,
1106 .listen = l2cap_sock_listen,
1107 .accept = l2cap_sock_accept,
1108 .getname = l2cap_sock_getname,
1109 .sendmsg = l2cap_sock_sendmsg,
1110 .recvmsg = l2cap_sock_recvmsg,
1111 .poll = bt_sock_poll,
1112 .ioctl = bt_sock_ioctl,
1113 .mmap = sock_no_mmap,
1114 .socketpair = sock_no_socketpair,
1115 .shutdown = l2cap_sock_shutdown,
1116 .setsockopt = l2cap_sock_setsockopt,
1117 .getsockopt = l2cap_sock_getsockopt
1120 static const struct net_proto_family l2cap_sock_family_ops = {
1121 .family = PF_BLUETOOTH,
1122 .owner = THIS_MODULE,
1123 .create = l2cap_sock_create,
1126 int __init l2cap_init_sockets(void)
1130 err = proto_register(&l2cap_proto, 0);
1134 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1138 BT_INFO("L2CAP socket layer initialized");
1143 BT_ERR("L2CAP socket registration failed");
1144 proto_unregister(&l2cap_proto);
1148 void l2cap_cleanup_sockets(void)
1150 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1151 BT_ERR("L2CAP socket unregistration failed");
1153 proto_unregister(&l2cap_proto);