Lines Matching defs:conn
172 struct hci_conn *conn;
181 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
182 if (conn)
183 conn->role = rp->role;
194 struct hci_conn *conn;
203 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
204 if (conn)
205 conn->link_policy = __le16_to_cpu(rp->policy);
216 struct hci_conn *conn;
230 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
231 if (conn)
232 conn->link_policy = get_unaligned_le16(sent + 2);
724 struct hci_conn *conn;
734 conn = hci_conn_hash_lookup_handle(hdev, handle);
735 if (!conn) {
747 conn->enc_key_size = 0;
749 conn->enc_key_size = rp->key_size;
752 if (conn->enc_key_size < hdev->min_enc_key_size) {
753 /* As slave role, the conn->state has been set to
754 * BT_CONNECTED and l2cap conn req might not be received
758 * handler of l2cap conn req will get the right secure
762 clear_bit(HCI_CONN_ENCRYPT, &conn->flags);
763 clear_bit(HCI_CONN_AES_CCM, &conn->flags);
767 hci_encrypt_cfm(conn, status);
796 struct hci_conn *conn;
805 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
806 if (conn)
807 conn->auth_payload_timeout = __le16_to_cpu(rp->timeout);
818 struct hci_conn *conn;
829 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
830 if (!conn) {
836 conn->auth_payload_timeout = get_unaligned_le16(sent + 2);
1102 struct hci_conn *conn;
1120 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
1121 if (conn) {
1122 conn->clock = le32_to_cpu(rp->clock);
1123 conn->clock_accuracy = le16_to_cpu(rp->accuracy);
1210 struct hci_conn *conn;
1226 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1227 if (conn)
1228 conn->pin_length = cp->pin_len;
1611 struct hci_conn *conn;
1615 conn = hci_lookup_le_connect(hdev);
1616 if (conn)
1618 &conn->le_conn_timeout,
1619 conn->conn_timeout);
1654 struct hci_conn *conn;
1661 conn = hci_lookup_le_connect(hdev);
1662 if (conn)
1664 &conn->le_conn_timeout,
1665 conn->conn_timeout);
2239 struct hci_conn *conn;
2248 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
2249 if (conn)
2250 conn->rssi = rp->rssi;
2262 struct hci_conn *conn;
2275 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
2276 if (!conn)
2281 conn->tx_power = rp->tx_power;
2284 conn->max_tx_power = rp->tx_power;
2327 struct hci_conn *conn;
2337 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
2339 bt_dev_dbg(hdev, "bdaddr %pMR hcon %p", &cp->bdaddr, conn);
2342 if (conn && conn->state == BT_CONNECT) {
2343 if (status != 0x0c || conn->attempt > 2) {
2344 conn->state = BT_CLOSED;
2345 hci_connect_cfm(conn, status);
2346 hci_conn_del(conn);
2348 conn->state = BT_CONNECT2;
2351 if (!conn) {
2352 conn = hci_conn_add_unset(hdev, ACL_LINK, &cp->bdaddr,
2354 if (!conn)
2388 if (link && link->conn) {
2389 link->conn->state = BT_CLOSED;
2391 hci_connect_cfm(link->conn, status);
2392 hci_conn_del(link->conn);
2402 struct hci_conn *conn;
2415 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2416 if (conn) {
2417 if (conn->state == BT_CONFIG) {
2418 hci_connect_cfm(conn, status);
2419 hci_conn_drop(conn);
2429 struct hci_conn *conn;
2442 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2443 if (conn) {
2444 if (conn->state == BT_CONFIG) {
2445 hci_connect_cfm(conn, status);
2446 hci_conn_drop(conn);
2454 struct hci_conn *conn)
2456 if (conn->state != BT_CONFIG || !conn->out)
2459 if (conn->pending_sec_level == BT_SECURITY_SDP)
2466 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
2467 conn->pending_sec_level != BT_SECURITY_FIPS &&
2468 conn->pending_sec_level != BT_SECURITY_HIGH &&
2469 conn->pending_sec_level != BT_SECURITY_MEDIUM)
2516 static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
2523 * conn objects that exist but are not (yet) connected however.
2527 if (conn && (conn->state == BT_CONFIG || conn->state == BT_CONNECTED))
2528 mgmt_device_connected(hdev, conn, name, name_len);
2563 struct hci_conn *conn;
2578 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
2581 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
2583 if (!conn)
2586 if (!hci_outgoing_auth_needed(hdev, conn))
2589 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
2592 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
2594 auth_cp.handle = __cpu_to_le16(conn->handle);
2606 struct hci_conn *conn;
2619 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2620 if (conn) {
2621 if (conn->state == BT_CONFIG) {
2622 hci_connect_cfm(conn, status);
2623 hci_conn_drop(conn);
2633 struct hci_conn *conn;
2646 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2647 if (conn) {
2648 if (conn->state == BT_CONFIG) {
2649 hci_connect_cfm(conn, status);
2650 hci_conn_drop(conn);
2671 if (link && link->conn) {
2672 link->conn->state = BT_CLOSED;
2674 hci_connect_cfm(link->conn, status);
2675 hci_conn_del(link->conn);
2717 struct hci_conn *conn;
2730 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2731 if (conn) {
2732 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
2734 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
2735 hci_sco_setup(conn, status);
2744 struct hci_conn *conn;
2757 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2758 if (conn) {
2759 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
2761 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
2762 hci_sco_setup(conn, status);
2772 struct hci_conn *conn;
2789 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2790 if (!conn)
2794 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
2795 conn->dst_type, status);
2797 if (conn->type == LE_LINK && conn->role == HCI_ROLE_SLAVE) {
2798 hdev->cur_adv_instance = conn->adv_instance;
2802 /* Inform sockets conn is gone before we delete it */
2803 hci_disconn_cfm(conn, HCI_ERROR_UNSPECIFIED);
2808 mgmt_conn = test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags);
2810 if (conn->type == ACL_LINK) {
2811 if (test_and_clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags))
2812 hci_remove_link_key(hdev, &conn->dst);
2815 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
2834 mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,
2837 hci_disconn_cfm(conn, cp->reason);
2845 hci_conn_del(conn);
2876 struct hci_conn *conn;
2878 conn = hci_conn_hash_lookup_le(hdev, peer_addr,
2880 if (!conn)
2889 conn->init_addr_type = own_address_type;
2891 bacpy(&conn->init_addr, &hdev->random_addr);
2893 bacpy(&conn->init_addr, &hdev->bdaddr);
2895 conn->resp_addr_type = peer_addr_type;
2896 bacpy(&conn->resp_addr, peer_addr);
2952 struct hci_conn *conn;
2965 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2966 if (conn) {
2967 if (conn->state == BT_CONFIG) {
2968 hci_connect_cfm(conn, status);
2969 hci_conn_drop(conn);
2979 struct hci_conn *conn;
2992 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2993 if (!conn)
2996 if (conn->state != BT_CONNECTED)
2999 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
3000 hci_conn_drop(conn);
3009 struct hci_conn *conn;
3022 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
3023 if (conn)
3024 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
3138 struct hci_conn *conn;
3145 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
3146 if (!conn) {
3166 conn = hci_conn_add_unset(hdev, ev->link_type,
3168 if (!conn) {
3169 bt_dev_err(hdev, "no memory for new conn");
3176 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK,
3178 if (!conn)
3181 conn->type = SCO_LINK;
3191 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
3197 status = hci_conn_set_handle(conn, __le16_to_cpu(ev->handle));
3201 if (conn->type == ACL_LINK) {
3202 conn->state = BT_CONFIG;
3203 hci_conn_hold(conn);
3205 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
3207 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
3209 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
3211 conn->state = BT_CONNECTED;
3213 hci_debugfs_create_conn(conn);
3214 hci_conn_add_sysfs(conn);
3217 set_bit(HCI_CONN_AUTH, &conn->flags);
3220 set_bit(HCI_CONN_ENCRYPT, &conn->flags);
3223 if (conn->type == ACL_LINK) {
3233 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
3236 cp.pkt_type = cpu_to_le16(conn->pkt_type);
3242 if (conn->type == ACL_LINK)
3243 hci_sco_setup(conn, ev->status);
3247 hci_conn_failed(conn, status);
3249 switch (conn->setting & SCO_AIRMODE_MASK) {
3256 hci_connect_cfm(conn, status);
3280 struct hci_conn *conn;
3329 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
3331 if (!conn) {
3332 conn = hci_conn_add_unset(hdev, ev->link_type, &ev->bdaddr,
3334 if (!conn) {
3340 memcpy(conn->dev_class, ev->dev_class, 3);
3347 conn->state = BT_CONNECT;
3359 conn->state = BT_CONNECT;
3362 cp.pkt_type = cpu_to_le16(conn->pkt_type);
3373 conn->state = BT_CONNECT2;
3374 hci_connect_cfm(conn, 0);
3404 struct hci_conn *conn;
3411 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3412 if (!conn)
3416 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
3417 conn->dst_type, ev->status);
3421 conn->state = BT_CLOSED;
3423 mgmt_connected = test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags);
3425 if (test_bit(HCI_CONN_AUTH_FAILURE, &conn->flags))
3430 mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,
3433 if (conn->type == ACL_LINK) {
3434 if (test_and_clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags))
3435 hci_remove_link_key(hdev, &conn->dst);
3440 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
3460 hci_disconn_cfm(conn, ev->reason);
3472 if (conn->type == LE_LINK && conn->role == HCI_ROLE_SLAVE) {
3473 hdev->cur_adv_instance = conn->adv_instance;
3477 hci_conn_del(conn);
3487 struct hci_conn *conn;
3493 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3494 if (!conn)
3498 clear_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3499 set_bit(HCI_CONN_AUTH, &conn->flags);
3500 conn->sec_level = conn->pending_sec_level;
3503 set_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3505 mgmt_auth_failed(conn, ev->status);
3508 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
3510 if (conn->state == BT_CONFIG) {
3511 if (!ev->status && hci_conn_ssp_enabled(conn)) {
3518 conn->state = BT_CONNECTED;
3519 hci_connect_cfm(conn, ev->status);
3520 hci_conn_drop(conn);
3523 hci_auth_cfm(conn, ev->status);
3525 hci_conn_hold(conn);
3526 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
3527 hci_conn_drop(conn);
3530 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
3538 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3539 hci_encrypt_cfm(conn, ev->status);
3551 struct hci_conn *conn;
3557 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3563 hci_check_pending_name(hdev, conn, &ev->bdaddr, ev->name,
3566 hci_check_pending_name(hdev, conn, &ev->bdaddr, NULL, 0);
3569 if (!conn)
3572 if (!hci_outgoing_auth_needed(hdev, conn))
3575 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
3578 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
3580 cp.handle = __cpu_to_le16(conn->handle);
3592 struct hci_conn *conn;
3598 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3599 if (!conn)
3605 set_bit(HCI_CONN_AUTH, &conn->flags);
3606 set_bit(HCI_CONN_ENCRYPT, &conn->flags);
3607 conn->sec_level = conn->pending_sec_level;
3610 if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256)
3611 set_bit(HCI_CONN_FIPS, &conn->flags);
3613 if ((conn->type == ACL_LINK && ev->encrypt == 0x02) ||
3614 conn->type == LE_LINK)
3615 set_bit(HCI_CONN_AES_CCM, &conn->flags);
3617 clear_bit(HCI_CONN_ENCRYPT, &conn->flags);
3618 clear_bit(HCI_CONN_AES_CCM, &conn->flags);
3625 if (ev->status && conn->type == LE_LINK) {
3630 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3633 if (!hci_conn_check_link_mode(conn))
3636 if (ev->status && conn->state == BT_CONNECTED) {
3638 set_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3643 hci_encrypt_cfm(conn, ev->status);
3644 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
3645 hci_conn_drop(conn);
3650 if (!ev->status && ev->encrypt && conn->type == ACL_LINK) {
3658 conn->enc_key_size = HCI_LINK_KEY_SIZE;
3662 cp.handle = cpu_to_le16(conn->handle);
3666 conn->enc_key_size = HCI_LINK_KEY_SIZE;
3676 * sent when the link is active and Encryption is enabled, the conn
3680 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags) &&
3681 test_bit(HCI_CONN_AES_CCM, &conn->flags) &&
3682 ((conn->type == ACL_LINK && lmp_ping_capable(hdev)) ||
3683 (conn->type == LE_LINK && (hdev->le_features[0] & HCI_LE_PING)))) {
3686 cp.handle = cpu_to_le16(conn->handle);
3688 if (hci_send_cmd(conn->hdev, HCI_OP_WRITE_AUTH_PAYLOAD_TO,
3694 hci_encrypt_cfm(conn, ev->status);
3704 struct hci_conn *conn;
3710 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3711 if (conn) {
3713 set_bit(HCI_CONN_SECURE, &conn->flags);
3715 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
3717 hci_key_change_cfm(conn, ev->status);
3727 struct hci_conn *conn;
3733 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3734 if (!conn)
3738 memcpy(conn->features[0], ev->features, 8);
3740 if (conn->state != BT_CONFIG)
3744 lmp_ext_feat_capable(conn)) {
3753 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
3756 bacpy(&cp.bdaddr, &conn->dst);
3760 mgmt_device_connected(hdev, conn, NULL, 0);
3763 if (!hci_outgoing_auth_needed(hdev, conn)) {
3764 conn->state = BT_CONNECTED;
3765 hci_connect_cfm(conn, ev->status);
3766 hci_conn_drop(conn);
3817 struct hci_conn *conn, *tmp;
3821 list_for_each_entry_safe(conn, tmp, &hdev->conn_hash.list, list) {
3822 if (conn->type != ISO_LINK || !bacmp(&conn->dst, BDADDR_ANY) ||
3823 conn->state == BT_OPEN || conn->iso_qos.ucast.cig != cig)
3826 if (HCI_CONN_HANDLE_UNSET(conn->handle))
3827 hci_conn_failed(conn, status);
3836 struct hci_conn *conn;
3872 conn = hci_conn_hash_lookup_cis(hdev, NULL, 0, rp->cig_id,
3874 if (!conn || !bacmp(&conn->dst, BDADDR_ANY))
3877 if (conn->state != BT_BOUND && conn->state != BT_CONNECT)
3880 if (hci_conn_set_handle(conn, __le16_to_cpu(rp->handle[i])))
3883 if (conn->state == BT_CONNECT)
3901 struct hci_conn *conn;
3911 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
3912 if (!conn)
3916 hci_connect_cfm(conn, rp->status);
3917 hci_conn_del(conn);
3925 if (conn->iso_qos.ucast.out.sdu && !conn->iso_qos.ucast.in.sdu)
3926 hci_connect_cfm(conn, rp->status);
3930 /* Confirm connection since conn->iso_qos is always configured
3933 hci_connect_cfm(conn, rp->status);
3936 if (!rp->status && test_bit(HCI_CONN_BIG_SYNC, &conn->flags))
3937 mgmt_device_connected(hdev, conn, NULL, 0);
3967 /* TODO: set the conn state */
4300 struct hci_conn *conn;
4305 conn = hci_conn_hash_lookup_handle(hdev, handle);
4306 if (conn) {
4308 &conn->flags))
4310 conn->state = BT_CLOSED;
4311 hci_connect_cfm(conn, status);
4312 hci_conn_del(conn);
4414 struct hci_conn *conn;
4420 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4421 if (conn) {
4423 conn->role = ev->role;
4425 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
4427 hci_role_switch_cfm(conn, ev->status, ev->role);
4452 struct hci_conn *conn;
4458 conn = hci_conn_hash_lookup_handle(hdev, handle);
4459 if (!conn)
4462 conn->sent -= count;
4464 switch (conn->type) {
4506 bt_dev_err(hdev, "unknown type %d conn %p",
4507 conn->type, conn);
4526 return chan->conn;
4557 struct hci_conn *conn = NULL;
4563 conn = __hci_conn_lookup_handle(hdev, handle);
4564 if (!conn)
4567 conn->sent -= block_count;
4569 switch (conn->type) {
4578 bt_dev_err(hdev, "unknown type %d conn %p",
4579 conn->type, conn);
4591 struct hci_conn *conn;
4597 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4598 if (conn) {
4599 conn->mode = ev->mode;
4602 &conn->flags)) {
4603 if (conn->mode == HCI_CM_ACTIVE)
4604 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
4606 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
4609 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
4610 hci_sco_setup(conn, ev->status);
4620 struct hci_conn *conn;
4626 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4627 if (!conn)
4630 if (conn->state == BT_CONNECTED) {
4631 hci_conn_hold(conn);
4632 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
4633 hci_conn_drop(conn);
4637 !test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags)) {
4643 if (conn->pending_sec_level == BT_SECURITY_HIGH)
4655 static void conn_set_key(struct hci_conn *conn, u8 key_type, u8 pin_len)
4660 conn->pin_length = pin_len;
4661 conn->key_type = key_type;
4670 conn->pending_sec_level = BT_SECURITY_HIGH;
4672 conn->pending_sec_level = BT_SECURITY_MEDIUM;
4676 conn->pending_sec_level = BT_SECURITY_MEDIUM;
4679 conn->pending_sec_level = BT_SECURITY_HIGH;
4682 conn->pending_sec_level = BT_SECURITY_FIPS;
4692 struct hci_conn *conn;
4710 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4711 if (conn) {
4712 clear_bit(HCI_CONN_NEW_LINK_KEY, &conn->flags);
4716 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
4722 (conn->pending_sec_level == BT_SECURITY_HIGH ||
4723 conn->pending_sec_level == BT_SECURITY_FIPS)) {
4728 conn_set_key(conn, key->type, key->pin_len);
4749 struct hci_conn *conn;
4758 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4759 if (!conn)
4766 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
4767 hci_conn_drop(conn);
4771 hci_conn_hold(conn);
4772 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
4773 hci_conn_drop(conn);
4775 set_bit(HCI_CONN_NEW_LINK_KEY, &conn->flags);
4776 conn_set_key(conn, ev->key_type, conn->pin_length);
4781 key = hci_add_link_key(hdev, conn, &ev->bdaddr, ev->link_key,
4790 conn_set_key(conn, key->type, key->pin_len);
4807 clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags);
4809 set_bit(HCI_CONN_FLUSH_KEY, &conn->flags);
4819 struct hci_conn *conn;
4825 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4826 if (conn && !ev->status) {
4829 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
4843 struct hci_conn *conn;
4849 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4850 if (conn && !ev->status)
4851 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
4966 struct hci_conn *conn;
4972 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4973 if (!conn)
4977 memcpy(conn->features[ev->page], ev->features, 8);
4982 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
4987 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
4997 clear_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
5001 set_bit(HCI_CONN_SC_ENABLED, &conn->flags);
5004 if (conn->state != BT_CONFIG)
5007 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
5010 bacpy(&cp.bdaddr, &conn->dst);
5014 mgmt_device_connected(hdev, conn, NULL, 0);
5017 if (!hci_outgoing_auth_needed(hdev, conn)) {
5018 conn->state = BT_CONNECTED;
5019 hci_connect_cfm(conn, ev->status);
5020 hci_conn_drop(conn);
5031 struct hci_conn *conn;
5051 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
5052 if (!conn) {
5065 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
5066 if (!conn)
5076 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
5083 status = hci_conn_set_handle(conn, __le16_to_cpu(ev->handle));
5085 conn->state = BT_CLOSED;
5089 conn->state = BT_CONNECTED;
5090 conn->type = ev->link_type;
5092 hci_debugfs_create_conn(conn);
5093 hci_conn_add_sysfs(conn);
5104 if (conn->out) {
5105 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
5107 if (hci_setup_sync(conn, conn->parent->handle))
5113 conn->state = BT_CLOSED;
5121 if (conn->codec.data_path == 0 && hdev->notify) {
5132 hci_connect_cfm(conn, status);
5134 hci_conn_del(conn);
5216 struct hci_conn *conn;
5223 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
5224 if (!conn)
5230 if (conn->type != LE_LINK)
5234 conn->sec_level = conn->pending_sec_level;
5236 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
5238 if (ev->status && conn->state == BT_CONNECTED) {
5239 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
5240 hci_conn_drop(conn);
5244 if (conn->state == BT_CONFIG) {
5246 conn->state = BT_CONNECTED;
5248 hci_connect_cfm(conn, ev->status);
5249 hci_conn_drop(conn);
5251 hci_auth_cfm(conn, ev->status);
5253 hci_conn_hold(conn);
5254 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
5255 hci_conn_drop(conn);
5262 static u8 hci_get_auth_req(struct hci_conn *conn)
5265 if (conn->remote_auth == HCI_AT_NO_BONDING ||
5266 conn->remote_auth == HCI_AT_NO_BONDING_MITM)
5267 return conn->remote_auth | (conn->auth_type & 0x01);
5272 if (conn->remote_cap != HCI_IO_NO_INPUT_OUTPUT &&
5273 conn->io_capability != HCI_IO_NO_INPUT_OUTPUT)
5274 return conn->remote_auth | 0x01;
5277 return (conn->remote_auth & ~0x01) | (conn->auth_type & 0x01);
5280 static u8 bredr_oob_data_present(struct hci_conn *conn)
5282 struct hci_dev *hdev = conn->hdev;
5285 data = hci_find_remote_oob_data(hdev, &conn->dst, BDADDR_BREDR);
5326 struct hci_conn *conn;
5332 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5333 if (!conn || !hci_dev_test_flag(hdev, HCI_SSP_ENABLED))
5337 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
5339 hci_conn_hold(conn);
5348 test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags) ||
5349 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
5355 cp.capability = (conn->io_capability == 0x04) ?
5356 HCI_IO_DISPLAY_YESNO : conn->io_capability;
5359 if (conn->remote_auth == 0xff) {
5363 if (conn->io_capability != HCI_IO_NO_INPUT_OUTPUT &&
5364 conn->auth_type != HCI_AT_NO_BONDING)
5365 conn->auth_type |= 0x01;
5367 conn->auth_type = hci_get_auth_req(conn);
5374 conn->auth_type &= HCI_AT_NO_BONDING_MITM;
5376 cp.authentication = conn->auth_type;
5377 cp.oob_data = bredr_oob_data_present(conn);
5399 struct hci_conn *conn;
5405 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5406 if (!conn)
5409 conn->remote_cap = ev->capability;
5410 conn->remote_auth = ev->authentication;
5421 struct hci_conn *conn;
5430 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5431 if (!conn)
5434 loc_mitm = (conn->auth_type & 0x01);
5435 rem_mitm = (conn->remote_auth & 0x01);
5440 * necessarily match conn->auth_type.
5442 if (conn->pending_sec_level > BT_SECURITY_MEDIUM &&
5443 conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) {
5451 if ((!loc_mitm || conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) &&
5452 (!rem_mitm || conn->io_capability == HCI_IO_NO_INPUT_OUTPUT)) {
5460 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) &&
5461 conn->io_capability != HCI_IO_NO_INPUT_OUTPUT &&
5483 queue_delayed_work(conn->hdev->workqueue,
5484 &conn->auto_accept_work, delay);
5516 struct hci_conn *conn;
5520 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5521 if (!conn)
5524 conn->passkey_notify = __le32_to_cpu(ev->passkey);
5525 conn->passkey_entered = 0;
5528 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
5529 conn->dst_type, conn->passkey_notify,
5530 conn->passkey_entered);
5537 struct hci_conn *conn;
5541 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5542 if (!conn)
5547 conn->passkey_entered = 0;
5551 conn->passkey_entered++;
5555 conn->passkey_entered--;
5559 conn->passkey_entered = 0;
5567 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
5568 conn->dst_type, conn->passkey_notify,
5569 conn->passkey_entered);
5576 struct hci_conn *conn;
5582 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5583 if (!conn || !hci_conn_ssp_enabled(conn))
5587 conn->remote_auth = 0xff;
5594 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
5595 mgmt_auth_failed(conn, ev->status);
5597 hci_conn_drop(conn);
5608 struct hci_conn *conn;
5614 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5615 if (conn)
5616 memcpy(conn->features[1], ev->features, 8);
5767 bredr_chan->conn->mtu = hdev->block_mtu;
5823 static void le_conn_update_addr(struct hci_conn *conn, bdaddr_t *bdaddr,
5826 if (conn->out) {
5827 conn->dst_type = bdaddr_type;
5828 conn->resp_addr_type = bdaddr_type;
5829 bacpy(&conn->resp_addr, bdaddr);
5835 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5836 bacpy(&conn->init_addr, local_rpa);
5837 } else if (hci_dev_test_flag(conn->hdev, HCI_PRIVACY)) {
5838 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5839 bacpy(&conn->init_addr, &conn->hdev->rpa);
5841 hci_copy_identity_address(conn->hdev, &conn->init_addr,
5842 &conn->init_addr_type);
5845 conn->resp_addr_type = conn->hdev->adv_addr_type;
5850 conn->resp_addr_type = ADDR_LE_DEV_RANDOM;
5851 bacpy(&conn->resp_addr, local_rpa);
5852 } else if (conn->hdev->adv_addr_type == ADDR_LE_DEV_RANDOM) {
5856 if (!ext_adv_capable(conn->hdev))
5857 bacpy(&conn->resp_addr,
5858 &conn->hdev->random_addr);
5860 bacpy(&conn->resp_addr, &conn->hdev->bdaddr);
5863 conn->init_addr_type = bdaddr_type;
5864 bacpy(&conn->init_addr, bdaddr);
5871 conn->le_conn_min_interval = conn->hdev->le_conn_min_interval;
5872 conn->le_conn_max_interval = conn->hdev->le_conn_max_interval;
5883 struct hci_conn *conn;
5894 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, bdaddr);
5895 if (!conn) {
5902 conn = hci_conn_add_unset(hdev, LE_LINK, bdaddr, role);
5903 if (!conn) {
5908 conn->dst_type = bdaddr_type;
5918 if (conn->out) {
5919 conn->resp_addr_type = bdaddr_type;
5920 bacpy(&conn->resp_addr, bdaddr);
5922 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5923 bacpy(&conn->init_addr, &hdev->rpa);
5926 &conn->init_addr,
5927 &conn->init_addr_type);
5931 cancel_delayed_work(&conn->le_conn_timeout);
5940 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
5945 le_conn_update_addr(conn, bdaddr, bdaddr_type, local_rpa);
5956 irk = hci_get_irk(hdev, &conn->dst, conn->dst_type);
5958 bacpy(&conn->dst, &irk->bdaddr);
5959 conn->dst_type = irk->addr_type;
5962 conn->dst_type = ev_bdaddr_type(hdev, conn->dst_type, NULL);
5968 if (status || hci_conn_set_handle(conn, handle))
5972 if (test_bit(HCI_CONN_CANCEL, &conn->flags)) {
5973 hci_conn_drop(conn);
5977 if (conn->dst_type == ADDR_LE_DEV_PUBLIC)
5983 if (hci_bdaddr_list_lookup(&hdev->reject_list, &conn->dst, addr_type)) {
5984 hci_conn_drop(conn);
5988 mgmt_device_connected(hdev, conn, NULL, 0);
5990 conn->sec_level = BT_SECURITY_LOW;
5991 conn->state = BT_CONFIG;
5998 conn->adv_instance = hdev->cur_adv_instance;
6000 conn->le_conn_interval = interval;
6001 conn->le_conn_latency = latency;
6002 conn->le_supv_timeout = supervision_timeout;
6004 hci_debugfs_create_conn(conn);
6005 hci_conn_add_sysfs(conn);
6016 if (conn->out ||
6020 cp.handle = __cpu_to_le16(conn->handle);
6025 hci_conn_hold(conn);
6027 conn->state = BT_CONNECTED;
6028 hci_connect_cfm(conn, status);
6031 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,
6032 conn->dst_type);
6035 if (params->conn) {
6036 hci_conn_drop(params->conn);
6037 hci_conn_put(params->conn);
6038 params->conn = NULL;
6079 struct hci_conn *conn;
6121 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->conn_handle));
6122 if (conn) {
6126 conn->adv_instance = ev->handle;
6129 bacmp(&conn->resp_addr, BDADDR_ANY))
6133 bacpy(&conn->resp_addr, &hdev->random_addr);
6138 bacpy(&conn->resp_addr, &adv->random_addr);
6149 struct hci_conn *conn;
6158 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6159 if (conn) {
6160 conn->le_conn_interval = le16_to_cpu(ev->interval);
6161 conn->le_conn_latency = le16_to_cpu(ev->latency);
6162 conn->le_supv_timeout = le16_to_cpu(ev->supervision_timeout);
6174 struct hci_conn *conn;
6225 conn = hci_connect_le(hdev, addr, addr_type, addr_resolved,
6228 if (!IS_ERR(conn)) {
6229 /* If HCI_AUTO_CONN_EXPLICIT is set, conn is already owned
6239 params->conn = hci_conn_get(conn);
6241 return conn;
6244 switch (PTR_ERR(conn)) {
6253 BT_DBG("Failed to connect: err %ld", PTR_ERR(conn));
6267 struct hci_conn *conn;
6350 conn = check_pending_le_conn(hdev, bdaddr, bdaddr_type, bdaddr_resolved,
6352 if (!ext_adv && conn && type == LE_ADV_IND &&
6357 memcpy(conn->le_adv_data, data, len);
6358 conn->le_adv_data_len = len;
6664 struct hci_conn *conn;
6670 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6671 if (conn) {
6673 memcpy(conn->features[0], ev->features, 8);
6675 if (conn->state == BT_CONFIG) {
6687 if (!conn->out && ev->status == 0x1a &&
6693 conn->state = BT_CONNECTED;
6694 hci_connect_cfm(conn, status);
6695 hci_conn_drop(conn);
6708 struct hci_conn *conn;
6715 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6716 if (conn == NULL)
6719 ltk = hci_find_ltk(hdev, &conn->dst, conn->dst_type, conn->role);
6735 cp.handle = cpu_to_le16(conn->handle);
6737 conn->pending_sec_level = smp_ltk_sec_level(ltk);
6739 conn->enc_key_size = ltk->enc_size;
6750 set_bit(HCI_CONN_STK_ENCRYPT, &conn->flags);
6754 clear_bit(HCI_CONN_STK_ENCRYPT, &conn->flags);
6875 struct hci_conn *conn;
6884 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6885 if (!conn)
6888 conn->le_tx_phy = ev->tx_phy;
6889 conn->le_rx_phy = ev->rx_phy;
6899 struct hci_conn *conn;
6908 conn = hci_conn_hash_lookup_handle(hdev, handle);
6909 if (!conn) {
6916 if (conn->type != ISO_LINK) {
6923 qos = &conn->iso_qos;
6925 pending = test_and_clear_bit(HCI_CONN_CREATE_CIS, &conn->flags);
6931 switch (conn->role) {
6961 conn->state = BT_CONNECTED;
6962 hci_debugfs_create_conn(conn);
6963 hci_conn_add_sysfs(conn);
6964 hci_iso_setup_path(conn);
6968 conn->state = BT_CLOSED;
6969 hci_connect_cfm(conn, ev->status);
6970 hci_conn_del(conn);
7061 struct hci_conn *conn;
7074 list_for_each_entry_rcu(conn, &hdev->conn_hash.list, list) {
7075 if (bacmp(&conn->dst, BDADDR_ANY) ||
7076 conn->type != ISO_LINK ||
7077 conn->iso_qos.bcast.big != ev->handle)
7080 if (hci_conn_set_handle(conn,
7085 conn->state = BT_CONNECTED;
7086 set_bit(HCI_CONN_BIG_CREATED, &conn->flags);
7088 hci_debugfs_create_conn(conn);
7089 hci_conn_add_sysfs(conn);
7090 hci_iso_setup_path(conn);
7095 hci_connect_cfm(conn, ev->status);
7097 hci_conn_del(conn);