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