hci: COMMAND_COMPLETE_EVENT->HCI_EVENT_IS_COMMAND_COMPLETE. COMMAND_STATUS_EVENT->HCI_EVENT_IS_COMMAND_STATUS

example/daemon/inquiry.c

@@ -128,13 +128,13 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
 		case W4_INQUIRY_MODE_COMPLETE:
 			switch(event){
 				case HCI_EVENT_COMMAND_COMPLETE:
-					if ( COMMAND_COMPLETE_EVENT(packet, hci_write_inquiry_mode) ) {
+					if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_inquiry_mode)) {
 						start_scan();
 						state = ACTIVE;
 					}
 					break;
 				case HCI_EVENT_COMMAND_STATUS:
-					if ( COMMAND_STATUS_EVENT(packet, hci_write_inquiry_mode) ) {
+					if (HCI_EVENT_IS_COMMAND_STATUS(packet, hci_write_inquiry_mode)) {
 						printf("Ignoring error (0x%x) from hci_write_inquiry_mode.\n", packet[2]);
 						start_scan();
 						state = ACTIVE;

example/daemon/l2cap_server.c

@@ -185,7 +185,7 @@ void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint
 					break;
 					
 				case HCI_EVENT_COMMAND_COMPLETE:
-					if ( COMMAND_COMPLETE_EVENT(packet, hci_write_class_of_device) ) {
+					if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_class_of_device)) {
 						printf("Ready\n");
 					}
 				default:

example/daemon/l2cap_throughput.c

@@ -117,7 +117,7 @@ void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint
                 
                 case HCI_EVENT_COMMAND_COMPLETE:
 					// use pairing yes/no
-					if ( COMMAND_COMPLETE_EVENT(packet, hci_write_class_of_device) ) {
+					if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_class_of_device)) {
     				    bt_send_cmd(&l2cap_create_channel_mtu_cmd, addr, PSM_TEST, PACKET_SIZE);
 					}
 					break;

example/embedded/gap_inquiry_and_bond.c

@@ -146,7 +146,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
             break;
 
         case W4_INQUIRY_MODE_COMPLETE:
-            if ( COMMAND_COMPLETE_EVENT(packet, hci_write_inquiry_mode) ) {
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_inquiry_mode)) {
                 start_scan();
                 state = ACTIVE;
             }

example/embedded/spp_flowcontrol.c

@@ -154,7 +154,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
                     break;
                 
                 case HCI_EVENT_COMMAND_COMPLETE:
-                    if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)){
+                    if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_bd_addr)){
                         reverse_bd_addr(&packet[6], event_addr);
                         printf("BD-ADDR: %s\n\r", bd_addr_to_str(event_addr));
                         break;

src/ble/sm.c

@@ -2005,11 +2005,11 @@ static void sm_event_packet_handler (uint8_t packet_type, uint16_t channel, uint
                     break;
                     
 				case HCI_EVENT_COMMAND_COMPLETE:
-                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_encrypt)){
+                    if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_le_encrypt)){
                         sm_handle_encryption_result(&packet[6]);
                         break;
                     }
-                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_rand)){
+                    if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_le_rand)){
                         sm_handle_random_result(&packet[6]);
                         break;
                     }

src/hci.c

@@ -1344,7 +1344,7 @@ static void event_handler(uint8_t *packet, int size){
             // log_info("HCI_EVENT_COMMAND_COMPLETE cmds old %u - new %u", hci_stack->num_cmd_packets, packet[2]);
             hci_stack->num_cmd_packets = packet[2];
 
-            if (COMMAND_COMPLETE_EVENT(packet, hci_read_buffer_size)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_buffer_size)){
                 // from offset 5
                 // status 
                 // "The HC_ACL_Data_Packet_Length return parameter will be used to determine the size of the L2CAP segments contained in ACL Data Packets"
@@ -1364,7 +1364,7 @@ static void event_handler(uint8_t *packet, int size){
                 }
             }
 #ifdef ENABLE_BLE
-            if (COMMAND_COMPLETE_EVENT(packet, hci_le_read_buffer_size)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_le_read_buffer_size)){
                 hci_stack->le_data_packets_length = little_endian_read_16(packet, 6);
                 hci_stack->le_acl_packets_total_num  = packet[8];
                     // determine usable ACL payload size
@@ -1373,23 +1373,23 @@ static void event_handler(uint8_t *packet, int size){
                     }
                 log_info("hci_le_read_buffer_size: size %u, count %u", hci_stack->le_data_packets_length, hci_stack->le_acl_packets_total_num);
             }         
-            if (COMMAND_COMPLETE_EVENT(packet, hci_le_read_white_list_size)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_le_read_white_list_size)){
                 hci_stack->le_whitelist_capacity = little_endian_read_16(packet, 6);
                 log_info("hci_le_read_white_list_size: size %u", hci_stack->le_whitelist_capacity);
             }   
 #endif
             // Dump local address
-            if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)) {
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_bd_addr)) {
                 reverse_bd_addr(&packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE + 1],
 				hci_stack->local_bd_addr);
                 log_info("Local Address, Status: 0x%02x: Addr: %s",
                     packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE], bd_addr_to_str(hci_stack->local_bd_addr));
             }
-            if (COMMAND_COMPLETE_EVENT(packet, hci_write_scan_enable)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_scan_enable)){
                 hci_emit_discoverable_enabled(hci_stack->discoverable);
             }
             // Note: HCI init checks 
-            if (COMMAND_COMPLETE_EVENT(packet, hci_read_local_supported_features)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_supported_features)){
                 memcpy(hci_stack->local_supported_features, &packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE+1], 8);
 
                 // determine usable ACL packet types based on host buffer size and supported features
@@ -1399,7 +1399,7 @@ static void event_handler(uint8_t *packet, int size){
                 // Classic/LE
                 log_info("BR/EDR support %u, LE support %u", hci_classic_supported(), hci_le_supported());
             }
-            if (COMMAND_COMPLETE_EVENT(packet, hci_read_local_version_information)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_version_information)){
                 // hci_stack->hci_version    = little_endian_read_16(packet, 4);
                 // hci_stack->hci_revision   = little_endian_read_16(packet, 6);
                 // hci_stack->lmp_version    = little_endian_read_16(packet, 8);
@@ -1407,12 +1407,12 @@ static void event_handler(uint8_t *packet, int size){
                 // hci_stack->lmp_subversion = little_endian_read_16(packet, 12);
                 log_info("Manufacturer: 0x%04x", hci_stack->manufacturer);
             }
-            if (COMMAND_COMPLETE_EVENT(packet, hci_read_local_supported_commands)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_supported_commands)){
                 hci_stack->local_supported_commands[0] =
                     (packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE+1+14] & 0X80) >> 7 |  // Octet 14, bit 7
                     (packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE+1+24] & 0x40) >> 5;   // Octet 24, bit 6 
             }
-            if (COMMAND_COMPLETE_EVENT(packet, hci_write_synchronous_flow_control_enable)){
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_synchronous_flow_control_enable)){
                 if (packet[5] == 0){
                     hci_stack->synchronous_flow_control_enabled = 1;
                 }
@@ -1785,7 +1785,7 @@ static void event_handler(uint8_t *packet, int size){
     // help with BT sleep
     if (hci_stack->state == HCI_STATE_FALLING_ASLEEP
         && hci_stack->substate == HCI_FALLING_ASLEEP_W4_WRITE_SCAN_ENABLE
-        && COMMAND_COMPLETE_EVENT(packet, hci_write_scan_enable)){
+        && HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_scan_enable)){
         hci_initializing_next_state();
     }
     
@@ -3046,7 +3046,7 @@ static void hci_emit_dedicated_bonding_result(bd_addr_t address, uint8_t status)
 }
 
 // query if remote side supports eSCO
-int hci_remote_eSCO_supported(hci_con_handle_t con_handle){
+int hci_remote_esco_supported(hci_con_handle_t con_handle){
     hci_connection_t * connection = hci_connection_for_handle(con_handle);
     if (!connection) return 0;
     return connection->remote_supported_feature_eSCO;

src/hci.h

@@ -103,8 +103,8 @@ extern "C" {
 #define IS_COMMAND(packet, command) (little_endian_read_16(packet,0) == command.opcode)
 
 // check if command complete event for given command
-#define COMMAND_COMPLETE_EVENT(event,cmd) ( event[0] == HCI_EVENT_COMMAND_COMPLETE && little_endian_read_16(event,3) == cmd.opcode)
+#define HCI_EVENT_IS_COMMAND_COMPLETE(event,cmd) ( event[0] == HCI_EVENT_COMMAND_COMPLETE && little_endian_read_16(event,3) == cmd.opcode)
-#define COMMAND_STATUS_EVENT(event,cmd) ( event[0] == HCI_EVENT_COMMAND_STATUS && little_endian_read_16(event,4) == cmd.opcode)
+#define HCI_EVENT_IS_COMMAND_STATUS(event,cmd) ( event[0] == HCI_EVENT_COMMAND_STATUS && little_endian_read_16(event,4) == cmd.opcode)
 
 // Code+Len=2, Pkts+Opcode=3; total=5
 #define OFFSET_OF_DATA_IN_COMMAND_COMPLETE 5

src/l2cap.c

@@ -934,7 +934,7 @@ static void l2cap_hci_event_handler(uint8_t packet_type, uint16_t cid, uint8_t *
             
         // handle successful create connection cancel command
         case HCI_EVENT_COMMAND_COMPLETE:
-            if ( COMMAND_COMPLETE_EVENT(packet, hci_create_connection_cancel) ) {
+            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_create_connection_cancel)) {
                 if (packet[5] == 0){
                     reverse_bd_addr(&packet[6], address);
                     // CONNECTION TERMINATED BY LOCAL HOST (0X16)

test/gatt_client/le_central.c

@@ -56,7 +56,7 @@ static void handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *pac
             advertisement_received = 1;
             memcpy(advertisement_packet, packet, size);
             
-            bt_flip_addr(address, &packet[4]);
+            reverse_bd_addr(&packet[4], address);
             le_central_connect(address, (bd_addr_type_t)packet[3]);
             break;
         }

test/hfp/mock.c

@@ -177,7 +177,7 @@ static void hci_event_sco_complete(){
 
     event[pos++] = 0; //status
     little_endian_store_16(event,  pos, sco_handle);   pos += 2; // sco handle
-    bt_flip_addr(&event[pos], dev_addr);    pos += 6;
+    reverse_bd_addr(dev_addr, &event[pos]);    pos += 6;
 
     event[pos++] = 0; // link_type
     event[pos++] = 0; // transmission_interval
@@ -237,7 +237,7 @@ uint8_t rfcomm_create_channel(bd_addr_t addr, uint8_t channel, uint16_t * out_ci
     event[pos++] = sizeof(event) - 2;
     event[pos++] = 0;
     
-    bt_flip_addr(&event[pos], addr);
+    reverse_bd_addr(addr, &event[pos]);
     memcpy(dev_addr, addr, 6);
     pos += 6;
     

test/pts/ble_central_test.c

@@ -257,7 +257,7 @@ const char * ad_event_types[] = {
 static void handle_advertising_event(uint8_t * packet, int size){
     // filter PTS
     bd_addr_t addr;
-    bt_flip_addr(addr, &packet[4]);
+    reverse_bd_addr(&packet[4], addr);
 
     // always request address resolution
     sm_address_resolution_lookup(packet[3], addr);
@@ -388,7 +388,7 @@ static void app_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
                     break;
 
                 case SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED:
-                    bt_flip_addr(event_address, &packet[5]);
+                    reverse_bd_addr(&packet[5], event_address);
                     // skip already detected pts
                     if (memcmp(event_address, current_pts_address, 6) == 0) break;
                     memcpy(current_pts_address, event_address, 6);
@@ -679,7 +679,7 @@ static void handle_gatt_client_event(uint8_t packet_type, uint8_t *packet, uint1
                     central_state = CENTRAL_IDLE;
                     hci_le_advertisement_address(&address_type, our_private_address);
                     printf("Our private address: %s\n", bd_addr_to_str(our_private_address));
-                    bt_flip_addr(flipped_address, our_private_address);
+                    reverse_bd_addr(our_private_address, flipped_address);
                     gatt_client_write_value_of_characteristic(gc_id, handle, gap_reconnection_address_characteristic.value_handle, 6, flipped_address);
                     reconnection_address_set = 1;
 #ifdef PTS_USES_RECONNECTION_ADDRESS_FOR_ITSELF

test/pts/ble_peripheral_test.c

@@ -324,7 +324,7 @@ static uint16_t att_read_callback(uint16_t con_handle, uint16_t attribute_handle
             return 1;
         case ATT_CHARACTERISTIC_GAP_RECONNECTION_ADDRESS_01_VALUE_HANDLE:
             if (buffer) {
-                bt_flip_addr(buffer, gap_reconnection_address);
+                reverse_bd_addr(gap_reconnection_address, buffer);
             }
             return 6;
 
@@ -399,7 +399,7 @@ static int att_write_callback(uint16_t con_handle, uint16_t attribute_handle, ui
             update_advertisements();
             return 0;
         case ATT_CHARACTERISTIC_GAP_RECONNECTION_ADDRESS_01_VALUE_HANDLE:
-            bt_flip_addr(gap_reconnection_address, buffer);
+            reverse_bd_addr(buffer, gap_reconnection_address);
             printf("Setting Reconnection Address to %s\n", bd_addr_to_str(gap_reconnection_address));
             return 0;
         default:
@@ -588,7 +588,7 @@ static void app_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
                 case SM_EVENT_PASSKEY_INPUT_NUMBER:
                     // display number
                     master_addr_type = packet[4];
-                    bt_flip_addr(event_address, &packet[5]);
+                    reverse_bd_addr(&packet[5], event_address);
                     printf("\nGAP Bonding %s (%u): Enter 6 digit passkey: '", bd_addr_to_str(master_address), master_addr_type);
                     fflush(stdout);
                     ui_passkey = 0;

test/pts/bnep_test.c

@@ -689,8 +689,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
                     break;
 
                 case HCI_EVENT_COMMAND_COMPLETE:
-					if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)){
+					if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_bd_addr)){
-                        bt_flip_addr(local_addr, &packet[6]);
+                        reverse_bd_addr(&packet[6], local_addr);
                         printf("BD-ADDR: %s\n", bd_addr_to_str(local_addr));
                         break;
                     }

test/pts/classic_test.c

@@ -194,7 +194,7 @@ static void inquiry_packet_handler (uint8_t packet_type, uint8_t *packet, uint16
             numResponses = packet[2];
             int offset = 3;
             for (i=0; i<numResponses && deviceCount < MAX_DEVICES;i++){
-                bt_flip_addr(addr, &packet[offset]);
+                reverse_bd_addr(&packet[offset], addr);
                 offset += 6;
                 index = getDeviceIndexForAddress(addr);
                 if (index >= 0) continue;   // already in our list
@@ -238,12 +238,12 @@ static void inquiry_packet_handler (uint8_t packet_type, uint8_t *packet, uint16
             break;
 
         case BTSTACK_EVENT_REMOTE_NAME_CACHED:
-            bt_flip_addr(addr, &packet[3]);
+            reverse_bd_addr(&packet[3], addr);
             printf("Cached remote name for %s: '%s'\n", bd_addr_to_str(addr), &packet[9]);
             break;
 
         case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE:
-            bt_flip_addr(addr, &packet[3]);
+            reverse_bd_addr(&packet[3], addr);
             index = getDeviceIndexForAddress(addr);
             if (index >= 0) {
                 if (packet[2] == 0) {
@@ -297,26 +297,26 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
         case HCI_EVENT_CONNECTION_COMPLETE:
             if (!packet[2]){
                 handle = little_endian_read_16(packet, 3);
-                bt_flip_addr(remote, &packet[5]);
+                reverse_bd_addr(&packet[5], remote);
                 printf("HCI_EVENT_CONNECTION_COMPLETE: handle 0x%04x\n", handle);
             }
             break;
 
         case HCI_EVENT_USER_PASSKEY_REQUEST:
-            bt_flip_addr(remote, &packet[2]);
+            reverse_bd_addr(&packet[2], remote);
             printf("GAP User Passkey Request for %s\nPasskey:", bd_addr_to_str(remote));
             fflush(stdout);
             ui_digits_for_passkey = 6;
             break;
 
         case HCI_EVENT_USER_CONFIRMATION_REQUEST:
-            bt_flip_addr(remote, &packet[2]);
+            reverse_bd_addr(&packet[2], remote);
             passkey = little_endian_read_32(packet, 8);
             printf("GAP User Confirmation Request for %s, number '%06u'\n", bd_addr_to_str(remote),passkey);
             break;
 
         case HCI_EVENT_PIN_CODE_REQUEST:
-            bt_flip_addr(remote, &packet[2]);
+            reverse_bd_addr(&packet[2], remote);
             printf("GAP Legacy PIN Request for %s (press ENTER to send)\nPasskey:", bd_addr_to_str(remote));
             fflush(stdout);
             ui_chars_for_pin = 1;
@@ -324,7 +324,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
 
         case L2CAP_EVENT_CHANNEL_OPENED:
             // inform about new l2cap connection
-            bt_flip_addr(remote, &packet[3]);
+            reverse_bd_addr(&packet[3], remote);
             psm = little_endian_read_16(packet, 11); 
             local_cid = little_endian_read_16(packet, 13); 
             handle = little_endian_read_16(packet, 9);
@@ -347,7 +347,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
 
         case RFCOMM_EVENT_INCOMING_CONNECTION:
             // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16)
-            bt_flip_addr(remote, &packet[2]); 
+            reverse_bd_addr(&packet[2], remote); 
             rfcomm_channel_nr = packet[8];
             rfcomm_channel_id = little_endian_read_16(packet, 9);
             printf("RFCOMM channel %u requested for %s\n\r", rfcomm_channel_nr, bd_addr_to_str(remote));

test/pts/hfp_ag_test.c

@@ -197,7 +197,7 @@ static void inquiry_packet_handler (uint8_t packet_type, uint8_t *packet, uint16
             numResponses = packet[2];
             int offset = 3;
             for (i=0; i<numResponses && deviceCount < MAX_DEVICES;i++){
-                bt_flip_addr(addr, &packet[offset]);
+                reverse_bd_addr(&packet[offset], addr);
                 offset += 6;
                 index = getDeviceIndexForAddress(addr);
                 if (index >= 0) continue;   // already in our list
@@ -242,12 +242,12 @@ static void inquiry_packet_handler (uint8_t packet_type, uint8_t *packet, uint16
             break;
 
         case BTSTACK_EVENT_REMOTE_NAME_CACHED:
-            bt_flip_addr(addr, &packet[3]);
+            reverse_bd_addr(&packet[3], addr);
             printf("Cached remote name for %s: '%s'\n", bd_addr_to_str(addr), &packet[9]);
             break;
 
         case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE:
-            bt_flip_addr(addr, &packet[3]);
+            reverse_bd_addr(&packet[3], addr);
             index = getDeviceIndexForAddress(addr);
             if (index >= 0) {
                 if (packet[2] == 0) {

test/pts/hfp_test.c

@@ -114,7 +114,7 @@ static void packet_handler(void * connection, uint8_t packet_type, uint16_t chan
         case HCI_EVENT_PIN_CODE_REQUEST:
             // inform about pin code request
             printf("Pin code request - using '0000'\n\r");
-            bt_flip_addr(event_addr, &packet[2]);
+            reverse_bd_addr(&packet[2], event_addr);
             hci_send_cmd(&hci_pin_code_request_reply, &event_addr, 4, "0000");
             break;
 

test/pts/l2cap_test.c

@@ -86,7 +86,7 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
             break;
         case L2CAP_EVENT_CHANNEL_OPENED:
             // inform about new l2cap connection
-            bt_flip_addr(event_addr, &packet[3]);
+            reverse_bd_addr(&packet[3], event_addr);
             psm = little_endian_read_16(packet, 11); 
             local_cid = little_endian_read_16(packet, 13); 
             handle = little_endian_read_16(packet, 9);

tool/conversion_to_1.0.cocci

@@ -10,3 +10,14 @@ expression handle;
 - hci_remote_eSCO_supported(handle)
 + hci_remote_esco_supported(handle)
 
+@@
+expression event, cmd;
+@@
+- COMMAND_COMPLETE_EVENT(event,cmd) 
++ HCI_EVENT_IS_COMMAND_COMPLETE(event,cmd) 
+
+@@
+expression event, cmd;
+@@
+- COMMAND_STATUS_EVENT(event,cmd) 
++ HCI_EVENT_IS_COMMAND_STATUS(event,cmd)