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 <net/bluetooth/bluetooth.h>
30 #include <net/bluetooth/hci_core.h>
31 #include <net/bluetooth/l2cap.h>
33 /* ---- L2CAP timers ---- */
34 static void l2cap_sock_timeout(unsigned long arg)
36 struct sock *sk = (struct sock *) arg;
39 BT_DBG("sock %p state %d", sk, sk->sk_state);
43 if (sock_owned_by_user(sk)) {
44 /* sk is owned by user. Try again later */
45 l2cap_sock_set_timer(sk, HZ / 5);
51 if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONFIG)
52 reason = ECONNREFUSED;
53 else if (sk->sk_state == BT_CONNECT &&
54 l2cap_pi(sk)->chan->sec_level != BT_SECURITY_SDP)
55 reason = ECONNREFUSED;
59 __l2cap_sock_close(sk, reason);
67 void l2cap_sock_set_timer(struct sock *sk, long timeout)
69 BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);
70 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
73 void l2cap_sock_clear_timer(struct sock *sk)
75 BT_DBG("sock %p state %d", sk, sk->sk_state);
76 sk_stop_timer(sk, &sk->sk_timer);
79 static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
82 struct hlist_node *node;
83 sk_for_each(sk, node, &l2cap_sk_list.head) {
84 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
86 if (chan->sport == psm && !bacmp(&bt_sk(sk)->src, src))
95 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
97 struct sock *sk = sock->sk;
98 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99 struct sockaddr_l2 la;
104 if (!addr || addr->sa_family != AF_BLUETOOTH)
107 memset(&la, 0, sizeof(la));
108 len = min_t(unsigned int, sizeof(la), alen);
109 memcpy(&la, addr, len);
111 if (la.l2_cid && la.l2_psm)
116 if (sk->sk_state != BT_OPEN) {
122 __u16 psm = __le16_to_cpu(la.l2_psm);
124 /* PSM must be odd and lsb of upper byte must be 0 */
125 if ((psm & 0x0101) != 0x0001) {
130 /* Restrict usage of well-known PSMs */
131 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
137 write_lock_bh(&l2cap_sk_list.lock);
139 if (la.l2_psm && __l2cap_get_sock_by_addr(la.l2_psm, &la.l2_bdaddr)) {
142 /* Save source address */
143 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
144 chan->psm = la.l2_psm;
145 chan->sport = la.l2_psm;
146 sk->sk_state = BT_BOUND;
148 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
149 __le16_to_cpu(la.l2_psm) == 0x0003)
150 chan->sec_level = BT_SECURITY_SDP;
154 chan->scid = la.l2_cid;
156 write_unlock_bh(&l2cap_sk_list.lock);
163 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
165 struct sock *sk = sock->sk;
166 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
167 struct sockaddr_l2 la;
172 if (!addr || alen < sizeof(addr->sa_family) ||
173 addr->sa_family != AF_BLUETOOTH)
176 memset(&la, 0, sizeof(la));
177 len = min_t(unsigned int, sizeof(la), alen);
178 memcpy(&la, addr, len);
180 if (la.l2_cid && la.l2_psm)
185 if ((sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM)
186 && !(la.l2_psm || la.l2_cid)) {
191 switch (chan->mode) {
192 case L2CAP_MODE_BASIC:
194 case L2CAP_MODE_ERTM:
195 case L2CAP_MODE_STREAMING:
204 switch (sk->sk_state) {
208 /* Already connecting */
212 /* Already connected */
226 /* PSM must be odd and lsb of upper byte must be 0 */
227 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 &&
228 sk->sk_type != SOCK_RAW && !la.l2_cid) {
233 /* Set destination address and psm */
234 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
235 chan->psm = la.l2_psm;
236 chan->dcid = la.l2_cid;
238 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
243 err = bt_sock_wait_state(sk, BT_CONNECTED,
244 sock_sndtimeo(sk, flags & O_NONBLOCK));
250 static int l2cap_sock_listen(struct socket *sock, int backlog)
252 struct sock *sk = sock->sk;
253 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
256 BT_DBG("sk %p backlog %d", sk, backlog);
260 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
261 || sk->sk_state != BT_BOUND) {
266 switch (chan->mode) {
267 case L2CAP_MODE_BASIC:
269 case L2CAP_MODE_ERTM:
270 case L2CAP_MODE_STREAMING:
279 if (!chan->psm && !chan->scid) {
280 bdaddr_t *src = &bt_sk(sk)->src;
285 write_lock_bh(&l2cap_sk_list.lock);
287 for (psm = 0x1001; psm < 0x1100; psm += 2)
288 if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm), src)) {
289 chan->psm = cpu_to_le16(psm);
290 chan->sport = cpu_to_le16(psm);
295 write_unlock_bh(&l2cap_sk_list.lock);
301 sk->sk_max_ack_backlog = backlog;
302 sk->sk_ack_backlog = 0;
303 sk->sk_state = BT_LISTEN;
310 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
312 DECLARE_WAITQUEUE(wait, current);
313 struct sock *sk = sock->sk, *nsk;
317 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
319 if (sk->sk_state != BT_LISTEN) {
324 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
326 BT_DBG("sk %p timeo %ld", sk, timeo);
328 /* Wait for an incoming connection. (wake-one). */
329 add_wait_queue_exclusive(sk_sleep(sk), &wait);
330 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
331 set_current_state(TASK_INTERRUPTIBLE);
338 timeo = schedule_timeout(timeo);
339 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
341 if (sk->sk_state != BT_LISTEN) {
346 if (signal_pending(current)) {
347 err = sock_intr_errno(timeo);
351 set_current_state(TASK_RUNNING);
352 remove_wait_queue(sk_sleep(sk), &wait);
357 newsock->state = SS_CONNECTED;
359 BT_DBG("new socket %p", nsk);
366 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
368 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
369 struct sock *sk = sock->sk;
370 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
372 BT_DBG("sock %p, sk %p", sock, sk);
374 addr->sa_family = AF_BLUETOOTH;
375 *len = sizeof(struct sockaddr_l2);
378 la->l2_psm = chan->psm;
379 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
380 la->l2_cid = cpu_to_le16(chan->dcid);
382 la->l2_psm = chan->sport;
383 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
384 la->l2_cid = cpu_to_le16(chan->scid);
390 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
392 struct sock *sk = sock->sk;
393 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
394 struct l2cap_options opts;
395 struct l2cap_conninfo cinfo;
401 if (get_user(len, optlen))
408 memset(&opts, 0, sizeof(opts));
409 opts.imtu = chan->imtu;
410 opts.omtu = chan->omtu;
411 opts.flush_to = chan->flush_to;
412 opts.mode = chan->mode;
413 opts.fcs = chan->fcs;
414 opts.max_tx = chan->max_tx;
415 opts.txwin_size = (__u16)chan->tx_win;
417 len = min_t(unsigned int, len, sizeof(opts));
418 if (copy_to_user(optval, (char *) &opts, len))
424 switch (chan->sec_level) {
425 case BT_SECURITY_LOW:
428 case BT_SECURITY_MEDIUM:
429 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
431 case BT_SECURITY_HIGH:
432 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
440 if (chan->role_switch)
441 opt |= L2CAP_LM_MASTER;
443 if (chan->force_reliable)
444 opt |= L2CAP_LM_RELIABLE;
446 if (put_user(opt, (u32 __user *) optval))
451 if (sk->sk_state != BT_CONNECTED &&
452 !(sk->sk_state == BT_CONNECT2 &&
453 bt_sk(sk)->defer_setup)) {
458 cinfo.hci_handle = chan->conn->hcon->handle;
459 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
461 len = min_t(unsigned int, len, sizeof(cinfo));
462 if (copy_to_user(optval, (char *) &cinfo, len))
476 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
478 struct sock *sk = sock->sk;
479 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
480 struct bt_security sec;
485 if (level == SOL_L2CAP)
486 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
488 if (level != SOL_BLUETOOTH)
491 if (get_user(len, optlen))
498 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
499 && sk->sk_type != SOCK_RAW) {
504 sec.level = chan->sec_level;
506 len = min_t(unsigned int, len, sizeof(sec));
507 if (copy_to_user(optval, (char *) &sec, len))
513 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
518 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
524 if (put_user(chan->flushable, (u32 __user *) optval))
538 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
540 struct sock *sk = sock->sk;
541 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
542 struct l2cap_options opts;
552 if (sk->sk_state == BT_CONNECTED) {
557 opts.imtu = chan->imtu;
558 opts.omtu = chan->omtu;
559 opts.flush_to = chan->flush_to;
560 opts.mode = chan->mode;
561 opts.fcs = chan->fcs;
562 opts.max_tx = chan->max_tx;
563 opts.txwin_size = (__u16)chan->tx_win;
565 len = min_t(unsigned int, sizeof(opts), optlen);
566 if (copy_from_user((char *) &opts, optval, len)) {
571 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
576 chan->mode = opts.mode;
577 switch (chan->mode) {
578 case L2CAP_MODE_BASIC:
579 chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
581 case L2CAP_MODE_ERTM:
582 case L2CAP_MODE_STREAMING:
591 chan->imtu = opts.imtu;
592 chan->omtu = opts.omtu;
593 chan->fcs = opts.fcs;
594 chan->max_tx = opts.max_tx;
595 chan->tx_win = (__u8)opts.txwin_size;
599 if (get_user(opt, (u32 __user *) optval)) {
604 if (opt & L2CAP_LM_AUTH)
605 chan->sec_level = BT_SECURITY_LOW;
606 if (opt & L2CAP_LM_ENCRYPT)
607 chan->sec_level = BT_SECURITY_MEDIUM;
608 if (opt & L2CAP_LM_SECURE)
609 chan->sec_level = BT_SECURITY_HIGH;
611 chan->role_switch = (opt & L2CAP_LM_MASTER);
612 chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
624 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
626 struct sock *sk = sock->sk;
627 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
628 struct bt_security sec;
634 if (level == SOL_L2CAP)
635 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
637 if (level != SOL_BLUETOOTH)
644 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
645 && sk->sk_type != SOCK_RAW) {
650 sec.level = BT_SECURITY_LOW;
652 len = min_t(unsigned int, sizeof(sec), optlen);
653 if (copy_from_user((char *) &sec, optval, len)) {
658 if (sec.level < BT_SECURITY_LOW ||
659 sec.level > BT_SECURITY_HIGH) {
664 chan->sec_level = sec.level;
668 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
673 if (get_user(opt, (u32 __user *) optval)) {
678 bt_sk(sk)->defer_setup = opt;
682 if (get_user(opt, (u32 __user *) optval)) {
687 if (opt > BT_FLUSHABLE_ON) {
692 if (opt == BT_FLUSHABLE_OFF) {
693 struct l2cap_conn *conn = chan->conn;
694 /* proceed futher only when we have l2cap_conn and
695 No Flush support in the LM */
696 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
702 chan->flushable = opt;
714 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
716 struct sock *sk = sock->sk;
717 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
722 BT_DBG("sock %p, sk %p", sock, sk);
724 err = sock_error(sk);
728 if (msg->msg_flags & MSG_OOB)
733 if (sk->sk_state != BT_CONNECTED) {
738 /* Connectionless channel */
739 if (sk->sk_type == SOCK_DGRAM) {
740 skb = l2cap_create_connless_pdu(chan, msg, len);
744 l2cap_do_send(chan, skb);
750 switch (chan->mode) {
751 case L2CAP_MODE_BASIC:
752 /* Check outgoing MTU */
753 if (len > chan->omtu) {
758 /* Create a basic PDU */
759 skb = l2cap_create_basic_pdu(chan, msg, len);
765 l2cap_do_send(chan, skb);
769 case L2CAP_MODE_ERTM:
770 case L2CAP_MODE_STREAMING:
771 /* Entire SDU fits into one PDU */
772 if (len <= chan->remote_mps) {
773 control = L2CAP_SDU_UNSEGMENTED;
774 skb = l2cap_create_iframe_pdu(chan, msg, len, control,
780 __skb_queue_tail(&chan->tx_q, skb);
782 if (chan->tx_send_head == NULL)
783 chan->tx_send_head = skb;
786 /* Segment SDU into multiples PDUs */
787 err = l2cap_sar_segment_sdu(chan, msg, len);
792 if (chan->mode == L2CAP_MODE_STREAMING) {
793 l2cap_streaming_send(chan);
798 if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
799 (chan->conn_state & L2CAP_CONN_WAIT_F)) {
803 err = l2cap_ertm_send(chan);
810 BT_DBG("bad state %1.1x", chan->mode);
819 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
821 struct sock *sk = sock->sk;
825 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
826 sk->sk_state = BT_CONFIG;
828 __l2cap_connect_rsp_defer(l2cap_pi(sk)->chan);
835 if (sock->type == SOCK_STREAM)
836 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
838 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
841 /* Kill socket (only if zapped and orphan)
842 * Must be called on unlocked socket.
844 void l2cap_sock_kill(struct sock *sk)
846 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
849 BT_DBG("sk %p state %d", sk, sk->sk_state);
851 /* Kill poor orphan */
852 bt_sock_unlink(&l2cap_sk_list, sk);
853 sock_set_flag(sk, SOCK_DEAD);
857 /* Must be called on unlocked socket. */
858 static void l2cap_sock_close(struct sock *sk)
860 l2cap_sock_clear_timer(sk);
862 __l2cap_sock_close(sk, ECONNRESET);
867 static void l2cap_sock_cleanup_listen(struct sock *parent)
871 BT_DBG("parent %p", parent);
873 /* Close not yet accepted channels */
874 while ((sk = bt_accept_dequeue(parent, NULL)))
875 l2cap_sock_close(sk);
877 parent->sk_state = BT_CLOSED;
878 sock_set_flag(parent, SOCK_ZAPPED);
881 void __l2cap_sock_close(struct sock *sk, int reason)
883 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
884 struct l2cap_conn *conn = chan->conn;
886 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
888 switch (sk->sk_state) {
890 l2cap_sock_cleanup_listen(sk);
895 if ((sk->sk_type == SOCK_SEQPACKET ||
896 sk->sk_type == SOCK_STREAM) &&
897 conn->hcon->type == ACL_LINK) {
898 l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
899 l2cap_send_disconn_req(conn, chan, reason);
901 l2cap_chan_del(chan, reason);
905 if ((sk->sk_type == SOCK_SEQPACKET ||
906 sk->sk_type == SOCK_STREAM) &&
907 conn->hcon->type == ACL_LINK) {
908 struct l2cap_conn_rsp rsp;
911 if (bt_sk(sk)->defer_setup)
912 result = L2CAP_CR_SEC_BLOCK;
914 result = L2CAP_CR_BAD_PSM;
916 rsp.scid = cpu_to_le16(chan->dcid);
917 rsp.dcid = cpu_to_le16(chan->scid);
918 rsp.result = cpu_to_le16(result);
919 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
920 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
924 l2cap_chan_del(chan, reason);
929 l2cap_chan_del(chan, reason);
933 sock_set_flag(sk, SOCK_ZAPPED);
938 static int l2cap_sock_shutdown(struct socket *sock, int how)
940 struct sock *sk = sock->sk;
941 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
944 BT_DBG("sock %p, sk %p", sock, sk);
950 if (!sk->sk_shutdown) {
951 if (chan->mode == L2CAP_MODE_ERTM)
952 err = __l2cap_wait_ack(sk);
954 sk->sk_shutdown = SHUTDOWN_MASK;
955 l2cap_sock_clear_timer(sk);
956 __l2cap_sock_close(sk, 0);
958 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
959 err = bt_sock_wait_state(sk, BT_CLOSED,
963 if (!err && sk->sk_err)
970 static int l2cap_sock_release(struct socket *sock)
972 struct sock *sk = sock->sk;
975 BT_DBG("sock %p, sk %p", sock, sk);
980 err = l2cap_sock_shutdown(sock, 2);
987 static void l2cap_sock_destruct(struct sock *sk)
991 skb_queue_purge(&sk->sk_receive_queue);
992 skb_queue_purge(&sk->sk_write_queue);
995 void l2cap_sock_init(struct sock *sk, struct sock *parent)
997 struct l2cap_pinfo *pi = l2cap_pi(sk);
998 struct l2cap_chan *chan = pi->chan;
1000 BT_DBG("sk %p", sk);
1003 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1005 sk->sk_type = parent->sk_type;
1006 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
1008 chan->imtu = pchan->imtu;
1009 chan->omtu = pchan->omtu;
1010 chan->conf_state = pchan->conf_state;
1011 chan->mode = pchan->mode;
1012 chan->fcs = pchan->fcs;
1013 chan->max_tx = pchan->max_tx;
1014 chan->tx_win = pchan->tx_win;
1015 chan->sec_level = pchan->sec_level;
1016 chan->role_switch = pchan->role_switch;
1017 chan->force_reliable = pchan->force_reliable;
1018 chan->flushable = pchan->flushable;
1020 chan->imtu = L2CAP_DEFAULT_MTU;
1022 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1023 chan->mode = L2CAP_MODE_ERTM;
1024 chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
1026 chan->mode = L2CAP_MODE_BASIC;
1028 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
1029 chan->fcs = L2CAP_FCS_CRC16;
1030 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1031 chan->sec_level = BT_SECURITY_LOW;
1032 chan->role_switch = 0;
1033 chan->force_reliable = 0;
1034 chan->flushable = BT_FLUSHABLE_OFF;
1037 /* Default config options */
1038 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1041 static struct proto l2cap_proto = {
1043 .owner = THIS_MODULE,
1044 .obj_size = sizeof(struct l2cap_pinfo)
1047 struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1051 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1055 sock_init_data(sock, sk);
1056 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1058 sk->sk_destruct = l2cap_sock_destruct;
1059 sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
1061 sock_reset_flag(sk, SOCK_ZAPPED);
1063 sk->sk_protocol = proto;
1064 sk->sk_state = BT_OPEN;
1066 setup_timer(&sk->sk_timer, l2cap_sock_timeout, (unsigned long) sk);
1068 bt_sock_link(&l2cap_sk_list, sk);
1072 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1076 struct l2cap_chan *chan;
1078 BT_DBG("sock %p", sock);
1080 sock->state = SS_UNCONNECTED;
1082 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1083 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1084 return -ESOCKTNOSUPPORT;
1086 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1089 sock->ops = &l2cap_sock_ops;
1091 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1095 chan = l2cap_chan_alloc(sk);
1097 l2cap_sock_kill(sk);
1101 l2cap_pi(sk)->chan = chan;
1103 l2cap_sock_init(sk, NULL);
1107 const struct proto_ops l2cap_sock_ops = {
1108 .family = PF_BLUETOOTH,
1109 .owner = THIS_MODULE,
1110 .release = l2cap_sock_release,
1111 .bind = l2cap_sock_bind,
1112 .connect = l2cap_sock_connect,
1113 .listen = l2cap_sock_listen,
1114 .accept = l2cap_sock_accept,
1115 .getname = l2cap_sock_getname,
1116 .sendmsg = l2cap_sock_sendmsg,
1117 .recvmsg = l2cap_sock_recvmsg,
1118 .poll = bt_sock_poll,
1119 .ioctl = bt_sock_ioctl,
1120 .mmap = sock_no_mmap,
1121 .socketpair = sock_no_socketpair,
1122 .shutdown = l2cap_sock_shutdown,
1123 .setsockopt = l2cap_sock_setsockopt,
1124 .getsockopt = l2cap_sock_getsockopt
1127 static const struct net_proto_family l2cap_sock_family_ops = {
1128 .family = PF_BLUETOOTH,
1129 .owner = THIS_MODULE,
1130 .create = l2cap_sock_create,
1133 int __init l2cap_init_sockets(void)
1137 err = proto_register(&l2cap_proto, 0);
1141 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1145 BT_INFO("L2CAP socket layer initialized");
1150 BT_ERR("L2CAP socket registration failed");
1151 proto_unregister(&l2cap_proto);
1155 void l2cap_cleanup_sockets(void)
1157 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1158 BT_ERR("L2CAP socket unregistration failed");
1160 proto_unregister(&l2cap_proto);