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 /* 39 * rfcomm.c 40 */ 41 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> // memcpy 45 #include <stdint.h> 46 47 #include "hci_cmd.h" 48 #include "btstack_util.h" 49 50 #include "btstack_util.h" 51 #include "btstack_memory.h" 52 #include "hci.h" 53 #include "hci_dump.h" 54 #include "btstack_debug.h" 55 #include "classic/rfcomm.h" 56 57 // workaround for missing PRIxPTR on mspgcc (16/20-bit MCU) 58 #ifndef PRIxPTR 59 #if defined(__MSP430X__) && defined(__MSP430X_LARGE__) 60 #define PRIxPTR "lx" 61 #else 62 #define PRIxPTR "x" 63 #endif 64 #endif 65 66 #define RFCOMM_MULIPLEXER_TIMEOUT_MS 60000 67 68 #define RFCOMM_CREDITS 10 69 70 // FCS calc 71 #define BT_RFCOMM_CODE_WORD 0xE0 // pol = x8+x2+x1+1 72 #define BT_RFCOMM_CRC_CHECK_LEN 3 73 #define BT_RFCOMM_UIHCRC_CHECK_LEN 2 74 75 #include "l2cap.h" 76 77 // global rfcomm data 78 static uint16_t rfcomm_client_cid_generator; // used for client channel IDs 79 80 // linked lists for all 81 static btstack_linked_list_t rfcomm_multiplexers = NULL; 82 static btstack_linked_list_t rfcomm_channels = NULL; 83 static btstack_linked_list_t rfcomm_services = NULL; 84 85 static gap_security_level_t rfcomm_security_level; 86 87 static void (*app_packet_handler)(uint8_t packet_type, 88 uint16_t channel, uint8_t *packet, uint16_t size); 89 90 static void rfcomm_run(void); 91 static void rfcomm_channel_state_machine(rfcomm_channel_t *channel, rfcomm_channel_event_t *event); 92 static void rfcomm_channel_state_machine_2(rfcomm_multiplexer_t * multiplexer, uint8_t dlci, rfcomm_channel_event_t *event); 93 static int rfcomm_channel_ready_for_open(rfcomm_channel_t *channel); 94 static void rfcomm_multiplexer_state_machine(rfcomm_multiplexer_t * multiplexer, RFCOMM_MULTIPLEXER_EVENT event); 95 96 97 // MARK: RFCOMM CLIENT EVENTS 98 99 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 100 static void rfcomm_emit_connection_request(rfcomm_channel_t *channel) { 101 log_info("RFCOMM_EVENT_INCOMING_CONNECTION addr %s channel #%u cid 0x%02x", 102 bd_addr_to_str(channel->multiplexer->remote_addr), channel->dlci>>1, channel->rfcomm_cid); 103 uint8_t event[11]; 104 event[0] = RFCOMM_EVENT_INCOMING_CONNECTION; 105 event[1] = sizeof(event) - 2; 106 bt_flip_addr(&event[2], channel->multiplexer->remote_addr); 107 event[8] = channel->dlci >> 1; 108 bt_store_16(event, 9, channel->rfcomm_cid); 109 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 110 (*app_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 111 } 112 113 // API Change: BTstack-0.3.50x uses 114 // data: event(8), len(8), status (8), address (48), server channel(8), rfcomm_cid(16), max frame size(16) 115 // next Cydia release will use SVN version of this 116 // data: event(8), len(8), status (8), address (48), handle (16), server channel(8), rfcomm_cid(16), max frame size(16) 117 static void rfcomm_emit_channel_opened(rfcomm_channel_t *channel, uint8_t status) { 118 log_info("RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE status 0x%x addr %s handle 0x%x channel #%u cid 0x%02x mtu %u", 119 status, bd_addr_to_str(channel->multiplexer->remote_addr), channel->multiplexer->con_handle, 120 channel->dlci>>1, channel->rfcomm_cid, channel->max_frame_size); 121 uint8_t event[16]; 122 uint8_t pos = 0; 123 event[pos++] = RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE; // 0 124 event[pos++] = sizeof(event) - 2; // 1 125 event[pos++] = status; // 2 126 bt_flip_addr(&event[pos], channel->multiplexer->remote_addr); pos += 6; // 3 127 bt_store_16(event, pos, channel->multiplexer->con_handle); pos += 2; // 9 128 event[pos++] = channel->dlci >> 1; // 11 129 bt_store_16(event, pos, channel->rfcomm_cid); pos += 2; // 12 - channel ID 130 bt_store_16(event, pos, channel->max_frame_size); pos += 2; // max frame size 131 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 132 (*app_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, pos); 133 } 134 135 // data: event(8), len(8), rfcomm_cid(16) 136 static void rfcomm_emit_channel_closed(rfcomm_channel_t * channel) { 137 log_info("RFCOMM_EVENT_CHANNEL_CLOSED cid 0x%02x", channel->rfcomm_cid); 138 uint8_t event[4]; 139 event[0] = RFCOMM_EVENT_CHANNEL_CLOSED; 140 event[1] = sizeof(event) - 2; 141 bt_store_16(event, 2, channel->rfcomm_cid); 142 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 143 (*app_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 144 } 145 146 static void rfcomm_emit_remote_line_status(rfcomm_channel_t *channel, uint8_t line_status){ 147 log_info("RFCOMM_EVENT_REMOTE_LINE_STATUS cid 0x%02x c, line status 0x%x", channel->rfcomm_cid, line_status); 148 uint8_t event[5]; 149 event[0] = RFCOMM_EVENT_REMOTE_LINE_STATUS; 150 event[1] = sizeof(event) - 2; 151 bt_store_16(event, 2, channel->rfcomm_cid); 152 event[4] = line_status; 153 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 154 (*app_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 155 } 156 157 static void rfcomm_emit_port_configuration(rfcomm_channel_t *channel){ 158 // notify client about new settings 159 uint8_t event[2+sizeof(rfcomm_rpn_data_t)]; 160 event[0] = RFCOMM_EVENT_PORT_CONFIGURATION; 161 event[1] = sizeof(rfcomm_rpn_data_t); 162 memcpy(&event[2], (uint8_t*) &channel->rpn_data, sizeof(rfcomm_rpn_data_t)); 163 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 164 (*app_packet_handler)(HCI_EVENT_PACKET, channel->rfcomm_cid, (uint8_t*)event, sizeof(event)); 165 } 166 167 // MARK RFCOMM RPN DATA HELPER 168 static void rfcomm_rpn_data_set_defaults(rfcomm_rpn_data_t * rpn_data){ 169 rpn_data->baud_rate = RPN_BAUD_9600; /* 9600 bps */ 170 rpn_data->flags = 0x03; /* 8-n-1 */ 171 rpn_data->flow_control = 0; /* no flow control */ 172 rpn_data->xon = 0xd1; /* XON */ 173 rpn_data->xoff = 0xd3; /* XOFF */ 174 rpn_data->parameter_mask_0 = 0x7f; /* parameter mask, all values set */ 175 rpn_data->parameter_mask_1 = 0x3f; /* parameter mask, all values set */ 176 } 177 178 static void rfcomm_rpn_data_update(rfcomm_rpn_data_t * dest, rfcomm_rpn_data_t * src){ 179 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_BAUD){ 180 dest->baud_rate = src->baud_rate; 181 } 182 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_DATA_BITS){ 183 dest->flags = (dest->flags & 0xfc) | (src->flags & 0x03); 184 } 185 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_STOP_BITS){ 186 dest->flags = (dest->flags & 0xfb) | (src->flags & 0x04); 187 } 188 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_PARITY){ 189 dest->flags = (dest->flags & 0xf7) | (src->flags & 0x08); 190 } 191 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_PARITY_TYPE){ 192 dest->flags = (dest->flags & 0xfc) | (src->flags & 0x30); 193 } 194 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_XON_CHAR){ 195 dest->xon = src->xon; 196 } 197 if (src->parameter_mask_0 & RPN_PARAM_MASK_0_XOFF_CHAR){ 198 dest->xoff = src->xoff; 199 } 200 int i; 201 for (i=0; i < 6 ; i++){ 202 uint8_t mask = 1 << i; 203 if (src->parameter_mask_1 & mask){ 204 dest->flags = (dest->flags & ~mask) | (src->flags & mask); 205 } 206 } 207 // always copy parameter mask, too. informative for client, needed for response 208 dest->parameter_mask_0 = src->parameter_mask_0; 209 dest->parameter_mask_1 = src->parameter_mask_1; 210 } 211 // MARK: RFCOMM MULTIPLEXER HELPER 212 213 static uint16_t rfcomm_max_frame_size_for_l2cap_mtu(uint16_t l2cap_mtu){ 214 // Assume RFCOMM header without credits and 2 byte (14 bit) length field 215 uint16_t max_frame_size = l2cap_mtu - 5; 216 log_info("rfcomm_max_frame_size_for_l2cap_mtu: %u -> %u", l2cap_mtu, max_frame_size); 217 return max_frame_size; 218 } 219 220 static void rfcomm_multiplexer_initialize(rfcomm_multiplexer_t *multiplexer){ 221 222 memset(multiplexer, 0, sizeof(rfcomm_multiplexer_t)); 223 224 multiplexer->state = RFCOMM_MULTIPLEXER_CLOSED; 225 multiplexer->fcon = 1; 226 multiplexer->send_dm_for_dlci = 0; 227 multiplexer->max_frame_size = rfcomm_max_frame_size_for_l2cap_mtu(l2cap_max_mtu()); 228 multiplexer->test_data_len = 0; 229 multiplexer->nsc_command = 0; 230 } 231 232 static rfcomm_multiplexer_t * rfcomm_multiplexer_create_for_addr(bd_addr_t addr){ 233 234 // alloc structure 235 rfcomm_multiplexer_t * multiplexer = btstack_memory_rfcomm_multiplexer_get(); 236 if (!multiplexer) return NULL; 237 238 // fill in 239 rfcomm_multiplexer_initialize(multiplexer); 240 BD_ADDR_COPY(&multiplexer->remote_addr, addr); 241 242 // add to services list 243 btstack_linked_list_add(&rfcomm_multiplexers, (btstack_linked_item_t *) multiplexer); 244 245 return multiplexer; 246 } 247 248 static rfcomm_multiplexer_t * rfcomm_multiplexer_for_addr(bd_addr_t addr){ 249 btstack_linked_item_t *it; 250 for (it = (btstack_linked_item_t *) rfcomm_multiplexers; it ; it = it->next){ 251 rfcomm_multiplexer_t * multiplexer = ((rfcomm_multiplexer_t *) it); 252 if (BD_ADDR_CMP(addr, multiplexer->remote_addr) == 0) { 253 return multiplexer; 254 }; 255 } 256 return NULL; 257 } 258 259 static rfcomm_multiplexer_t * rfcomm_multiplexer_for_l2cap_cid(uint16_t l2cap_cid) { 260 btstack_linked_item_t *it; 261 for (it = (btstack_linked_item_t *) rfcomm_multiplexers; it ; it = it->next){ 262 rfcomm_multiplexer_t * multiplexer = ((rfcomm_multiplexer_t *) it); 263 if (multiplexer->l2cap_cid == l2cap_cid) { 264 return multiplexer; 265 }; 266 } 267 return NULL; 268 } 269 270 static int rfcomm_multiplexer_has_channels(rfcomm_multiplexer_t * multiplexer){ 271 btstack_linked_item_t *it; 272 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 273 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 274 if (channel->multiplexer == multiplexer) { 275 return 1; 276 } 277 } 278 return 0; 279 } 280 281 // MARK: RFCOMM CHANNEL HELPER 282 283 static void rfcomm_dump_channels(void){ 284 #ifndef EMBEDDED 285 btstack_linked_item_t * it; 286 int channels = 0; 287 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 288 rfcomm_channel_t * channel = (rfcomm_channel_t *) it; 289 log_info("Channel #%u: addr %p, state %u", channels, channel, channel->state); 290 channels++; 291 } 292 #endif 293 } 294 295 static void rfcomm_channel_initialize(rfcomm_channel_t *channel, rfcomm_multiplexer_t *multiplexer, 296 rfcomm_service_t *service, uint8_t server_channel){ 297 298 // don't use 0 as channel id 299 if (rfcomm_client_cid_generator == 0) ++rfcomm_client_cid_generator; 300 301 // setup channel 302 memset(channel, 0, sizeof(rfcomm_channel_t)); 303 304 channel->state = RFCOMM_CHANNEL_CLOSED; 305 channel->state_var = RFCOMM_CHANNEL_STATE_VAR_NONE; 306 307 channel->multiplexer = multiplexer; 308 channel->service = service; 309 channel->rfcomm_cid = rfcomm_client_cid_generator++; 310 channel->max_frame_size = multiplexer->max_frame_size; 311 312 channel->credits_incoming = 0; 313 channel->credits_outgoing = 0; 314 315 // set defaults for port configuration (even for services) 316 rfcomm_rpn_data_set_defaults(&channel->rpn_data); 317 318 // incoming flow control not active 319 channel->new_credits_incoming =RFCOMM_CREDITS; 320 channel->incoming_flow_control = 0; 321 322 channel->rls_line_status = RFCOMM_RLS_STATUS_INVALID; 323 324 if (service) { 325 // incoming connection 326 channel->outgoing = 0; 327 channel->dlci = (server_channel << 1) | multiplexer->outgoing; 328 if (channel->max_frame_size > service->max_frame_size) { 329 channel->max_frame_size = service->max_frame_size; 330 } 331 channel->incoming_flow_control = service->incoming_flow_control; 332 channel->new_credits_incoming = service->incoming_initial_credits; 333 } else { 334 // outgoing connection 335 channel->outgoing = 1; 336 channel->dlci = (server_channel << 1) | (multiplexer->outgoing ^ 1); 337 338 } 339 } 340 341 // service == NULL -> outgoing channel 342 static rfcomm_channel_t * rfcomm_channel_create(rfcomm_multiplexer_t * multiplexer, 343 rfcomm_service_t * service, uint8_t server_channel){ 344 345 log_info("rfcomm_channel_create for service %p, channel %u --- list of channels:", service, server_channel); 346 rfcomm_dump_channels(); 347 348 // alloc structure 349 rfcomm_channel_t * channel = btstack_memory_rfcomm_channel_get(); 350 if (!channel) return NULL; 351 352 // fill in 353 rfcomm_channel_initialize(channel, multiplexer, service, server_channel); 354 355 // add to services list 356 btstack_linked_list_add(&rfcomm_channels, (btstack_linked_item_t *) channel); 357 358 return channel; 359 } 360 361 static rfcomm_channel_t * rfcomm_channel_for_rfcomm_cid(uint16_t rfcomm_cid){ 362 btstack_linked_item_t *it; 363 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 364 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 365 if (channel->rfcomm_cid == rfcomm_cid) { 366 return channel; 367 }; 368 } 369 return NULL; 370 } 371 372 static rfcomm_channel_t * rfcomm_channel_for_multiplexer_and_dlci(rfcomm_multiplexer_t * multiplexer, uint8_t dlci){ 373 btstack_linked_item_t *it; 374 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 375 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 376 if (channel->dlci == dlci && channel->multiplexer == multiplexer) { 377 return channel; 378 }; 379 } 380 return NULL; 381 } 382 383 static rfcomm_service_t * rfcomm_service_for_channel(uint8_t server_channel){ 384 btstack_linked_item_t *it; 385 for (it = (btstack_linked_item_t *) rfcomm_services; it ; it = it->next){ 386 rfcomm_service_t * service = ((rfcomm_service_t *) it); 387 if ( service->server_channel == server_channel){ 388 return service; 389 }; 390 } 391 return NULL; 392 } 393 394 // MARK: RFCOMM SEND 395 396 /** 397 * @param credits - only used for RFCOMM flow control in UIH wiht P/F = 1 398 */ 399 static int rfcomm_send_packet_for_multiplexer(rfcomm_multiplexer_t *multiplexer, uint8_t address, uint8_t control, uint8_t credits, uint8_t *data, uint16_t len){ 400 401 if (!l2cap_can_send_packet_now(multiplexer->l2cap_cid)) return BTSTACK_ACL_BUFFERS_FULL; 402 403 l2cap_reserve_packet_buffer(); 404 uint8_t * rfcomm_out_buffer = l2cap_get_outgoing_buffer(); 405 406 uint16_t pos = 0; 407 uint8_t crc_fields = 3; 408 409 rfcomm_out_buffer[pos++] = address; 410 rfcomm_out_buffer[pos++] = control; 411 412 // length field can be 1 or 2 octets 413 if (len < 128){ 414 rfcomm_out_buffer[pos++] = (len << 1)| 1; // bits 0-6 415 } else { 416 rfcomm_out_buffer[pos++] = (len & 0x7f) << 1; // bits 0-6 417 rfcomm_out_buffer[pos++] = len >> 7; // bits 7-14 418 crc_fields++; 419 } 420 421 // add credits for UIH frames when PF bit is set 422 if (control == BT_RFCOMM_UIH_PF){ 423 rfcomm_out_buffer[pos++] = credits; 424 } 425 426 // copy actual data 427 if (len) { 428 memcpy(&rfcomm_out_buffer[pos], data, len); 429 pos += len; 430 } 431 432 // UIH frames only calc FCS over address + control (5.1.1) 433 if ((control & 0xef) == BT_RFCOMM_UIH){ 434 crc_fields = 2; 435 } 436 rfcomm_out_buffer[pos++] = crc8_calc(rfcomm_out_buffer, crc_fields); // calc fcs 437 438 int err = l2cap_send_prepared(multiplexer->l2cap_cid, pos); 439 440 return err; 441 } 442 443 // simplified version of rfcomm_send_packet_for_multiplexer for prepared rfcomm packet (UIH, 2 byte len, no credits) 444 static int rfcomm_send_uih_prepared(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint16_t len){ 445 446 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1) | (dlci << 2); 447 uint8_t control = BT_RFCOMM_UIH; 448 449 uint8_t * rfcomm_out_buffer = l2cap_get_outgoing_buffer(); 450 451 uint16_t pos = 0; 452 rfcomm_out_buffer[pos++] = address; 453 rfcomm_out_buffer[pos++] = control; 454 rfcomm_out_buffer[pos++] = (len & 0x7f) << 1; // bits 0-6 455 rfcomm_out_buffer[pos++] = len >> 7; // bits 7-14 456 457 // actual data is already in place 458 pos += len; 459 460 // UIH frames only calc FCS over address + control (5.1.1) 461 rfcomm_out_buffer[pos++] = crc8_calc(rfcomm_out_buffer, 2); // calc fcs 462 463 int err = l2cap_send_prepared(multiplexer->l2cap_cid, pos); 464 465 return err; 466 } 467 468 // C/R Flag in Address 469 // - terms: initiator = station that creates multiplexer with SABM 470 // - terms: responder = station that responds to multiplexer setup with UA 471 // "For SABM, UA, DM and DISC frames C/R bit is set according to Table 1 in GSM 07.10, section 5.2.1.2" 472 // - command initiator = 1 /response responder = 1 473 // - command responder = 0 /response initiator = 0 474 // "For UIH frames, the C/R bit is always set according to section 5.4.3.1 in GSM 07.10. 475 // This applies independently of what is contained wthin the UIH frames, either data or control messages." 476 // - c/r = 1 for frames by initiating station, 0 = for frames by responding station 477 478 // C/R Flag in Message 479 // "In the message level, the C/R bit in the command type field is set as stated in section 5.4.6.2 in GSM 07.10." 480 // - If the C/R bit is set to 1 the message is a command 481 // - if it is set to 0 the message is a response. 482 483 // temp/old messge construction 484 485 // new object oriented version 486 static int rfcomm_send_sabm(rfcomm_multiplexer_t *multiplexer, uint8_t dlci){ 487 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1) | (dlci << 2); // command 488 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_SABM, 0, NULL, 0); 489 } 490 491 static int rfcomm_send_disc(rfcomm_multiplexer_t *multiplexer, uint8_t dlci){ 492 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1) | (dlci << 2); // command 493 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_DISC, 0, NULL, 0); 494 } 495 496 static int rfcomm_send_ua(rfcomm_multiplexer_t *multiplexer, uint8_t dlci){ 497 uint8_t address = (1 << 0) | ((multiplexer->outgoing ^ 1) << 1) | (dlci << 2); // response 498 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UA, 0, NULL, 0); 499 } 500 501 static int rfcomm_send_dm_pf(rfcomm_multiplexer_t *multiplexer, uint8_t dlci){ 502 uint8_t address = (1 << 0) | ((multiplexer->outgoing ^ 1) << 1) | (dlci << 2); // response 503 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_DM_PF, 0, NULL, 0); 504 } 505 506 static int rfcomm_send_uih_fc_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t fcon) { 507 uint8_t address = (1 << 0) | (multiplexer->outgoing<< 1); 508 uint8_t payload[2]; 509 uint8_t pos = 0; 510 payload[pos++] = fcon ? BT_RFCOMM_FCON_RSP : BT_RFCOMM_FCOFF_RSP; 511 payload[pos++] = (0 << 1) | 1; // len 512 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 513 } 514 515 // static int rfcomm_send_uih_test_cmd(rfcomm_multiplexer_t *multiplexer, uint8_t * data, uint16_t len) { 516 // uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 517 // uint8_t payload[2+len]; 518 // uint8_t pos = 0; 519 // payload[pos++] = BT_RFCOMM_TEST_CMD; 520 // payload[pos++] = (len + 1) << 1 | 1; // len 521 // memcpy(&payload[pos], data, len); 522 // pos += len; 523 // return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 524 // } 525 526 static int rfcomm_send_uih_test_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t * data, uint16_t len) { 527 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 528 uint8_t payload[2+RFCOMM_TEST_DATA_MAX_LEN]; 529 uint8_t pos = 0; 530 payload[pos++] = BT_RFCOMM_TEST_RSP; 531 if (len > RFCOMM_TEST_DATA_MAX_LEN) { 532 len = RFCOMM_TEST_DATA_MAX_LEN; 533 } 534 payload[pos++] = (len << 1) | 1; // len 535 memcpy(&payload[pos], data, len); 536 pos += len; 537 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 538 } 539 540 static int rfcomm_send_uih_msc_cmd(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint8_t signals) { 541 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 542 uint8_t payload[4]; 543 uint8_t pos = 0; 544 payload[pos++] = BT_RFCOMM_MSC_CMD; 545 payload[pos++] = (2 << 1) | 1; // len 546 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 547 payload[pos++] = signals; 548 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 549 } 550 551 static int rfcomm_send_uih_msc_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint8_t signals) { 552 uint8_t address = (1 << 0) | (multiplexer->outgoing<< 1); 553 uint8_t payload[4]; 554 uint8_t pos = 0; 555 payload[pos++] = BT_RFCOMM_MSC_RSP; 556 payload[pos++] = (2 << 1) | 1; // len 557 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 558 payload[pos++] = signals; 559 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 560 } 561 562 static int rfcomm_send_uih_nsc_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t command) { 563 uint8_t address = (1 << 0) | (multiplexer->outgoing<< 1); 564 uint8_t payload[3]; 565 uint8_t pos = 0; 566 payload[pos++] = BT_RFCOMM_NSC_RSP; 567 payload[pos++] = (1 << 1) | 1; // len 568 payload[pos++] = command; 569 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 570 } 571 572 static int rfcomm_send_uih_pn_command(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint16_t max_frame_size){ 573 uint8_t payload[10]; 574 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 575 uint8_t pos = 0; 576 payload[pos++] = BT_RFCOMM_PN_CMD; 577 payload[pos++] = (8 << 1) | 1; // len 578 payload[pos++] = dlci; 579 payload[pos++] = 0xf0; // pre-defined for Bluetooth, see 5.5.3 of TS 07.10 Adaption for RFCOMM 580 payload[pos++] = 0; // priority 581 payload[pos++] = 0; // max 60 seconds ack 582 payload[pos++] = max_frame_size & 0xff; // max framesize low 583 payload[pos++] = max_frame_size >> 8; // max framesize high 584 payload[pos++] = 0x00; // number of retransmissions 585 payload[pos++] = 0x00; // (unused error recovery window) initial number of credits 586 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 587 } 588 589 // "The response may not change the DLCI, the priority, the convergence layer, or the timer value." RFCOMM-tutorial.pdf 590 static int rfcomm_send_uih_pn_response(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, 591 uint8_t priority, uint16_t max_frame_size){ 592 uint8_t payload[10]; 593 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 594 uint8_t pos = 0; 595 payload[pos++] = BT_RFCOMM_PN_RSP; 596 payload[pos++] = (8 << 1) | 1; // len 597 payload[pos++] = dlci; 598 payload[pos++] = 0xe0; // pre defined for Bluetooth, see 5.5.3 of TS 07.10 Adaption for RFCOMM 599 payload[pos++] = priority; // priority 600 payload[pos++] = 0; // max 60 seconds ack 601 payload[pos++] = max_frame_size & 0xff; // max framesize low 602 payload[pos++] = max_frame_size >> 8; // max framesize high 603 payload[pos++] = 0x00; // number of retransmissions 604 payload[pos++] = 0x00; // (unused error recovery window) initial number of credits 605 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 606 } 607 608 static int rfcomm_send_uih_rls_cmd(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint8_t line_status) { 609 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 610 uint8_t payload[4]; 611 uint8_t pos = 0; 612 payload[pos++] = BT_RFCOMM_RLS_CMD; 613 payload[pos++] = (2 << 1) | 1; // len 614 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 615 payload[pos++] = line_status; 616 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 617 } 618 619 static int rfcomm_send_uih_rls_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint8_t line_status) { 620 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 621 uint8_t payload[4]; 622 uint8_t pos = 0; 623 payload[pos++] = BT_RFCOMM_RLS_RSP; 624 payload[pos++] = (2 << 1) | 1; // len 625 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 626 payload[pos++] = line_status; 627 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 628 } 629 630 static int rfcomm_send_uih_rpn_cmd(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, rfcomm_rpn_data_t *rpn_data) { 631 uint8_t payload[10]; 632 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 633 uint8_t pos = 0; 634 payload[pos++] = BT_RFCOMM_RPN_CMD; 635 payload[pos++] = (8 << 1) | 1; // len 636 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 637 payload[pos++] = rpn_data->baud_rate; 638 payload[pos++] = rpn_data->flags; 639 payload[pos++] = rpn_data->flow_control; 640 payload[pos++] = rpn_data->xon; 641 payload[pos++] = rpn_data->xoff; 642 payload[pos++] = rpn_data->parameter_mask_0; 643 payload[pos++] = rpn_data->parameter_mask_1; 644 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 645 } 646 647 static int rfcomm_send_uih_rpn_req(rfcomm_multiplexer_t *multiplexer, uint8_t dlci) { 648 uint8_t payload[3]; 649 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 650 uint8_t pos = 0; 651 payload[pos++] = BT_RFCOMM_RPN_CMD; 652 payload[pos++] = (1 << 1) | 1; // len 653 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 654 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 655 } 656 657 static int rfcomm_send_uih_rpn_rsp(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, rfcomm_rpn_data_t *rpn_data) { 658 uint8_t payload[10]; 659 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1); 660 uint8_t pos = 0; 661 payload[pos++] = BT_RFCOMM_RPN_RSP; 662 payload[pos++] = (8 << 1) | 1; // len 663 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); // CMD => C/R = 1 664 payload[pos++] = rpn_data->baud_rate; 665 payload[pos++] = rpn_data->flags; 666 payload[pos++] = rpn_data->flow_control; 667 payload[pos++] = rpn_data->xon; 668 payload[pos++] = rpn_data->xoff; 669 payload[pos++] = rpn_data->parameter_mask_0; 670 payload[pos++] = rpn_data->parameter_mask_1; 671 return rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos); 672 } 673 674 static void rfcomm_send_uih_credits(rfcomm_multiplexer_t *multiplexer, uint8_t dlci, uint8_t credits){ 675 uint8_t address = (1 << 0) | (multiplexer->outgoing << 1) | (dlci << 2); 676 rfcomm_send_packet_for_multiplexer(multiplexer, address, BT_RFCOMM_UIH_PF, credits, NULL, 0); 677 } 678 679 // MARK: RFCOMM MULTIPLEXER 680 static void rfcomm_multiplexer_stop_timer(rfcomm_multiplexer_t * multiplexer){ 681 if (multiplexer->timer_active) { 682 btstack_run_loop_remove_timer(&multiplexer->timer); 683 multiplexer->timer_active = 0; 684 } 685 } 686 static void rfcomm_multiplexer_free(rfcomm_multiplexer_t * multiplexer){ 687 btstack_linked_list_remove( &rfcomm_multiplexers, (btstack_linked_item_t *) multiplexer); 688 btstack_memory_rfcomm_multiplexer_free(multiplexer); 689 } 690 691 static void rfcomm_multiplexer_finalize(rfcomm_multiplexer_t * multiplexer){ 692 // remove (potential) timer 693 rfcomm_multiplexer_stop_timer(multiplexer); 694 695 // close and remove all channels 696 btstack_linked_item_t *it = (btstack_linked_item_t *) &rfcomm_channels; 697 while (it->next){ 698 rfcomm_channel_t * channel = (rfcomm_channel_t *) it->next; 699 if (channel->multiplexer == multiplexer) { 700 // emit appropriate events 701 if (channel->state == RFCOMM_CHANNEL_OPEN) { 702 rfcomm_emit_channel_closed(channel); 703 } else { 704 rfcomm_emit_channel_opened(channel, RFCOMM_MULTIPLEXER_STOPPED); 705 } 706 // remove from list 707 it->next = it->next->next; 708 // free channel struct 709 btstack_memory_rfcomm_channel_free(channel); 710 } else { 711 it = it->next; 712 } 713 } 714 715 // remove mutliplexer 716 rfcomm_multiplexer_free(multiplexer); 717 } 718 719 static void rfcomm_multiplexer_timer_handler(btstack_timer_source_t *timer){ 720 rfcomm_multiplexer_t * multiplexer = (rfcomm_multiplexer_t *) btstack_linked_item_get_user( (btstack_linked_item_t *) timer); 721 if (rfcomm_multiplexer_has_channels(multiplexer)) return; 722 723 log_info("rfcomm_multiplexer_timer_handler timeout: shutting down multiplexer! (no channels)"); 724 uint16_t l2cap_cid = multiplexer->l2cap_cid; 725 rfcomm_multiplexer_finalize(multiplexer); 726 l2cap_disconnect(l2cap_cid, 0x13); 727 } 728 729 static void rfcomm_multiplexer_prepare_idle_timer(rfcomm_multiplexer_t * multiplexer){ 730 if (multiplexer->timer_active) { 731 btstack_run_loop_remove_timer(&multiplexer->timer); 732 multiplexer->timer_active = 0; 733 } 734 if (rfcomm_multiplexer_has_channels(multiplexer)) return; 735 736 // start idle timer for multiplexer timeout check as there are no rfcomm channels yet 737 btstack_run_loop_set_timer(&multiplexer->timer, RFCOMM_MULIPLEXER_TIMEOUT_MS); 738 multiplexer->timer.process = rfcomm_multiplexer_timer_handler; 739 btstack_linked_item_set_user((btstack_linked_item_t*) &multiplexer->timer, multiplexer); 740 btstack_run_loop_add_timer(&multiplexer->timer); 741 multiplexer->timer_active = 1; 742 } 743 744 static void rfcomm_multiplexer_opened(rfcomm_multiplexer_t *multiplexer){ 745 log_info("Multiplexer up and running"); 746 multiplexer->state = RFCOMM_MULTIPLEXER_OPEN; 747 748 rfcomm_channel_event_t event = { CH_EVT_MULTIPLEXER_READY }; 749 750 // transition of channels that wait for multiplexer 751 btstack_linked_item_t *it; 752 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 753 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 754 if (channel->multiplexer != multiplexer) continue; 755 rfcomm_channel_state_machine(channel, &event); 756 } 757 758 rfcomm_run(); 759 rfcomm_multiplexer_prepare_idle_timer(multiplexer); 760 } 761 762 763 /** 764 * @return handled packet 765 */ 766 static int rfcomm_multiplexer_hci_event_handler(uint8_t *packet, uint16_t size){ 767 bd_addr_t event_addr; 768 uint16_t psm; 769 uint16_t l2cap_cid; 770 hci_con_handle_t con_handle; 771 rfcomm_multiplexer_t *multiplexer = NULL; 772 uint8_t status; 773 774 switch (packet[0]) { 775 776 // accept incoming PSM_RFCOMM connection if no multiplexer exists yet 777 case L2CAP_EVENT_INCOMING_CONNECTION: 778 // data: event(8), len(8), address(48), handle (16), psm (16), source cid(16) dest cid(16) 779 bt_flip_addr(event_addr, &packet[2]); 780 con_handle = READ_BT_16(packet, 8); 781 psm = READ_BT_16(packet, 10); 782 l2cap_cid = READ_BT_16(packet, 12); 783 784 if (psm != PSM_RFCOMM) break; 785 786 multiplexer = rfcomm_multiplexer_for_addr(event_addr); 787 788 if (multiplexer) { 789 log_info("INCOMING_CONNECTION (l2cap_cid 0x%02x) for PSM_RFCOMM => decline - multiplexer already exists", l2cap_cid); 790 l2cap_decline_connection(l2cap_cid, 0x04); // no resources available 791 return 1; 792 } 793 794 // create and inititialize new multiplexer instance (incoming) 795 multiplexer = rfcomm_multiplexer_create_for_addr(event_addr); 796 if (!multiplexer){ 797 log_info("INCOMING_CONNECTION (l2cap_cid 0x%02x) for PSM_RFCOMM => decline - no memory left", l2cap_cid); 798 l2cap_decline_connection(l2cap_cid, 0x04); // no resources available 799 return 1; 800 } 801 802 multiplexer->con_handle = con_handle; 803 multiplexer->l2cap_cid = l2cap_cid; 804 multiplexer->state = RFCOMM_MULTIPLEXER_W4_SABM_0; 805 806 log_info("L2CAP_EVENT_INCOMING_CONNECTION (l2cap_cid 0x%02x) for PSM_RFCOMM => accept", l2cap_cid); 807 l2cap_accept_connection(l2cap_cid); 808 return 1; 809 810 // l2cap connection opened -> store l2cap_cid, remote_addr 811 case L2CAP_EVENT_CHANNEL_OPENED: 812 813 if (READ_BT_16(packet, 11) != PSM_RFCOMM) break; 814 815 status = packet[2]; 816 log_info("L2CAP_EVENT_CHANNEL_OPENED for PSM_RFCOMM, status %u", status); 817 818 // get multiplexer for remote addr 819 con_handle = READ_BT_16(packet, 9); 820 l2cap_cid = READ_BT_16(packet, 13); 821 bt_flip_addr(event_addr, &packet[3]); 822 multiplexer = rfcomm_multiplexer_for_addr(event_addr); 823 if (!multiplexer) { 824 log_error("L2CAP_EVENT_CHANNEL_OPENED but no multiplexer prepared"); 825 return 1; 826 } 827 828 // on l2cap open error discard everything 829 if (status){ 830 831 // remove (potential) timer 832 rfcomm_multiplexer_stop_timer(multiplexer); 833 834 // emit rfcomm_channel_opened with status and free channel 835 btstack_linked_item_t * it = (btstack_linked_item_t *) &rfcomm_channels; 836 while (it->next) { 837 rfcomm_channel_t * channel = (rfcomm_channel_t *) it->next; 838 if (channel->multiplexer == multiplexer){ 839 rfcomm_emit_channel_opened(channel, status); 840 it->next = it->next->next; 841 btstack_memory_rfcomm_channel_free(channel); 842 } else { 843 it = it->next; 844 } 845 } 846 847 // free multiplexer 848 rfcomm_multiplexer_free(multiplexer); 849 return 1; 850 } 851 852 if (multiplexer->state == RFCOMM_MULTIPLEXER_W4_CONNECT) { 853 log_info("L2CAP_EVENT_CHANNEL_OPENED: outgoing connection"); 854 // wrong remote addr 855 if (BD_ADDR_CMP(event_addr, multiplexer->remote_addr)) break; 856 multiplexer->l2cap_cid = l2cap_cid; 857 multiplexer->con_handle = con_handle; 858 // send SABM #0 859 multiplexer->state = RFCOMM_MULTIPLEXER_SEND_SABM_0; 860 } else { // multiplexer->state == RFCOMM_MULTIPLEXER_W4_SABM_0 861 862 // set max frame size based on l2cap MTU 863 multiplexer->max_frame_size = rfcomm_max_frame_size_for_l2cap_mtu(READ_BT_16(packet, 17)); 864 } 865 return 1; 866 867 // l2cap disconnect -> state = RFCOMM_MULTIPLEXER_CLOSED; 868 869 case DAEMON_EVENT_HCI_PACKET_SENT: 870 // testing DMA done code 871 rfcomm_run(); 872 break; 873 874 case L2CAP_EVENT_CHANNEL_CLOSED: 875 // data: event (8), len(8), channel (16) 876 l2cap_cid = READ_BT_16(packet, 2); 877 multiplexer = rfcomm_multiplexer_for_l2cap_cid(l2cap_cid); 878 log_info("L2CAP_EVENT_CHANNEL_CLOSED cid 0x%0x, mult %p", l2cap_cid, multiplexer); 879 if (!multiplexer) break; 880 log_info("L2CAP_EVENT_CHANNEL_CLOSED state %u", multiplexer->state); 881 switch (multiplexer->state) { 882 case RFCOMM_MULTIPLEXER_W4_CONNECT: 883 case RFCOMM_MULTIPLEXER_SEND_SABM_0: 884 case RFCOMM_MULTIPLEXER_W4_SABM_0: 885 case RFCOMM_MULTIPLEXER_SEND_UA_0: 886 case RFCOMM_MULTIPLEXER_W4_UA_0: 887 case RFCOMM_MULTIPLEXER_OPEN: 888 // don't call l2cap_disconnect as it's alreay closed 889 rfcomm_multiplexer_finalize(multiplexer); 890 return 1; 891 default: 892 break; 893 } 894 break; 895 default: 896 break; 897 } 898 return 0; 899 } 900 901 static int rfcomm_multiplexer_l2cap_packet_handler(uint16_t channel, uint8_t *packet, uint16_t size){ 902 903 // get or create a multiplexer for a certain device 904 rfcomm_multiplexer_t *multiplexer = rfcomm_multiplexer_for_l2cap_cid(channel); 905 if (!multiplexer) return 0; 906 907 uint16_t l2cap_cid = multiplexer->l2cap_cid; 908 909 // but only care for multiplexer control channel 910 uint8_t frame_dlci = packet[0] >> 2; 911 if (frame_dlci) return 0; 912 const uint8_t length_offset = (packet[2] & 1) ^ 1; // to be used for pos >= 3 913 const uint8_t credit_offset = ((packet[1] & BT_RFCOMM_UIH_PF) == BT_RFCOMM_UIH_PF) ? 1 : 0; // credits for uih_pf frames 914 const uint8_t payload_offset = 3 + length_offset + credit_offset; 915 switch (packet[1]){ 916 917 case BT_RFCOMM_SABM: 918 if (multiplexer->state == RFCOMM_MULTIPLEXER_W4_SABM_0){ 919 log_info("Received SABM #0"); 920 multiplexer->outgoing = 0; 921 multiplexer->state = RFCOMM_MULTIPLEXER_SEND_UA_0; 922 return 1; 923 } 924 break; 925 926 case BT_RFCOMM_UA: 927 if (multiplexer->state == RFCOMM_MULTIPLEXER_W4_UA_0) { 928 // UA #0 -> send UA #0, state = RFCOMM_MULTIPLEXER_OPEN 929 log_info("Received UA #0 "); 930 rfcomm_multiplexer_opened(multiplexer); 931 return 1; 932 } 933 break; 934 935 case BT_RFCOMM_DISC: 936 // DISC #0 -> send UA #0, close multiplexer 937 log_info("Received DISC #0, (ougoing = %u)", multiplexer->outgoing); 938 multiplexer->state = RFCOMM_MULTIPLEXER_SEND_UA_0_AND_DISC; 939 return 1; 940 941 case BT_RFCOMM_DM: 942 // DM #0 - we shouldn't get this, just give up 943 log_info("Received DM #0"); 944 log_info("-> Closing down multiplexer"); 945 rfcomm_multiplexer_finalize(multiplexer); 946 l2cap_disconnect(l2cap_cid, 0x13); 947 return 1; 948 949 case BT_RFCOMM_UIH: 950 if (packet[payload_offset] == BT_RFCOMM_CLD_CMD){ 951 // Multiplexer close down (CLD) -> close mutliplexer 952 log_info("Received Multiplexer close down command"); 953 log_info("-> Closing down multiplexer"); 954 rfcomm_multiplexer_finalize(multiplexer); 955 l2cap_disconnect(l2cap_cid, 0x13); 956 return 1; 957 } 958 switch (packet[payload_offset]){ 959 case BT_RFCOMM_CLD_CMD: 960 // Multiplexer close down (CLD) -> close mutliplexer 961 log_info("Received Multiplexer close down command"); 962 log_info("-> Closing down multiplexer"); 963 rfcomm_multiplexer_finalize(multiplexer); 964 l2cap_disconnect(l2cap_cid, 0x13); 965 return 1; 966 967 case BT_RFCOMM_FCON_CMD: 968 multiplexer->fcon = 0x81; 969 break; 970 971 case BT_RFCOMM_FCOFF_CMD: 972 multiplexer->fcon = 0x80; 973 break; 974 975 case BT_RFCOMM_TEST_CMD: { 976 log_info("Received test command"); 977 int len = packet[payload_offset+1] >> 1; // length < 125 978 if (len > RFCOMM_TEST_DATA_MAX_LEN){ 979 len = RFCOMM_TEST_DATA_MAX_LEN; 980 } 981 multiplexer->test_data_len = len; 982 memcpy(multiplexer->test_data, &packet[payload_offset + 2], len); 983 return 1; 984 } 985 default: 986 break; 987 } 988 break; 989 990 default: 991 break; 992 993 } 994 return 0; 995 } 996 997 static void rfcomm_multiplexer_state_machine(rfcomm_multiplexer_t * multiplexer, RFCOMM_MULTIPLEXER_EVENT event){ 998 999 uint16_t l2cap_cid = multiplexer->l2cap_cid; 1000 1001 // process stored DM responses 1002 if (multiplexer->send_dm_for_dlci){ 1003 uint8_t dlci = multiplexer->send_dm_for_dlci; 1004 multiplexer->send_dm_for_dlci = 0; 1005 rfcomm_send_dm_pf(multiplexer, dlci); 1006 return; 1007 } 1008 1009 if (multiplexer->nsc_command){ 1010 uint8_t command = multiplexer->nsc_command; 1011 multiplexer->nsc_command = 0; 1012 rfcomm_send_uih_nsc_rsp(multiplexer, command); 1013 return; 1014 } 1015 1016 if (multiplexer->fcon & 0x80){ 1017 multiplexer->fcon &= 0x01; 1018 rfcomm_send_uih_fc_rsp(multiplexer, multiplexer->fcon); 1019 if (multiplexer->fcon == 0) return; 1020 // trigger client to send again after sending FCon Response 1021 uint8_t packet_sent_event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0}; 1022 btstack_linked_item_t *it; 1023 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = it->next){ 1024 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 1025 if (channel->multiplexer != multiplexer) continue; 1026 (*app_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) packet_sent_event, sizeof(packet_sent_event)); 1027 } 1028 return; 1029 } 1030 1031 switch (multiplexer->state) { 1032 case RFCOMM_MULTIPLEXER_SEND_SABM_0: 1033 switch (event) { 1034 case MULT_EV_READY_TO_SEND: 1035 log_info("Sending SABM #0 - (multi 0x%p)", multiplexer); 1036 multiplexer->state = RFCOMM_MULTIPLEXER_W4_UA_0; 1037 rfcomm_send_sabm(multiplexer, 0); 1038 break; 1039 default: 1040 break; 1041 } 1042 break; 1043 case RFCOMM_MULTIPLEXER_SEND_UA_0: 1044 switch (event) { 1045 case MULT_EV_READY_TO_SEND: 1046 log_info("Sending UA #0"); 1047 multiplexer->state = RFCOMM_MULTIPLEXER_OPEN; 1048 rfcomm_send_ua(multiplexer, 0); 1049 rfcomm_multiplexer_opened(multiplexer); 1050 break; 1051 default: 1052 break; 1053 } 1054 break; 1055 case RFCOMM_MULTIPLEXER_SEND_UA_0_AND_DISC: 1056 switch (event) { 1057 case MULT_EV_READY_TO_SEND: 1058 // try to detect authentication errors: drop link key if multiplexer closed before first channel got opened 1059 if (!multiplexer->at_least_one_connection){ 1060 log_info("TODO: no connections established - delete link key prophylactically"); 1061 // hci_send_cmd(&hci_delete_stored_link_key, multiplexer->remote_addr); 1062 } 1063 log_info("Sending UA #0"); 1064 log_info("Closing down multiplexer"); 1065 multiplexer->state = RFCOMM_MULTIPLEXER_CLOSED; 1066 rfcomm_send_ua(multiplexer, 0); 1067 rfcomm_multiplexer_finalize(multiplexer); 1068 l2cap_disconnect(l2cap_cid, 0x13); 1069 default: 1070 break; 1071 } 1072 break; 1073 case RFCOMM_MULTIPLEXER_OPEN: 1074 switch (event) { 1075 case MULT_EV_READY_TO_SEND: 1076 // respond to test command 1077 if (multiplexer->test_data_len){ 1078 int len = multiplexer->test_data_len; 1079 log_info("Sending TEST Response with %u bytes", len); 1080 multiplexer->test_data_len = 0; 1081 rfcomm_send_uih_test_rsp(multiplexer, multiplexer->test_data, len); 1082 return; 1083 } 1084 break; 1085 default: 1086 break; 1087 } 1088 break; 1089 default: 1090 break; 1091 } 1092 } 1093 1094 // MARK: RFCOMM CHANNEL 1095 1096 static void rfcomm_channel_send_credits(rfcomm_channel_t *channel, uint8_t credits){ 1097 rfcomm_send_uih_credits(channel->multiplexer, channel->dlci, credits); 1098 channel->credits_incoming += credits; 1099 } 1100 1101 static void rfcomm_channel_opened(rfcomm_channel_t *rfChannel){ 1102 1103 log_info("rfcomm_channel_opened!"); 1104 1105 rfChannel->state = RFCOMM_CHANNEL_OPEN; 1106 rfcomm_emit_channel_opened(rfChannel, 0); 1107 rfcomm_emit_port_configuration(rfChannel); 1108 1109 // remove (potential) timer 1110 rfcomm_multiplexer_t *multiplexer = rfChannel->multiplexer; 1111 if (multiplexer->timer_active) { 1112 btstack_run_loop_remove_timer(&multiplexer->timer); 1113 multiplexer->timer_active = 0; 1114 } 1115 // hack for problem detecting authentication failure 1116 multiplexer->at_least_one_connection = 1; 1117 1118 // start next connection request if pending 1119 rfcomm_run(); 1120 } 1121 1122 static void rfcomm_channel_packet_handler_uih(rfcomm_multiplexer_t *multiplexer, uint8_t * packet, uint16_t size){ 1123 const uint8_t frame_dlci = packet[0] >> 2; 1124 const uint8_t length_offset = (packet[2] & 1) ^ 1; // to be used for pos >= 3 1125 const uint8_t credit_offset = ((packet[1] & BT_RFCOMM_UIH_PF) == BT_RFCOMM_UIH_PF) ? 1 : 0; // credits for uih_pf frames 1126 const uint8_t payload_offset = 3 + length_offset + credit_offset; 1127 1128 rfcomm_channel_t * channel = rfcomm_channel_for_multiplexer_and_dlci(multiplexer, frame_dlci); 1129 if (!channel) return; 1130 1131 // handle new outgoing credits 1132 if (packet[1] == BT_RFCOMM_UIH_PF) { 1133 1134 // add them 1135 uint16_t new_credits = packet[3+length_offset]; 1136 channel->credits_outgoing += new_credits; 1137 log_info( "RFCOMM data UIH_PF, new credits: %u, now %u", new_credits, channel->credits_outgoing); 1138 1139 // notify channel statemachine 1140 rfcomm_channel_event_t channel_event = { CH_EVT_RCVD_CREDITS }; 1141 rfcomm_channel_state_machine(channel, &channel_event); 1142 } 1143 1144 // contains payload? 1145 if (size - 1 > payload_offset){ 1146 1147 // log_info( "RFCOMM data UIH_PF, size %u, channel %p", size-payload_offset-1, rfChannel->connection); 1148 1149 // decrease incoming credit counter 1150 if (channel->credits_incoming > 0){ 1151 channel->credits_incoming--; 1152 } 1153 1154 // deliver payload 1155 (*app_packet_handler)(RFCOMM_DATA_PACKET, channel->rfcomm_cid, 1156 &packet[payload_offset], size-payload_offset-1); 1157 } 1158 1159 // automatically provide new credits to remote device, if no incoming flow control 1160 if (!channel->incoming_flow_control && channel->credits_incoming < 5){ 1161 channel->new_credits_incoming =RFCOMM_CREDITS; 1162 } 1163 } 1164 1165 static void rfcomm_channel_accept_pn(rfcomm_channel_t *channel, rfcomm_channel_event_pn_t *event){ 1166 // priority of client request 1167 channel->pn_priority = event->priority; 1168 1169 // new credits 1170 channel->credits_outgoing = event->credits_outgoing; 1171 1172 // negotiate max frame size 1173 if (channel->max_frame_size > channel->multiplexer->max_frame_size) { 1174 channel->max_frame_size = channel->multiplexer->max_frame_size; 1175 } 1176 if (channel->max_frame_size > event->max_frame_size) { 1177 channel->max_frame_size = event->max_frame_size; 1178 } 1179 1180 } 1181 1182 static void rfcomm_channel_finalize(rfcomm_channel_t *channel){ 1183 1184 rfcomm_multiplexer_t *multiplexer = channel->multiplexer; 1185 1186 // remove from list 1187 btstack_linked_list_remove( &rfcomm_channels, (btstack_linked_item_t *) channel); 1188 1189 // free channel 1190 btstack_memory_rfcomm_channel_free(channel); 1191 1192 // update multiplexer timeout after channel was removed from list 1193 rfcomm_multiplexer_prepare_idle_timer(multiplexer); 1194 } 1195 1196 static void rfcomm_channel_state_machine_2(rfcomm_multiplexer_t * multiplexer, uint8_t dlci, rfcomm_channel_event_t *event){ 1197 1198 // TODO: if client max frame size is smaller than RFCOMM_DEFAULT_SIZE, send PN 1199 1200 1201 // lookup existing channel 1202 rfcomm_channel_t * channel = rfcomm_channel_for_multiplexer_and_dlci(multiplexer, dlci); 1203 1204 // log_info("rfcomm_channel_state_machine_2 lookup dlci #%u = 0x%08x - event %u", dlci, (int) channel, event->type); 1205 1206 if (channel) { 1207 rfcomm_channel_state_machine(channel, event); 1208 return; 1209 } 1210 1211 // service registered? 1212 rfcomm_service_t * service = rfcomm_service_for_channel(dlci >> 1); 1213 // log_info("rfcomm_channel_state_machine_2 service dlci #%u = 0x%08x", dlci, (int) service); 1214 if (!service) { 1215 // discard request by sending disconnected mode 1216 multiplexer->send_dm_for_dlci = dlci; 1217 return; 1218 } 1219 1220 // create channel for some events 1221 switch (event->type) { 1222 case CH_EVT_RCVD_SABM: 1223 case CH_EVT_RCVD_PN: 1224 case CH_EVT_RCVD_RPN_REQ: 1225 case CH_EVT_RCVD_RPN_CMD: 1226 // setup incoming channel 1227 channel = rfcomm_channel_create(multiplexer, service, dlci >> 1); 1228 if (!channel){ 1229 // discard request by sending disconnected mode 1230 multiplexer->send_dm_for_dlci = dlci; 1231 } 1232 break; 1233 default: 1234 break; 1235 } 1236 1237 if (!channel) { 1238 // discard request by sending disconnected mode 1239 multiplexer->send_dm_for_dlci = dlci; 1240 return; 1241 } 1242 rfcomm_channel_state_machine(channel, event); 1243 } 1244 1245 static void rfcomm_channel_packet_handler(rfcomm_multiplexer_t * multiplexer, uint8_t *packet, uint16_t size){ 1246 1247 // rfcomm: (0) addr [76543 server channel] [2 direction: initiator uses 1] [1 C/R: CMD by initiator = 1] [0 EA=1] 1248 const uint8_t frame_dlci = packet[0] >> 2; 1249 uint8_t message_dlci; // used by commands in UIH(_PF) packets 1250 uint8_t message_len; // " 1251 1252 // rfcomm: (1) command/control 1253 // -- credits_offset = 1 if command == BT_RFCOMM_UIH_PF 1254 const uint8_t credit_offset = ((packet[1] & BT_RFCOMM_UIH_PF) == BT_RFCOMM_UIH_PF) ? 1 : 0; // credits for uih_pf frames 1255 // rfcomm: (2) length. if bit 0 is cleared, 2 byte length is used. (little endian) 1256 const uint8_t length_offset = (packet[2] & 1) ^ 1; // to be used for pos >= 3 1257 // rfcomm: (3+length_offset) credits if credits_offset == 1 1258 // rfcomm: (3+length_offest+credits_offset) 1259 const uint8_t payload_offset = 3 + length_offset + credit_offset; 1260 1261 rfcomm_channel_event_t event; 1262 rfcomm_channel_event_pn_t event_pn; 1263 rfcomm_channel_event_rpn_t event_rpn; 1264 rfcomm_channel_event_msc_t event_msc; 1265 1266 // switch by rfcomm message type 1267 switch(packet[1]) { 1268 1269 case BT_RFCOMM_SABM: 1270 event.type = CH_EVT_RCVD_SABM; 1271 log_info("Received SABM #%u", frame_dlci); 1272 rfcomm_channel_state_machine_2(multiplexer, frame_dlci, &event); 1273 break; 1274 1275 case BT_RFCOMM_UA: 1276 event.type = CH_EVT_RCVD_UA; 1277 log_info("Received UA #%u",frame_dlci); 1278 rfcomm_channel_state_machine_2(multiplexer, frame_dlci, &event); 1279 break; 1280 1281 case BT_RFCOMM_DISC: 1282 event.type = CH_EVT_RCVD_DISC; 1283 rfcomm_channel_state_machine_2(multiplexer, frame_dlci, &event); 1284 break; 1285 1286 case BT_RFCOMM_DM: 1287 case BT_RFCOMM_DM_PF: 1288 event.type = CH_EVT_RCVD_DM; 1289 rfcomm_channel_state_machine_2(multiplexer, frame_dlci, &event); 1290 break; 1291 1292 case BT_RFCOMM_UIH_PF: 1293 case BT_RFCOMM_UIH: 1294 1295 message_len = packet[payload_offset+1] >> 1; 1296 1297 switch (packet[payload_offset]) { 1298 case BT_RFCOMM_PN_CMD: 1299 message_dlci = packet[payload_offset+2]; 1300 event_pn.super.type = CH_EVT_RCVD_PN; 1301 event_pn.priority = packet[payload_offset+4]; 1302 event_pn.max_frame_size = READ_BT_16(packet, payload_offset+6); 1303 event_pn.credits_outgoing = packet[payload_offset+9]; 1304 log_info("Received UIH Parameter Negotiation Command for #%u, credits %u", 1305 message_dlci, event_pn.credits_outgoing); 1306 rfcomm_channel_state_machine_2(multiplexer, message_dlci, (rfcomm_channel_event_t*) &event_pn); 1307 break; 1308 1309 case BT_RFCOMM_PN_RSP: 1310 message_dlci = packet[payload_offset+2]; 1311 event_pn.super.type = CH_EVT_RCVD_PN_RSP; 1312 event_pn.priority = packet[payload_offset+4]; 1313 event_pn.max_frame_size = READ_BT_16(packet, payload_offset+6); 1314 event_pn.credits_outgoing = packet[payload_offset+9]; 1315 log_info("Received UIH Parameter Negotiation Response max frame %u, credits %u", 1316 event_pn.max_frame_size, event_pn.credits_outgoing); 1317 rfcomm_channel_state_machine_2(multiplexer, message_dlci, (rfcomm_channel_event_t*) &event_pn); 1318 break; 1319 1320 case BT_RFCOMM_MSC_CMD: 1321 message_dlci = packet[payload_offset+2] >> 2; 1322 event_msc.super.type = CH_EVT_RCVD_MSC_CMD; 1323 event_msc.modem_status = packet[payload_offset+3]; 1324 log_info("Received MSC CMD for #%u, ", message_dlci); 1325 rfcomm_channel_state_machine_2(multiplexer, message_dlci, (rfcomm_channel_event_t*) &event_msc); 1326 break; 1327 1328 case BT_RFCOMM_MSC_RSP: 1329 message_dlci = packet[payload_offset+2] >> 2; 1330 event.type = CH_EVT_RCVD_MSC_RSP; 1331 log_info("Received MSC RSP for #%u", message_dlci); 1332 rfcomm_channel_state_machine_2(multiplexer, message_dlci, &event); 1333 break; 1334 1335 case BT_RFCOMM_RPN_CMD: 1336 message_dlci = packet[payload_offset+2] >> 2; 1337 switch (message_len){ 1338 case 1: 1339 log_info("Received Remote Port Negotiation Request for #%u", message_dlci); 1340 event.type = CH_EVT_RCVD_RPN_REQ; 1341 rfcomm_channel_state_machine_2(multiplexer, message_dlci, &event); 1342 break; 1343 case 8: 1344 log_info("Received Remote Port Negotiation Update for #%u", message_dlci); 1345 event_rpn.super.type = CH_EVT_RCVD_RPN_CMD; 1346 event_rpn.data = *(rfcomm_rpn_data_t*) &packet[payload_offset+3]; 1347 rfcomm_channel_state_machine_2(multiplexer, message_dlci, (rfcomm_channel_event_t*) &event_rpn); 1348 break; 1349 default: 1350 break; 1351 } 1352 break; 1353 1354 case BT_RFCOMM_RPN_RSP: 1355 log_info("Received RPN response"); 1356 break; 1357 1358 case BT_RFCOMM_RLS_CMD: { 1359 log_info("Received RLS command"); 1360 message_dlci = packet[payload_offset+2] >> 2; 1361 rfcomm_channel_event_rls_t event_rls; 1362 event_rls.super.type = CH_EVT_RCVD_RLS_CMD; 1363 event_rls.line_status = packet[payload_offset+3]; 1364 rfcomm_channel_state_machine_2(multiplexer, message_dlci, (rfcomm_channel_event_t*) &event_rls); 1365 break; 1366 } 1367 1368 case BT_RFCOMM_RLS_RSP: 1369 log_info("Received RLS response"); 1370 break; 1371 1372 // Following commands are handled by rfcomm_multiplexer_l2cap_packet_handler 1373 // case BT_RFCOMM_TEST_CMD: 1374 // case BT_RFCOMM_FCOFF_CMD: 1375 // case BT_RFCOMM_FCON_CMD: 1376 // everything else is an not supported command 1377 default: { 1378 log_error("Received unknown UIH command packet - 0x%02x", packet[payload_offset]); 1379 multiplexer->nsc_command = packet[payload_offset]; 1380 break; 1381 } 1382 } 1383 break; 1384 1385 default: 1386 log_error("Received unknown RFCOMM message type %x", packet[1]); 1387 break; 1388 } 1389 1390 // trigger next action - example W4_PN_RSP: transition to SEND_SABM which only depends on "can send" 1391 rfcomm_run(); 1392 } 1393 1394 static void rfcomm_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1395 1396 // multiplexer handler 1397 int handled = 0; 1398 switch (packet_type) { 1399 case HCI_EVENT_PACKET: 1400 handled = rfcomm_multiplexer_hci_event_handler(packet, size); 1401 break; 1402 case L2CAP_DATA_PACKET: 1403 handled = rfcomm_multiplexer_l2cap_packet_handler(channel, packet, size); 1404 break; 1405 default: 1406 break; 1407 } 1408 1409 if (handled) { 1410 rfcomm_run(); 1411 return; 1412 } 1413 1414 // we only handle l2cap packet over open multiplexer channel now 1415 if (packet_type != L2CAP_DATA_PACKET) { 1416 (*app_packet_handler)(packet_type, channel, packet, size); 1417 return; 1418 } 1419 rfcomm_multiplexer_t * multiplexer = rfcomm_multiplexer_for_l2cap_cid(channel); 1420 if (!multiplexer || multiplexer->state != RFCOMM_MULTIPLEXER_OPEN) { 1421 (*app_packet_handler)(packet_type, channel, packet, size); 1422 return; 1423 } 1424 1425 // channel data ? 1426 // rfcomm: (0) addr [76543 server channel] [2 direction: initiator uses 1] [1 C/R: CMD by initiator = 1] [0 EA=1] 1427 const uint8_t frame_dlci = packet[0] >> 2; 1428 1429 if (frame_dlci && (packet[1] == BT_RFCOMM_UIH || packet[1] == BT_RFCOMM_UIH_PF)) { 1430 rfcomm_channel_packet_handler_uih(multiplexer, packet, size); 1431 rfcomm_run(); 1432 return; 1433 } 1434 1435 rfcomm_channel_packet_handler(multiplexer, packet, size); 1436 } 1437 1438 static int rfcomm_channel_ready_for_open(rfcomm_channel_t *channel){ 1439 // note: exchanging MSC isn't neccessary to consider channel open 1440 // note: having outgoing credits is also not necessary to consider channel open 1441 // log_info("rfcomm_channel_ready_for_open state %u, flags needed %04x, current %04x, rf credits %u, l2cap credits %u ", channel->state, RFCOMM_CHANNEL_STATE_VAR_RCVD_MSC_RSP|RFCOMM_CHANNEL_STATE_VAR_SENT_MSC_RSP|RFCOMM_CHANNEL_STATE_VAR_SENT_CREDITS, channel->state_var, channel->credits_outgoing, channel->multiplexer->l2cap_credits); 1442 // if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SENT_MSC_RSP) == 0) return 0; 1443 // if (channel->credits_outgoing == 0) return 0; 1444 log_info("rfcomm_channel_ready_for_open state %u, flags needed %04x, current %04x, rf credits %u", 1445 channel->state, RFCOMM_CHANNEL_STATE_VAR_RCVD_MSC_RSP, channel->state_var, channel->credits_outgoing); 1446 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_RCVD_MSC_RSP) == 0) return 0; 1447 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SENT_CREDITS) == 0) return 0; 1448 1449 return 1; 1450 } 1451 1452 static int rfcomm_channel_ready_for_incoming_dlc_setup(rfcomm_channel_t * channel){ 1453 log_info("rfcomm_channel_ready_for_incoming_dlc_setup state var %04x", channel->state_var); 1454 // Client accept and SABM/UA is required, PN RSP is needed if PN was received 1455 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_CLIENT_ACCEPTED) == 0) return 0; 1456 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_RCVD_SABM ) == 0) return 0; 1457 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_UA ) != 0) return 0; 1458 if ((channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_PN_RSP ) != 0) return 0; 1459 return 1; 1460 } 1461 1462 inline static void rfcomm_channel_state_add(rfcomm_channel_t *channel, RFCOMM_CHANNEL_STATE_VAR event){ 1463 channel->state_var = (RFCOMM_CHANNEL_STATE_VAR) (channel->state_var | event); 1464 } 1465 inline static void rfcomm_channel_state_remove(rfcomm_channel_t *channel, RFCOMM_CHANNEL_STATE_VAR event){ 1466 channel->state_var = (RFCOMM_CHANNEL_STATE_VAR) (channel->state_var & ~event); 1467 } 1468 1469 static void rfcomm_channel_state_machine(rfcomm_channel_t *channel, rfcomm_channel_event_t *event){ 1470 1471 // log_info("rfcomm_channel_state_machine: state %u, state_var %04x, event %u", channel->state, channel->state_var ,event->type); 1472 1473 rfcomm_multiplexer_t *multiplexer = channel->multiplexer; 1474 1475 // TODO: integrate in common switch 1476 if (event->type == CH_EVT_RCVD_DISC){ 1477 rfcomm_emit_channel_closed(channel); 1478 channel->state = RFCOMM_CHANNEL_SEND_UA_AFTER_DISC; 1479 return; 1480 } 1481 1482 // TODO: integrate in common switch 1483 if (event->type == CH_EVT_RCVD_DM){ 1484 log_info("Received DM message for #%u", channel->dlci); 1485 log_info("-> Closing channel locally for #%u", channel->dlci); 1486 rfcomm_emit_channel_closed(channel); 1487 rfcomm_channel_finalize(channel); 1488 return; 1489 } 1490 1491 // remote port negotiation command - just accept everything for now 1492 // 1493 // "The RPN command can be used before a new DLC is opened and should be used whenever the port settings change." 1494 // "The RPN command is specified as optional in TS 07.10, but it is mandatory to recognize and respond to it in RFCOMM. 1495 // (Although the handling of individual settings are implementation-dependent.)" 1496 // 1497 1498 // TODO: integrate in common switch 1499 if (event->type == CH_EVT_RCVD_RPN_CMD){ 1500 // control port parameters 1501 rfcomm_channel_event_rpn_t *event_rpn = (rfcomm_channel_event_rpn_t*) event; 1502 rfcomm_rpn_data_update(&channel->rpn_data, &event_rpn->data); 1503 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_RPN_RSP); 1504 // notify client about new settings 1505 rfcomm_emit_port_configuration(channel); 1506 return; 1507 } 1508 1509 // TODO: integrate in common switch 1510 if (event->type == CH_EVT_RCVD_RPN_REQ){ 1511 // no values got accepted (no values have beens sent) 1512 channel->rpn_data.parameter_mask_0 = 0x00; 1513 channel->rpn_data.parameter_mask_1 = 0x00; 1514 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_RPN_RSP); 1515 return; 1516 } 1517 1518 if (event->type == CH_EVT_RCVD_RLS_CMD){ 1519 rfcomm_channel_event_rls_t * event_rls = (rfcomm_channel_event_rls_t*) event; 1520 channel->rls_line_status = event_rls->line_status & 0x0f; 1521 log_info("CH_EVT_RCVD_RLS_CMD setting line status to 0x%0x", channel->rls_line_status); 1522 rfcomm_emit_remote_line_status(channel, event_rls->line_status); 1523 return; 1524 } 1525 1526 // TODO: integrate in common swich 1527 if (event->type == CH_EVT_READY_TO_SEND){ 1528 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_RPN_RSP){ 1529 log_info("Sending Remote Port Negotiation RSP for #%u", channel->dlci); 1530 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_RPN_RSP); 1531 rfcomm_send_uih_rpn_rsp(multiplexer, channel->dlci, &channel->rpn_data); 1532 return; 1533 } 1534 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_RSP){ 1535 log_info("Sending MSC RSP for #%u", channel->dlci); 1536 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_RSP); 1537 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SENT_MSC_RSP); 1538 rfcomm_send_uih_msc_rsp(multiplexer, channel->dlci, 0x8d); // ea=1,fc=0,rtc=1,rtr=1,ic=0,dv=1 1539 return; 1540 } 1541 if (channel->rls_line_status != RFCOMM_RLS_STATUS_INVALID){ 1542 log_info("Sending RLS RSP 0x%0x", channel->rls_line_status); 1543 uint8_t line_status = channel->rls_line_status; 1544 channel->rls_line_status = RFCOMM_RLS_STATUS_INVALID; 1545 rfcomm_send_uih_rls_rsp(multiplexer, channel->dlci, line_status); 1546 return; 1547 } 1548 } 1549 1550 // emit MSC status to app 1551 if (event->type == CH_EVT_RCVD_MSC_CMD){ 1552 // notify client about new settings 1553 rfcomm_channel_event_msc_t *event_msc = (rfcomm_channel_event_msc_t*) event; 1554 uint8_t modem_status_event[2+1]; 1555 modem_status_event[0] = RFCOMM_EVENT_REMOTE_MODEM_STATUS; 1556 modem_status_event[1] = 1; 1557 modem_status_event[2] = event_msc->modem_status; 1558 (*app_packet_handler)(HCI_EVENT_PACKET, channel->rfcomm_cid, (uint8_t*)&modem_status_event, sizeof(modem_status_event)); 1559 // no return, MSC_CMD will be handled by state machine below 1560 } 1561 1562 rfcomm_channel_event_pn_t * event_pn = (rfcomm_channel_event_pn_t*) event; 1563 1564 switch (channel->state) { 1565 case RFCOMM_CHANNEL_CLOSED: 1566 switch (event->type){ 1567 case CH_EVT_RCVD_SABM: 1568 log_info("-> Inform app"); 1569 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_SABM); 1570 channel->state = RFCOMM_CHANNEL_INCOMING_SETUP; 1571 rfcomm_emit_connection_request(channel); 1572 break; 1573 case CH_EVT_RCVD_PN: 1574 rfcomm_channel_accept_pn(channel, event_pn); 1575 log_info("-> Inform app"); 1576 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_PN); 1577 channel->state = RFCOMM_CHANNEL_INCOMING_SETUP; 1578 rfcomm_emit_connection_request(channel); 1579 break; 1580 default: 1581 break; 1582 } 1583 break; 1584 1585 case RFCOMM_CHANNEL_INCOMING_SETUP: 1586 switch (event->type){ 1587 case CH_EVT_RCVD_SABM: 1588 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_SABM); 1589 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_CLIENT_ACCEPTED) { 1590 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_UA); 1591 } 1592 break; 1593 case CH_EVT_RCVD_PN: 1594 rfcomm_channel_accept_pn(channel, event_pn); 1595 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_PN); 1596 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_CLIENT_ACCEPTED) { 1597 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_PN_RSP); 1598 } 1599 break; 1600 case CH_EVT_READY_TO_SEND: 1601 // if / else if is used to check for state transition after sending 1602 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_PN_RSP){ 1603 log_info("Sending UIH Parameter Negotiation Respond for #%u", channel->dlci); 1604 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_PN_RSP); 1605 rfcomm_send_uih_pn_response(multiplexer, channel->dlci, channel->pn_priority, channel->max_frame_size); 1606 } else if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_UA){ 1607 log_info("Sending UA #%u", channel->dlci); 1608 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_UA); 1609 rfcomm_send_ua(multiplexer, channel->dlci); 1610 } 1611 if (rfcomm_channel_ready_for_incoming_dlc_setup(channel)){ 1612 log_info("Incomping setup done, requesting send MSC CMD and send Credits"); 1613 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_CMD); 1614 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_CREDITS); 1615 channel->state = RFCOMM_CHANNEL_DLC_SETUP; 1616 } 1617 break; 1618 default: 1619 break; 1620 } 1621 break; 1622 1623 case RFCOMM_CHANNEL_W4_MULTIPLEXER: 1624 switch (event->type) { 1625 case CH_EVT_MULTIPLEXER_READY: 1626 log_info("Muliplexer opened, sending UIH PN next"); 1627 channel->state = RFCOMM_CHANNEL_SEND_UIH_PN; 1628 break; 1629 default: 1630 break; 1631 } 1632 break; 1633 1634 case RFCOMM_CHANNEL_SEND_UIH_PN: 1635 switch (event->type) { 1636 case CH_EVT_READY_TO_SEND: 1637 log_info("Sending UIH Parameter Negotiation Command for #%u (channel 0x%p)", channel->dlci, channel ); 1638 channel->state = RFCOMM_CHANNEL_W4_PN_RSP; 1639 rfcomm_send_uih_pn_command(multiplexer, channel->dlci, channel->max_frame_size); 1640 break; 1641 default: 1642 break; 1643 } 1644 break; 1645 1646 case RFCOMM_CHANNEL_W4_PN_RSP: 1647 switch (event->type){ 1648 case CH_EVT_RCVD_PN_RSP: 1649 // update max frame size 1650 if (channel->max_frame_size > event_pn->max_frame_size) { 1651 channel->max_frame_size = event_pn->max_frame_size; 1652 } 1653 // new credits 1654 channel->credits_outgoing = event_pn->credits_outgoing; 1655 channel->state = RFCOMM_CHANNEL_SEND_SABM_W4_UA; 1656 break; 1657 default: 1658 break; 1659 } 1660 break; 1661 1662 case RFCOMM_CHANNEL_SEND_SABM_W4_UA: 1663 switch (event->type) { 1664 case CH_EVT_READY_TO_SEND: 1665 log_info("Sending SABM #%u", channel->dlci); 1666 channel->state = RFCOMM_CHANNEL_W4_UA; 1667 rfcomm_send_sabm(multiplexer, channel->dlci); 1668 break; 1669 default: 1670 break; 1671 } 1672 break; 1673 1674 case RFCOMM_CHANNEL_W4_UA: 1675 switch (event->type){ 1676 case CH_EVT_RCVD_UA: 1677 channel->state = RFCOMM_CHANNEL_DLC_SETUP; 1678 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_CMD); 1679 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_CREDITS); 1680 break; 1681 default: 1682 break; 1683 } 1684 break; 1685 1686 case RFCOMM_CHANNEL_DLC_SETUP: 1687 switch (event->type){ 1688 case CH_EVT_RCVD_MSC_CMD: 1689 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_MSC_CMD); 1690 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_RSP); 1691 break; 1692 case CH_EVT_RCVD_MSC_RSP: 1693 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_RCVD_MSC_RSP); 1694 break; 1695 1696 case CH_EVT_READY_TO_SEND: 1697 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_CMD){ 1698 log_info("Sending MSC CMD for #%u", channel->dlci); 1699 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_CMD); 1700 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SENT_MSC_CMD); 1701 rfcomm_send_uih_msc_cmd(multiplexer, channel->dlci , 0x8d); // ea=1,fc=0,rtc=1,rtr=1,ic=0,dv=1 1702 break; 1703 } 1704 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_SEND_CREDITS){ 1705 log_info("Providing credits for #%u", channel->dlci); 1706 rfcomm_channel_state_remove(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_CREDITS); 1707 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SENT_CREDITS); 1708 1709 if (channel->new_credits_incoming) { 1710 uint8_t new_credits = channel->new_credits_incoming; 1711 channel->new_credits_incoming = 0; 1712 rfcomm_channel_send_credits(channel, new_credits); 1713 } 1714 break; 1715 1716 } 1717 break; 1718 default: 1719 break; 1720 } 1721 // finally done? 1722 if (rfcomm_channel_ready_for_open(channel)){ 1723 channel->state = RFCOMM_CHANNEL_OPEN; 1724 rfcomm_channel_opened(channel); 1725 } 1726 break; 1727 1728 case RFCOMM_CHANNEL_OPEN: 1729 switch (event->type){ 1730 case CH_EVT_RCVD_MSC_CMD: 1731 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_MSC_RSP); 1732 break; 1733 case CH_EVT_READY_TO_SEND: 1734 if (channel->new_credits_incoming) { 1735 uint8_t new_credits = channel->new_credits_incoming; 1736 channel->new_credits_incoming = 0; 1737 rfcomm_channel_send_credits(channel, new_credits); 1738 break; 1739 } 1740 break; 1741 case CH_EVT_RCVD_CREDITS: { 1742 // notify daemon -> might trigger re-try of parked connections 1743 uint8_t credits_event[2] = { DAEMON_EVENT_NEW_RFCOMM_CREDITS, 0 }; 1744 (*app_packet_handler)(DAEMON_EVENT_PACKET, channel->rfcomm_cid, credits_event, sizeof(credits_event)); 1745 break; 1746 } 1747 default: 1748 break; 1749 } 1750 break; 1751 1752 case RFCOMM_CHANNEL_SEND_DM: 1753 switch (event->type) { 1754 case CH_EVT_READY_TO_SEND: 1755 log_info("Sending DM_PF for #%u", channel->dlci); 1756 // don't emit channel closed - channel was never open 1757 channel->state = RFCOMM_CHANNEL_CLOSED; 1758 rfcomm_send_dm_pf(multiplexer, channel->dlci); 1759 rfcomm_channel_finalize(channel); 1760 break; 1761 default: 1762 break; 1763 } 1764 break; 1765 1766 case RFCOMM_CHANNEL_SEND_DISC: 1767 switch (event->type) { 1768 case CH_EVT_READY_TO_SEND: 1769 channel->state = RFCOMM_CHANNEL_W4_UA_AFTER_UA; 1770 rfcomm_send_disc(multiplexer, channel->dlci); 1771 break; 1772 default: 1773 break; 1774 } 1775 break; 1776 1777 case RFCOMM_CHANNEL_W4_UA_AFTER_UA: 1778 switch (event->type){ 1779 case CH_EVT_RCVD_UA: 1780 channel->state = RFCOMM_CHANNEL_CLOSED; 1781 rfcomm_emit_channel_closed(channel); 1782 rfcomm_channel_finalize(channel); 1783 break; 1784 default: 1785 break; 1786 } 1787 break; 1788 1789 case RFCOMM_CHANNEL_SEND_UA_AFTER_DISC: 1790 switch (event->type) { 1791 case CH_EVT_READY_TO_SEND: 1792 log_info("Sending UA after DISC for #%u", channel->dlci); 1793 channel->state = RFCOMM_CHANNEL_CLOSED; 1794 rfcomm_send_ua(multiplexer, channel->dlci); 1795 rfcomm_channel_finalize(channel); 1796 break; 1797 default: 1798 break; 1799 } 1800 break; 1801 1802 default: 1803 break; 1804 } 1805 } 1806 1807 1808 // MARK: RFCOMM RUN 1809 // process outstanding signaling tasks 1810 static void rfcomm_run(void){ 1811 1812 btstack_linked_item_t *it; 1813 btstack_linked_item_t *next; 1814 1815 for (it = (btstack_linked_item_t *) rfcomm_multiplexers; it ; it = next){ 1816 1817 next = it->next; // be prepared for removal of channel in state machine 1818 1819 rfcomm_multiplexer_t * multiplexer = ((rfcomm_multiplexer_t *) it); 1820 1821 if (!l2cap_can_send_packet_now(multiplexer->l2cap_cid)) { 1822 // log_info("rfcomm_run A cannot send l2cap packet for #%u, credits %u", multiplexer->l2cap_cid, multiplexer->l2cap_credits); 1823 continue; 1824 } 1825 // log_info("rfcomm_run: multi 0x%08x, state %u", (int) multiplexer, multiplexer->state); 1826 1827 rfcomm_multiplexer_state_machine(multiplexer, MULT_EV_READY_TO_SEND); 1828 } 1829 1830 for (it = (btstack_linked_item_t *) rfcomm_channels; it ; it = next){ 1831 1832 next = it->next; // be prepared for removal of channel in state machine 1833 1834 rfcomm_channel_t * channel = ((rfcomm_channel_t *) it); 1835 rfcomm_multiplexer_t * multiplexer = channel->multiplexer; 1836 1837 if (!l2cap_can_send_packet_now(multiplexer->l2cap_cid)) { 1838 // log_info("rfcomm_run B cannot send l2cap packet for #%u, credits %u", multiplexer->l2cap_cid, multiplexer->l2cap_credits); 1839 continue; 1840 } 1841 1842 rfcomm_channel_event_t event = { CH_EVT_READY_TO_SEND }; 1843 rfcomm_channel_state_machine(channel, &event); 1844 } 1845 } 1846 1847 // MARK: RFCOMM BTstack API 1848 1849 void rfcomm_init(void){ 1850 rfcomm_client_cid_generator = 0; 1851 rfcomm_multiplexers = NULL; 1852 rfcomm_services = NULL; 1853 rfcomm_channels = NULL; 1854 rfcomm_security_level = LEVEL_2; 1855 } 1856 1857 void rfcomm_set_required_security_level(gap_security_level_t security_level){ 1858 rfcomm_security_level = security_level; 1859 } 1860 1861 // register packet handler 1862 void rfcomm_register_packet_handler(void (*handler)(uint8_t packet_type, 1863 uint16_t channel, uint8_t *packet, uint16_t size)){ 1864 app_packet_handler = handler; 1865 } 1866 1867 int rfcomm_can_send_packet_now(uint16_t rfcomm_cid){ 1868 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1869 if (!channel){ 1870 log_error("rfcomm_send cid 0x%02x doesn't exist!", rfcomm_cid); 1871 return 1; 1872 } 1873 if (!channel->credits_outgoing) return 0; 1874 if ((channel->multiplexer->fcon & 1) == 0) return 0; 1875 1876 return l2cap_can_send_packet_now(channel->multiplexer->l2cap_cid); 1877 } 1878 1879 static int rfcomm_assert_send_valid(rfcomm_channel_t * channel , uint16_t len){ 1880 if (len > channel->max_frame_size){ 1881 log_error("rfcomm_send cid 0x%02x, rfcomm data lenght exceeds MTU!", channel->rfcomm_cid); 1882 return RFCOMM_DATA_LEN_EXCEEDS_MTU; 1883 } 1884 1885 if (!channel->credits_outgoing){ 1886 log_info("rfcomm_send cid 0x%02x, no rfcomm outgoing credits!", channel->rfcomm_cid); 1887 return RFCOMM_NO_OUTGOING_CREDITS; 1888 } 1889 1890 if ((channel->multiplexer->fcon & 1) == 0){ 1891 log_info("rfcomm_send cid 0x%02x, aggregate flow off!", channel->rfcomm_cid); 1892 return RFCOMM_AGGREGATE_FLOW_OFF; 1893 } 1894 return 0; 1895 } 1896 1897 // pre: rfcomm_can_send_packet_now(rfcomm_cid) == true 1898 int rfcomm_reserve_packet_buffer(void){ 1899 return l2cap_reserve_packet_buffer(); 1900 } 1901 1902 void rfcomm_release_packet_buffer(void){ 1903 l2cap_release_packet_buffer(); 1904 } 1905 1906 uint8_t * rfcomm_get_outgoing_buffer(void){ 1907 uint8_t * rfcomm_out_buffer = l2cap_get_outgoing_buffer(); 1908 // address + control + length (16) + no credit field 1909 return &rfcomm_out_buffer[4]; 1910 } 1911 1912 uint16_t rfcomm_get_max_frame_size(uint16_t rfcomm_cid){ 1913 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1914 if (!channel){ 1915 log_error("rfcomm_get_max_frame_size cid 0x%02x doesn't exist!", rfcomm_cid); 1916 return 0; 1917 } 1918 return channel->max_frame_size; 1919 } 1920 int rfcomm_send_prepared(uint16_t rfcomm_cid, uint16_t len){ 1921 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1922 if (!channel){ 1923 log_error("rfcomm_send_prepared cid 0x%02x doesn't exist!", rfcomm_cid); 1924 return 0; 1925 } 1926 1927 int err = rfcomm_assert_send_valid(channel, len); 1928 if (err) return err; 1929 1930 // send might cause l2cap to emit new credits, update counters first 1931 channel->credits_outgoing--; 1932 1933 int result = rfcomm_send_uih_prepared(channel->multiplexer, channel->dlci, len); 1934 1935 if (result != 0) { 1936 channel->credits_outgoing++; 1937 log_info("rfcomm_send: error %d", result); 1938 return result; 1939 } 1940 1941 return result; 1942 } 1943 1944 int rfcomm_send(uint16_t rfcomm_cid, uint8_t *data, uint16_t len){ 1945 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1946 if (!channel){ 1947 log_error("rfcomm_send cid 0x%02x doesn't exist!", rfcomm_cid); 1948 return 1; 1949 } 1950 1951 int err = rfcomm_assert_send_valid(channel, len); 1952 if (err) return err; 1953 1954 rfcomm_reserve_packet_buffer(); 1955 uint8_t * rfcomm_payload = rfcomm_get_outgoing_buffer(); 1956 memcpy(rfcomm_payload, data, len); 1957 return rfcomm_send_prepared(rfcomm_cid, len); 1958 } 1959 1960 // Sends Local Lnie Status, see LINE_STATUS_.. 1961 int rfcomm_send_local_line_status(uint16_t rfcomm_cid, uint8_t line_status){ 1962 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1963 if (!channel){ 1964 log_error("rfcomm_send_local_line_status cid 0x%02x doesn't exist!", rfcomm_cid); 1965 return 0; 1966 } 1967 return rfcomm_send_uih_rls_cmd(channel->multiplexer, channel->dlci, line_status); 1968 } 1969 1970 // Sned local modem status. see MODEM_STAUS_.. 1971 int rfcomm_send_modem_status(uint16_t rfcomm_cid, uint8_t modem_status){ 1972 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1973 if (!channel){ 1974 log_error("rfcomm_send_modem_status cid 0x%02x doesn't exist!", rfcomm_cid); 1975 return 0; 1976 } 1977 return rfcomm_send_uih_msc_cmd(channel->multiplexer, channel->dlci, modem_status); 1978 } 1979 1980 // Configure remote port 1981 int rfcomm_send_port_configuration(uint16_t rfcomm_cid, rpn_baud_t baud_rate, rpn_data_bits_t data_bits, rpn_stop_bits_t stop_bits, rpn_parity_t parity, rpn_flow_control_t flow_control){ 1982 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 1983 if (!channel){ 1984 log_error("rfcomm_send_port_configuration cid 0x%02x doesn't exist!", rfcomm_cid); 1985 return 0; 1986 } 1987 rfcomm_rpn_data_t rpn_data; 1988 rpn_data.baud_rate = baud_rate; 1989 rpn_data.flags = data_bits | (stop_bits << 2) | (parity << 3); 1990 rpn_data.flow_control = flow_control; 1991 rpn_data.xon = 0; 1992 rpn_data.xoff = 0; 1993 rpn_data.parameter_mask_0 = 0x1f; // all but xon/xoff 1994 rpn_data.parameter_mask_1 = 0x3f; // all flow control options 1995 return rfcomm_send_uih_rpn_cmd(channel->multiplexer, channel->dlci, &rpn_data); 1996 } 1997 1998 // Query remote port 1999 int rfcomm_query_port_configuration(uint16_t rfcomm_cid){ 2000 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 2001 if (!channel){ 2002 log_error("rfcomm_query_port_configuration cid 0x%02x doesn't exist!", rfcomm_cid); 2003 return 0; 2004 } 2005 return rfcomm_send_uih_rpn_req(channel->multiplexer, channel->dlci); 2006 } 2007 2008 2009 static uint8_t rfcomm_create_channel_internal(bd_addr_t addr, uint8_t server_channel, uint8_t incoming_flow_control, uint8_t initial_credits, uint16_t * out_rfcomm_cid){ 2010 log_info("RFCOMM_CREATE_CHANNEL addr %s channel #%u init credits %u", bd_addr_to_str(addr), server_channel, initial_credits); 2011 2012 // create new multiplexer if necessary 2013 uint8_t status = 0; 2014 int new_multiplexer = 0; 2015 rfcomm_channel_t * channel = NULL; 2016 rfcomm_multiplexer_t * multiplexer = rfcomm_multiplexer_for_addr(addr); 2017 if (!multiplexer) { 2018 multiplexer = rfcomm_multiplexer_create_for_addr(addr); 2019 if (!multiplexer){ 2020 status = BTSTACK_MEMORY_ALLOC_FAILED; 2021 goto fail; 2022 } 2023 multiplexer->outgoing = 1; 2024 multiplexer->state = RFCOMM_MULTIPLEXER_W4_CONNECT; 2025 new_multiplexer = 1; 2026 } 2027 2028 // prepare channel 2029 channel = rfcomm_channel_create(multiplexer, NULL, server_channel); 2030 if (!channel){ 2031 status = BTSTACK_MEMORY_ALLOC_FAILED; 2032 goto fail; 2033 } 2034 // rfcomm_cid is already assigned by rfcomm_channel_create 2035 channel->incoming_flow_control = incoming_flow_control; 2036 channel->new_credits_incoming = initial_credits; 2037 2038 // return rfcomm_cid 2039 if (out_rfcomm_cid){ 2040 *out_rfcomm_cid = channel->rfcomm_cid; 2041 } 2042 2043 // start multiplexer setup 2044 if (multiplexer->state != RFCOMM_MULTIPLEXER_OPEN) { 2045 channel->state = RFCOMM_CHANNEL_W4_MULTIPLEXER; 2046 uint16_t l2cap_cid = 0; 2047 status = l2cap_create_channel(rfcomm_packet_handler, addr, PSM_RFCOMM, l2cap_max_mtu(), &l2cap_cid); 2048 if (status) goto fail; 2049 multiplexer->l2cap_cid = l2cap_cid; 2050 return 0; 2051 } 2052 2053 channel->state = RFCOMM_CHANNEL_SEND_UIH_PN; 2054 2055 // start connecting, if multiplexer is already up and running 2056 rfcomm_run(); 2057 return 0; 2058 2059 fail: 2060 if (new_multiplexer) btstack_memory_rfcomm_multiplexer_free(multiplexer); 2061 if (channel) btstack_memory_rfcomm_channel_free(channel); 2062 return status; 2063 } 2064 2065 uint8_t rfcomm_create_channel_with_initial_credits(bd_addr_t addr, uint8_t server_channel, uint8_t initial_credits, uint16_t * out_rfcomm_cid){ 2066 return rfcomm_create_channel_internal(addr, server_channel, 1, initial_credits, out_rfcomm_cid); 2067 } 2068 2069 uint8_t rfcomm_create_channel(bd_addr_t addr, uint8_t server_channel, uint16_t * out_rfcomm_cid){ 2070 return rfcomm_create_channel_internal(addr, server_channel, 0, RFCOMM_CREDITS, out_rfcomm_cid); 2071 } 2072 2073 void rfcomm_disconnect(uint16_t rfcomm_cid){ 2074 log_info("RFCOMM_DISCONNECT cid 0x%02x", rfcomm_cid); 2075 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 2076 if (channel) { 2077 channel->state = RFCOMM_CHANNEL_SEND_DISC; 2078 } 2079 2080 // process 2081 rfcomm_run(); 2082 } 2083 2084 static uint8_t rfcomm_register_service_internal(uint8_t channel, uint16_t max_frame_size, uint8_t incoming_flow_control, uint8_t initial_credits){ log_info("RFCOMM_REGISTER_SERVICE channel #%u mtu %u flow_control %u credits %u", 2085 channel, max_frame_size, incoming_flow_control, initial_credits); 2086 2087 // check if already registered 2088 rfcomm_service_t * service = rfcomm_service_for_channel(channel); 2089 if (service){ 2090 return RFCOMM_CHANNEL_ALREADY_REGISTERED; 2091 } 2092 2093 // alloc structure 2094 service = btstack_memory_rfcomm_service_get(); 2095 if (!service) { 2096 return BTSTACK_MEMORY_ALLOC_FAILED; 2097 } 2098 2099 // register with l2cap if not registered before, max MTU 2100 if (btstack_linked_list_empty(&rfcomm_services)){ 2101 l2cap_register_service(rfcomm_packet_handler, PSM_RFCOMM, 0xffff, rfcomm_security_level); 2102 } 2103 2104 // fill in 2105 service->server_channel = channel; 2106 service->max_frame_size = max_frame_size; 2107 service->incoming_flow_control = incoming_flow_control; 2108 service->incoming_initial_credits = initial_credits; 2109 2110 // add to services list 2111 btstack_linked_list_add(&rfcomm_services, (btstack_linked_item_t *) service); 2112 2113 return 0; 2114 } 2115 2116 uint8_t rfcomm_register_service_with_initial_credits(uint8_t channel, uint16_t max_frame_size, uint8_t initial_credits){ 2117 return rfcomm_register_service_internal(channel, max_frame_size, 1, initial_credits); 2118 } 2119 2120 uint8_t rfcomm_register_service(uint8_t channel, uint16_t max_frame_size){ 2121 return rfcomm_register_service_internal(channel, max_frame_size, 0,RFCOMM_CREDITS); 2122 } 2123 2124 void rfcomm_unregister_service(uint8_t service_channel){ 2125 log_info("RFCOMM_UNREGISTER_SERVICE #%u", service_channel); 2126 rfcomm_service_t *service = rfcomm_service_for_channel(service_channel); 2127 if (!service) return; 2128 btstack_linked_list_remove(&rfcomm_services, (btstack_linked_item_t *) service); 2129 btstack_memory_rfcomm_service_free(service); 2130 2131 // unregister if no services active 2132 if (btstack_linked_list_empty(&rfcomm_services)){ 2133 // bt_send_cmd(&l2cap_unregister_service, PSM_RFCOMM); 2134 l2cap_unregister_service(PSM_RFCOMM); 2135 } 2136 } 2137 2138 void rfcomm_accept_connection(uint16_t rfcomm_cid){ 2139 log_info("RFCOMM_ACCEPT_CONNECTION cid 0x%02x", rfcomm_cid); 2140 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 2141 if (!channel) return; 2142 switch (channel->state) { 2143 case RFCOMM_CHANNEL_INCOMING_SETUP: 2144 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_CLIENT_ACCEPTED); 2145 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_RCVD_PN){ 2146 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_PN_RSP); 2147 } 2148 if (channel->state_var & RFCOMM_CHANNEL_STATE_VAR_RCVD_SABM){ 2149 rfcomm_channel_state_add(channel, RFCOMM_CHANNEL_STATE_VAR_SEND_UA); 2150 } 2151 // at least one of { PN RSP, UA } needs to be sent 2152 // state transistion incoming setup -> dlc setup happens in rfcomm_run after these have been sent 2153 break; 2154 default: 2155 break; 2156 } 2157 2158 // process 2159 rfcomm_run(); 2160 } 2161 2162 void rfcomm_decline_connection(uint16_t rfcomm_cid){ 2163 log_info("RFCOMM_DECLINE_CONNECTION cid 0x%02x", rfcomm_cid); 2164 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 2165 if (!channel) return; 2166 switch (channel->state) { 2167 case RFCOMM_CHANNEL_INCOMING_SETUP: 2168 channel->state = RFCOMM_CHANNEL_SEND_DM; 2169 break; 2170 default: 2171 break; 2172 } 2173 2174 // process 2175 rfcomm_run(); 2176 } 2177 2178 void rfcomm_grant_credits(uint16_t rfcomm_cid, uint8_t credits){ 2179 log_info("RFCOMM_GRANT_CREDITS cid 0x%02x credits %u", rfcomm_cid, credits); 2180 rfcomm_channel_t * channel = rfcomm_channel_for_rfcomm_cid(rfcomm_cid); 2181 if (!channel) return; 2182 if (!channel->incoming_flow_control) return; 2183 channel->new_credits_incoming += credits; 2184 2185 // process 2186 rfcomm_run(); 2187 } 2188 2189 2190 2191 2192