Merge "system/stack/bnep: Migrate to libbluetooth_log" into main (e3a95533) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -339,6 +339,7 @@ cc_defaults {
		"libchrome",
		],
		shared_libs: [
		"libbase",
		"liblog",
		],
		target: {

system/stack/bnep/bnep_api.cc

+10 −10

Original line number	Diff line number	Diff line
		@@ -24,7 +24,7 @@

		#include "bnep_api.h"

		#include <base/logging.h>
		#include <bluetooth/log.h>
		#include <string.h>

		#include "bnep_int.h"
		@@ -37,6 +37,7 @@
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		using namespace bluetooth;
		using bluetooth::Uuid;

		/*******************************************************************************
		@@ -136,7 +137,7 @@ tBNEP_RESULT BNEP_Connect(const RawAddress& p_rem_bda, const Uuid& src_uuid,
		uint16_t cid;
		tBNEP_CONN* p_bcb = bnepu_find_bcb_by_bd_addr(p_rem_bda);

		VLOG(0) << __func__ << " BDA:" << p_rem_bda;
		log::verbose("BDA:{}", ADDRESS_TO_LOGGABLE_STR(p_rem_bda));

		if (!bnep_cb.profile_registered) return BNEP_WRONG_STATE;

		@@ -162,7 +163,7 @@ tBNEP_RESULT BNEP_Connect(const RawAddress& p_rem_bda, const Uuid& src_uuid,
		*/
		p_bcb->con_state = BNEP_STATE_SEC_CHECKING;

		LOG_VERBOSE("BNEP initiating security procedures for src uuid %s",
		log::verbose("BNEP initiating security procedures for src uuid {}",
		p_bcb->src_uuid.ToString().c_str());

		bnep_sec_check_complete(&p_bcb->rem_bda, BT_TRANSPORT_BR_EDR, p_bcb);
		@@ -177,7 +178,7 @@ tBNEP_RESULT BNEP_Connect(const RawAddress& p_rem_bda, const Uuid& src_uuid,
		p_bcb->l2cap_cid = cid;

		} else {
		LOG_ERROR("BNEP - Originate failed");
		log::error("BNEP - Originate failed");
		if (bnep_cb.p_conn_state_cb)
		(*bnep_cb.p_conn_state_cb)(p_bcb->handle, p_bcb->rem_bda,
		BNEP_CONN_FAILED, false);
		@@ -221,7 +222,7 @@ tBNEP_RESULT BNEP_ConnectResp(uint16_t handle, tBNEP_RESULT resp) {
		(!(p_bcb->con_flags & BNEP_FLAGS_SETUP_RCVD)))
		return (BNEP_WRONG_STATE);

		LOG_DEBUG("handle %d, responce %d", handle, resp);
		log::debug("handle {}, responce {}", handle, resp);

		/* Form appropriate responce based on profile responce */
		if (resp == BNEP_CONN_FAILED_SRC_UUID)
		@@ -294,7 +295,7 @@ tBNEP_RESULT BNEP_Disconnect(uint16_t handle) {

		if (p_bcb->con_state == BNEP_STATE_IDLE) return (BNEP_WRONG_HANDLE);

		LOG_VERBOSE("BNEP_Disconnect() for handle %d", handle);
		log::verbose("BNEP_Disconnect() for handle {}", handle);

		L2CA_DisconnectReq(p_bcb->l2cap_cid);

		@@ -340,8 +341,7 @@ tBNEP_RESULT BNEP_WriteBuf(uint16_t handle, const RawAddress& dest_addr,
		p_bcb = &(bnep_cb.bcb[handle - 1]);
		/* Check MTU size */
		if (p_buf->len > BNEP_MTU_SIZE) {
		LOG_ERROR("%s length %d exceeded MTU %d", __func__, p_buf->len,
		BNEP_MTU_SIZE);
		log::error("length {} exceeded MTU {}", p_buf->len, BNEP_MTU_SIZE);
		osi_free(p_buf);
		return (BNEP_MTU_EXCEDED);
		}
		@@ -445,7 +445,7 @@ tBNEP_RESULT BNEP_Write(uint16_t handle, const RawAddress& dest_addr,

		/* Check MTU size. Consider the possibility of having extension headers */
		if (len > BNEP_MTU_SIZE) {
		LOG_ERROR("%s length %d exceeded MTU %d", __func__, len, BNEP_MTU_SIZE);
		log::error("length {} exceeded MTU {}", len, BNEP_MTU_SIZE);
		return (BNEP_MTU_EXCEDED);
		}

system/stack/bnep/bnep_main.cc

+30 −26

Original line number	Diff line number	Diff line
		@@ -24,7 +24,7 @@

		#define LOG_TAG "bluetooth"

		#include <base/logging.h>
		#include <bluetooth/log.h>
		#include <string.h>

		#include "bnep_api.h"
		@@ -42,6 +42,8 @@
		#include "stack/include/bt_types.h"
		#include "types/raw_address.h"

		using namespace bluetooth;

		/******************************************************************************/
		/* G L O B A L B N E P D A T A */
		/******************************************************************************/
		@@ -90,7 +92,7 @@ tBNEP_RESULT bnep_register_with_l2cap(void) {
		if (!L2CA_Register2(BT_PSM_BNEP, bnep_cb.reg_info, false /* enable_snoop */,
		nullptr, BNEP_MTU_SIZE, BNEP_MTU_SIZE,
		BTA_SEC_AUTHENTICATE \| BTA_SEC_ENCRYPT)) {
		LOG_ERROR("BNEP - Registration failed");
		log::error("BNEP - Registration failed");
		return BNEP_SECURITY_FAIL;
		}

		@@ -130,7 +132,7 @@ static void bnep_connect_ind(const RawAddress& bd_addr, uint16_t l2cap_cid,
		alarm_set_on_mloop(p_bcb->conn_timer, BNEP_CONN_TIMEOUT_MS,
		bnep_conn_timer_timeout, p_bcb);

		LOG_DEBUG("BNEP - Rcvd L2CAP conn ind, CID: 0x%x", p_bcb->l2cap_cid);
		log::debug("BNEP - Rcvd L2CAP conn ind, CID: 0x{:x}", p_bcb->l2cap_cid);
		}

		static void bnep_on_l2cap_error(uint16_t l2cap_cid, uint16_t result) {
		@@ -165,7 +167,7 @@ static void bnep_connect_cfm(uint16_t l2cap_cid, uint16_t result) {
		/* Find CCB based on CID */
		p_bcb = bnepu_find_bcb_by_cid(l2cap_cid);
		if (p_bcb == NULL) {
		LOG_WARN("BNEP - Rcvd conn cnf for unknown CID 0x%x", l2cap_cid);
		log::warn("BNEP - Rcvd conn cnf for unknown CID 0x{:x}", l2cap_cid);
		return;
		}

		@@ -179,9 +181,10 @@ static void bnep_connect_cfm(uint16_t l2cap_cid, uint16_t result) {
		alarm_set_on_mloop(p_bcb->conn_timer, BNEP_CONN_TIMEOUT_MS,
		bnep_conn_timer_timeout, p_bcb);

		LOG_DEBUG("BNEP - got conn cnf, sent cfg req, CID: 0x%x", p_bcb->l2cap_cid);
		log::debug("BNEP - got conn cnf, sent cfg req, CID: 0x{:x}",
		p_bcb->l2cap_cid);
		} else {
		LOG(ERROR) << __func__ << ": invoked with non OK status";
		log::error("invoked with non OK status");
		}
		}

		@@ -199,12 +202,12 @@ static void bnep_config_cfm(uint16_t l2cap_cid, uint16_t initiator,
		tL2CAP_CFG_INFO* p_cfg) {
		tBNEP_CONN* p_bcb;

		LOG_DEBUG("BNEP - Rcvd cfg cfm, CID: 0x%x", l2cap_cid);
		log::debug("BNEP - Rcvd cfg cfm, CID: 0x{:x}", l2cap_cid);

		/* Find CCB based on CID */
		p_bcb = bnepu_find_bcb_by_cid(l2cap_cid);
		if (p_bcb == NULL) {
		LOG_WARN("BNEP - Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
		log::warn("BNEP - Rcvd L2CAP cfg ind, unknown CID: 0x{:x}", l2cap_cid);
		return;
		}

		@@ -236,11 +239,11 @@ static void bnep_disconnect_ind(uint16_t l2cap_cid, bool ack_needed) {
		/* Find CCB based on CID */
		p_bcb = bnepu_find_bcb_by_cid(l2cap_cid);
		if (p_bcb == NULL) {
		LOG_WARN("BNEP - Rcvd L2CAP disc, unknown CID: 0x%x", l2cap_cid);
		log::warn("BNEP - Rcvd L2CAP disc, unknown CID: 0x{:x}", l2cap_cid);
		return;
		}

		LOG_DEBUG("BNEP - Rcvd L2CAP disc, CID: 0x%x", l2cap_cid);
		log::debug("BNEP - Rcvd L2CAP disc, CID: 0x{:x}", l2cap_cid);

		/* Tell the user if there is a callback */
		if (p_bcb->con_state == BNEP_STATE_CONNECTED) {
		@@ -272,7 +275,7 @@ static void bnep_congestion_ind(uint16_t l2cap_cid, bool is_congested) {
		/* Find BCB based on CID */
		p_bcb = bnepu_find_bcb_by_cid(l2cap_cid);
		if (p_bcb == NULL) {
		LOG_WARN("BNEP - Rcvd L2CAP cong, unknown CID: 0x%x", l2cap_cid);
		log::warn("BNEP - Rcvd L2CAP cong, unknown CID: 0x{:x}", l2cap_cid);
		return;
		}

		@@ -329,7 +332,7 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {
		/* Find CCB based on CID */
		p_bcb = bnepu_find_bcb_by_cid(l2cap_cid);
		if (p_bcb == NULL) {
		LOG_WARN("BNEP - Rcvd L2CAP data, unknown CID: 0x%x", l2cap_cid);
		log::warn("BNEP - Rcvd L2CAP data, unknown CID: 0x{:x}", l2cap_cid);
		osi_free(p_buf);
		return;
		}
		@@ -339,12 +342,13 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {
		extension_present = type >> 7;
		type &= 0x7f;
		if (type >= sizeof(bnep_frame_hdr_sizes) / sizeof(bnep_frame_hdr_sizes[0])) {
		LOG_INFO("BNEP - rcvd frame, bad type: 0x%02x", type);
		log::info("BNEP - rcvd frame, bad type: 0x{:02x}", type);
		osi_free(p_buf);
		return;
		}
		if ((rem_len <= bnep_frame_hdr_sizes[type]) \|\| (rem_len > BNEP_MTU_SIZE)) {
		LOG_DEBUG("BNEP - rcvd frame, bad len: %d type: 0x%02x", p_buf->len, type);
		log::debug("BNEP - rcvd frame, bad len: {} type: 0x{:02x}", p_buf->len,
		type);
		osi_free(p_buf);
		return;
		}
		@@ -354,7 +358,7 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {
		if ((p_bcb->con_state != BNEP_STATE_CONNECTED) &&
		(!(p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED)) &&
		(type != BNEP_FRAME_CONTROL)) {
		LOG_WARN("BNEP - Ignored L2CAP data while in state: %d, CID: 0x%x",
		log::warn("BNEP - Ignored L2CAP data while in state: {}, CID: 0x{:x}",
		p_bcb->con_state, l2cap_cid);

		if (extension_present) {
		@@ -398,12 +402,12 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {
		}

		if (type > BNEP_FRAME_COMPRESSED_ETHERNET_DEST_ONLY) {
		LOG_DEBUG("BNEP - rcvd frame, unknown type: 0x%02x", type);
		log::debug("BNEP - rcvd frame, unknown type: 0x{:02x}", type);
		osi_free(p_buf);
		return;
		}

		LOG_DEBUG("BNEP - rcv frame, type: %d len: %d Ext: %d", type, p_buf->len,
		log::debug("BNEP - rcv frame, type: {} len: {} Ext: {}", type, p_buf->len,
		extension_present);

		/* Initialize addresses to 'not supplied' */
		@@ -476,7 +480,7 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {

		/* if unknown extension present stop processing */
		if (ext_type) {
		LOG_DEBUG("Data extension type 0x%x found", ext_type);
		log::debug("Data extension type 0x{:x} found", ext_type);
		break;
		}

		@@ -524,13 +528,13 @@ static void bnep_data_ind(uint16_t l2cap_cid, BT_HDR* p_buf) {
		void bnep_conn_timer_timeout(void* data) {
		tBNEP_CONN* p_bcb = (tBNEP_CONN*)data;

		LOG_DEBUG(
		"BNEP - CCB timeout in state: %d CID: 0x%x flags %x, re_transmit %d",
		log::debug(
		"BNEP - CCB timeout in state: {} CID: 0x{:x} flags {:x}, re_transmit {}",
		p_bcb->con_state, p_bcb->l2cap_cid, p_bcb->con_flags,
		p_bcb->re_transmits);

		if (p_bcb->con_state == BNEP_STATE_CONN_SETUP) {
		LOG_DEBUG("BNEP - CCB timeout in state: %d CID: 0x%x", p_bcb->con_state,
		log::debug("BNEP - CCB timeout in state: {} CID: 0x{:x}", p_bcb->con_state,
		p_bcb->l2cap_cid);

		if (!(p_bcb->con_flags & BNEP_FLAGS_IS_ORIG)) {
		@@ -555,7 +559,7 @@ void bnep_conn_timer_timeout(void* data) {
		return;
		}
		} else if (p_bcb->con_state != BNEP_STATE_CONNECTED) {
		LOG_DEBUG("BNEP - CCB timeout in state: %d CID: 0x%x", p_bcb->con_state,
		log::debug("BNEP - CCB timeout in state: {} CID: 0x{:x}", p_bcb->con_state,
		p_bcb->l2cap_cid);

		L2CA_DisconnectReq(p_bcb->l2cap_cid);

system/stack/bnep/bnep_utils.cc

+78 −84

Original line number	Diff line number	Diff line
		@@ -22,7 +22,7 @@
		*
		******************************************************************************/

		#include <base/logging.h>
		#include <bluetooth/log.h>
		#include <stdio.h>
		#include <string.h>

		@@ -36,6 +36,7 @@
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		using namespace bluetooth;
		using bluetooth::Uuid;

		/******************************************************************************/
		@@ -169,7 +170,7 @@ void bnep_send_conn_req(tBNEP_CONN* p_bcb) {
		BT_HDR* p_buf = (BT_HDR*)osi_malloc(BNEP_BUF_SIZE);
		uint8_t p, p_start;

		LOG_VERBOSE("%s: sending setup req with dst uuid %s", __func__,
		log::verbose("sending setup req with dst uuid {}",
		p_bcb->dst_uuid.ToString().c_str());

		p_buf->offset = L2CAP_MIN_OFFSET;
		@@ -198,7 +199,7 @@ void bnep_send_conn_req(tBNEP_CONN* p_bcb) {
		memcpy(p, p_bcb->src_uuid.To128BitBE().data(), Uuid::kNumBytes128);
		p += Uuid::kNumBytes128;
		} else {
		LOG_ERROR("%s: uuid: %s, invalid length: %zu", __func__,
		log::error("uuid: {}, invalid length: {}",
		p_bcb->dst_uuid.ToString().c_str(),
		p_bcb->dst_uuid.GetShortestRepresentationSize());
		}
		@@ -221,7 +222,8 @@ void bnep_send_conn_response(tBNEP_CONN* p_bcb, uint16_t resp_code) {
		BT_HDR* p_buf = (BT_HDR*)osi_malloc(BNEP_BUF_SIZE);
		uint8_t* p;

		LOG_DEBUG("BNEP - bnep_send_conn_response for CID: 0x%x", p_bcb->l2cap_cid);
		log::debug("BNEP - bnep_send_conn_response for CID: 0x{:x}",
		p_bcb->l2cap_cid);

		p_buf->offset = L2CAP_MIN_OFFSET;
		p = (uint8_t*)(p_buf + 1) + L2CAP_MIN_OFFSET;
		@@ -253,7 +255,7 @@ void bnepu_send_peer_our_filters(tBNEP_CONN* p_bcb) {
		uint8_t* p;
		uint16_t xx;

		LOG_VERBOSE("BNEP sending peer our filters");
		log::verbose("BNEP sending peer our filters");

		p_buf->offset = L2CAP_MIN_OFFSET;
		p = (uint8_t*)(p_buf + 1) + L2CAP_MIN_OFFSET;
		@@ -295,7 +297,7 @@ void bnepu_send_peer_our_multi_filters(tBNEP_CONN* p_bcb) {
		uint8_t* p;
		uint16_t xx;

		LOG_VERBOSE("BNEP sending peer our multicast filters");
		log::verbose("BNEP sending peer our multicast filters");

		p_buf->offset = L2CAP_MIN_OFFSET;
		p = (uint8_t*)(p_buf + 1) + L2CAP_MIN_OFFSET;
		@@ -338,7 +340,7 @@ void bnepu_send_peer_filter_rsp(tBNEP_CONN* p_bcb, uint16_t response_code) {
		BT_HDR* p_buf = (BT_HDR*)osi_malloc(BNEP_BUF_SIZE);
		uint8_t* p;

		LOG_VERBOSE("BNEP sending filter response");
		log::verbose("BNEP sending filter response");

		p_buf->offset = L2CAP_MIN_OFFSET;
		p = (uint8_t*)(p_buf + 1) + L2CAP_MIN_OFFSET;
		@@ -369,7 +371,8 @@ void bnep_send_command_not_understood(tBNEP_CONN* p_bcb, uint8_t cmd_code) {
		BT_HDR* p_buf = (BT_HDR*)osi_malloc(BNEP_BUF_SIZE);
		uint8_t* p;

		LOG_VERBOSE("BNEP - bnep_send_command_not_understood for CID: 0x%x, cmd 0x%x",
		log::verbose(
		"BNEP - bnep_send_command_not_understood for CID: 0x{:x}, cmd 0x{:x}",
		p_bcb->l2cap_cid, cmd_code);

		p_buf->offset = L2CAP_MIN_OFFSET;
		@@ -400,10 +403,12 @@ void bnep_send_command_not_understood(tBNEP_CONN* p_bcb, uint8_t cmd_code) {
		*
		******************************************************************************/
		void bnepu_check_send_packet(tBNEP_CONN* p_bcb, BT_HDR* p_buf) {
		LOG_DEBUG("BNEP - bnepu_check_send_packet for CID: 0x%x", p_bcb->l2cap_cid);
		log::debug("BNEP - bnepu_check_send_packet for CID: 0x{:x}",
		p_bcb->l2cap_cid);
		if (p_bcb->con_flags & BNEP_FLAGS_L2CAP_CONGESTED) {
		if (fixed_queue_length(p_bcb->xmit_q) >= BNEP_MAX_XMITQ_DEPTH) {
		LOG_WARN("BNEP - congested, dropping buf, CID: 0x%x", p_bcb->l2cap_cid);
		log::warn("BNEP - congested, dropping buf, CID: 0x{:x}",
		p_bcb->l2cap_cid);

		osi_free(p_buf);
		} else {
		@@ -531,12 +536,12 @@ static uint8_t* bnepu_init_hdr(BT_HDR* p_buf, uint16_t hdr_len,
		******************************************************************************/
		void bnep_process_setup_conn_req(tBNEP_CONN* p_bcb, uint8_t* p_setup,
		uint8_t len) {
		LOG_DEBUG("BNEP - for CID: 0x%x", p_bcb->l2cap_cid);
		log::debug("BNEP - for CID: 0x{:x}", p_bcb->l2cap_cid);

		if (p_bcb->con_state != BNEP_STATE_CONN_SETUP &&
		p_bcb->con_state != BNEP_STATE_SEC_CHECKING &&
		p_bcb->con_state != BNEP_STATE_CONNECTED) {
		LOG_ERROR("BNEP - setup request in bad state %d", p_bcb->con_state);
		log::error("BNEP - setup request in bad state {}", p_bcb->con_state);
		bnep_send_conn_response(p_bcb, BNEP_SETUP_CONN_NOT_ALLOWED);
		return;
		}
		@@ -544,7 +549,7 @@ void bnep_process_setup_conn_req(tBNEP_CONN* p_bcb, uint8_t* p_setup,
		/* Check if we already initiated security check or if waiting for user
		* responce */
		if (p_bcb->con_flags & BNEP_FLAGS_SETUP_RCVD) {
		LOG_WARN(
		log::warn(
		"BNEP - Duplicate Setup message received while doing security check");
		return;
		}
		@@ -553,7 +558,7 @@ void bnep_process_setup_conn_req(tBNEP_CONN* p_bcb, uint8_t* p_setup,
		if (p_bcb->con_state != BNEP_STATE_CONNECTED &&
		(!(p_bcb->con_flags & BNEP_FLAGS_SETUP_RCVD)) &&
		(p_bcb->con_flags & BNEP_FLAGS_IS_ORIG)) {
		LOG_ERROR("BNEP - setup request when we are originator state:%hu",
		log::error("BNEP - setup request when we are originator state:{}",
		p_bcb->con_state);
		bnep_send_conn_response(p_bcb, BNEP_SETUP_CONN_NOT_ALLOWED);
		return;
		@@ -596,7 +601,7 @@ void bnep_process_setup_conn_req(tBNEP_CONN* p_bcb, uint8_t* p_setup,
		p_bcb->dst_uuid = Uuid::From128BitBE(p_setup);
		p_setup += len;
		} else {
		LOG_ERROR("BNEP - Bad UID len %d in ConnReq", len);
		log::error("BNEP - Bad UID len {} in ConnReq", len);
		bnep_send_conn_response(p_bcb, BNEP_SETUP_INVALID_UUID_SIZE);
		return;
		}
		@@ -604,7 +609,7 @@ void bnep_process_setup_conn_req(tBNEP_CONN* p_bcb, uint8_t* p_setup,
		p_bcb->con_state = BNEP_STATE_SEC_CHECKING;
		p_bcb->con_flags \|= BNEP_FLAGS_SETUP_RCVD;

		LOG_DEBUG("BNEP initiating security check for incoming call for uuid %s",
		log::debug("BNEP initiating security check for incoming call for uuid {}",
		p_bcb->src_uuid.ToString().c_str());
		bnep_sec_check_complete(&p_bcb->rem_bda, BT_TRANSPORT_BR_EDR, p_bcb);
		}
		@@ -624,17 +629,17 @@ void bnep_process_setup_conn_responce(tBNEP_CONN* p_bcb, uint8_t* p_setup) {
		tBNEP_RESULT resp;
		uint16_t resp_code;

		LOG_VERBOSE("BNEP received setup responce");
		log::verbose("BNEP received setup responce");
		/* The state should be either SETUP or CONNECTED */
		if (p_bcb->con_state != BNEP_STATE_CONN_SETUP) {
		/* Should we disconnect ? */
		LOG_ERROR("BNEP - setup response in bad state %d", p_bcb->con_state);
		log::error("BNEP - setup response in bad state {}", p_bcb->con_state);
		return;
		}

		/* Check if we are the originator */
		if (!(p_bcb->con_flags & BNEP_FLAGS_IS_ORIG)) {
		LOG_ERROR("BNEP - setup response when we are not originator");
		log::error("BNEP - setup response when we are not originator");
		return;
		}

		@@ -662,7 +667,7 @@ void bnep_process_setup_conn_responce(tBNEP_CONN* p_bcb, uint8_t* p_setup) {
		/* Check the responce code */
		if (resp_code != BNEP_SETUP_CONN_OK) {
		if (p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED) {
		LOG_VERBOSE("BNEP - role change response is %d", resp_code);
		log::verbose("BNEP - role change response is {}", resp_code);

		/* Restore the earlier BNEP status */
		p_bcb->con_state = BNEP_STATE_CONNECTED;
		@@ -680,7 +685,7 @@ void bnep_process_setup_conn_responce(tBNEP_CONN* p_bcb, uint8_t* p_setup) {

		return;
		} else {
		LOG_ERROR("BNEP - setup response %d is not OK", resp_code);
		log::error("BNEP - setup response {} is not OK", resp_code);

		L2CA_DisconnectReq(p_bcb->l2cap_cid);

		@@ -715,8 +720,8 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		if (p == NULL \|\| rem_len == NULL) {
		if (rem_len != NULL) *rem_len = 0;
		LOG_VERBOSE("%s: invalid packet: p = %p rem_len = %p", __func__, p,
		rem_len);
		log::verbose("invalid packet: p = {} rem_len = {}", fmt::ptr(p),
		fmt::ptr(rem_len));
		return NULL;
		}
		uint16_t rem_len_orig = *rem_len;
		@@ -731,37 +736,33 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,
		control_type = *p++;
		rem_len = rem_len - 1;

		LOG_VERBOSE(
		"%s: BNEP processing control packet rem_len %d, is_ext %d, ctrl_type %d",
		__func__, *rem_len, is_ext, control_type);
		log::verbose(
		"BNEP processing control packet rem_len {}, is_ext {}, ctrl_type {}",
		*rem_len, is_ext, control_type);

		switch (control_type) {
		case BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD:
		if (*rem_len < 1) {
		LOG_ERROR(
		"%s: Received BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD with bad length",
		__func__);
		log::error(
		"Received BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD with bad length");
		goto bad_packet_length;
		}
		LOG_ERROR(
		"%s: Received BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD for pkt type: %d",
		__func__, *p);
		log::error(
		"Received BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD for pkt type: {}", *p);
		p++;
		rem_len = rem_len - 1;
		break;

		case BNEP_SETUP_CONNECTION_REQUEST_MSG:
		if (*rem_len < 1) {
		LOG_ERROR(
		"%s: Received BNEP_SETUP_CONNECTION_REQUEST_MSG with bad length",
		__func__);
		log::error(
		"Received BNEP_SETUP_CONNECTION_REQUEST_MSG with bad length");
		goto bad_packet_length;
		}
		len = *p++;
		if (rem_len < ((2 len) + 1)) {
		LOG_ERROR(
		"%s: Received BNEP_SETUP_CONNECTION_REQUEST_MSG with bad length",
		__func__);
		log::error(
		"Received BNEP_SETUP_CONNECTION_REQUEST_MSG with bad length");
		goto bad_packet_length;
		}
		if (!is_ext) bnep_process_setup_conn_req(p_bcb, p, (uint8_t)len);
		@@ -771,9 +772,8 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		case BNEP_SETUP_CONNECTION_RESPONSE_MSG:
		if (*rem_len < 2) {
		LOG_ERROR(
		"%s: Received BNEP_SETUP_CONNECTION_RESPONSE_MSG with bad length",
		__func__);
		log::error(
		"Received BNEP_SETUP_CONNECTION_RESPONSE_MSG with bad length");
		goto bad_packet_length;
		}
		if (!is_ext) bnep_process_setup_conn_responce(p_bcb, p);
		@@ -783,14 +783,12 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		case BNEP_FILTER_NET_TYPE_SET_MSG:
		if (*rem_len < 2) {
		LOG_ERROR("%s: Received BNEP_FILTER_NET_TYPE_SET_MSG with bad length",
		__func__);
		log::error("Received BNEP_FILTER_NET_TYPE_SET_MSG with bad length");
		goto bad_packet_length;
		}
		BE_STREAM_TO_UINT16(len, p);
		if (*rem_len < (len + 2)) {
		LOG_ERROR("%s: Received BNEP_FILTER_NET_TYPE_SET_MSG with bad length",
		__func__);
		log::error("Received BNEP_FILTER_NET_TYPE_SET_MSG with bad length");
		goto bad_packet_length;
		}
		bnepu_process_peer_filter_set(p_bcb, p, len);
		@@ -800,9 +798,8 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		case BNEP_FILTER_NET_TYPE_RESPONSE_MSG:
		if (*rem_len < 2) {
		LOG_ERROR(
		"%s: Received BNEP_FILTER_NET_TYPE_RESPONSE_MSG with bad length",
		__func__);
		log::error(
		"Received BNEP_FILTER_NET_TYPE_RESPONSE_MSG with bad length");
		goto bad_packet_length;
		}
		bnepu_process_peer_filter_rsp(p_bcb, p);
		@@ -812,14 +809,12 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		case BNEP_FILTER_MULTI_ADDR_SET_MSG:
		if (*rem_len < 2) {
		LOG_ERROR("%s: Received BNEP_FILTER_MULTI_ADDR_SET_MSG with bad length",
		__func__);
		log::error("Received BNEP_FILTER_MULTI_ADDR_SET_MSG with bad length");
		goto bad_packet_length;
		}
		BE_STREAM_TO_UINT16(len, p);
		if (*rem_len < (len + 2)) {
		LOG_ERROR("%s: Received BNEP_FILTER_MULTI_ADDR_SET_MSG with bad length",
		__func__);
		log::error("Received BNEP_FILTER_MULTI_ADDR_SET_MSG with bad length");
		goto bad_packet_length;
		}
		bnepu_process_peer_multicast_filter_set(p_bcb, p, len);
		@@ -829,9 +824,8 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,

		case BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG:
		if (*rem_len < 2) {
		LOG_ERROR(
		"%s: Received BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG with bad length",
		__func__);
		log::error(
		"Received BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG with bad length");
		goto bad_packet_length;
		}
		bnepu_process_multicast_filter_rsp(p_bcb, p);
		@@ -840,7 +834,7 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,
		break;

		default:
		LOG_ERROR("%s: BNEP - bad ctl pkt type: %d", __func__, control_type);
		log::error("BNEP - bad ctl pkt type: {}", control_type);
		bnep_send_command_not_understood(p_bcb, control_type);
		if (is_ext && (ext_len > 0)) {
		if (*rem_len < (ext_len - 1)) {
		@@ -854,7 +848,7 @@ uint8_t* bnep_process_control_packet(tBNEP_CONN* p_bcb, uint8_t* p,
		return p;

		bad_packet_length:
		LOG_ERROR("%s: bad control packet length: original=%d remaining=%d", __func__,
		log::error("bad control packet length: original={} remaining={}",
		rem_len_orig, *rem_len);
		*rem_len = 0;
		return NULL;
		@@ -880,15 +874,15 @@ void bnepu_process_peer_filter_set(tBNEP_CONN* p_bcb, uint8_t* p_filters,

		if ((p_bcb->con_state != BNEP_STATE_CONNECTED) &&
		(!(p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED))) {
		LOG_VERBOSE(
		log::verbose(
		"BNEP received filter set from peer when there is no connection");
		return;
		}

		LOG_VERBOSE("BNEP received filter set from peer");
		log::verbose("BNEP received filter set from peer");
		/* Check for length not a multiple of 4 */
		if (len & 3) {
		LOG_VERBOSE("BNEP - bad filter len: %d", len);
		log::verbose("BNEP - bad filter len: {}", len);
		bnepu_send_peer_filter_rsp(p_bcb, BNEP_FILTER_CRL_BAD_RANGE);
		return;
		}
		@@ -944,17 +938,17 @@ void bnepu_process_peer_filter_rsp(tBNEP_CONN* p_bcb, uint8_t* p_data) {
		uint16_t resp_code;
		tBNEP_RESULT result;

		LOG_VERBOSE("BNEP received filter responce");
		log::verbose("BNEP received filter responce");
		/* The state should be CONNECTED */
		if ((p_bcb->con_state != BNEP_STATE_CONNECTED) &&
		(!(p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED))) {
		LOG_ERROR("BNEP - filter response in bad state %d", p_bcb->con_state);
		log::error("BNEP - filter response in bad state {}", p_bcb->con_state);
		return;
		}

		/* Check if we are the originator */
		if (!(p_bcb->con_flags & BNEP_FLAGS_FILTER_RESP_PEND)) {
		LOG_ERROR("BNEP - filter response when not expecting");
		log::error("BNEP - filter response when not expecting");
		return;
		}

		@@ -986,18 +980,18 @@ void bnepu_process_multicast_filter_rsp(tBNEP_CONN* p_bcb, uint8_t* p_data) {
		uint16_t resp_code;
		tBNEP_RESULT result;

		LOG_VERBOSE("BNEP received multicast filter responce");
		log::verbose("BNEP received multicast filter responce");
		/* The state should be CONNECTED */
		if ((p_bcb->con_state != BNEP_STATE_CONNECTED) &&
		(!(p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED))) {
		LOG_ERROR("BNEP - multicast filter response in bad state %d",
		log::error("BNEP - multicast filter response in bad state {}",
		p_bcb->con_state);
		return;
		}

		/* Check if we are the originator */
		if (!(p_bcb->con_flags & BNEP_FLAGS_MULTI_RESP_PEND)) {
		LOG_ERROR("BNEP - multicast filter response when not expecting");
		log::error("BNEP - multicast filter response when not expecting");
		return;
		}

		@@ -1034,20 +1028,20 @@ void bnepu_process_peer_multicast_filter_set(tBNEP_CONN* p_bcb,

		if ((p_bcb->con_state != BNEP_STATE_CONNECTED) &&
		(!(p_bcb->con_flags & BNEP_FLAGS_CONN_COMPLETED))) {
		LOG_VERBOSE(
		log::verbose(
		"BNEP received multicast filter set from peer when there is no "
		"connection");
		return;
		}

		if (len % 12) {
		LOG_VERBOSE("BNEP - bad filter len: %d", len);
		log::verbose("BNEP - bad filter len: {}", len);
		bnepu_send_peer_multicast_filter_rsp(p_bcb, BNEP_FILTER_CRL_BAD_RANGE);
		return;
		}

		if (len > (BNEP_MAX_MULTI_FILTERS * 2 * BD_ADDR_LEN)) {
		LOG_VERBOSE("BNEP - Too many filters");
		log::verbose("BNEP - Too many filters");
		bnepu_send_peer_multicast_filter_rsp(p_bcb, BNEP_FILTER_CRL_MAX_REACHED);
		return;
		}
		@@ -1088,7 +1082,7 @@ void bnepu_process_peer_multicast_filter_set(tBNEP_CONN* p_bcb,
		}
		}

		LOG_VERBOSE("BNEP multicast filters %d", p_bcb->rcvd_mcast_filters);
		log::verbose("BNEP multicast filters {}", p_bcb->rcvd_mcast_filters);
		bnepu_send_peer_multicast_filter_rsp(p_bcb, resp_code);

		if (bnep_cb.p_mfilter_ind_cb)
		@@ -1109,7 +1103,7 @@ void bnepu_send_peer_multicast_filter_rsp(tBNEP_CONN* p_bcb,
		BT_HDR* p_buf = (BT_HDR*)osi_malloc(BNEP_BUF_SIZE);
		uint8_t* p;

		LOG_VERBOSE("BNEP sending multicast filter response %d", response_code);
		log::verbose("BNEP sending multicast filter response {}", response_code);

		p_buf->offset = L2CAP_MIN_OFFSET;
		p = (uint8_t*)(p_buf + 1) + L2CAP_MIN_OFFSET;
		@@ -1150,7 +1144,7 @@ void bnep_sec_check_complete(const RawAddress* bd_addr, tBT_TRANSPORT trasnport,

		/* check if the port is still waiting for security to complete */
		if (p_bcb->con_state != BNEP_STATE_SEC_CHECKING) {
		LOG_ERROR("BNEP Connection in wrong state %d when security is completed",
		log::error("BNEP Connection in wrong state {} when security is completed",
		p_bcb->con_state);
		return;
		}
		@@ -1230,7 +1224,7 @@ tBNEP_RESULT bnep_is_packet_allowed(tBNEP_CONN* p_bcb,
		}

		if (i == p_bcb->rcvd_num_filters) {
		LOG_VERBOSE("Ignoring protocol 0x%x in BNEP data write", proto);
		log::verbose("Ignoring protocol 0x{:x} in BNEP data write", proto);
		return BNEP_IGNORE_CMD;
		}
		}
		@@ -1258,8 +1252,8 @@ tBNEP_RESULT bnep_is_packet_allowed(tBNEP_CONN* p_bcb,
		*/
		if ((p_bcb->rcvd_mcast_filters == 0xFFFF) \|\|
		(i == p_bcb->rcvd_mcast_filters)) {
		VLOG(1) << "Ignoring multicast address " << dest_addr
		<< " in BNEP data write";
		log::verbose("Ignoring multicast address {} in BNEP data write",
		ADDRESS_TO_LOGGABLE_STR(dest_addr));
		return BNEP_IGNORE_CMD;
		}
		}