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