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