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);
130 err = bt_sock_wait_state(sk, BT_CONNECTED,
131 sock_sndtimeo(sk, flags & O_NONBLOCK));
133 if (sock_owned_by_user(sk))
138 static int l2cap_sock_listen(struct socket *sock, int backlog)
140 struct sock *sk = sock->sk;
141 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
144 BT_DBG("sk %p backlog %d", sk, backlog);
148 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
149 || sk->sk_state != BT_BOUND) {
154 switch (chan->mode) {
155 case L2CAP_MODE_BASIC:
157 case L2CAP_MODE_ERTM:
158 case L2CAP_MODE_STREAMING:
167 sk->sk_max_ack_backlog = backlog;
168 sk->sk_ack_backlog = 0;
170 chan->state = BT_LISTEN;
171 sk->sk_state = BT_LISTEN;
178 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
180 DECLARE_WAITQUEUE(wait, current);
181 struct sock *sk = sock->sk, *nsk;
185 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
187 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
189 BT_DBG("sk %p timeo %ld", sk, timeo);
191 /* Wait for an incoming connection. (wake-one). */
192 add_wait_queue_exclusive(sk_sleep(sk), &wait);
194 set_current_state(TASK_INTERRUPTIBLE);
196 if (sk->sk_state != BT_LISTEN) {
201 nsk = bt_accept_dequeue(sk, newsock);
210 if (signal_pending(current)) {
211 err = sock_intr_errno(timeo);
216 timeo = schedule_timeout(timeo);
217 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
219 __set_current_state(TASK_RUNNING);
220 remove_wait_queue(sk_sleep(sk), &wait);
225 newsock->state = SS_CONNECTED;
227 BT_DBG("new socket %p", nsk);
234 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
236 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
237 struct sock *sk = sock->sk;
238 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
240 BT_DBG("sock %p, sk %p", sock, sk);
242 addr->sa_family = AF_BLUETOOTH;
243 *len = sizeof(struct sockaddr_l2);
246 la->l2_psm = chan->psm;
247 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
248 la->l2_cid = cpu_to_le16(chan->dcid);
250 la->l2_psm = chan->sport;
251 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
252 la->l2_cid = cpu_to_le16(chan->scid);
258 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
260 struct sock *sk = sock->sk;
261 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
262 struct l2cap_options opts;
263 struct l2cap_conninfo cinfo;
269 if (get_user(len, optlen))
276 memset(&opts, 0, sizeof(opts));
277 opts.imtu = chan->imtu;
278 opts.omtu = chan->omtu;
279 opts.flush_to = chan->flush_to;
280 opts.mode = chan->mode;
281 opts.fcs = chan->fcs;
282 opts.max_tx = chan->max_tx;
283 opts.txwin_size = chan->tx_win;
285 len = min_t(unsigned int, len, sizeof(opts));
286 if (copy_to_user(optval, (char *) &opts, len))
292 switch (chan->sec_level) {
293 case BT_SECURITY_LOW:
296 case BT_SECURITY_MEDIUM:
297 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
299 case BT_SECURITY_HIGH:
300 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
308 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
309 opt |= L2CAP_LM_MASTER;
311 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
312 opt |= L2CAP_LM_RELIABLE;
314 if (put_user(opt, (u32 __user *) optval))
319 if (sk->sk_state != BT_CONNECTED &&
320 !(sk->sk_state == BT_CONNECT2 &&
321 bt_sk(sk)->defer_setup)) {
326 memset(&cinfo, 0, sizeof(cinfo));
327 cinfo.hci_handle = chan->conn->hcon->handle;
328 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
330 len = min_t(unsigned int, len, sizeof(cinfo));
331 if (copy_to_user(optval, (char *) &cinfo, len))
345 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
347 struct sock *sk = sock->sk;
348 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
349 struct bt_security sec;
355 if (level == SOL_L2CAP)
356 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
358 if (level != SOL_BLUETOOTH)
361 if (get_user(len, optlen))
368 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
369 chan->chan_type != L2CAP_CHAN_RAW) {
374 memset(&sec, 0, sizeof(sec));
375 sec.level = chan->sec_level;
377 if (sk->sk_state == BT_CONNECTED)
378 sec.key_size = chan->conn->hcon->enc_key_size;
380 len = min_t(unsigned int, len, sizeof(sec));
381 if (copy_to_user(optval, (char *) &sec, len))
387 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
392 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
398 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
399 (u32 __user *) optval))
405 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
406 && sk->sk_type != SOCK_RAW) {
411 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
413 len = min_t(unsigned int, len, sizeof(pwr));
414 if (copy_to_user(optval, (char *) &pwr, len))
419 case BT_CHANNEL_POLICY:
425 if (put_user(chan->chan_policy, (u32 __user *) optval))
438 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
440 struct sock *sk = sock->sk;
441 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
442 struct l2cap_options opts;
452 if (sk->sk_state == BT_CONNECTED) {
457 opts.imtu = chan->imtu;
458 opts.omtu = chan->omtu;
459 opts.flush_to = chan->flush_to;
460 opts.mode = chan->mode;
461 opts.fcs = chan->fcs;
462 opts.max_tx = chan->max_tx;
463 opts.txwin_size = chan->tx_win;
465 len = min_t(unsigned int, sizeof(opts), optlen);
466 if (copy_from_user((char *) &opts, optval, len)) {
471 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
476 chan->mode = opts.mode;
477 switch (chan->mode) {
478 case L2CAP_MODE_BASIC:
479 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
481 case L2CAP_MODE_ERTM:
482 case L2CAP_MODE_STREAMING:
491 chan->imtu = opts.imtu;
492 chan->omtu = opts.omtu;
493 chan->fcs = opts.fcs;
494 chan->max_tx = opts.max_tx;
495 chan->tx_win = opts.txwin_size;
499 if (get_user(opt, (u32 __user *) optval)) {
504 if (opt & L2CAP_LM_AUTH)
505 chan->sec_level = BT_SECURITY_LOW;
506 if (opt & L2CAP_LM_ENCRYPT)
507 chan->sec_level = BT_SECURITY_MEDIUM;
508 if (opt & L2CAP_LM_SECURE)
509 chan->sec_level = BT_SECURITY_HIGH;
511 if (opt & L2CAP_LM_MASTER)
512 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
514 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
516 if (opt & L2CAP_LM_RELIABLE)
517 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
519 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
531 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
533 struct sock *sk = sock->sk;
534 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
535 struct bt_security sec;
537 struct l2cap_conn *conn;
543 if (level == SOL_L2CAP)
544 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
546 if (level != SOL_BLUETOOTH)
553 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
554 chan->chan_type != L2CAP_CHAN_RAW) {
559 sec.level = BT_SECURITY_LOW;
561 len = min_t(unsigned int, sizeof(sec), optlen);
562 if (copy_from_user((char *) &sec, optval, len)) {
567 if (sec.level < BT_SECURITY_LOW ||
568 sec.level > BT_SECURITY_HIGH) {
573 chan->sec_level = sec.level;
580 /*change security for LE channels */
581 if (chan->scid == L2CAP_CID_LE_DATA) {
582 if (!conn->hcon->out) {
587 if (smp_conn_security(conn, sec.level))
589 sk->sk_state = BT_CONFIG;
591 /* or for ACL link, under defer_setup time */
592 } else if (sk->sk_state == BT_CONNECT2 &&
593 bt_sk(sk)->defer_setup) {
594 err = l2cap_chan_check_security(chan);
601 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
606 if (get_user(opt, (u32 __user *) optval)) {
611 bt_sk(sk)->defer_setup = opt;
615 if (get_user(opt, (u32 __user *) optval)) {
620 if (opt > BT_FLUSHABLE_ON) {
625 if (opt == BT_FLUSHABLE_OFF) {
626 struct l2cap_conn *conn = chan->conn;
627 /* proceed further only when we have l2cap_conn and
628 No Flush support in the LM */
629 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
636 set_bit(FLAG_FLUSHABLE, &chan->flags);
638 clear_bit(FLAG_FLUSHABLE, &chan->flags);
642 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
643 chan->chan_type != L2CAP_CHAN_RAW) {
648 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
650 len = min_t(unsigned int, sizeof(pwr), optlen);
651 if (copy_from_user((char *) &pwr, optval, len)) {
656 if (pwr.force_active)
657 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
659 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
662 case BT_CHANNEL_POLICY:
668 if (get_user(opt, (u32 __user *) optval)) {
673 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
678 if (chan->mode != L2CAP_MODE_ERTM &&
679 chan->mode != L2CAP_MODE_STREAMING) {
684 chan->chan_policy = (u8) opt;
696 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
698 struct sock *sk = sock->sk;
699 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
702 BT_DBG("sock %p, sk %p", sock, sk);
704 err = sock_error(sk);
708 if (msg->msg_flags & MSG_OOB)
713 if (sk->sk_state != BT_CONNECTED) {
718 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
724 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
726 struct sock *sk = sock->sk;
727 struct l2cap_pinfo *pi = l2cap_pi(sk);
732 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
733 sk->sk_state = BT_CONFIG;
735 __l2cap_connect_rsp_defer(pi->chan);
742 if (sock->type == SOCK_STREAM)
743 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
745 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
747 if (pi->chan->mode != L2CAP_MODE_ERTM)
750 /* Attempt to put pending rx data in the socket buffer */
754 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
757 if (pi->rx_busy_skb) {
758 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
759 pi->rx_busy_skb = NULL;
764 /* Restore data flow when half of the receive buffer is
765 * available. This avoids resending large numbers of
768 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
769 l2cap_chan_busy(pi->chan, 0);
776 /* Kill socket (only if zapped and orphan)
777 * Must be called on unlocked socket.
779 static void l2cap_sock_kill(struct sock *sk)
781 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
784 BT_DBG("sk %p state %d", sk, sk->sk_state);
786 /* Kill poor orphan */
788 l2cap_chan_destroy(l2cap_pi(sk)->chan);
789 sock_set_flag(sk, SOCK_DEAD);
793 static int l2cap_sock_shutdown(struct socket *sock, int how)
795 struct sock *sk = sock->sk;
796 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
799 BT_DBG("sock %p, sk %p", sock, sk);
805 if (!sk->sk_shutdown) {
806 if (chan->mode == L2CAP_MODE_ERTM)
807 err = __l2cap_wait_ack(sk);
809 sk->sk_shutdown = SHUTDOWN_MASK;
810 l2cap_chan_close(chan, 0);
812 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
813 err = bt_sock_wait_state(sk, BT_CLOSED,
817 if (!err && sk->sk_err)
824 static int l2cap_sock_release(struct socket *sock)
826 struct sock *sk = sock->sk;
829 BT_DBG("sock %p, sk %p", sock, sk);
834 err = l2cap_sock_shutdown(sock, 2);
841 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
843 struct sock *sk, *parent = data;
845 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
850 l2cap_sock_init(sk, parent);
852 return l2cap_pi(sk)->chan;
855 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
858 struct sock *sk = data;
859 struct l2cap_pinfo *pi = l2cap_pi(sk);
864 err = sock_queue_rcv_skb(sk, skb);
866 /* For ERTM, handle one skb that doesn't fit into the recv
867 * buffer. This is important to do because the data frames
868 * have already been acked, so the skb cannot be discarded.
870 * Notify the l2cap core that the buffer is full, so the
871 * LOCAL_BUSY state is entered and no more frames are
872 * acked and reassembled until there is buffer space
875 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
876 pi->rx_busy_skb = skb;
877 l2cap_chan_busy(pi->chan, 1);
884 static void l2cap_sock_close_cb(void *data)
886 struct sock *sk = data;
891 static void l2cap_sock_state_change_cb(void *data, int state)
893 struct sock *sk = data;
895 sk->sk_state = state;
898 static struct l2cap_ops l2cap_chan_ops = {
899 .name = "L2CAP Socket Interface",
900 .new_connection = l2cap_sock_new_connection_cb,
901 .recv = l2cap_sock_recv_cb,
902 .close = l2cap_sock_close_cb,
903 .state_change = l2cap_sock_state_change_cb,
906 static void l2cap_sock_destruct(struct sock *sk)
910 if (l2cap_pi(sk)->rx_busy_skb) {
911 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
912 l2cap_pi(sk)->rx_busy_skb = NULL;
915 skb_queue_purge(&sk->sk_receive_queue);
916 skb_queue_purge(&sk->sk_write_queue);
919 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
921 struct l2cap_pinfo *pi = l2cap_pi(sk);
922 struct l2cap_chan *chan = pi->chan;
927 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
929 sk->sk_type = parent->sk_type;
930 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
932 chan->chan_type = pchan->chan_type;
933 chan->imtu = pchan->imtu;
934 chan->omtu = pchan->omtu;
935 chan->conf_state = pchan->conf_state;
936 chan->mode = pchan->mode;
937 chan->fcs = pchan->fcs;
938 chan->max_tx = pchan->max_tx;
939 chan->tx_win = pchan->tx_win;
940 chan->tx_win_max = pchan->tx_win_max;
941 chan->sec_level = pchan->sec_level;
942 chan->flags = pchan->flags;
944 security_sk_clone(parent, sk);
947 switch (sk->sk_type) {
949 chan->chan_type = L2CAP_CHAN_RAW;
952 chan->chan_type = L2CAP_CHAN_CONN_LESS;
956 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
960 chan->imtu = L2CAP_DEFAULT_MTU;
962 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
963 chan->mode = L2CAP_MODE_ERTM;
964 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
966 chan->mode = L2CAP_MODE_BASIC;
968 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
969 chan->fcs = L2CAP_FCS_CRC16;
970 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
971 chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
972 chan->sec_level = BT_SECURITY_LOW;
974 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
977 /* Default config options */
978 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
981 chan->ops = &l2cap_chan_ops;
984 static struct proto l2cap_proto = {
986 .owner = THIS_MODULE,
987 .obj_size = sizeof(struct l2cap_pinfo)
990 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
993 struct l2cap_chan *chan;
995 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
999 sock_init_data(sock, sk);
1000 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1002 sk->sk_destruct = l2cap_sock_destruct;
1003 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1005 sock_reset_flag(sk, SOCK_ZAPPED);
1007 sk->sk_protocol = proto;
1008 sk->sk_state = BT_OPEN;
1010 chan = l2cap_chan_create(sk);
1012 l2cap_sock_kill(sk);
1016 l2cap_pi(sk)->chan = chan;
1021 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1026 BT_DBG("sock %p", sock);
1028 sock->state = SS_UNCONNECTED;
1030 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1031 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1032 return -ESOCKTNOSUPPORT;
1034 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1037 sock->ops = &l2cap_sock_ops;
1039 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1043 l2cap_sock_init(sk, NULL);
1047 static const struct proto_ops l2cap_sock_ops = {
1048 .family = PF_BLUETOOTH,
1049 .owner = THIS_MODULE,
1050 .release = l2cap_sock_release,
1051 .bind = l2cap_sock_bind,
1052 .connect = l2cap_sock_connect,
1053 .listen = l2cap_sock_listen,
1054 .accept = l2cap_sock_accept,
1055 .getname = l2cap_sock_getname,
1056 .sendmsg = l2cap_sock_sendmsg,
1057 .recvmsg = l2cap_sock_recvmsg,
1058 .poll = bt_sock_poll,
1059 .ioctl = bt_sock_ioctl,
1060 .mmap = sock_no_mmap,
1061 .socketpair = sock_no_socketpair,
1062 .shutdown = l2cap_sock_shutdown,
1063 .setsockopt = l2cap_sock_setsockopt,
1064 .getsockopt = l2cap_sock_getsockopt
1067 static const struct net_proto_family l2cap_sock_family_ops = {
1068 .family = PF_BLUETOOTH,
1069 .owner = THIS_MODULE,
1070 .create = l2cap_sock_create,
1073 int __init l2cap_init_sockets(void)
1077 err = proto_register(&l2cap_proto, 0);
1081 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1085 BT_INFO("L2CAP socket layer initialized");
1090 BT_ERR("L2CAP socket registration failed");
1091 proto_unregister(&l2cap_proto);
1095 void l2cap_cleanup_sockets(void)
1097 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1098 BT_ERR("L2CAP socket unregistration failed");
1100 proto_unregister(&l2cap_proto);