← Back to branch summary

~ubuntu-branches/ubuntu/karmic/linux-ports/karmic

« back to all changes in this revision

Viewing changes to net/bluetooth/l2cap.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich, Luke Yelavich, Michael Casadevall, Tim Gardner, Upstream Kernel Changes
  • Date: 2009-05-06 18:18:55 UTC
  • Revision ID: james.westby@ubuntu.com-20090506181855-t00baeevpnvd9o7a
Tags: 2.6.30-1.1
[ Luke Yelavich ]
* initial release for karmic
* SAUCE: rebase-ports - adjust for the karmic ports kernel
* SAUCE: rebase-ports - also remove abi dirs/files on rebase
* Update configs after rebase against mainline Jaunty tree
* [Config] Disable CONFIG_BLK_DEV_UB and CONFIG_USB_LIBUSUAL as per
  mainline jaunty
* forward-port patch to drbd for powerpc compilation
* [Config] disable CONFIG_LENOVO_SL_LAPTOP for i386 due to FTBFS
* add .o files found in arch/powerpc/lib to all powerpc kernel header
  packages
* [Config] enable CONFIG_DRM_I915_KMS for i386 as per karmic mainline

[ Michael Casadevall ]

* Disable kgdb on sparc64
* [sparc] [Config] Disable GPIO LEDS
* [ia64] Rename -ia64-generic to -ia64 in line with other architectures
* Correct kernel image path for sparc builds
* [hppa] Fix HPPA config files to build modules for all udebian

Rebase on top of karmic mainline 2.6.30-1.1

[ Tim Gardner ]

* [Config] armel: disable staging drivers, fixes FTBS
* [Config] armel imx51: Disable CONFIG_MTD_NAND_MXC, fixes FTBS

[ Upstream Kernel Changes ]

* mpt2sas: Change reset_type enum to avoid namespace collision.
  Submitted upstream.

* Initial release after rebasing against v2.6.30-rc3

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/bluetooth/l2cap.c
50
50
#include <net/bluetooth/hci_core.h>
51
51
#include <net/bluetooth/l2cap.h>
52
52
 
53
 
#ifndef CONFIG_BT_L2CAP_DEBUG
54
 
#undef  BT_DBG
55
 
#define BT_DBG(D...)
56
 
#endif
57
 
 
58
 
#define VERSION "2.11"
59
 
 
60
 
static u32 l2cap_feat_mask = 0x0000;
 
53
#define VERSION "2.13"
 
54
 
 
55
static u32 l2cap_feat_mask = 0x0080;
 
56
static u8 l2cap_fixed_chan[8] = { 0x02, };
61
57
 
62
58
static const struct proto_ops l2cap_sock_ops;
63
59
 
82
78
 
83
79
        bh_lock_sock(sk);
84
80
 
85
 
        if (sk->sk_state == BT_CONNECT &&
86
 
                        (l2cap_pi(sk)->link_mode & (L2CAP_LM_AUTH |
87
 
                                        L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE)))
 
81
        if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONFIG)
 
82
                reason = ECONNREFUSED;
 
83
        else if (sk->sk_state == BT_CONNECT &&
 
84
                                l2cap_pi(sk)->sec_level != BT_SECURITY_SDP)
88
85
                reason = ECONNREFUSED;
89
86
        else
90
87
                reason = ETIMEDOUT;
209
206
 
210
207
        BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
211
208
 
 
209
        conn->disc_reason = 0x13;
 
210
 
212
211
        l2cap_pi(sk)->conn = conn;
213
212
 
214
213
        if (sk->sk_type == SOCK_SEQPACKET) {
264
263
}
265
264
 
266
265
/* Service level security */
267
 
static inline int l2cap_check_link_mode(struct sock *sk)
 
266
static inline int l2cap_check_security(struct sock *sk)
268
267
{
269
268
        struct l2cap_conn *conn = l2cap_pi(sk)->conn;
270
 
 
271
 
        if ((l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) ||
272
 
                                (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE))
273
 
                return hci_conn_encrypt(conn->hcon);
274
 
 
275
 
        if (l2cap_pi(sk)->link_mode & L2CAP_LM_AUTH)
276
 
                return hci_conn_auth(conn->hcon);
277
 
 
278
 
        return 1;
 
269
        __u8 auth_type;
 
270
 
 
271
        if (l2cap_pi(sk)->psm == cpu_to_le16(0x0001)) {
 
272
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
 
273
                        auth_type = HCI_AT_NO_BONDING_MITM;
 
274
                else
 
275
                        auth_type = HCI_AT_NO_BONDING;
 
276
 
 
277
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_LOW)
 
278
                        l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
 
279
        } else {
 
280
                switch (l2cap_pi(sk)->sec_level) {
 
281
                case BT_SECURITY_HIGH:
 
282
                        auth_type = HCI_AT_GENERAL_BONDING_MITM;
 
283
                        break;
 
284
                case BT_SECURITY_MEDIUM:
 
285
                        auth_type = HCI_AT_GENERAL_BONDING;
 
286
                        break;
 
287
                default:
 
288
                        auth_type = HCI_AT_NO_BONDING;
 
289
                        break;
 
290
                }
 
291
        }
 
292
 
 
293
        return hci_conn_security(conn->hcon, l2cap_pi(sk)->sec_level,
 
294
                                                                auth_type);
279
295
}
280
296
 
281
297
static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
317
333
        struct l2cap_conn *conn = l2cap_pi(sk)->conn;
318
334
 
319
335
        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
320
 
                if (l2cap_check_link_mode(sk)) {
 
336
                if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
 
337
                        return;
 
338
 
 
339
                if (l2cap_check_security(sk)) {
321
340
                        struct l2cap_conn_req req;
322
341
                        req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
323
342
                        req.psm  = l2cap_pi(sk)->psm;
361
380
                }
362
381
 
363
382
                if (sk->sk_state == BT_CONNECT) {
364
 
                        if (l2cap_check_link_mode(sk)) {
 
383
                        if (l2cap_check_security(sk)) {
365
384
                                struct l2cap_conn_req req;
366
385
                                req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
367
386
                                req.psm  = l2cap_pi(sk)->psm;
376
395
                        rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
377
396
                        rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
378
397
 
379
 
                        if (l2cap_check_link_mode(sk)) {
380
 
                                sk->sk_state = BT_CONFIG;
381
 
                                rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
382
 
                                rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
 
398
                        if (l2cap_check_security(sk)) {
 
399
                                if (bt_sk(sk)->defer_setup) {
 
400
                                        struct sock *parent = bt_sk(sk)->parent;
 
401
                                        rsp.result = cpu_to_le16(L2CAP_CR_PEND);
 
402
                                        rsp.status = cpu_to_le16(L2CAP_CS_AUTHOR_PEND);
 
403
                                        parent->sk_data_ready(parent, 0);
 
404
 
 
405
                                } else {
 
406
                                        sk->sk_state = BT_CONFIG;
 
407
                                        rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
 
408
                                        rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
 
409
                                }
383
410
                        } else {
384
411
                                rsp.result = cpu_to_le16(L2CAP_CR_PEND);
385
412
                                rsp.status = cpu_to_le16(L2CAP_CS_AUTHEN_PEND);
431
458
        read_lock(&l->lock);
432
459
 
433
460
        for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
434
 
                if (l2cap_pi(sk)->link_mode & L2CAP_LM_RELIABLE)
 
461
                if (l2cap_pi(sk)->force_reliable)
435
462
                        sk->sk_err = err;
436
463
        }
437
464
 
442
469
{
443
470
        struct l2cap_conn *conn = (void *) arg;
444
471
 
 
472
        conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
445
473
        conn->info_ident = 0;
446
474
 
447
475
        l2cap_conn_start(conn);
475
503
        spin_lock_init(&conn->lock);
476
504
        rwlock_init(&conn->chan_list.lock);
477
505
 
 
506
        conn->disc_reason = 0x13;
 
507
 
478
508
        return conn;
479
509
}
480
510
 
488
518
 
489
519
        BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
490
520
 
491
 
        if (conn->rx_skb)
492
 
                kfree_skb(conn->rx_skb);
 
521
        kfree_skb(conn->rx_skb);
493
522
 
494
523
        /* Kill channels */
495
524
        while ((sk = conn->chan_list.head)) {
613
642
 
614
643
        case BT_CONNECTED:
615
644
        case BT_CONFIG:
616
 
        case BT_CONNECT2:
617
645
                if (sk->sk_type == SOCK_SEQPACKET) {
618
646
                        struct l2cap_conn *conn = l2cap_pi(sk)->conn;
619
647
                        struct l2cap_disconn_req req;
629
657
                        l2cap_chan_del(sk, reason);
630
658
                break;
631
659
 
 
660
        case BT_CONNECT2:
 
661
                if (sk->sk_type == SOCK_SEQPACKET) {
 
662
                        struct l2cap_conn *conn = l2cap_pi(sk)->conn;
 
663
                        struct l2cap_conn_rsp rsp;
 
664
                        __u16 result;
 
665
 
 
666
                        if (bt_sk(sk)->defer_setup)
 
667
                                result = L2CAP_CR_SEC_BLOCK;
 
668
                        else
 
669
                                result = L2CAP_CR_BAD_PSM;
 
670
 
 
671
                        rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
 
672
                        rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
 
673
                        rsp.result = cpu_to_le16(result);
 
674
                        rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
 
675
                        l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
 
676
                                        L2CAP_CONN_RSP, sizeof(rsp), &rsp);
 
677
                } else
 
678
                        l2cap_chan_del(sk, reason);
 
679
                break;
 
680
 
632
681
        case BT_CONNECT:
633
682
        case BT_DISCONN:
634
683
                l2cap_chan_del(sk, reason);
658
707
 
659
708
        if (parent) {
660
709
                sk->sk_type = parent->sk_type;
 
710
                bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 
711
 
661
712
                pi->imtu = l2cap_pi(parent)->imtu;
662
713
                pi->omtu = l2cap_pi(parent)->omtu;
663
 
                pi->link_mode = l2cap_pi(parent)->link_mode;
 
714
                pi->sec_level = l2cap_pi(parent)->sec_level;
 
715
                pi->role_switch = l2cap_pi(parent)->role_switch;
 
716
                pi->force_reliable = l2cap_pi(parent)->force_reliable;
664
717
        } else {
665
718
                pi->imtu = L2CAP_DEFAULT_MTU;
666
719
                pi->omtu = 0;
667
 
                pi->link_mode = 0;
 
720
                pi->sec_level = BT_SECURITY_LOW;
 
721
                pi->role_switch = 0;
 
722
                pi->force_reliable = 0;
668
723
        }
669
724
 
670
725
        /* Default config options */
728
783
        return 0;
729
784
}
730
785
 
731
 
static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 
786
static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
732
787
{
733
 
        struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
734
788
        struct sock *sk = sock->sk;
735
 
        int err = 0;
 
789
        struct sockaddr_l2 la;
 
790
        int len, err = 0;
736
791
 
737
 
        BT_DBG("sk %p, %s %d", sk, batostr(&la->l2_bdaddr), la->l2_psm);
 
792
        BT_DBG("sk %p", sk);
738
793
 
739
794
        if (!addr || addr->sa_family != AF_BLUETOOTH)
740
795
                return -EINVAL;
741
796
 
 
797
        memset(&la, 0, sizeof(la));
 
798
        len = min_t(unsigned int, sizeof(la), alen);
 
799
        memcpy(&la, addr, len);
 
800
 
 
801
        if (la.l2_cid)
 
802
                return -EINVAL;
 
803
 
742
804
        lock_sock(sk);
743
805
 
744
806
        if (sk->sk_state != BT_OPEN) {
746
808
                goto done;
747
809
        }
748
810
 
749
 
        if (la->l2_psm && btohs(la->l2_psm) < 0x1001 &&
 
811
        if (la.l2_psm && btohs(la.l2_psm) < 0x1001 &&
750
812
                                !capable(CAP_NET_BIND_SERVICE)) {
751
813
                err = -EACCES;
752
814
                goto done;
754
816
 
755
817
        write_lock_bh(&l2cap_sk_list.lock);
756
818
 
757
 
        if (la->l2_psm && __l2cap_get_sock_by_addr(la->l2_psm, &la->l2_bdaddr)) {
 
819
        if (la.l2_psm && __l2cap_get_sock_by_addr(la.l2_psm, &la.l2_bdaddr)) {
758
820
                err = -EADDRINUSE;
759
821
        } else {
760
822
                /* Save source address */
761
 
                bacpy(&bt_sk(sk)->src, &la->l2_bdaddr);
762
 
                l2cap_pi(sk)->psm   = la->l2_psm;
763
 
                l2cap_pi(sk)->sport = la->l2_psm;
 
823
                bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
 
824
                l2cap_pi(sk)->psm   = la.l2_psm;
 
825
                l2cap_pi(sk)->sport = la.l2_psm;
764
826
                sk->sk_state = BT_BOUND;
 
827
 
 
828
                if (btohs(la.l2_psm) == 0x0001 || btohs(la.l2_psm) == 0x0003)
 
829
                        l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
765
830
        }
766
831
 
767
832
        write_unlock_bh(&l2cap_sk_list.lock);
781
846
        __u8 auth_type;
782
847
        int err = 0;
783
848
 
784
 
        BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst), l2cap_pi(sk)->psm);
 
849
        BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst),
 
850
                                                        l2cap_pi(sk)->psm);
785
851
 
786
852
        if (!(hdev = hci_get_route(dst, src)))
787
853
                return -EHOSTUNREACH;
790
856
 
791
857
        err = -ENOMEM;
792
858
 
793
 
        if (l2cap_pi(sk)->link_mode & L2CAP_LM_AUTH ||
794
 
                        l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT ||
795
 
                                l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE) {
796
 
                if (l2cap_pi(sk)->psm == cpu_to_le16(0x0001))
 
859
        if (sk->sk_type == SOCK_RAW) {
 
860
                switch (l2cap_pi(sk)->sec_level) {
 
861
                case BT_SECURITY_HIGH:
 
862
                        auth_type = HCI_AT_DEDICATED_BONDING_MITM;
 
863
                        break;
 
864
                case BT_SECURITY_MEDIUM:
 
865
                        auth_type = HCI_AT_DEDICATED_BONDING;
 
866
                        break;
 
867
                default:
 
868
                        auth_type = HCI_AT_NO_BONDING;
 
869
                        break;
 
870
                }
 
871
        } else if (l2cap_pi(sk)->psm == cpu_to_le16(0x0001)) {
 
872
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
797
873
                        auth_type = HCI_AT_NO_BONDING_MITM;
798
874
                else
 
875
                        auth_type = HCI_AT_NO_BONDING;
 
876
 
 
877
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_LOW)
 
878
                        l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
 
879
        } else {
 
880
                switch (l2cap_pi(sk)->sec_level) {
 
881
                case BT_SECURITY_HIGH:
799
882
                        auth_type = HCI_AT_GENERAL_BONDING_MITM;
800
 
        } else {
801
 
                if (l2cap_pi(sk)->psm == cpu_to_le16(0x0001))
802
 
                        auth_type = HCI_AT_NO_BONDING;
803
 
                else
 
883
                        break;
 
884
                case BT_SECURITY_MEDIUM:
804
885
                        auth_type = HCI_AT_GENERAL_BONDING;
 
886
                        break;
 
887
                default:
 
888
                        auth_type = HCI_AT_NO_BONDING;
 
889
                        break;
 
890
                }
805
891
        }
806
892
 
807
 
        hcon = hci_connect(hdev, ACL_LINK, dst, auth_type);
 
893
        hcon = hci_connect(hdev, ACL_LINK, dst,
 
894
                                        l2cap_pi(sk)->sec_level, auth_type);
808
895
        if (!hcon)
809
896
                goto done;
810
897
 
840
927
 
841
928
static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
842
929
{
843
 
        struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
844
930
        struct sock *sk = sock->sk;
845
 
        int err = 0;
 
931
        struct sockaddr_l2 la;
 
932
        int len, err = 0;
 
933
 
 
934
        BT_DBG("sk %p", sk);
 
935
 
 
936
        if (!addr || addr->sa_family != AF_BLUETOOTH)
 
937
                return -EINVAL;
 
938
 
 
939
        memset(&la, 0, sizeof(la));
 
940
        len = min_t(unsigned int, sizeof(la), alen);
 
941
        memcpy(&la, addr, len);
 
942
 
 
943
        if (la.l2_cid)
 
944
                return -EINVAL;
846
945
 
847
946
        lock_sock(sk);
848
947
 
849
 
        BT_DBG("sk %p", sk);
850
 
 
851
 
        if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_l2)) {
852
 
                err = -EINVAL;
853
 
                goto done;
854
 
        }
855
 
 
856
 
        if (sk->sk_type == SOCK_SEQPACKET && !la->l2_psm) {
 
948
        if (sk->sk_type == SOCK_SEQPACKET && !la.l2_psm) {
857
949
                err = -EINVAL;
858
950
                goto done;
859
951
        }
880
972
        }
881
973
 
882
974
        /* Set destination address and psm */
883
 
        bacpy(&bt_sk(sk)->dst, &la->l2_bdaddr);
884
 
        l2cap_pi(sk)->psm = la->l2_psm;
 
975
        bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
 
976
        l2cap_pi(sk)->psm = la.l2_psm;
885
977
 
886
978
        if ((err = l2cap_do_connect(sk)))
887
979
                goto done;
1005
1097
        addr->sa_family = AF_BLUETOOTH;
1006
1098
        *len = sizeof(struct sockaddr_l2);
1007
1099
 
1008
 
        if (peer)
 
1100
        if (peer) {
 
1101
                la->l2_psm = l2cap_pi(sk)->psm;
1009
1102
                bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
1010
 
        else
 
1103
                la->l2_cid = htobs(l2cap_pi(sk)->dcid);
 
1104
        } else {
 
1105
                la->l2_psm = l2cap_pi(sk)->sport;
1011
1106
                bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
 
1107
                la->l2_cid = htobs(l2cap_pi(sk)->scid);
 
1108
        }
1012
1109
 
1013
 
        la->l2_psm = l2cap_pi(sk)->psm;
1014
1110
        return 0;
1015
1111
}
1016
1112
 
1111
1207
        return err;
1112
1208
}
1113
1209
 
1114
 
static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 
1210
static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
 
1211
{
 
1212
        struct sock *sk = sock->sk;
 
1213
 
 
1214
        lock_sock(sk);
 
1215
 
 
1216
        if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
 
1217
                struct l2cap_conn_rsp rsp;
 
1218
 
 
1219
                sk->sk_state = BT_CONFIG;
 
1220
 
 
1221
                rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
 
1222
                rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
 
1223
                rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
 
1224
                rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
 
1225
                l2cap_send_cmd(l2cap_pi(sk)->conn, l2cap_pi(sk)->ident,
 
1226
                                        L2CAP_CONN_RSP, sizeof(rsp), &rsp);
 
1227
 
 
1228
                release_sock(sk);
 
1229
                return 0;
 
1230
        }
 
1231
 
 
1232
        release_sock(sk);
 
1233
 
 
1234
        return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 
1235
}
 
1236
 
 
1237
static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, int optlen)
1115
1238
{
1116
1239
        struct sock *sk = sock->sk;
1117
1240
        struct l2cap_options opts;
1118
 
        int err = 0, len;
 
1241
        int len, err = 0;
1119
1242
        u32 opt;
1120
1243
 
1121
1244
        BT_DBG("sk %p", sk);
1145
1268
                        break;
1146
1269
                }
1147
1270
 
1148
 
                l2cap_pi(sk)->link_mode = opt;
1149
 
                break;
1150
 
 
1151
 
        default:
1152
 
                err = -ENOPROTOOPT;
1153
 
                break;
1154
 
        }
1155
 
 
1156
 
        release_sock(sk);
1157
 
        return err;
1158
 
}
1159
 
 
1160
 
static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 
1271
                if (opt & L2CAP_LM_AUTH)
 
1272
                        l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;
 
1273
                if (opt & L2CAP_LM_ENCRYPT)
 
1274
                        l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
 
1275
                if (opt & L2CAP_LM_SECURE)
 
1276
                        l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;
 
1277
 
 
1278
                l2cap_pi(sk)->role_switch    = (opt & L2CAP_LM_MASTER);
 
1279
                l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);
 
1280
                break;
 
1281
 
 
1282
        default:
 
1283
                err = -ENOPROTOOPT;
 
1284
                break;
 
1285
        }
 
1286
 
 
1287
        release_sock(sk);
 
1288
        return err;
 
1289
}
 
1290
 
 
1291
static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 
1292
{
 
1293
        struct sock *sk = sock->sk;
 
1294
        struct bt_security sec;
 
1295
        int len, err = 0;
 
1296
        u32 opt;
 
1297
 
 
1298
        BT_DBG("sk %p", sk);
 
1299
 
 
1300
        if (level == SOL_L2CAP)
 
1301
                return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 
1302
 
 
1303
        if (level != SOL_BLUETOOTH)
 
1304
                return -ENOPROTOOPT;
 
1305
 
 
1306
        lock_sock(sk);
 
1307
 
 
1308
        switch (optname) {
 
1309
        case BT_SECURITY:
 
1310
                if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_RAW) {
 
1311
                        err = -EINVAL;
 
1312
                        break;
 
1313
                }
 
1314
 
 
1315
                sec.level = BT_SECURITY_LOW;
 
1316
 
 
1317
                len = min_t(unsigned int, sizeof(sec), optlen);
 
1318
                if (copy_from_user((char *) &sec, optval, len)) {
 
1319
                        err = -EFAULT;
 
1320
                        break;
 
1321
                }
 
1322
 
 
1323
                if (sec.level < BT_SECURITY_LOW ||
 
1324
                                        sec.level > BT_SECURITY_HIGH) {
 
1325
                        err = -EINVAL;
 
1326
                        break;
 
1327
                }
 
1328
 
 
1329
                l2cap_pi(sk)->sec_level = sec.level;
 
1330
                break;
 
1331
 
 
1332
        case BT_DEFER_SETUP:
 
1333
                if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 
1334
                        err = -EINVAL;
 
1335
                        break;
 
1336
                }
 
1337
 
 
1338
                if (get_user(opt, (u32 __user *) optval)) {
 
1339
                        err = -EFAULT;
 
1340
                        break;
 
1341
                }
 
1342
 
 
1343
                bt_sk(sk)->defer_setup = opt;
 
1344
                break;
 
1345
 
 
1346
        default:
 
1347
                err = -ENOPROTOOPT;
 
1348
                break;
 
1349
        }
 
1350
 
 
1351
        release_sock(sk);
 
1352
        return err;
 
1353
}
 
1354
 
 
1355
static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
1161
1356
{
1162
1357
        struct sock *sk = sock->sk;
1163
1358
        struct l2cap_options opts;
1164
1359
        struct l2cap_conninfo cinfo;
1165
1360
        int len, err = 0;
 
1361
        u32 opt;
1166
1362
 
1167
1363
        BT_DBG("sk %p", sk);
1168
1364
 
1185
1381
                break;
1186
1382
 
1187
1383
        case L2CAP_LM:
1188
 
                if (put_user(l2cap_pi(sk)->link_mode, (u32 __user *) optval))
 
1384
                switch (l2cap_pi(sk)->sec_level) {
 
1385
                case BT_SECURITY_LOW:
 
1386
                        opt = L2CAP_LM_AUTH;
 
1387
                        break;
 
1388
                case BT_SECURITY_MEDIUM:
 
1389
                        opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
 
1390
                        break;
 
1391
                case BT_SECURITY_HIGH:
 
1392
                        opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
 
1393
                                                        L2CAP_LM_SECURE;
 
1394
                        break;
 
1395
                default:
 
1396
                        opt = 0;
 
1397
                        break;
 
1398
                }
 
1399
 
 
1400
                if (l2cap_pi(sk)->role_switch)
 
1401
                        opt |= L2CAP_LM_MASTER;
 
1402
 
 
1403
                if (l2cap_pi(sk)->force_reliable)
 
1404
                        opt |= L2CAP_LM_RELIABLE;
 
1405
 
 
1406
                if (put_user(opt, (u32 __user *) optval))
1189
1407
                        err = -EFAULT;
1190
1408
                break;
1191
1409
 
1192
1410
        case L2CAP_CONNINFO:
1193
 
                if (sk->sk_state != BT_CONNECTED) {
 
1411
                if (sk->sk_state != BT_CONNECTED &&
 
1412
                                        !(sk->sk_state == BT_CONNECT2 &&
 
1413
                                                bt_sk(sk)->defer_setup)) {
1194
1414
                        err = -ENOTCONN;
1195
1415
                        break;
1196
1416
                }
1213
1433
        return err;
1214
1434
}
1215
1435
 
 
1436
static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 
1437
{
 
1438
        struct sock *sk = sock->sk;
 
1439
        struct bt_security sec;
 
1440
        int len, err = 0;
 
1441
 
 
1442
        BT_DBG("sk %p", sk);
 
1443
 
 
1444
        if (level == SOL_L2CAP)
 
1445
                return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
 
1446
 
 
1447
        if (level != SOL_BLUETOOTH)
 
1448
                return -ENOPROTOOPT;
 
1449
 
 
1450
        if (get_user(len, optlen))
 
1451
                return -EFAULT;
 
1452
 
 
1453
        lock_sock(sk);
 
1454
 
 
1455
        switch (optname) {
 
1456
        case BT_SECURITY:
 
1457
                if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_RAW) {
 
1458
                        err = -EINVAL;
 
1459
                        break;
 
1460
                }
 
1461
 
 
1462
                sec.level = l2cap_pi(sk)->sec_level;
 
1463
 
 
1464
                len = min_t(unsigned int, len, sizeof(sec));
 
1465
                if (copy_to_user(optval, (char *) &sec, len))
 
1466
                        err = -EFAULT;
 
1467
 
 
1468
                break;
 
1469
 
 
1470
        case BT_DEFER_SETUP:
 
1471
                if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 
1472
                        err = -EINVAL;
 
1473
                        break;
 
1474
                }
 
1475
 
 
1476
                if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
 
1477
                        err = -EFAULT;
 
1478
 
 
1479
                break;
 
1480
 
 
1481
        default:
 
1482
                err = -ENOPROTOOPT;
 
1483
                break;
 
1484
        }
 
1485
 
 
1486
        release_sock(sk);
 
1487
        return err;
 
1488
}
 
1489
 
1216
1490
static int l2cap_sock_shutdown(struct socket *sock, int how)
1217
1491
{
1218
1492
        struct sock *sk = sock->sk;
1275
1549
                 */
1276
1550
                parent->sk_data_ready(parent, 0);
1277
1551
        }
1278
 
 
1279
 
        if (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE) {
1280
 
                struct l2cap_conn *conn = l2cap_pi(sk)->conn;
1281
 
                hci_conn_change_link_key(conn->hcon);
1282
 
        }
1283
1552
}
1284
1553
 
1285
1554
/* Copy frame to all raw sockets on that connection */
1554
1823
 
1555
1824
        if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) &&
1556
1825
                                        cmd->ident == conn->info_ident) {
1557
 
                conn->info_ident = 0;
1558
1826
                del_timer(&conn->info_timer);
 
1827
 
 
1828
                conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
 
1829
                conn->info_ident = 0;
 
1830
 
1559
1831
                l2cap_conn_start(conn);
1560
1832
        }
1561
1833
 
1585
1857
        /* Check if the ACL is secure enough (if not SDP) */
1586
1858
        if (psm != cpu_to_le16(0x0001) &&
1587
1859
                                !hci_conn_check_link_mode(conn->hcon)) {
 
1860
                conn->disc_reason = 0x05;
1588
1861
                result = L2CAP_CR_SEC_BLOCK;
1589
1862
                goto response;
1590
1863
        }
1626
1899
 
1627
1900
        l2cap_pi(sk)->ident = cmd->ident;
1628
1901
 
1629
 
        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
1630
 
                if (l2cap_check_link_mode(sk)) {
1631
 
                        sk->sk_state = BT_CONFIG;
1632
 
                        result = L2CAP_CR_SUCCESS;
1633
 
                        status = L2CAP_CS_NO_INFO;
 
1902
        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) {
 
1903
                if (l2cap_check_security(sk)) {
 
1904
                        if (bt_sk(sk)->defer_setup) {
 
1905
                                sk->sk_state = BT_CONNECT2;
 
1906
                                result = L2CAP_CR_PEND;
 
1907
                                status = L2CAP_CS_AUTHOR_PEND;
 
1908
                                parent->sk_data_ready(parent, 0);
 
1909
                        } else {
 
1910
                                sk->sk_state = BT_CONFIG;
 
1911
                                result = L2CAP_CR_SUCCESS;
 
1912
                                status = L2CAP_CS_NO_INFO;
 
1913
                        }
1634
1914
                } else {
1635
1915
                        sk->sk_state = BT_CONNECT2;
1636
1916
                        result = L2CAP_CR_PEND;
1700
1980
                l2cap_pi(sk)->dcid = dcid;
1701
1981
                l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
1702
1982
 
 
1983
                l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_CONNECT_PEND;
 
1984
 
1703
1985
                l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
1704
1986
                                        l2cap_build_conf_req(sk, req), req);
1705
1987
                break;
1706
1988
 
1707
1989
        case L2CAP_CR_PEND:
 
1990
                l2cap_pi(sk)->conf_state |= L2CAP_CONF_CONNECT_PEND;
1708
1991
                break;
1709
1992
 
1710
1993
        default:
1913
2196
                put_unaligned(cpu_to_le32(l2cap_feat_mask), (__le32 *) rsp->data);
1914
2197
                l2cap_send_cmd(conn, cmd->ident,
1915
2198
                                        L2CAP_INFO_RSP, sizeof(buf), buf);
 
2199
        } else if (type == L2CAP_IT_FIXED_CHAN) {
 
2200
                u8 buf[12];
 
2201
                struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
 
2202
                rsp->type   = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
 
2203
                rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
 
2204
                memcpy(buf + 4, l2cap_fixed_chan, 8);
 
2205
                l2cap_send_cmd(conn, cmd->ident,
 
2206
                                        L2CAP_INFO_RSP, sizeof(buf), buf);
1916
2207
        } else {
1917
2208
                struct l2cap_info_rsp rsp;
1918
2209
                rsp.type   = cpu_to_le16(type);
1934
2225
 
1935
2226
        BT_DBG("type 0x%4.4x result 0x%2.2x", type, result);
1936
2227
 
1937
 
        conn->info_ident = 0;
1938
 
 
1939
2228
        del_timer(&conn->info_timer);
1940
2229
 
1941
 
        if (type == L2CAP_IT_FEAT_MASK)
 
2230
        if (type == L2CAP_IT_FEAT_MASK) {
1942
2231
                conn->feat_mask = get_unaligned_le32(rsp->data);
1943
2232
 
1944
 
        l2cap_conn_start(conn);
 
2233
                if (conn->feat_mask & 0x0080) {
 
2234
                        struct l2cap_info_req req;
 
2235
                        req.type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
 
2236
 
 
2237
                        conn->info_ident = l2cap_get_ident(conn);
 
2238
 
 
2239
                        l2cap_send_cmd(conn, conn->info_ident,
 
2240
                                        L2CAP_INFO_REQ, sizeof(req), &req);
 
2241
                } else {
 
2242
                        conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
 
2243
                        conn->info_ident = 0;
 
2244
 
 
2245
                        l2cap_conn_start(conn);
 
2246
                }
 
2247
        } else if (type == L2CAP_IT_FIXED_CHAN) {
 
2248
                conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
 
2249
                conn->info_ident = 0;
 
2250
 
 
2251
                l2cap_conn_start(conn);
 
2252
        }
1945
2253
 
1946
2254
        return 0;
1947
2255
}
2148
2456
                        continue;
2149
2457
 
2150
2458
                if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) {
2151
 
                        lm1 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
 
2459
                        lm1 |= HCI_LM_ACCEPT;
 
2460
                        if (l2cap_pi(sk)->role_switch)
 
2461
                                lm1 |= HCI_LM_MASTER;
2152
2462
                        exact++;
2153
 
                } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
2154
 
                        lm2 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
 
2463
                } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
 
2464
                        lm2 |= HCI_LM_ACCEPT;
 
2465
                        if (l2cap_pi(sk)->role_switch)
 
2466
                                lm2 |= HCI_LM_MASTER;
 
2467
                }
2155
2468
        }
2156
2469
        read_unlock(&l2cap_sk_list.lock);
2157
2470
 
2177
2490
        return 0;
2178
2491
}
2179
2492
 
2180
 
static int l2cap_disconn_ind(struct hci_conn *hcon, u8 reason)
 
2493
static int l2cap_disconn_ind(struct hci_conn *hcon)
 
2494
{
 
2495
        struct l2cap_conn *conn = hcon->l2cap_data;
 
2496
 
 
2497
        BT_DBG("hcon %p", hcon);
 
2498
 
 
2499
        if (hcon->type != ACL_LINK || !conn)
 
2500
                return 0x13;
 
2501
 
 
2502
        return conn->disc_reason;
 
2503
}
 
2504
 
 
2505
static int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
2181
2506
{
2182
2507
        BT_DBG("hcon %p reason %d", hcon, reason);
2183
2508
 
2189
2514
        return 0;
2190
2515
}
2191
2516
 
2192
 
static int l2cap_auth_cfm(struct hci_conn *hcon, u8 status)
2193
 
{
2194
 
        struct l2cap_chan_list *l;
2195
 
        struct l2cap_conn *conn = hcon->l2cap_data;
2196
 
        struct sock *sk;
2197
 
 
2198
 
        if (!conn)
2199
 
                return 0;
2200
 
 
2201
 
        l = &conn->chan_list;
2202
 
 
2203
 
        BT_DBG("conn %p", conn);
2204
 
 
2205
 
        read_lock(&l->lock);
2206
 
 
2207
 
        for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
2208
 
                struct l2cap_pinfo *pi = l2cap_pi(sk);
2209
 
 
2210
 
                bh_lock_sock(sk);
2211
 
 
2212
 
                if ((pi->link_mode & (L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE)) &&
2213
 
                                        !(hcon->link_mode & HCI_LM_ENCRYPT) &&
2214
 
                                                                !status) {
2215
 
                        bh_unlock_sock(sk);
2216
 
                        continue;
2217
 
                }
2218
 
 
2219
 
                if (sk->sk_state == BT_CONNECT) {
2220
 
                        if (!status) {
2221
 
                                struct l2cap_conn_req req;
2222
 
                                req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
2223
 
                                req.psm  = l2cap_pi(sk)->psm;
2224
 
 
2225
 
                                l2cap_pi(sk)->ident = l2cap_get_ident(conn);
2226
 
 
2227
 
                                l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
2228
 
                                        L2CAP_CONN_REQ, sizeof(req), &req);
2229
 
                        } else {
2230
 
                                l2cap_sock_clear_timer(sk);
2231
 
                                l2cap_sock_set_timer(sk, HZ / 10);
2232
 
                        }
2233
 
                } else if (sk->sk_state == BT_CONNECT2) {
2234
 
                        struct l2cap_conn_rsp rsp;
2235
 
                        __u16 result;
2236
 
 
2237
 
                        if (!status) {
2238
 
                                sk->sk_state = BT_CONFIG;
2239
 
                                result = L2CAP_CR_SUCCESS;
2240
 
                        } else {
2241
 
                                sk->sk_state = BT_DISCONN;
2242
 
                                l2cap_sock_set_timer(sk, HZ / 10);
2243
 
                                result = L2CAP_CR_SEC_BLOCK;
2244
 
                        }
2245
 
 
2246
 
                        rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
2247
 
                        rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
2248
 
                        rsp.result = cpu_to_le16(result);
2249
 
                        rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
2250
 
                        l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
2251
 
                                        L2CAP_CONN_RSP, sizeof(rsp), &rsp);
2252
 
                }
2253
 
 
2254
 
                bh_unlock_sock(sk);
2255
 
        }
2256
 
 
2257
 
        read_unlock(&l->lock);
2258
 
 
2259
 
        return 0;
2260
 
}
2261
 
 
2262
 
static int l2cap_encrypt_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
2263
 
{
2264
 
        struct l2cap_chan_list *l;
2265
 
        struct l2cap_conn *conn = hcon->l2cap_data;
2266
 
        struct sock *sk;
2267
 
 
2268
 
        if (!conn)
2269
 
                return 0;
2270
 
 
2271
 
        l = &conn->chan_list;
2272
 
 
2273
 
        BT_DBG("conn %p", conn);
2274
 
 
2275
 
        read_lock(&l->lock);
2276
 
 
2277
 
        for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
2278
 
                struct l2cap_pinfo *pi = l2cap_pi(sk);
2279
 
 
2280
 
                bh_lock_sock(sk);
2281
 
 
2282
 
                if ((pi->link_mode & (L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE)) &&
2283
 
                                        (sk->sk_state == BT_CONNECTED ||
2284
 
                                                sk->sk_state == BT_CONFIG) &&
2285
 
                                                !status && encrypt == 0x00) {
 
2517
static inline void l2cap_check_encryption(struct sock *sk, u8 encrypt)
 
2518
{
 
2519
        if (sk->sk_type != SOCK_SEQPACKET)
 
2520
                return;
 
2521
 
 
2522
        if (encrypt == 0x00) {
 
2523
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_MEDIUM) {
 
2524
                        l2cap_sock_clear_timer(sk);
 
2525
                        l2cap_sock_set_timer(sk, HZ * 5);
 
2526
                } else if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
2286
2527
                        __l2cap_sock_close(sk, ECONNREFUSED);
 
2528
        } else {
 
2529
                if (l2cap_pi(sk)->sec_level == BT_SECURITY_MEDIUM)
 
2530
                        l2cap_sock_clear_timer(sk);
 
2531
        }
 
2532
}
 
2533
 
 
2534
static int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
 
2535
{
 
2536
        struct l2cap_chan_list *l;
 
2537
        struct l2cap_conn *conn = hcon->l2cap_data;
 
2538
        struct sock *sk;
 
2539
 
 
2540
        if (!conn)
 
2541
                return 0;
 
2542
 
 
2543
        l = &conn->chan_list;
 
2544
 
 
2545
        BT_DBG("conn %p", conn);
 
2546
 
 
2547
        read_lock(&l->lock);
 
2548
 
 
2549
        for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
 
2550
                bh_lock_sock(sk);
 
2551
 
 
2552
                if (l2cap_pi(sk)->conf_state & L2CAP_CONF_CONNECT_PEND) {
 
2553
                        bh_unlock_sock(sk);
 
2554
                        continue;
 
2555
                }
 
2556
 
 
2557
                if (!status && (sk->sk_state == BT_CONNECTED ||
 
2558
                                                sk->sk_state == BT_CONFIG)) {
 
2559
                        l2cap_check_encryption(sk, encrypt);
2287
2560
                        bh_unlock_sock(sk);
2288
2561
                        continue;
2289
2562
                }
2381
2654
                        goto drop;
2382
2655
 
2383
2656
                skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2384
 
                              skb->len);
 
2657
                                                                skb->len);
2385
2658
                conn->rx_len = len - skb->len;
2386
2659
        } else {
2387
2660
                BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len);
2403
2676
                }
2404
2677
 
2405
2678
                skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2406
 
                              skb->len);
 
2679
                                                                skb->len);
2407
2680
                conn->rx_len -= skb->len;
2408
2681
 
2409
2682
                if (!conn->rx_len) {
2429
2702
        sk_for_each(sk, node, &l2cap_sk_list.head) {
2430
2703
                struct l2cap_pinfo *pi = l2cap_pi(sk);
2431
2704
 
2432
 
                str += sprintf(str, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d 0x%x\n",
 
2705
                str += sprintf(str, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d\n",
2433
2706
                                batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
2434
2707
                                sk->sk_state, btohs(pi->psm), pi->scid, pi->dcid,
2435
 
                                pi->imtu, pi->omtu, pi->link_mode);
 
2708
                                pi->imtu, pi->omtu, pi->sec_level);
2436
2709
        }
2437
2710
 
2438
2711
        read_unlock_bh(&l2cap_sk_list.lock);
2452
2725
        .accept         = l2cap_sock_accept,
2453
2726
        .getname        = l2cap_sock_getname,
2454
2727
        .sendmsg        = l2cap_sock_sendmsg,
2455
 
        .recvmsg        = bt_sock_recvmsg,
 
2728
        .recvmsg        = l2cap_sock_recvmsg,
2456
2729
        .poll           = bt_sock_poll,
2457
2730
        .ioctl          = bt_sock_ioctl,
2458
2731
        .mmap           = sock_no_mmap,
2474
2747
        .connect_ind    = l2cap_connect_ind,
2475
2748
        .connect_cfm    = l2cap_connect_cfm,
2476
2749
        .disconn_ind    = l2cap_disconn_ind,
2477
 
        .auth_cfm       = l2cap_auth_cfm,
2478
 
        .encrypt_cfm    = l2cap_encrypt_cfm,
 
2750
        .disconn_cfm    = l2cap_disconn_cfm,
 
2751
        .security_cfm   = l2cap_security_cfm,
2479
2752
        .recv_acldata   = l2cap_recv_acldata
2480
2753
};
2481
2754