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/security.h>
31 #include <linux/export.h>
33 #include <net/bluetooth/bluetooth.h>
34 #include <net/bluetooth/hci_core.h>
35 #include <net/bluetooth/l2cap.h>
36 #include <net/bluetooth/smp.h>
38 static const struct proto_ops l2cap_sock_ops;
39 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
40 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
42 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
44 struct sock *sk = sock->sk;
45 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
46 struct sockaddr_l2 la;
51 if (!addr || addr->sa_family != AF_BLUETOOTH)
54 memset(&la, 0, sizeof(la));
55 len = min_t(unsigned int, sizeof(la), alen);
56 memcpy(&la, addr, len);
58 if (la.l2_cid && la.l2_psm)
63 if (sk->sk_state != BT_OPEN) {
69 __u16 psm = __le16_to_cpu(la.l2_psm);
71 /* PSM must be odd and lsb of upper byte must be 0 */
72 if ((psm & 0x0101) != 0x0001) {
77 /* Restrict usage of well-known PSMs */
78 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
85 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
87 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
92 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
93 __le16_to_cpu(la.l2_psm) == 0x0003)
94 chan->sec_level = BT_SECURITY_SDP;
96 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
98 chan->state = BT_BOUND;
99 sk->sk_state = BT_BOUND;
106 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
108 struct sock *sk = sock->sk;
109 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
110 struct sockaddr_l2 la;
115 if (!addr || alen < sizeof(addr->sa_family) ||
116 addr->sa_family != AF_BLUETOOTH)
119 memset(&la, 0, sizeof(la));
120 len = min_t(unsigned int, sizeof(la), alen);
121 memcpy(&la, addr, len);
123 if (la.l2_cid && la.l2_psm)
126 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
133 err = bt_sock_wait_state(sk, BT_CONNECTED,
134 sock_sndtimeo(sk, flags & O_NONBLOCK));
141 static int l2cap_sock_listen(struct socket *sock, int backlog)
143 struct sock *sk = sock->sk;
144 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
147 BT_DBG("sk %p backlog %d", sk, backlog);
151 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
152 || sk->sk_state != BT_BOUND) {
157 switch (chan->mode) {
158 case L2CAP_MODE_BASIC:
160 case L2CAP_MODE_ERTM:
161 case L2CAP_MODE_STREAMING:
170 sk->sk_max_ack_backlog = backlog;
171 sk->sk_ack_backlog = 0;
173 chan->state = BT_LISTEN;
174 sk->sk_state = BT_LISTEN;
181 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
183 DECLARE_WAITQUEUE(wait, current);
184 struct sock *sk = sock->sk, *nsk;
188 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
190 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
192 BT_DBG("sk %p timeo %ld", sk, timeo);
194 /* Wait for an incoming connection. (wake-one). */
195 add_wait_queue_exclusive(sk_sleep(sk), &wait);
197 set_current_state(TASK_INTERRUPTIBLE);
199 if (sk->sk_state != BT_LISTEN) {
204 nsk = bt_accept_dequeue(sk, newsock);
213 if (signal_pending(current)) {
214 err = sock_intr_errno(timeo);
219 timeo = schedule_timeout(timeo);
220 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
222 __set_current_state(TASK_RUNNING);
223 remove_wait_queue(sk_sleep(sk), &wait);
228 newsock->state = SS_CONNECTED;
230 BT_DBG("new socket %p", nsk);
237 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
239 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
240 struct sock *sk = sock->sk;
241 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
243 BT_DBG("sock %p, sk %p", sock, sk);
245 addr->sa_family = AF_BLUETOOTH;
246 *len = sizeof(struct sockaddr_l2);
249 la->l2_psm = chan->psm;
250 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
251 la->l2_cid = cpu_to_le16(chan->dcid);
253 la->l2_psm = chan->sport;
254 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
255 la->l2_cid = cpu_to_le16(chan->scid);
261 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
263 struct sock *sk = sock->sk;
264 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
265 struct l2cap_options opts;
266 struct l2cap_conninfo cinfo;
272 if (get_user(len, optlen))
279 memset(&opts, 0, sizeof(opts));
280 opts.imtu = chan->imtu;
281 opts.omtu = chan->omtu;
282 opts.flush_to = chan->flush_to;
283 opts.mode = chan->mode;
284 opts.fcs = chan->fcs;
285 opts.max_tx = chan->max_tx;
286 opts.txwin_size = chan->tx_win;
288 len = min_t(unsigned int, len, sizeof(opts));
289 if (copy_to_user(optval, (char *) &opts, len))
295 switch (chan->sec_level) {
296 case BT_SECURITY_LOW:
299 case BT_SECURITY_MEDIUM:
300 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
302 case BT_SECURITY_HIGH:
303 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
311 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
312 opt |= L2CAP_LM_MASTER;
314 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
315 opt |= L2CAP_LM_RELIABLE;
317 if (put_user(opt, (u32 __user *) optval))
322 if (sk->sk_state != BT_CONNECTED &&
323 !(sk->sk_state == BT_CONNECT2 &&
324 bt_sk(sk)->defer_setup)) {
329 memset(&cinfo, 0, sizeof(cinfo));
330 cinfo.hci_handle = chan->conn->hcon->handle;
331 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
333 len = min_t(unsigned int, len, sizeof(cinfo));
334 if (copy_to_user(optval, (char *) &cinfo, len))
348 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
350 struct sock *sk = sock->sk;
351 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
352 struct bt_security sec;
358 if (level == SOL_L2CAP)
359 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
361 if (level != SOL_BLUETOOTH)
364 if (get_user(len, optlen))
371 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
372 chan->chan_type != L2CAP_CHAN_RAW) {
377 memset(&sec, 0, sizeof(sec));
378 sec.level = chan->sec_level;
380 if (sk->sk_state == BT_CONNECTED)
381 sec.key_size = chan->conn->hcon->enc_key_size;
383 len = min_t(unsigned int, len, sizeof(sec));
384 if (copy_to_user(optval, (char *) &sec, len))
390 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
395 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
401 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
402 (u32 __user *) optval))
408 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
409 && sk->sk_type != SOCK_RAW) {
414 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
416 len = min_t(unsigned int, len, sizeof(pwr));
417 if (copy_to_user(optval, (char *) &pwr, len))
422 case BT_CHANNEL_POLICY:
428 if (put_user(chan->chan_policy, (u32 __user *) optval))
441 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
443 struct sock *sk = sock->sk;
444 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
445 struct l2cap_options opts;
455 if (sk->sk_state == BT_CONNECTED) {
460 opts.imtu = chan->imtu;
461 opts.omtu = chan->omtu;
462 opts.flush_to = chan->flush_to;
463 opts.mode = chan->mode;
464 opts.fcs = chan->fcs;
465 opts.max_tx = chan->max_tx;
466 opts.txwin_size = chan->tx_win;
468 len = min_t(unsigned int, sizeof(opts), optlen);
469 if (copy_from_user((char *) &opts, optval, len)) {
474 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
479 chan->mode = opts.mode;
480 switch (chan->mode) {
481 case L2CAP_MODE_BASIC:
482 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
484 case L2CAP_MODE_ERTM:
485 case L2CAP_MODE_STREAMING:
494 chan->imtu = opts.imtu;
495 chan->omtu = opts.omtu;
496 chan->fcs = opts.fcs;
497 chan->max_tx = opts.max_tx;
498 chan->tx_win = opts.txwin_size;
502 if (get_user(opt, (u32 __user *) optval)) {
507 if (opt & L2CAP_LM_AUTH)
508 chan->sec_level = BT_SECURITY_LOW;
509 if (opt & L2CAP_LM_ENCRYPT)
510 chan->sec_level = BT_SECURITY_MEDIUM;
511 if (opt & L2CAP_LM_SECURE)
512 chan->sec_level = BT_SECURITY_HIGH;
514 if (opt & L2CAP_LM_MASTER)
515 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
517 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
519 if (opt & L2CAP_LM_RELIABLE)
520 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
522 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
534 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
536 struct sock *sk = sock->sk;
537 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
538 struct bt_security sec;
540 struct l2cap_conn *conn;
546 if (level == SOL_L2CAP)
547 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
549 if (level != SOL_BLUETOOTH)
556 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
557 chan->chan_type != L2CAP_CHAN_RAW) {
562 sec.level = BT_SECURITY_LOW;
564 len = min_t(unsigned int, sizeof(sec), optlen);
565 if (copy_from_user((char *) &sec, optval, len)) {
570 if (sec.level < BT_SECURITY_LOW ||
571 sec.level > BT_SECURITY_HIGH) {
576 chan->sec_level = sec.level;
583 /*change security for LE channels */
584 if (chan->scid == L2CAP_CID_LE_DATA) {
585 if (!conn->hcon->out) {
590 if (smp_conn_security(conn, sec.level))
592 sk->sk_state = BT_CONFIG;
593 chan->state = BT_CONFIG;
595 /* or for ACL link */
596 } else if ((sk->sk_state == BT_CONNECT2 &&
597 bt_sk(sk)->defer_setup) ||
598 sk->sk_state == BT_CONNECTED) {
599 if (!l2cap_chan_check_security(chan))
600 bt_sk(sk)->suspended = true;
602 sk->sk_state_change(sk);
609 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
614 if (get_user(opt, (u32 __user *) optval)) {
619 bt_sk(sk)->defer_setup = opt;
623 if (get_user(opt, (u32 __user *) optval)) {
628 if (opt > BT_FLUSHABLE_ON) {
633 if (opt == BT_FLUSHABLE_OFF) {
634 struct l2cap_conn *conn = chan->conn;
635 /* proceed further only when we have l2cap_conn and
636 No Flush support in the LM */
637 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
644 set_bit(FLAG_FLUSHABLE, &chan->flags);
646 clear_bit(FLAG_FLUSHABLE, &chan->flags);
650 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
651 chan->chan_type != L2CAP_CHAN_RAW) {
656 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
658 len = min_t(unsigned int, sizeof(pwr), optlen);
659 if (copy_from_user((char *) &pwr, optval, len)) {
664 if (pwr.force_active)
665 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
667 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
670 case BT_CHANNEL_POLICY:
676 if (get_user(opt, (u32 __user *) optval)) {
681 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
686 if (chan->mode != L2CAP_MODE_ERTM &&
687 chan->mode != L2CAP_MODE_STREAMING) {
692 chan->chan_policy = (u8) opt;
704 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
706 struct sock *sk = sock->sk;
707 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
710 BT_DBG("sock %p, sk %p", sock, sk);
712 err = sock_error(sk);
716 if (msg->msg_flags & MSG_OOB)
721 if (sk->sk_state != BT_CONNECTED) {
726 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
732 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
734 struct sock *sk = sock->sk;
735 struct l2cap_pinfo *pi = l2cap_pi(sk);
740 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
741 sk->sk_state = BT_CONFIG;
742 pi->chan->state = BT_CONFIG;
744 __l2cap_connect_rsp_defer(pi->chan);
751 if (sock->type == SOCK_STREAM)
752 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
754 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
756 if (pi->chan->mode != L2CAP_MODE_ERTM)
759 /* Attempt to put pending rx data in the socket buffer */
763 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
766 if (pi->rx_busy_skb) {
767 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
768 pi->rx_busy_skb = NULL;
773 /* Restore data flow when half of the receive buffer is
774 * available. This avoids resending large numbers of
777 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
778 l2cap_chan_busy(pi->chan, 0);
785 /* Kill socket (only if zapped and orphan)
786 * Must be called on unlocked socket.
788 static void l2cap_sock_kill(struct sock *sk)
790 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
793 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
795 /* Kill poor orphan */
797 l2cap_chan_destroy(l2cap_pi(sk)->chan);
798 sock_set_flag(sk, SOCK_DEAD);
802 static int l2cap_sock_shutdown(struct socket *sock, int how)
804 struct sock *sk = sock->sk;
805 struct l2cap_chan *chan;
806 struct l2cap_conn *conn;
809 BT_DBG("sock %p, sk %p", sock, sk);
814 chan = l2cap_pi(sk)->chan;
818 mutex_lock(&conn->chan_lock);
820 l2cap_chan_lock(chan);
823 if (!sk->sk_shutdown) {
824 if (chan->mode == L2CAP_MODE_ERTM)
825 err = __l2cap_wait_ack(sk);
827 sk->sk_shutdown = SHUTDOWN_MASK;
830 l2cap_chan_close(chan, 0);
833 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
834 err = bt_sock_wait_state(sk, BT_CLOSED,
838 if (!err && sk->sk_err)
842 l2cap_chan_unlock(chan);
845 mutex_unlock(&conn->chan_lock);
850 static int l2cap_sock_release(struct socket *sock)
852 struct sock *sk = sock->sk;
855 BT_DBG("sock %p, sk %p", sock, sk);
860 err = l2cap_sock_shutdown(sock, 2);
867 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
869 struct sock *sk, *parent = data;
871 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
876 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
878 l2cap_sock_init(sk, parent);
880 return l2cap_pi(sk)->chan;
883 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
886 struct sock *sk = data;
887 struct l2cap_pinfo *pi = l2cap_pi(sk);
891 if (pi->rx_busy_skb) {
896 err = sock_queue_rcv_skb(sk, skb);
898 /* For ERTM, handle one skb that doesn't fit into the recv
899 * buffer. This is important to do because the data frames
900 * have already been acked, so the skb cannot be discarded.
902 * Notify the l2cap core that the buffer is full, so the
903 * LOCAL_BUSY state is entered and no more frames are
904 * acked and reassembled until there is buffer space
907 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
908 pi->rx_busy_skb = skb;
909 l2cap_chan_busy(pi->chan, 1);
919 static void l2cap_sock_close_cb(void *data)
921 struct sock *sk = data;
926 static void l2cap_sock_state_change_cb(void *data, int state)
928 struct sock *sk = data;
930 sk->sk_state = state;
933 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
934 unsigned long len, int nb,
937 struct sock *sk = chan->sk;
939 return bt_skb_send_alloc(sk, len, nb, err);
942 static struct l2cap_ops l2cap_chan_ops = {
943 .name = "L2CAP Socket Interface",
944 .new_connection = l2cap_sock_new_connection_cb,
945 .recv = l2cap_sock_recv_cb,
946 .close = l2cap_sock_close_cb,
947 .state_change = l2cap_sock_state_change_cb,
948 .alloc_skb = l2cap_sock_alloc_skb_cb,
951 static void l2cap_sock_destruct(struct sock *sk)
955 if (l2cap_pi(sk)->rx_busy_skb) {
956 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
957 l2cap_pi(sk)->rx_busy_skb = NULL;
960 skb_queue_purge(&sk->sk_receive_queue);
961 skb_queue_purge(&sk->sk_write_queue);
964 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
966 struct l2cap_pinfo *pi = l2cap_pi(sk);
967 struct l2cap_chan *chan = pi->chan;
972 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
974 sk->sk_type = parent->sk_type;
975 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
977 chan->chan_type = pchan->chan_type;
978 chan->imtu = pchan->imtu;
979 chan->omtu = pchan->omtu;
980 chan->conf_state = pchan->conf_state;
981 chan->mode = pchan->mode;
982 chan->fcs = pchan->fcs;
983 chan->max_tx = pchan->max_tx;
984 chan->tx_win = pchan->tx_win;
985 chan->tx_win_max = pchan->tx_win_max;
986 chan->sec_level = pchan->sec_level;
987 chan->flags = pchan->flags;
989 security_sk_clone(parent, sk);
992 switch (sk->sk_type) {
994 chan->chan_type = L2CAP_CHAN_RAW;
997 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1001 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1005 chan->imtu = L2CAP_DEFAULT_MTU;
1007 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1008 chan->mode = L2CAP_MODE_ERTM;
1009 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1011 chan->mode = L2CAP_MODE_BASIC;
1013 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
1014 chan->fcs = L2CAP_FCS_CRC16;
1015 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1016 chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
1017 chan->sec_level = BT_SECURITY_LOW;
1019 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1022 /* Default config options */
1023 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1026 chan->ops = &l2cap_chan_ops;
1029 static struct proto l2cap_proto = {
1031 .owner = THIS_MODULE,
1032 .obj_size = sizeof(struct l2cap_pinfo)
1035 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1038 struct l2cap_chan *chan;
1040 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1044 sock_init_data(sock, sk);
1045 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1047 sk->sk_destruct = l2cap_sock_destruct;
1048 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1050 sock_reset_flag(sk, SOCK_ZAPPED);
1052 sk->sk_protocol = proto;
1053 sk->sk_state = BT_OPEN;
1055 chan = l2cap_chan_create(sk);
1057 l2cap_sock_kill(sk);
1061 l2cap_pi(sk)->chan = chan;
1066 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1071 BT_DBG("sock %p", sock);
1073 sock->state = SS_UNCONNECTED;
1075 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1076 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1077 return -ESOCKTNOSUPPORT;
1079 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1082 sock->ops = &l2cap_sock_ops;
1084 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1088 l2cap_sock_init(sk, NULL);
1092 static const struct proto_ops l2cap_sock_ops = {
1093 .family = PF_BLUETOOTH,
1094 .owner = THIS_MODULE,
1095 .release = l2cap_sock_release,
1096 .bind = l2cap_sock_bind,
1097 .connect = l2cap_sock_connect,
1098 .listen = l2cap_sock_listen,
1099 .accept = l2cap_sock_accept,
1100 .getname = l2cap_sock_getname,
1101 .sendmsg = l2cap_sock_sendmsg,
1102 .recvmsg = l2cap_sock_recvmsg,
1103 .poll = bt_sock_poll,
1104 .ioctl = bt_sock_ioctl,
1105 .mmap = sock_no_mmap,
1106 .socketpair = sock_no_socketpair,
1107 .shutdown = l2cap_sock_shutdown,
1108 .setsockopt = l2cap_sock_setsockopt,
1109 .getsockopt = l2cap_sock_getsockopt
1112 static const struct net_proto_family l2cap_sock_family_ops = {
1113 .family = PF_BLUETOOTH,
1114 .owner = THIS_MODULE,
1115 .create = l2cap_sock_create,
1118 int __init l2cap_init_sockets(void)
1122 err = proto_register(&l2cap_proto, 0);
1126 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1130 BT_INFO("L2CAP socket layer initialized");
1135 BT_ERR("L2CAP socket registration failed");
1136 proto_unregister(&l2cap_proto);
1140 void l2cap_cleanup_sockets(void)
1142 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1143 BT_ERR("L2CAP socket unregistration failed");
1145 proto_unregister(&l2cap_proto);