1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define __BTSTACK_FILE__ "panu_demo.c" 39 40 /* 41 * panu_demo.c 42 * Author: Ole Reinhardt <[email protected]> 43 */ 44 45 /* EXAMPLE_START(panu_demo): PANU Demo 46 * 47 * @text This example implements both a PANU client and a server. In server mode, it 48 * sets up a BNEP server and registers a PANU SDP record and waits for incoming connections. 49 * In client mode, it connects to a remote device, does an SDP Query to identify the PANU 50 * service and initiates a BNEP connection. 51 * 52 * Note: currently supported only on Linux and Mac. 53 */ 54 55 #include <stdio.h> 56 57 #include "btstack_config.h" 58 #include "btstack.h" 59 60 static int record_id = -1; 61 static uint16_t bnep_l2cap_psm = 0; 62 static uint32_t bnep_remote_uuid = 0; 63 static uint16_t bnep_version = 0; 64 static uint16_t bnep_cid = 0; 65 66 static uint16_t sdp_bnep_l2cap_psm = 0; 67 static uint16_t sdp_bnep_version = 0; 68 static uint32_t sdp_bnep_remote_uuid = 0; 69 70 static uint8_t attribute_value[1000]; 71 static const unsigned int attribute_value_buffer_size = sizeof(attribute_value); 72 73 // MBP 2016 74 static const char * remote_addr_string = "F4-0F-24-3B-1B-E1"; 75 // Wiko Sunny static const char * remote_addr_string = "A0:4C:5B:0F:B2:42"; 76 77 static bd_addr_t remote_addr; 78 79 static btstack_packet_callback_registration_t hci_event_callback_registration; 80 81 // outgoing network packet 82 static const uint8_t * network_buffer; 83 static uint16_t network_buffer_len; 84 85 /* @section Main application configuration 86 * 87 * @text In the application configuration, L2CAP and BNEP are initialized and a BNEP service, for server mode, 88 * is registered, before the Bluetooth stack gets started, as shown in Listing PanuSetup. 89 */ 90 91 /* LISTING_START(PanuSetup): Panu setup */ 92 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 93 static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 94 static void network_send_packet_callback(const uint8_t * packet, uint16_t size); 95 96 static void panu_setup(void){ 97 98 // register for HCI events 99 hci_event_callback_registration.callback = &packet_handler; 100 hci_add_event_handler(&hci_event_callback_registration); 101 102 // Initialize L2CAP 103 l2cap_init(); 104 105 // Initialise BNEP 106 bnep_init(); 107 108 // Minimum L2CAP MTU for bnep is 1691 bytes 109 bnep_register_service(packet_handler, BLUETOOTH_SERVICE_CLASS_PANU, 1691); 110 111 // Initialize network interface 112 btstack_network_init(&network_send_packet_callback); 113 } 114 /* LISTING_END */ 115 116 // PANU client routines 117 static char * get_string_from_data_element(uint8_t * element){ 118 de_size_t de_size = de_get_size_type(element); 119 int pos = de_get_header_size(element); 120 int len = 0; 121 switch (de_size){ 122 case DE_SIZE_VAR_8: 123 len = element[1]; 124 break; 125 case DE_SIZE_VAR_16: 126 len = big_endian_read_16(element, 1); 127 break; 128 default: 129 break; 130 } 131 char * str = (char*)malloc(len+1); 132 memcpy(str, &element[pos], len); 133 str[len] ='\0'; 134 return str; 135 } 136 137 138 /* @section SDP parser callback 139 * 140 * @text The SDP parsers retrieves the BNEP PAN UUID as explained in 141 * Section [on SDP BNEP Query example](#sec:sdpbnepqueryExample}. 142 */ 143 static void handle_sdp_client_record_complete(void){ 144 145 printf("SDP BNEP Record complete\n"); 146 147 // accept first entry or if we foudn a NAP and only have a PANU yet 148 if ((bnep_remote_uuid == 0) || (sdp_bnep_remote_uuid == BLUETOOTH_SERVICE_CLASS_NAP && bnep_remote_uuid == BLUETOOTH_SERVICE_CLASS_PANU)){ 149 bnep_l2cap_psm = sdp_bnep_l2cap_psm; 150 bnep_remote_uuid = sdp_bnep_remote_uuid; 151 bnep_version = sdp_bnep_version; 152 } 153 } 154 155 static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) { 156 157 UNUSED(packet_type); 158 UNUSED(channel); 159 UNUSED(size); 160 161 des_iterator_t des_list_it; 162 des_iterator_t prot_it; 163 char *str; 164 165 switch (hci_event_packet_get_type(packet)){ 166 case SDP_EVENT_QUERY_ATTRIBUTE_VALUE: 167 // Handle new SDP record 168 if (sdp_event_query_attribute_byte_get_record_id(packet) != record_id) { 169 handle_sdp_client_record_complete(); 170 // next record started 171 record_id = sdp_event_query_attribute_byte_get_record_id(packet); 172 printf("SDP Record: Nr: %d\n", record_id); 173 } 174 175 if (sdp_event_query_attribute_byte_get_attribute_length(packet) <= attribute_value_buffer_size) { 176 attribute_value[sdp_event_query_attribute_byte_get_data_offset(packet)] = sdp_event_query_attribute_byte_get_data(packet); 177 178 if ((uint16_t)(sdp_event_query_attribute_byte_get_data_offset(packet)+1) == sdp_event_query_attribute_byte_get_attribute_length(packet)) { 179 180 switch(sdp_event_query_attribute_byte_get_attribute_id(packet)) { 181 case BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST: 182 if (de_get_element_type(attribute_value) != DE_DES) break; 183 for (des_iterator_init(&des_list_it, attribute_value); des_iterator_has_more(&des_list_it); des_iterator_next(&des_list_it)) { 184 uint8_t * element = des_iterator_get_element(&des_list_it); 185 if (de_get_element_type(element) != DE_UUID) continue; 186 uint32_t uuid = de_get_uuid32(element); 187 switch (uuid){ 188 case BLUETOOTH_SERVICE_CLASS_PANU: 189 case BLUETOOTH_SERVICE_CLASS_NAP: 190 case BLUETOOTH_SERVICE_CLASS_GN: 191 printf("SDP Attribute 0x%04x: BNEP PAN protocol UUID: %04x\n", sdp_event_query_attribute_byte_get_attribute_id(packet), uuid); 192 sdp_bnep_remote_uuid = uuid; 193 break; 194 default: 195 break; 196 } 197 } 198 break; 199 case 0x0100: 200 case 0x0101: 201 str = get_string_from_data_element(attribute_value); 202 printf("SDP Attribute: 0x%04x: %s\n", sdp_event_query_attribute_byte_get_attribute_id(packet), str); 203 free(str); 204 break; 205 case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST: { 206 printf("SDP Attribute: 0x%04x\n", sdp_event_query_attribute_byte_get_attribute_id(packet)); 207 208 for (des_iterator_init(&des_list_it, attribute_value); des_iterator_has_more(&des_list_it); des_iterator_next(&des_list_it)) { 209 uint8_t *des_element; 210 uint8_t *element; 211 uint32_t uuid; 212 213 if (des_iterator_get_type(&des_list_it) != DE_DES) continue; 214 215 des_element = des_iterator_get_element(&des_list_it); 216 des_iterator_init(&prot_it, des_element); 217 element = des_iterator_get_element(&prot_it); 218 219 if (de_get_element_type(element) != DE_UUID) continue; 220 221 uuid = de_get_uuid32(element); 222 switch (uuid){ 223 case BLUETOOTH_PROTOCOL_L2CAP: 224 if (!des_iterator_has_more(&prot_it)) continue; 225 des_iterator_next(&prot_it); 226 de_element_get_uint16(des_iterator_get_element(&prot_it), &sdp_bnep_l2cap_psm); 227 break; 228 case BLUETOOTH_PROTOCOL_BNEP: 229 if (!des_iterator_has_more(&prot_it)) continue; 230 des_iterator_next(&prot_it); 231 de_element_get_uint16(des_iterator_get_element(&prot_it), &sdp_bnep_version); 232 break; 233 default: 234 break; 235 } 236 } 237 printf("Summary: uuid 0x%04x, l2cap_psm 0x%04x, bnep_version 0x%04x\n", sdp_bnep_remote_uuid, sdp_bnep_l2cap_psm, sdp_bnep_version); 238 239 } 240 break; 241 default: 242 break; 243 } 244 } 245 } else { 246 fprintf(stderr, "SDP attribute value buffer size exceeded: available %d, required %d\n", attribute_value_buffer_size, sdp_event_query_attribute_byte_get_attribute_length(packet)); 247 } 248 break; 249 250 case SDP_EVENT_QUERY_COMPLETE: 251 handle_sdp_client_record_complete(); 252 fprintf(stderr, "General query done with status %d, bnep psm %04x.\n", sdp_event_query_complete_get_status(packet), bnep_l2cap_psm); 253 if (bnep_l2cap_psm){ 254 /* Create BNEP connection */ 255 bnep_connect(packet_handler, remote_addr, bnep_l2cap_psm, BLUETOOTH_SERVICE_CLASS_PANU, bnep_remote_uuid); 256 } else { 257 fprintf(stderr, "No BNEP service found\n"); 258 } 259 260 break; 261 } 262 } 263 264 /* 265 * @section Packet Handler 266 * 267 * @text The packet handler responds to various HCI Events. 268 */ 269 270 /* LISTING_START(packetHandler): Packet Handler */ 271 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) 272 { 273 /* LISTING_PAUSE */ 274 UNUSED(channel); 275 276 uint8_t event; 277 bd_addr_t event_addr; 278 bd_addr_t local_addr; 279 uint16_t uuid_source; 280 uint16_t uuid_dest; 281 uint16_t mtu; 282 283 /* LISTING_RESUME */ 284 switch (packet_type) { 285 case HCI_EVENT_PACKET: 286 event = hci_event_packet_get_type(packet); 287 switch (event) { 288 /* @text When BTSTACK_EVENT_STATE with state HCI_STATE_WORKING 289 * is received and the example is started in client mode, the remote SDP BNEP query is started. 290 */ 291 case BTSTACK_EVENT_STATE: 292 if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING){ 293 printf("Start SDP BNEP query for remote PAN Network Access Point (NAP).\n"); 294 sdp_client_query_uuid16(&handle_sdp_client_query_result, remote_addr, BLUETOOTH_SERVICE_CLASS_NAP); 295 } 296 break; 297 298 /* LISTING_PAUSE */ 299 case HCI_EVENT_PIN_CODE_REQUEST: 300 // inform about pin code request 301 printf("Pin code request - using '0000'\n"); 302 hci_event_pin_code_request_get_bd_addr(packet, event_addr); 303 gap_pin_code_response(event_addr, "0000"); 304 break; 305 306 case HCI_EVENT_USER_CONFIRMATION_REQUEST: 307 // inform about user confirmation request 308 printf("SSP User Confirmation Request with numeric value '%06u'\n", little_endian_read_32(packet, 8)); 309 printf("SSP User Confirmation Auto accept\n"); 310 break; 311 312 /* LISTING_RESUME */ 313 314 /* @text BNEP_EVENT_CHANNEL_OPENED is received after a BNEP connection was established or 315 * or when the connection fails. The status field returns the error code. 316 * 317 * The TAP network interface is then configured. A data source is set up and registered with the 318 * run loop to receive Ethernet packets from the TAP interface. 319 * 320 * The event contains both the source and destination UUIDs, as well as the MTU for this connection and 321 * the BNEP Channel ID, which is used for sending Ethernet packets over BNEP. 322 */ 323 case BNEP_EVENT_CHANNEL_OPENED: 324 if (bnep_event_channel_opened_get_status(packet)) { 325 printf("BNEP channel open failed, status %02x\n", bnep_event_channel_opened_get_status(packet)); 326 } else { 327 bnep_cid = bnep_event_channel_opened_get_bnep_cid(packet); 328 uuid_source = bnep_event_channel_opened_get_source_uuid(packet); 329 uuid_dest = bnep_event_channel_opened_get_destination_uuid(packet); 330 mtu = bnep_event_channel_opened_get_mtu(packet); 331 memcpy(&event_addr, &packet[11], sizeof(bd_addr_t)); 332 printf("BNEP connection open succeeded to %s source UUID 0x%04x dest UUID: 0x%04x, max frame size %u\n", bd_addr_to_str(event_addr), uuid_source, uuid_dest, mtu); 333 /* Setup network interface */ 334 gap_local_bd_addr(local_addr); 335 btstack_network_up(local_addr); 336 printf("Network Interface %s activated\n", btstack_network_get_name()); 337 } 338 break; 339 340 /* @text If there is a timeout during the connection setup, BNEP_EVENT_CHANNEL_TIMEOUT will be received 341 * and the BNEP connection will be closed 342 */ 343 case BNEP_EVENT_CHANNEL_TIMEOUT: 344 printf("BNEP channel timeout! Channel will be closed\n"); 345 break; 346 347 /* @text BNEP_EVENT_CHANNEL_CLOSED is received when the connection gets closed. 348 */ 349 case BNEP_EVENT_CHANNEL_CLOSED: 350 printf("BNEP channel closed\n"); 351 btstack_network_down(); 352 break; 353 354 /* @text BNEP_EVENT_CAN_SEND_NOW indicates that a new packet can be send. This triggers the send of a 355 * stored network packet. The tap datas source can be enabled again 356 */ 357 case BNEP_EVENT_CAN_SEND_NOW: 358 if (network_buffer_len > 0) { 359 bnep_send(bnep_cid, (uint8_t*) network_buffer, network_buffer_len); 360 network_buffer_len = 0; 361 btstack_network_packet_sent(); 362 } 363 break; 364 365 default: 366 break; 367 } 368 break; 369 370 /* @text Ethernet packets from the remote device are received in the packet handler with type BNEP_DATA_PACKET. 371 * It is forwarded to the TAP interface. 372 */ 373 case BNEP_DATA_PACKET: 374 // Write out the ethernet frame to the network interface 375 btstack_network_process_packet(packet, size); 376 break; 377 378 default: 379 break; 380 } 381 } 382 /* LISTING_END */ 383 384 /* 385 * @section Network packet handler 386 * 387 * @text A pointer to the network packet is stored and a BNEP_EVENT_CAN_SEND_NOW requested 388 */ 389 390 /* LISTING_START(networkPacketHandler): Network Packet Handler */ 391 static void network_send_packet_callback(const uint8_t * packet, uint16_t size){ 392 network_buffer = packet; 393 network_buffer_len = size; 394 bnep_request_can_send_now_event(bnep_cid); 395 } 396 /* LISTING_END */ 397 398 int btstack_main(int argc, const char * argv[]); 399 int btstack_main(int argc, const char * argv[]){ 400 401 (void)argc; 402 (void)argv; 403 404 panu_setup(); 405 406 // parse human readable Bluetooth address 407 sscanf_bd_addr(remote_addr_string, remote_addr); 408 409 // Turn on the device 410 hci_power_control(HCI_POWER_ON); 411 return 0; 412 } 413 414 /* EXAMPLE_END */ 415 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4 -*- */ 416 417