Merge "RESTRICT AUTOMERGE Disallow unexpected incoming HID connections" into tm-dev (2377e234) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_hid_host.cpp

+5 −3

Original line number	Diff line number	Diff line
		@@ -282,7 +282,8 @@ static jboolean connectHidNative(JNIEnv* env, jobject object,
		}

		static jboolean disconnectHidNative(JNIEnv* env, jobject object,
		jbyteArray address) {
		jbyteArray address,
		jboolean reconnect_allowed) {
		jbyte* addr;
		jboolean ret = JNI_TRUE;
		if (!sBluetoothHidInterface) return JNI_FALSE;
		@@ -293,7 +294,8 @@ static jboolean disconnectHidNative(JNIEnv* env, jobject object,
		return JNI_FALSE;
		}

		bt_status_t status = sBluetoothHidInterface->disconnect((RawAddress*)addr);
		bt_status_t status =
		sBluetoothHidInterface->disconnect((RawAddress*)addr, reconnect_allowed);
		if (status != BT_STATUS_SUCCESS) {
		ALOGE("Failed disconnect hid channel, status: %d", status);
		ret = JNI_FALSE;
		@@ -509,7 +511,7 @@ static JNINativeMethod sMethods[] = {
		{"initializeNative", "()V", (void*)initializeNative},
		{"cleanupNative", "()V", (void*)cleanupNative},
		{"connectHidNative", "([B)Z", (void*)connectHidNative},
		{"disconnectHidNative", "([B)Z", (void*)disconnectHidNative},
		{"disconnectHidNative", "([BZ)Z", (void*)disconnectHidNative},
		{"getProtocolModeNative", "([B)Z", (void*)getProtocolModeNative},
		{"virtualUnPlugNative", "([B)Z", (void*)virtualUnPlugNative},
		{"setProtocolModeNative", "([BB)Z", (void*)setProtocolModeNative},

android/app/src/com/android/bluetooth/hid/HidHostService.java

+5 −2

Original line number	Diff line number	Diff line
		@@ -186,7 +186,10 @@ public class HidHostService extends ProfileService {
		break;
		case MESSAGE_DISCONNECT: {
		BluetoothDevice device = (BluetoothDevice) msg.obj;
		if (!disconnectHidNative(getByteAddress(device))) {
		int connectionPolicy = getConnectionPolicy(device);
		boolean reconnectAllowed =
		connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED;
		if (!disconnectHidNative(getByteAddress(device), reconnectAllowed)) {
		broadcastConnectionState(device, BluetoothProfile.STATE_DISCONNECTING);
		broadcastConnectionState(device, BluetoothProfile.STATE_DISCONNECTED);
		break;
		@@ -1019,7 +1022,7 @@ public class HidHostService extends ProfileService {

		private native boolean connectHidNative(byte[] btAddress);

		private native boolean disconnectHidNative(byte[] btAddress);
		private native boolean disconnectHidNative(byte[] btAddress, boolean reconnectAllowed);

		private native boolean getProtocolModeNative(byte[] btAddress);

system/btif/include/btif_hh.h

+3 −1

Original line number	Diff line number	Diff line
		@@ -106,6 +106,7 @@ typedef struct {
		uint8_t dev_handle;
		RawAddress bd_addr;
		tBTA_HH_ATTR_MASK attr_mask;
		bool reconnect_allowed;
		} btif_hh_added_device_t;

		/**
		@@ -130,7 +131,8 @@ extern btif_hh_cb_t btif_hh_cb;
		extern btif_hh_device_t* btif_hh_find_connected_dev_by_handle(uint8_t handle);
		extern void btif_hh_remove_device(RawAddress bd_addr);
		extern bool btif_hh_add_added_dev(const RawAddress& bda,
		tBTA_HH_ATTR_MASK attr_mask);
		tBTA_HH_ATTR_MASK attr_mask,
		bool reconnect_allowed);
		extern bt_status_t btif_hh_virtual_unplug(const RawAddress* bd_addr);
		extern void btif_hh_disconnect(RawAddress* bd_addr);
		extern void btif_hh_setreport(btif_hh_device_t* p_dev,

system/btif/include/btif_storage.h

+23 −0

Original line number	Diff line number	Diff line
		@@ -196,6 +196,29 @@ void btif_storage_load_consolidate_devices(void);
		******************************************************************************/
		bt_status_t btif_storage_load_bonded_devices(void);

		/*******************************************************************************
		*
		* Function btif_storage_set_hid_connection_policy
		*
		* Description Stores connection policy info in nvram
		*
		* Returns BT_STATUS_SUCCESS
		*
		******************************************************************************/
		bt_status_t btif_storage_set_hid_connection_policy(const RawAddress& addr,
		bool reconnect_allowed);
		/*******************************************************************************
		*
		* Function btif_storage_get_hid_connection_policy
		*
		* Description get connection policy info from nvram
		*
		* Returns BT_STATUS_SUCCESS
		*
		******************************************************************************/
		bt_status_t btif_storage_get_hid_connection_policy(const RawAddress& addr,
		bool* reconnect_allowed);

		/*******************************************************************************
		*
		* Function btif_storage_add_hid_device_info

system/btif/src/btif_hh.cc

+81 −5

Original line number	Diff line number	Diff line
		@@ -308,6 +308,24 @@ btif_hh_device_t* btif_hh_find_connected_dev_by_handle(uint8_t handle) {
		return &btif_hh_cb.devices[i];
		}
		}
		return nullptr;
		}

		/*******************************************************************************
		*
		* Function btif_hh_find_added_dev
		*
		* Description Return the added device pointer of the specified address
		*
		* Returns Added device entry
		******************************************************************************/
		btif_hh_added_device_t* btif_hh_find_added_dev(const RawAddress& addr) {
		for (int i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
		btif_hh_added_device_t* added_dev = &btif_hh_cb.added_devices[i];
		if (added_dev->bd_addr == addr) {
		return added_dev;
		}
		}
		return NULL;
		}

		@@ -351,6 +369,23 @@ static btif_hh_device_t* btif_hh_find_connected_dev_by_bda(
		return NULL;
		}

		static bool btif_hh_connection_allowed(const RawAddress& bda) {
		/* Accept connection only if reconnection is allowed for the known device, or
		* outgoing connection was requested */
		btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(bda);
		if (added_dev != nullptr && added_dev->reconnect_allowed) {
		LOG_VERBOSE("Connection allowed %s", PRIVATE_ADDRESS(bda));
		return true;
		} else if (btif_hh_cb.pending_conn_address == bda) {
		LOG_VERBOSE("Device connection was pending for: %s, status: %s",
		PRIVATE_ADDRESS(bda),
		btif_hh_status_text(btif_hh_cb.status).c_str());
		return true;
		}

		return false;
		}

		/*******************************************************************************
		*
		* Function btif_hh_stop_vup_timer
		@@ -396,7 +431,8 @@ void btif_hh_start_vup_timer(const RawAddress* bd_addr) {
		*
		* Returns true if add successfully, otherwise false.
		******************************************************************************/
		bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask) {
		bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask,
		bool reconnect_allowed) {
		int i;
		for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {
		if (btif_hh_cb.added_devices[i].bd_addr == bda) {
		@@ -410,6 +446,7 @@ bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask) {
		btif_hh_cb.added_devices[i].bd_addr = bda;
		btif_hh_cb.added_devices[i].dev_handle = BTA_HH_INVALID_HANDLE;
		btif_hh_cb.added_devices[i].attr_mask = attr_mask;
		btif_hh_cb.added_devices[i].reconnect_allowed = reconnect_allowed;
		return true;
		}
		}
		@@ -775,9 +812,26 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) {
		p_data->status);
		break;

		case BTA_HH_OPEN_EVT:
		case BTA_HH_OPEN_EVT: {
		BTIF_TRACE_WARNING("%s: BTA_HH_OPN_EVT: handle=%d, status =%d", __func__,
		p_data->conn.handle, p_data->conn.status);

		if (!btif_hh_connection_allowed(p_data->conn.bda)) {
		LOG_WARN("Reject incoming HID Connection, device: %s",
		PRIVATE_ADDRESS(p_data->conn.bda));
		btif_hh_device_t* p_dev =
		btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
		if (p_dev != nullptr) {
		p_dev->dev_status = BTHH_CONN_STATE_DISCONNECTED;
		}

		btif_hh_cb.status = (BTIF_HH_STATUS)BTIF_HH_DEV_DISCONNECTED;
		BTA_HhClose(p_data->conn.handle);
		HAL_CBACK(bt_hh_callbacks, connection_state_cb, &p_data->conn.bda,
		BTHH_CONN_STATE_DISCONNECTED);
		return;
		}

		btif_hh_cb.pending_conn_address = RawAddress::kEmpty;
		if (p_data->conn.status == BTA_HH_OK) {
		p_dev = btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
		@@ -836,6 +890,7 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) {
		btif_hh_cb.status = (BTIF_HH_STATUS)BTIF_HH_DEV_DISCONNECTED;
		}
		break;
		}

		case BTA_HH_CLOSE_EVT:
		BTIF_TRACE_DEBUG("BTA_HH_CLOSE_EVT: status = %d, handle = %d",
		@@ -1009,7 +1064,7 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) {
		p_data->dscp_info.version,
		p_data->dscp_info.ctry_code, len,
		p_data->dscp_info.descriptor.dsc_list);
		if (btif_hh_add_added_dev(p_dev->bd_addr, p_dev->attr_mask)) {
		if (btif_hh_add_added_dev(p_dev->bd_addr, p_dev->attr_mask, true)) {
		tBTA_HH_DEV_DSCP_INFO dscp_info;
		bt_status_t ret;
		btif_hh_copy_hid_info(&dscp_info, &p_data->dscp_info);
		@@ -1025,6 +1080,8 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) {
		p_data->dscp_info.ssr_min_tout, len,
		p_data->dscp_info.descriptor.dsc_list);

		btif_storage_set_hid_connection_policy(p_dev->bd_addr, true);

		ASSERTC(ret == BT_STATUS_SUCCESS, "storing hid info failed", ret);
		BTIF_TRACE_WARNING("BTA_HH_GET_DSCP_EVT: Called add device");

		@@ -1312,6 +1369,13 @@ static bt_status_t init(bthh_callbacks_t* callbacks) {
		******************************************************************************/
		static bt_status_t connect(RawAddress* bd_addr) {
		if (btif_hh_cb.status != BTIF_HH_DEV_CONNECTING) {
		/* If the device was already added, ensure that reconnections are allowed */
		btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(*bd_addr);
		if (added_dev != nullptr && !added_dev->reconnect_allowed) {
		added_dev->reconnect_allowed = true;
		btif_storage_set_hid_connection_policy(*bd_addr, true);
		}

		btif_transfer_context(btif_hh_handle_evt, BTIF_HH_CONNECT_REQ_EVT,
		(char*)bd_addr, sizeof(RawAddress), NULL);
		return BT_STATUS_SUCCESS;
		@@ -1332,7 +1396,7 @@ static bt_status_t connect(RawAddress* bd_addr) {
		* Returns bt_status_t
		*
		******************************************************************************/
		static bt_status_t disconnect(RawAddress* bd_addr) {
		static bt_status_t disconnect(RawAddress* bd_addr, bool reconnect_allowed) {
		CHECK_BTHH_INIT();
		BTIF_TRACE_EVENT("BTHH: %s", __func__);
		btif_hh_device_t* p_dev;
		@@ -1342,6 +1406,17 @@ static bt_status_t disconnect(RawAddress* bd_addr) {
		btif_hh_cb.status);
		return BT_STATUS_FAIL;
		}

		if (!reconnect_allowed) {
		LOG_INFO("Incoming reconnections disabled for device %s",
		PRIVATE_ADDRESS((*bd_addr)));
		btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(*bd_addr);
		if (added_dev != nullptr && added_dev->reconnect_allowed) {
		added_dev->reconnect_allowed = false;
		btif_storage_set_hid_connection_policy(added_dev->bd_addr, false);
		}
		}

		p_dev = btif_hh_find_connected_dev_by_bda(*bd_addr);
		if (p_dev != NULL) {
		return btif_transfer_context(btif_hh_handle_evt, BTIF_HH_DISCONNECT_REQ_EVT,
		@@ -1473,9 +1548,10 @@ static bt_status_t set_info(RawAddress* bd_addr, bthh_hid_info_t hid_info) {
		(uint8_t*)osi_malloc(dscp_info.descriptor.dl_len);
		memcpy(dscp_info.descriptor.dsc_list, &(hid_info.dsc_list), hid_info.dl_len);

		if (btif_hh_add_added_dev(*bd_addr, hid_info.attr_mask)) {
		if (btif_hh_add_added_dev(*bd_addr, hid_info.attr_mask, true)) {
		BTA_HhAddDev(*bd_addr, hid_info.attr_mask, hid_info.sub_class,
		hid_info.app_id, dscp_info);
		btif_storage_set_hid_connection_policy(*bd_addr, true);
		}

		osi_free_and_reset((void**)&dscp_info.descriptor.dsc_list);