Commit 3fe318ee authored by Brian Gix's avatar Brian Gix Committed by Luiz Augusto von Dentz
Browse files

Bluetooth: move hci_get_random_address() to hci_sync 



This function has no dependencies on the deprecated hci_request
mechanism, so has been moved unchanged to hci_sync.c

Signed-off-by: default avatarBrian Gix <brian.gix@intel.com>
Signed-off-by: default avatarLuiz Augusto von Dentz <luiz.von.dentz@intel.com>
parent dd50a864

include/net/bluetooth/hci_sync.h

+5 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ struct hci_cmd_sync_work_entry { 
	hci_cmd_sync_work_destroy_t destroy;

};



struct adv_info;

/* Function with sync suffix shall not be called with hdev->lock held as they

 * wait the command to complete and in the meantime an event could be received

 * which could attempt to acquire hdev->lock causing a deadlock.
@@ -51,6 +52,10 @@ int hci_update_class_sync(struct hci_dev *hdev); 
int hci_update_name_sync(struct hci_dev *hdev);

int hci_write_ssp_mode_sync(struct hci_dev *hdev, u8 mode);



int hci_get_random_address(struct hci_dev *hdev, bool require_privacy,

			   bool use_rpa, struct adv_info *adv_instance,

			   u8 *own_addr_type, bdaddr_t *rand_addr);



int hci_update_random_address_sync(struct hci_dev *hdev, bool require_privacy,

				   bool rpa, u8 *own_addr_type);

net/bluetooth/hci_request.c

+92 −163
Original line number Diff line number Diff line
@@ -650,6 +650,96 @@ static inline bool hci_is_le_conn_scanning(struct hci_dev *hdev) 
	return false;

}



static void set_random_addr(struct hci_request *req, bdaddr_t *rpa);

static int hci_update_random_address(struct hci_request *req,

				     bool require_privacy, bool use_rpa,

				     u8 *own_addr_type)

{

	struct hci_dev *hdev = req->hdev;

	int err;



	/* If privacy is enabled use a resolvable private address. If

	 * current RPA has expired or there is something else than

	 * the current RPA in use, then generate a new one.

	 */

	if (use_rpa) {

		/* If Controller supports LL Privacy use own address type is

		 * 0x03

		 */

		if (use_ll_privacy(hdev))

			*own_addr_type = ADDR_LE_DEV_RANDOM_RESOLVED;

		else

			*own_addr_type = ADDR_LE_DEV_RANDOM;



		if (rpa_valid(hdev))

			return 0;



		err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa);

		if (err < 0) {

			bt_dev_err(hdev, "failed to generate new RPA");

			return err;

		}



		set_random_addr(req, &hdev->rpa);



		return 0;

	}



	/* In case of required privacy without resolvable private address,

	 * use an non-resolvable private address. This is useful for active

	 * scanning and non-connectable advertising.

	 */

	if (require_privacy) {

		bdaddr_t nrpa;



		while (true) {

			/* The non-resolvable private address is generated

			 * from random six bytes with the two most significant

			 * bits cleared.

			 */

			get_random_bytes(&nrpa, 6);

			nrpa.b[5] &= 0x3f;



			/* The non-resolvable private address shall not be

			 * equal to the public address.

			 */

			if (bacmp(&hdev->bdaddr, &nrpa))

				break;

		}



		*own_addr_type = ADDR_LE_DEV_RANDOM;

		set_random_addr(req, &nrpa);

		return 0;

	}



	/* If forcing static address is in use or there is no public

	 * address use the static address as random address (but skip

	 * the HCI command if the current random address is already the

	 * static one.

	 *

	 * In case BR/EDR has been disabled on a dual-mode controller

	 * and a static address has been configured, then use that

	 * address instead of the public BR/EDR address.

	 */

	if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||

	    !bacmp(&hdev->bdaddr, BDADDR_ANY) ||

	    (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&

	     bacmp(&hdev->static_addr, BDADDR_ANY))) {

		*own_addr_type = ADDR_LE_DEV_RANDOM;

		if (bacmp(&hdev->static_addr, &hdev->random_addr))

			hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6,

				    &hdev->static_addr);

		return 0;

	}



	/* Neither privacy nor static address is being used so use a

	 * public address.

	 */

	*own_addr_type = ADDR_LE_DEV_PUBLIC;



	return 0;

}



/* Ensure to call hci_req_add_le_scan_disable() first to disable the

 * controller based address resolution to be able to reconfigure

 * resolving list.
@@ -859,79 +949,6 @@ static void interleave_scan_work(struct work_struct *work) 
				   &hdev->interleave_scan, timeout);

}



int hci_get_random_address(struct hci_dev *hdev, bool require_privacy,

			   bool use_rpa, struct adv_info *adv_instance,

			   u8 *own_addr_type, bdaddr_t *rand_addr)

{

	int err;



	bacpy(rand_addr, BDADDR_ANY);



	/* If privacy is enabled use a resolvable private address. If

	 * current RPA has expired then generate a new one.

	 */

	if (use_rpa) {

		/* If Controller supports LL Privacy use own address type is

		 * 0x03

		 */

		if (use_ll_privacy(hdev))

			*own_addr_type = ADDR_LE_DEV_RANDOM_RESOLVED;

		else

			*own_addr_type = ADDR_LE_DEV_RANDOM;



		if (adv_instance) {

			if (adv_rpa_valid(adv_instance))

				return 0;

		} else {

			if (rpa_valid(hdev))

				return 0;

		}



		err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa);

		if (err < 0) {

			bt_dev_err(hdev, "failed to generate new RPA");

			return err;

		}



		bacpy(rand_addr, &hdev->rpa);



		return 0;

	}



	/* In case of required privacy without resolvable private address,

	 * use an non-resolvable private address. This is useful for

	 * non-connectable advertising.

	 */

	if (require_privacy) {

		bdaddr_t nrpa;



		while (true) {

			/* The non-resolvable private address is generated

			 * from random six bytes with the two most significant

			 * bits cleared.

			 */

			get_random_bytes(&nrpa, 6);

			nrpa.b[5] &= 0x3f;



			/* The non-resolvable private address shall not be

			 * equal to the public address.

			 */

			if (bacmp(&hdev->bdaddr, &nrpa))

				break;

		}



		*own_addr_type = ADDR_LE_DEV_RANDOM;

		bacpy(rand_addr, &nrpa);



		return 0;

	}



	/* No privacy so use a public address. */

	*own_addr_type = ADDR_LE_DEV_PUBLIC;



	return 0;

}



static void set_random_addr(struct hci_request *req, bdaddr_t *rpa)

{

	struct hci_dev *hdev = req->hdev;
@@ -956,95 +973,7 @@ static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 
	hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa);

}



int hci_update_random_address(struct hci_request *req, bool require_privacy,

			      bool use_rpa, u8 *own_addr_type)

{

	struct hci_dev *hdev = req->hdev;

	int err;



	/* If privacy is enabled use a resolvable private address. If

	 * current RPA has expired or there is something else than

	 * the current RPA in use, then generate a new one.

	 */

	if (use_rpa) {

		/* If Controller supports LL Privacy use own address type is

		 * 0x03

		 */

		if (use_ll_privacy(hdev))

			*own_addr_type = ADDR_LE_DEV_RANDOM_RESOLVED;

		else

			*own_addr_type = ADDR_LE_DEV_RANDOM;



		if (rpa_valid(hdev))

			return 0;



		err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa);

		if (err < 0) {

			bt_dev_err(hdev, "failed to generate new RPA");

			return err;

		}



		set_random_addr(req, &hdev->rpa);



		return 0;

	}



	/* In case of required privacy without resolvable private address,

	 * use an non-resolvable private address. This is useful for active

	 * scanning and non-connectable advertising.

	 */

	if (require_privacy) {

		bdaddr_t nrpa;



		while (true) {

			/* The non-resolvable private address is generated

			 * from random six bytes with the two most significant

			 * bits cleared.

			 */

			get_random_bytes(&nrpa, 6);

			nrpa.b[5] &= 0x3f;



			/* The non-resolvable private address shall not be

			 * equal to the public address.

			 */

			if (bacmp(&hdev->bdaddr, &nrpa))

				break;

		}



		*own_addr_type = ADDR_LE_DEV_RANDOM;

		set_random_addr(req, &nrpa);

		return 0;

	}



	/* If forcing static address is in use or there is no public

	 * address use the static address as random address (but skip

	 * the HCI command if the current random address is already the

	 * static one.

	 *

	 * In case BR/EDR has been disabled on a dual-mode controller

	 * and a static address has been configured, then use that

	 * address instead of the public BR/EDR address.

	 */

	if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||

	    !bacmp(&hdev->bdaddr, BDADDR_ANY) ||

	    (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&

	     bacmp(&hdev->static_addr, BDADDR_ANY))) {

		*own_addr_type = ADDR_LE_DEV_RANDOM;

		if (bacmp(&hdev->static_addr, &hdev->random_addr))

			hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6,

				    &hdev->static_addr);

		return 0;

	}



	/* Neither privacy nor static address is being used so use a

	 * public address.

	 */

	*own_addr_type = ADDR_LE_DEV_PUBLIC;



	return 0;

}



void __hci_abort_conn(struct hci_request *req, struct hci_conn *conn,

static void __hci_abort_conn(struct hci_request *req, struct hci_conn *conn,

			     u8 reason)

{

	switch (conn->state) {

net/bluetooth/hci_request.h

+0 −9
Original line number Diff line number Diff line
@@ -74,16 +74,7 @@ void hci_req_add_le_passive_scan(struct hci_request *req); 
void hci_req_prepare_suspend(struct hci_dev *hdev, enum suspended_state next);



int hci_req_update_adv_data(struct hci_dev *hdev, u8 instance);

int hci_get_random_address(struct hci_dev *hdev, bool require_privacy,

			   bool use_rpa, struct adv_info *adv_instance,

			   u8 *own_addr_type, bdaddr_t *rand_addr);



int hci_update_random_address(struct hci_request *req, bool require_privacy,

			      bool use_rpa, u8 *own_addr_type);



int hci_abort_conn(struct hci_conn *conn, u8 reason);

void __hci_abort_conn(struct hci_request *req, struct hci_conn *conn,

		      u8 reason);



void hci_request_setup(struct hci_dev *hdev);

void hci_request_cancel_all(struct hci_dev *hdev);

net/bluetooth/hci_sync.c

+73 −0
Original line number Diff line number Diff line
@@ -5992,3 +5992,76 @@ int hci_le_pa_terminate_sync(struct hci_dev *hdev, u16 handle) 
	return __hci_cmd_sync_status(hdev, HCI_OP_LE_PA_TERM_SYNC,

				     sizeof(cp), &cp, HCI_CMD_TIMEOUT);

}



int hci_get_random_address(struct hci_dev *hdev, bool require_privacy,

			   bool use_rpa, struct adv_info *adv_instance,

			   u8 *own_addr_type, bdaddr_t *rand_addr)

{

	int err;



	bacpy(rand_addr, BDADDR_ANY);



	/* If privacy is enabled use a resolvable private address. If

	 * current RPA has expired then generate a new one.

	 */

	if (use_rpa) {

		/* If Controller supports LL Privacy use own address type is

		 * 0x03

		 */

		if (use_ll_privacy(hdev))

			*own_addr_type = ADDR_LE_DEV_RANDOM_RESOLVED;

		else

			*own_addr_type = ADDR_LE_DEV_RANDOM;



		if (adv_instance) {

			if (adv_rpa_valid(adv_instance))

				return 0;

		} else {

			if (rpa_valid(hdev))

				return 0;

		}



		err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa);

		if (err < 0) {

			bt_dev_err(hdev, "failed to generate new RPA");

			return err;

		}



		bacpy(rand_addr, &hdev->rpa);



		return 0;

	}



	/* In case of required privacy without resolvable private address,

	 * use an non-resolvable private address. This is useful for

	 * non-connectable advertising.

	 */

	if (require_privacy) {

		bdaddr_t nrpa;



		while (true) {

			/* The non-resolvable private address is generated

			 * from random six bytes with the two most significant

			 * bits cleared.

			 */

			get_random_bytes(&nrpa, 6);

			nrpa.b[5] &= 0x3f;



			/* The non-resolvable private address shall not be

			 * equal to the public address.

			 */

			if (bacmp(&hdev->bdaddr, &nrpa))

				break;

		}



		*own_addr_type = ADDR_LE_DEV_RANDOM;

		bacpy(rand_addr, &nrpa);



		return 0;

	}



	/* No privacy so use a public address. */

	*own_addr_type = ADDR_LE_DEV_PUBLIC;



	return 0;

}