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