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>
32 #include <net/bluetooth/smp.h>
34 static const struct proto_ops l2cap_sock_ops;
35 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
36 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
38 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
40 struct sock *sk = sock->sk;
41 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
42 struct sockaddr_l2 la;
47 if (!addr || addr->sa_family != AF_BLUETOOTH)
50 memset(&la, 0, sizeof(la));
51 len = min_t(unsigned int, sizeof(la), alen);
52 memcpy(&la, addr, len);
54 if (la.l2_cid && la.l2_psm)
59 if (sk->sk_state != BT_OPEN) {
65 __u16 psm = __le16_to_cpu(la.l2_psm);
67 /* PSM must be odd and lsb of upper byte must be 0 */
68 if ((psm & 0x0101) != 0x0001) {
73 /* Restrict usage of well-known PSMs */
74 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
81 err = l2cap_add_scid(chan, la.l2_cid);
83 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
88 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
89 __le16_to_cpu(la.l2_psm) == 0x0003)
90 chan->sec_level = BT_SECURITY_SDP;
92 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
94 chan->state = BT_BOUND;
95 sk->sk_state = BT_BOUND;
102 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
104 struct sock *sk = sock->sk;
105 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
106 struct sockaddr_l2 la;
111 if (!addr || alen < sizeof(addr->sa_family) ||
112 addr->sa_family != AF_BLUETOOTH)
115 memset(&la, 0, sizeof(la));
116 len = min_t(unsigned int, sizeof(la), alen);
117 memcpy(&la, addr, len);
119 if (la.l2_cid && la.l2_psm)
124 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
125 && !(la.l2_psm || la.l2_cid)) {
130 switch (chan->mode) {
131 case L2CAP_MODE_BASIC:
133 case L2CAP_MODE_ERTM:
134 case L2CAP_MODE_STREAMING:
143 switch (sk->sk_state) {
147 /* Already connecting */
151 /* Already connected */
165 /* PSM must be odd and lsb of upper byte must be 0 */
166 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
167 chan->chan_type != L2CAP_CHAN_RAW) {
172 /* Set destination address and psm */
173 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
174 chan->psm = la.l2_psm;
175 chan->dcid = la.l2_cid;
177 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
182 err = bt_sock_wait_state(sk, BT_CONNECTED,
183 sock_sndtimeo(sk, flags & O_NONBLOCK));
189 static int l2cap_sock_listen(struct socket *sock, int backlog)
191 struct sock *sk = sock->sk;
192 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
195 BT_DBG("sk %p backlog %d", sk, backlog);
199 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
200 || sk->sk_state != BT_BOUND) {
205 switch (chan->mode) {
206 case L2CAP_MODE_BASIC:
208 case L2CAP_MODE_ERTM:
209 case L2CAP_MODE_STREAMING:
218 sk->sk_max_ack_backlog = backlog;
219 sk->sk_ack_backlog = 0;
221 chan->state = BT_LISTEN;
222 sk->sk_state = BT_LISTEN;
229 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
231 DECLARE_WAITQUEUE(wait, current);
232 struct sock *sk = sock->sk, *nsk;
236 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
238 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
240 BT_DBG("sk %p timeo %ld", sk, timeo);
242 /* Wait for an incoming connection. (wake-one). */
243 add_wait_queue_exclusive(sk_sleep(sk), &wait);
245 set_current_state(TASK_INTERRUPTIBLE);
247 if (sk->sk_state != BT_LISTEN) {
252 nsk = bt_accept_dequeue(sk, newsock);
261 if (signal_pending(current)) {
262 err = sock_intr_errno(timeo);
267 timeo = schedule_timeout(timeo);
268 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
270 __set_current_state(TASK_RUNNING);
271 remove_wait_queue(sk_sleep(sk), &wait);
276 newsock->state = SS_CONNECTED;
278 BT_DBG("new socket %p", nsk);
285 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
287 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
288 struct sock *sk = sock->sk;
289 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
291 BT_DBG("sock %p, sk %p", sock, sk);
293 addr->sa_family = AF_BLUETOOTH;
294 *len = sizeof(struct sockaddr_l2);
297 la->l2_psm = chan->psm;
298 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
299 la->l2_cid = cpu_to_le16(chan->dcid);
301 la->l2_psm = chan->sport;
302 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
303 la->l2_cid = cpu_to_le16(chan->scid);
309 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
311 struct sock *sk = sock->sk;
312 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
313 struct l2cap_options opts;
314 struct l2cap_conninfo cinfo;
320 if (get_user(len, optlen))
327 memset(&opts, 0, sizeof(opts));
328 opts.imtu = chan->imtu;
329 opts.omtu = chan->omtu;
330 opts.flush_to = chan->flush_to;
331 opts.mode = chan->mode;
332 opts.fcs = chan->fcs;
333 opts.max_tx = chan->max_tx;
334 opts.txwin_size = chan->tx_win;
336 len = min_t(unsigned int, len, sizeof(opts));
337 if (copy_to_user(optval, (char *) &opts, len))
343 switch (chan->sec_level) {
344 case BT_SECURITY_LOW:
347 case BT_SECURITY_MEDIUM:
348 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
350 case BT_SECURITY_HIGH:
351 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
359 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
360 opt |= L2CAP_LM_MASTER;
362 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
363 opt |= L2CAP_LM_RELIABLE;
365 if (put_user(opt, (u32 __user *) optval))
370 if (sk->sk_state != BT_CONNECTED &&
371 !(sk->sk_state == BT_CONNECT2 &&
372 bt_sk(sk)->defer_setup)) {
377 memset(&cinfo, 0, sizeof(cinfo));
378 cinfo.hci_handle = chan->conn->hcon->handle;
379 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
381 len = min_t(unsigned int, len, sizeof(cinfo));
382 if (copy_to_user(optval, (char *) &cinfo, len))
396 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
398 struct sock *sk = sock->sk;
399 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
400 struct bt_security sec;
406 if (level == SOL_L2CAP)
407 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
409 if (level != SOL_BLUETOOTH)
412 if (get_user(len, optlen))
419 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
420 chan->chan_type != L2CAP_CHAN_RAW) {
425 memset(&sec, 0, sizeof(sec));
426 sec.level = chan->sec_level;
428 if (sk->sk_state == BT_CONNECTED)
429 sec.key_size = chan->conn->hcon->enc_key_size;
431 len = min_t(unsigned int, len, sizeof(sec));
432 if (copy_to_user(optval, (char *) &sec, len))
438 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
443 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
449 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
450 (u32 __user *) optval))
456 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
457 && sk->sk_type != SOCK_RAW) {
462 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
464 len = min_t(unsigned int, len, sizeof(pwr));
465 if (copy_to_user(optval, (char *) &pwr, len))
479 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
481 struct sock *sk = sock->sk;
482 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
483 struct l2cap_options opts;
493 if (sk->sk_state == BT_CONNECTED) {
498 opts.imtu = chan->imtu;
499 opts.omtu = chan->omtu;
500 opts.flush_to = chan->flush_to;
501 opts.mode = chan->mode;
502 opts.fcs = chan->fcs;
503 opts.max_tx = chan->max_tx;
504 opts.txwin_size = chan->tx_win;
506 len = min_t(unsigned int, sizeof(opts), optlen);
507 if (copy_from_user((char *) &opts, optval, len)) {
512 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
517 chan->mode = opts.mode;
518 switch (chan->mode) {
519 case L2CAP_MODE_BASIC:
520 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
522 case L2CAP_MODE_ERTM:
523 case L2CAP_MODE_STREAMING:
532 chan->imtu = opts.imtu;
533 chan->omtu = opts.omtu;
534 chan->fcs = opts.fcs;
535 chan->max_tx = opts.max_tx;
536 chan->tx_win = opts.txwin_size;
540 if (get_user(opt, (u32 __user *) optval)) {
545 if (opt & L2CAP_LM_AUTH)
546 chan->sec_level = BT_SECURITY_LOW;
547 if (opt & L2CAP_LM_ENCRYPT)
548 chan->sec_level = BT_SECURITY_MEDIUM;
549 if (opt & L2CAP_LM_SECURE)
550 chan->sec_level = BT_SECURITY_HIGH;
552 if (opt & L2CAP_LM_MASTER)
553 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
555 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
557 if (opt & L2CAP_LM_RELIABLE)
558 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
560 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
572 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
574 struct sock *sk = sock->sk;
575 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
576 struct bt_security sec;
578 struct l2cap_conn *conn;
584 if (level == SOL_L2CAP)
585 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
587 if (level != SOL_BLUETOOTH)
594 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
595 chan->chan_type != L2CAP_CHAN_RAW) {
600 sec.level = BT_SECURITY_LOW;
602 len = min_t(unsigned int, sizeof(sec), optlen);
603 if (copy_from_user((char *) &sec, optval, len)) {
608 if (sec.level < BT_SECURITY_LOW ||
609 sec.level > BT_SECURITY_HIGH) {
614 chan->sec_level = sec.level;
617 if (conn && chan->scid == L2CAP_CID_LE_DATA) {
618 if (!conn->hcon->out) {
623 if (smp_conn_security(conn, sec.level))
627 sk->sk_state = BT_CONFIG;
632 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
637 if (get_user(opt, (u32 __user *) optval)) {
642 bt_sk(sk)->defer_setup = opt;
646 if (get_user(opt, (u32 __user *) optval)) {
651 if (opt > BT_FLUSHABLE_ON) {
656 if (opt == BT_FLUSHABLE_OFF) {
657 struct l2cap_conn *conn = chan->conn;
658 /* proceed further only when we have l2cap_conn and
659 No Flush support in the LM */
660 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
667 set_bit(FLAG_FLUSHABLE, &chan->flags);
669 clear_bit(FLAG_FLUSHABLE, &chan->flags);
673 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
674 chan->chan_type != L2CAP_CHAN_RAW) {
679 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
681 len = min_t(unsigned int, sizeof(pwr), optlen);
682 if (copy_from_user((char *) &pwr, optval, len)) {
687 if (pwr.force_active)
688 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
690 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
702 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
704 struct sock *sk = sock->sk;
705 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
708 BT_DBG("sock %p, sk %p", sock, sk);
710 err = sock_error(sk);
714 if (msg->msg_flags & MSG_OOB)
719 if (sk->sk_state != BT_CONNECTED) {
724 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
730 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
732 struct sock *sk = sock->sk;
733 struct l2cap_pinfo *pi = l2cap_pi(sk);
738 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
739 sk->sk_state = BT_CONFIG;
741 __l2cap_connect_rsp_defer(pi->chan);
748 if (sock->type == SOCK_STREAM)
749 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
751 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
753 if (pi->chan->mode != L2CAP_MODE_ERTM)
756 /* Attempt to put pending rx data in the socket buffer */
760 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
763 if (pi->rx_busy_skb) {
764 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
765 pi->rx_busy_skb = NULL;
770 /* Restore data flow when half of the receive buffer is
771 * available. This avoids resending large numbers of
774 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
775 l2cap_chan_busy(pi->chan, 0);
782 /* Kill socket (only if zapped and orphan)
783 * Must be called on unlocked socket.
785 static void l2cap_sock_kill(struct sock *sk)
787 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
790 BT_DBG("sk %p state %d", sk, sk->sk_state);
792 /* Kill poor orphan */
794 l2cap_chan_destroy(l2cap_pi(sk)->chan);
795 sock_set_flag(sk, SOCK_DEAD);
799 static int l2cap_sock_shutdown(struct socket *sock, int how)
801 struct sock *sk = sock->sk;
802 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
805 BT_DBG("sock %p, sk %p", sock, sk);
811 if (!sk->sk_shutdown) {
812 if (chan->mode == L2CAP_MODE_ERTM)
813 err = __l2cap_wait_ack(sk);
815 sk->sk_shutdown = SHUTDOWN_MASK;
816 l2cap_chan_close(chan, 0);
818 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
819 err = bt_sock_wait_state(sk, BT_CLOSED,
823 if (!err && sk->sk_err)
830 static int l2cap_sock_release(struct socket *sock)
832 struct sock *sk = sock->sk;
835 BT_DBG("sock %p, sk %p", sock, sk);
840 err = l2cap_sock_shutdown(sock, 2);
847 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
849 struct sock *sk, *parent = data;
851 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
856 l2cap_sock_init(sk, parent);
858 return l2cap_pi(sk)->chan;
861 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
864 struct sock *sk = data;
865 struct l2cap_pinfo *pi = l2cap_pi(sk);
870 err = sock_queue_rcv_skb(sk, skb);
872 /* For ERTM, handle one skb that doesn't fit into the recv
873 * buffer. This is important to do because the data frames
874 * have already been acked, so the skb cannot be discarded.
876 * Notify the l2cap core that the buffer is full, so the
877 * LOCAL_BUSY state is entered and no more frames are
878 * acked and reassembled until there is buffer space
881 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
882 pi->rx_busy_skb = skb;
883 l2cap_chan_busy(pi->chan, 1);
890 static void l2cap_sock_close_cb(void *data)
892 struct sock *sk = data;
897 static void l2cap_sock_state_change_cb(void *data, int state)
899 struct sock *sk = data;
901 sk->sk_state = state;
904 static struct l2cap_ops l2cap_chan_ops = {
905 .name = "L2CAP Socket Interface",
906 .new_connection = l2cap_sock_new_connection_cb,
907 .recv = l2cap_sock_recv_cb,
908 .close = l2cap_sock_close_cb,
909 .state_change = l2cap_sock_state_change_cb,
912 static void l2cap_sock_destruct(struct sock *sk)
916 if (l2cap_pi(sk)->rx_busy_skb) {
917 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
918 l2cap_pi(sk)->rx_busy_skb = NULL;
921 skb_queue_purge(&sk->sk_receive_queue);
922 skb_queue_purge(&sk->sk_write_queue);
925 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
927 struct l2cap_pinfo *pi = l2cap_pi(sk);
928 struct l2cap_chan *chan = pi->chan;
933 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
935 sk->sk_type = parent->sk_type;
936 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
938 chan->chan_type = pchan->chan_type;
939 chan->imtu = pchan->imtu;
940 chan->omtu = pchan->omtu;
941 chan->conf_state = pchan->conf_state;
942 chan->mode = pchan->mode;
943 chan->fcs = pchan->fcs;
944 chan->max_tx = pchan->max_tx;
945 chan->tx_win = pchan->tx_win;
946 chan->sec_level = pchan->sec_level;
947 chan->flags = pchan->flags;
950 switch (sk->sk_type) {
952 chan->chan_type = L2CAP_CHAN_RAW;
955 chan->chan_type = L2CAP_CHAN_CONN_LESS;
959 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
963 chan->imtu = L2CAP_DEFAULT_MTU;
965 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
966 chan->mode = L2CAP_MODE_ERTM;
967 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
969 chan->mode = L2CAP_MODE_BASIC;
971 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
972 chan->fcs = L2CAP_FCS_CRC16;
973 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
974 chan->sec_level = BT_SECURITY_LOW;
976 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
979 /* Default config options */
980 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
983 chan->ops = &l2cap_chan_ops;
986 static struct proto l2cap_proto = {
988 .owner = THIS_MODULE,
989 .obj_size = sizeof(struct l2cap_pinfo)
992 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
995 struct l2cap_chan *chan;
997 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1001 sock_init_data(sock, sk);
1002 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1004 sk->sk_destruct = l2cap_sock_destruct;
1005 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1007 sock_reset_flag(sk, SOCK_ZAPPED);
1009 sk->sk_protocol = proto;
1010 sk->sk_state = BT_OPEN;
1012 chan = l2cap_chan_create(sk);
1014 l2cap_sock_kill(sk);
1018 l2cap_pi(sk)->chan = chan;
1023 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1028 BT_DBG("sock %p", sock);
1030 sock->state = SS_UNCONNECTED;
1032 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1033 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1034 return -ESOCKTNOSUPPORT;
1036 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1039 sock->ops = &l2cap_sock_ops;
1041 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1045 l2cap_sock_init(sk, NULL);
1049 static const struct proto_ops l2cap_sock_ops = {
1050 .family = PF_BLUETOOTH,
1051 .owner = THIS_MODULE,
1052 .release = l2cap_sock_release,
1053 .bind = l2cap_sock_bind,
1054 .connect = l2cap_sock_connect,
1055 .listen = l2cap_sock_listen,
1056 .accept = l2cap_sock_accept,
1057 .getname = l2cap_sock_getname,
1058 .sendmsg = l2cap_sock_sendmsg,
1059 .recvmsg = l2cap_sock_recvmsg,
1060 .poll = bt_sock_poll,
1061 .ioctl = bt_sock_ioctl,
1062 .mmap = sock_no_mmap,
1063 .socketpair = sock_no_socketpair,
1064 .shutdown = l2cap_sock_shutdown,
1065 .setsockopt = l2cap_sock_setsockopt,
1066 .getsockopt = l2cap_sock_getsockopt
1069 static const struct net_proto_family l2cap_sock_family_ops = {
1070 .family = PF_BLUETOOTH,
1071 .owner = THIS_MODULE,
1072 .create = l2cap_sock_create,
1075 int __init l2cap_init_sockets(void)
1079 err = proto_register(&l2cap_proto, 0);
1083 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1087 BT_INFO("L2CAP socket layer initialized");
1092 BT_ERR("L2CAP socket registration failed");
1093 proto_unregister(&l2cap_proto);
1097 void l2cap_cleanup_sockets(void)
1099 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1100 BT_ERR("L2CAP socket unregistration failed");
1102 proto_unregister(&l2cap_proto);