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, 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, la.l2_cid, &la.l2_bdaddr);
132 err = bt_sock_wait_state(sk, BT_CONNECTED,
133 sock_sndtimeo(sk, flags & O_NONBLOCK));
140 static int l2cap_sock_listen(struct socket *sock, int backlog)
142 struct sock *sk = sock->sk;
143 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
146 BT_DBG("sk %p backlog %d", sk, backlog);
150 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
151 || sk->sk_state != BT_BOUND) {
156 switch (chan->mode) {
157 case L2CAP_MODE_BASIC:
159 case L2CAP_MODE_ERTM:
160 case L2CAP_MODE_STREAMING:
169 sk->sk_max_ack_backlog = backlog;
170 sk->sk_ack_backlog = 0;
172 chan->state = BT_LISTEN;
173 sk->sk_state = BT_LISTEN;
180 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
182 DECLARE_WAITQUEUE(wait, current);
183 struct sock *sk = sock->sk, *nsk;
187 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
189 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
191 BT_DBG("sk %p timeo %ld", sk, timeo);
193 /* Wait for an incoming connection. (wake-one). */
194 add_wait_queue_exclusive(sk_sleep(sk), &wait);
196 set_current_state(TASK_INTERRUPTIBLE);
198 if (sk->sk_state != BT_LISTEN) {
203 nsk = bt_accept_dequeue(sk, newsock);
212 if (signal_pending(current)) {
213 err = sock_intr_errno(timeo);
218 timeo = schedule_timeout(timeo);
219 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
221 __set_current_state(TASK_RUNNING);
222 remove_wait_queue(sk_sleep(sk), &wait);
227 newsock->state = SS_CONNECTED;
229 BT_DBG("new socket %p", nsk);
236 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
238 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
239 struct sock *sk = sock->sk;
240 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
242 BT_DBG("sock %p, sk %p", sock, sk);
244 addr->sa_family = AF_BLUETOOTH;
245 *len = sizeof(struct sockaddr_l2);
248 la->l2_psm = chan->psm;
249 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
250 la->l2_cid = cpu_to_le16(chan->dcid);
252 la->l2_psm = chan->sport;
253 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
254 la->l2_cid = cpu_to_le16(chan->scid);
260 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
262 struct sock *sk = sock->sk;
263 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
264 struct l2cap_options opts;
265 struct l2cap_conninfo cinfo;
271 if (get_user(len, optlen))
278 memset(&opts, 0, sizeof(opts));
279 opts.imtu = chan->imtu;
280 opts.omtu = chan->omtu;
281 opts.flush_to = chan->flush_to;
282 opts.mode = chan->mode;
283 opts.fcs = chan->fcs;
284 opts.max_tx = chan->max_tx;
285 opts.txwin_size = chan->tx_win;
287 len = min_t(unsigned int, len, sizeof(opts));
288 if (copy_to_user(optval, (char *) &opts, len))
294 switch (chan->sec_level) {
295 case BT_SECURITY_LOW:
298 case BT_SECURITY_MEDIUM:
299 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
301 case BT_SECURITY_HIGH:
302 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
310 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
311 opt |= L2CAP_LM_MASTER;
313 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
314 opt |= L2CAP_LM_RELIABLE;
316 if (put_user(opt, (u32 __user *) optval))
321 if (sk->sk_state != BT_CONNECTED &&
322 !(sk->sk_state == BT_CONNECT2 &&
323 bt_sk(sk)->defer_setup)) {
328 memset(&cinfo, 0, sizeof(cinfo));
329 cinfo.hci_handle = chan->conn->hcon->handle;
330 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
332 len = min_t(unsigned int, len, sizeof(cinfo));
333 if (copy_to_user(optval, (char *) &cinfo, len))
347 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
349 struct sock *sk = sock->sk;
350 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
351 struct bt_security sec;
357 if (level == SOL_L2CAP)
358 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
360 if (level != SOL_BLUETOOTH)
363 if (get_user(len, optlen))
370 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
371 chan->chan_type != L2CAP_CHAN_RAW) {
376 memset(&sec, 0, sizeof(sec));
377 sec.level = chan->sec_level;
379 if (sk->sk_state == BT_CONNECTED)
380 sec.key_size = chan->conn->hcon->enc_key_size;
382 len = min_t(unsigned int, len, sizeof(sec));
383 if (copy_to_user(optval, (char *) &sec, len))
389 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
394 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
400 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
401 (u32 __user *) optval))
407 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
408 && sk->sk_type != SOCK_RAW) {
413 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
415 len = min_t(unsigned int, len, sizeof(pwr));
416 if (copy_to_user(optval, (char *) &pwr, len))
421 case BT_CHANNEL_POLICY:
427 if (put_user(chan->chan_policy, (u32 __user *) optval))
440 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
442 struct sock *sk = sock->sk;
443 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
444 struct l2cap_options opts;
454 if (sk->sk_state == BT_CONNECTED) {
459 opts.imtu = chan->imtu;
460 opts.omtu = chan->omtu;
461 opts.flush_to = chan->flush_to;
462 opts.mode = chan->mode;
463 opts.fcs = chan->fcs;
464 opts.max_tx = chan->max_tx;
465 opts.txwin_size = chan->tx_win;
467 len = min_t(unsigned int, sizeof(opts), optlen);
468 if (copy_from_user((char *) &opts, optval, len)) {
473 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
478 chan->mode = opts.mode;
479 switch (chan->mode) {
480 case L2CAP_MODE_BASIC:
481 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
483 case L2CAP_MODE_ERTM:
484 case L2CAP_MODE_STREAMING:
493 chan->imtu = opts.imtu;
494 chan->omtu = opts.omtu;
495 chan->fcs = opts.fcs;
496 chan->max_tx = opts.max_tx;
497 chan->tx_win = opts.txwin_size;
501 if (get_user(opt, (u32 __user *) optval)) {
506 if (opt & L2CAP_LM_AUTH)
507 chan->sec_level = BT_SECURITY_LOW;
508 if (opt & L2CAP_LM_ENCRYPT)
509 chan->sec_level = BT_SECURITY_MEDIUM;
510 if (opt & L2CAP_LM_SECURE)
511 chan->sec_level = BT_SECURITY_HIGH;
513 if (opt & L2CAP_LM_MASTER)
514 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
516 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
518 if (opt & L2CAP_LM_RELIABLE)
519 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
521 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
533 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
535 struct sock *sk = sock->sk;
536 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
537 struct bt_security sec;
539 struct l2cap_conn *conn;
545 if (level == SOL_L2CAP)
546 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
548 if (level != SOL_BLUETOOTH)
555 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
556 chan->chan_type != L2CAP_CHAN_RAW) {
561 sec.level = BT_SECURITY_LOW;
563 len = min_t(unsigned int, sizeof(sec), optlen);
564 if (copy_from_user((char *) &sec, optval, len)) {
569 if (sec.level < BT_SECURITY_LOW ||
570 sec.level > BT_SECURITY_HIGH) {
575 chan->sec_level = sec.level;
582 /*change security for LE channels */
583 if (chan->scid == L2CAP_CID_LE_DATA) {
584 if (!conn->hcon->out) {
589 if (smp_conn_security(conn, sec.level))
591 sk->sk_state = BT_CONFIG;
592 chan->state = BT_CONFIG;
594 /* or for ACL link, under defer_setup time */
595 } else if (sk->sk_state == BT_CONNECT2 &&
596 bt_sk(sk)->defer_setup) {
597 err = l2cap_chan_check_security(chan);
604 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
609 if (get_user(opt, (u32 __user *) optval)) {
614 bt_sk(sk)->defer_setup = opt;
618 if (get_user(opt, (u32 __user *) optval)) {
623 if (opt > BT_FLUSHABLE_ON) {
628 if (opt == BT_FLUSHABLE_OFF) {
629 struct l2cap_conn *conn = chan->conn;
630 /* proceed further only when we have l2cap_conn and
631 No Flush support in the LM */
632 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
639 set_bit(FLAG_FLUSHABLE, &chan->flags);
641 clear_bit(FLAG_FLUSHABLE, &chan->flags);
645 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
646 chan->chan_type != L2CAP_CHAN_RAW) {
651 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
653 len = min_t(unsigned int, sizeof(pwr), optlen);
654 if (copy_from_user((char *) &pwr, optval, len)) {
659 if (pwr.force_active)
660 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
662 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
665 case BT_CHANNEL_POLICY:
671 if (get_user(opt, (u32 __user *) optval)) {
676 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
681 if (chan->mode != L2CAP_MODE_ERTM &&
682 chan->mode != L2CAP_MODE_STREAMING) {
687 chan->chan_policy = (u8) opt;
699 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
701 struct sock *sk = sock->sk;
702 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
705 BT_DBG("sock %p, sk %p", sock, sk);
707 err = sock_error(sk);
711 if (msg->msg_flags & MSG_OOB)
716 if (sk->sk_state != BT_CONNECTED) {
721 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
727 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
729 struct sock *sk = sock->sk;
730 struct l2cap_pinfo *pi = l2cap_pi(sk);
735 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
736 sk->sk_state = BT_CONFIG;
737 pi->chan->state = BT_CONFIG;
739 __l2cap_connect_rsp_defer(pi->chan);
746 if (sock->type == SOCK_STREAM)
747 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
749 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
751 if (pi->chan->mode != L2CAP_MODE_ERTM)
754 /* Attempt to put pending rx data in the socket buffer */
758 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
761 if (pi->rx_busy_skb) {
762 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
763 pi->rx_busy_skb = NULL;
768 /* Restore data flow when half of the receive buffer is
769 * available. This avoids resending large numbers of
772 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
773 l2cap_chan_busy(pi->chan, 0);
780 /* Kill socket (only if zapped and orphan)
781 * Must be called on unlocked socket.
783 static void l2cap_sock_kill(struct sock *sk)
785 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
788 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
790 /* Kill poor orphan */
792 l2cap_chan_destroy(l2cap_pi(sk)->chan);
793 sock_set_flag(sk, SOCK_DEAD);
797 static int l2cap_sock_shutdown(struct socket *sock, int how)
799 struct sock *sk = sock->sk;
800 struct l2cap_chan *chan;
801 struct l2cap_conn *conn;
804 BT_DBG("sock %p, sk %p", sock, sk);
809 chan = l2cap_pi(sk)->chan;
813 mutex_lock(&conn->chan_lock);
815 l2cap_chan_lock(chan);
818 if (!sk->sk_shutdown) {
819 if (chan->mode == L2CAP_MODE_ERTM)
820 err = __l2cap_wait_ack(sk);
822 sk->sk_shutdown = SHUTDOWN_MASK;
825 l2cap_chan_close(chan, 0);
828 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
829 err = bt_sock_wait_state(sk, BT_CLOSED,
833 if (!err && sk->sk_err)
837 l2cap_chan_unlock(chan);
840 mutex_unlock(&conn->chan_lock);
845 static int l2cap_sock_release(struct socket *sock)
847 struct sock *sk = sock->sk;
850 BT_DBG("sock %p, sk %p", sock, sk);
855 err = l2cap_sock_shutdown(sock, 2);
862 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
864 struct sock *sk, *parent = data;
866 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
871 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
873 l2cap_sock_init(sk, parent);
875 return l2cap_pi(sk)->chan;
878 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
881 struct sock *sk = data;
882 struct l2cap_pinfo *pi = l2cap_pi(sk);
886 if (pi->rx_busy_skb) {
891 err = sock_queue_rcv_skb(sk, skb);
893 /* For ERTM, handle one skb that doesn't fit into the recv
894 * buffer. This is important to do because the data frames
895 * have already been acked, so the skb cannot be discarded.
897 * Notify the l2cap core that the buffer is full, so the
898 * LOCAL_BUSY state is entered and no more frames are
899 * acked and reassembled until there is buffer space
902 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
903 pi->rx_busy_skb = skb;
904 l2cap_chan_busy(pi->chan, 1);
914 static void l2cap_sock_close_cb(void *data)
916 struct sock *sk = data;
921 static void l2cap_sock_state_change_cb(void *data, int state)
923 struct sock *sk = data;
925 sk->sk_state = state;
928 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
929 unsigned long len, int nb,
932 struct sock *sk = chan->sk;
934 return bt_skb_send_alloc(sk, len, nb, err);
937 static struct l2cap_ops l2cap_chan_ops = {
938 .name = "L2CAP Socket Interface",
939 .new_connection = l2cap_sock_new_connection_cb,
940 .recv = l2cap_sock_recv_cb,
941 .close = l2cap_sock_close_cb,
942 .state_change = l2cap_sock_state_change_cb,
943 .alloc_skb = l2cap_sock_alloc_skb_cb,
946 static void l2cap_sock_destruct(struct sock *sk)
950 if (l2cap_pi(sk)->rx_busy_skb) {
951 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
952 l2cap_pi(sk)->rx_busy_skb = NULL;
955 skb_queue_purge(&sk->sk_receive_queue);
956 skb_queue_purge(&sk->sk_write_queue);
959 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
961 struct l2cap_pinfo *pi = l2cap_pi(sk);
962 struct l2cap_chan *chan = pi->chan;
967 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
969 sk->sk_type = parent->sk_type;
970 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
972 chan->chan_type = pchan->chan_type;
973 chan->imtu = pchan->imtu;
974 chan->omtu = pchan->omtu;
975 chan->conf_state = pchan->conf_state;
976 chan->mode = pchan->mode;
977 chan->fcs = pchan->fcs;
978 chan->max_tx = pchan->max_tx;
979 chan->tx_win = pchan->tx_win;
980 chan->tx_win_max = pchan->tx_win_max;
981 chan->sec_level = pchan->sec_level;
982 chan->flags = pchan->flags;
984 security_sk_clone(parent, sk);
987 switch (sk->sk_type) {
989 chan->chan_type = L2CAP_CHAN_RAW;
992 chan->chan_type = L2CAP_CHAN_CONN_LESS;
996 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1000 chan->imtu = L2CAP_DEFAULT_MTU;
1002 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1003 chan->mode = L2CAP_MODE_ERTM;
1004 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1006 chan->mode = L2CAP_MODE_BASIC;
1008 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
1009 chan->fcs = L2CAP_FCS_CRC16;
1010 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1011 chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
1012 chan->sec_level = BT_SECURITY_LOW;
1014 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1017 /* Default config options */
1018 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1021 chan->ops = &l2cap_chan_ops;
1024 static struct proto l2cap_proto = {
1026 .owner = THIS_MODULE,
1027 .obj_size = sizeof(struct l2cap_pinfo)
1030 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1033 struct l2cap_chan *chan;
1035 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1039 sock_init_data(sock, sk);
1040 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1042 sk->sk_destruct = l2cap_sock_destruct;
1043 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1045 sock_reset_flag(sk, SOCK_ZAPPED);
1047 sk->sk_protocol = proto;
1048 sk->sk_state = BT_OPEN;
1050 chan = l2cap_chan_create(sk);
1052 l2cap_sock_kill(sk);
1056 l2cap_pi(sk)->chan = chan;
1061 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1066 BT_DBG("sock %p", sock);
1068 sock->state = SS_UNCONNECTED;
1070 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1071 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1072 return -ESOCKTNOSUPPORT;
1074 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1077 sock->ops = &l2cap_sock_ops;
1079 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1083 l2cap_sock_init(sk, NULL);
1087 static const struct proto_ops l2cap_sock_ops = {
1088 .family = PF_BLUETOOTH,
1089 .owner = THIS_MODULE,
1090 .release = l2cap_sock_release,
1091 .bind = l2cap_sock_bind,
1092 .connect = l2cap_sock_connect,
1093 .listen = l2cap_sock_listen,
1094 .accept = l2cap_sock_accept,
1095 .getname = l2cap_sock_getname,
1096 .sendmsg = l2cap_sock_sendmsg,
1097 .recvmsg = l2cap_sock_recvmsg,
1098 .poll = bt_sock_poll,
1099 .ioctl = bt_sock_ioctl,
1100 .mmap = sock_no_mmap,
1101 .socketpair = sock_no_socketpair,
1102 .shutdown = l2cap_sock_shutdown,
1103 .setsockopt = l2cap_sock_setsockopt,
1104 .getsockopt = l2cap_sock_getsockopt
1107 static const struct net_proto_family l2cap_sock_family_ops = {
1108 .family = PF_BLUETOOTH,
1109 .owner = THIS_MODULE,
1110 .create = l2cap_sock_create,
1113 int __init l2cap_init_sockets(void)
1117 err = proto_register(&l2cap_proto, 0);
1121 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1125 BT_INFO("L2CAP socket layer initialized");
1130 BT_ERR("L2CAP socket registration failed");
1131 proto_unregister(&l2cap_proto);
1135 void l2cap_cleanup_sockets(void)
1137 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1138 BT_ERR("L2CAP socket unregistration failed");
1140 proto_unregister(&l2cap_proto);