stack/rfcomm/port_api.cc

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 1999-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  this file contains the Serial Port API code
  22  *
  23  ******************************************************************************/
  24
  25 #define LOG_TAG "bt_port_api"
  26
  27 #include <base/logging.h>
  28 #include <string.h>
  29
  30 #include "osi/include/log.h"
  31 #include "osi/include/mutex.h"
  32
  33 #include "bt_common.h"
  34 #include "btm_api.h"
  35 #include "btm_int.h"
  36 #include "l2c_api.h"
  37 #include "port_api.h"
  38 #include "port_int.h"
  39 #include "rfc_int.h"
  40 #include "rfcdefs.h"
  41 #include "sdp_api.h"
  42
  43 /* duration of break in 200ms units */
  44 #define PORT_BREAK_DURATION 1
  45
  46 #define info(fmt, ...) LOG_INFO(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
  47 #define debug(fmt, ...) LOG_DEBUG(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
  48 #define error(fmt, ...) \
  49   LOG_ERROR(LOG_TAG, "## ERROR : %s: " fmt "##", __func__, ##__VA_ARGS__)
  50 #define asrt(s)                                                            \
  51   if (!(s))                                                                \
  52   LOG_ERROR(LOG_TAG, "## %s assert %s failed at line:%d ##", __func__, #s, \
  53             __LINE__)
  54
  55 /* Mapping from PORT_* result codes to human readable strings. */
  56 static const char* result_code_strings[] = {"Success",
  57                                             "Unknown error",
  58                                             "Already opened",
  59                                             "Command pending",
  60                                             "App not registered",
  61                                             "No memory",
  62                                             "No resources",
  63                                             "Bad BD address",
  64                                             "Unspecified error",
  65                                             "Bad handle",
  66                                             "Not opened",
  67                                             "Line error",
  68                                             "Start failed",
  69                                             "Parameter negotiation failed",
  70                                             "Port negotiation failed",
  71                                             "Sec failed",
  72                                             "Peer connection failed",
  73                                             "Peer failed",
  74                                             "Peer timeout",
  75                                             "Closed",
  76                                             "TX full",
  77                                             "Local closed",
  78                                             "Local timeout",
  79                                             "TX queue disabled",
  80                                             "Page timeout",
  81                                             "Invalid SCN",
  82                                             "Unknown result code"};
  83
  84 /*******************************************************************************
  85  *
  86  * Function         RFCOMM_CreateConnection
  87  *
  88  * Description      RFCOMM_CreateConnection function is used from the
  89  *                  application to establish serial port connection to the peer
  90  *                  device, or allow RFCOMM to accept a connection from the peer
  91  *                  application.
  92  *
  93  * Parameters:      scn          - Service Channel Number as registered with
  94  *                                 the SDP (server) or obtained using SDP from
  95  *                                 the peer device (client).
  96  *                  is_server    - true if requesting application is a server
  97  *                  mtu          - Maximum frame size the application can accept
  98  *                  bd_addr      - address of the peer (client)
  99  *                  mask         - specifies events to be enabled.  A value
 100  *                                 of zero disables all events.
 101  *                  p_handle     - OUT pointer to the handle.
 102  *                  p_mgmt_cb    - pointer to callback function to receive
 103  *                                 connection up/down events.
 104  * Notes:
 105  *
 106  * Server can call this function with the same scn parameter multiple times if
 107  * it is ready to accept multiple simulteneous connections.
 108  *
 109  * DLCI for the connection is (scn * 2 + 1) if client originates connection on
 110  * existing none initiator multiplexer channel.  Otherwise it is (scn * 2).
 111  * For the server DLCI can be changed later if client will be calling it using
 112  * (scn * 2 + 1) dlci.
 113  *
 114  ******************************************************************************/
 115 int RFCOMM_CreateConnection(uint16_t uuid, uint8_t scn, bool is_server,
 116                             uint16_t mtu, const RawAddress& bd_addr,
 117                             uint16_t* p_handle, tPORT_CALLBACK* p_mgmt_cb) {
 118   tPORT* p_port;
 119   uint8_t dlci;
 120   tRFC_MCB* p_mcb = port_find_mcb(bd_addr);
 121   uint16_t rfcomm_mtu;
 122
 123   VLOG(0) << __func__ << " BDA: " << bd_addr;
 124
 125   *p_handle = 0;
 126
 127   if ((scn == 0) || (scn >= PORT_MAX_RFC_PORTS)) {
 128     /* Server Channel Number(SCN) should be in range 1...30 */
 129     RFCOMM_TRACE_ERROR("RFCOMM_CreateConnection - invalid SCN");
 130     return (PORT_INVALID_SCN);
 131   }
 132
 133   /* For client that originate connection on the existing none initiator */
 134   /* multiplexer channel DLCI should be odd */
 135   if (p_mcb && !p_mcb->is_initiator && !is_server)
 136     dlci = (scn << 1) + 1;
 137   else
 138     dlci = (scn << 1);
 139   RFCOMM_TRACE_API(
 140       "RFCOMM_CreateConnection(): scn:%d, dlci:%d, is_server:%d mtu:%d, "
 141       "p_mcb:%p",
 142       scn, dlci, is_server, mtu, p_mcb);
 143
 144   /* For the server side always allocate a new port.  On the client side */
 145   /* do not allow the same (dlci, bd_addr) to be opened twice by application */
 146   if (!is_server) {
 147     p_port = port_find_port(dlci, bd_addr);
 148     if (p_port != NULL) {
 149       /* if existing port is also a client port */
 150       if (p_port->is_server == false) {
 151         RFCOMM_TRACE_ERROR(
 152             "RFCOMM_CreateConnection - already opened state:%d, RFC state:%d, "
 153             "MCB state:%d",
 154             p_port->state, p_port->rfc.state,
 155             p_port->rfc.p_mcb ? p_port->rfc.p_mcb->state : 0);
 156         *p_handle = p_port->inx;
 157         return (PORT_ALREADY_OPENED);
 158       }
 159     }
 160   }
 161
 162   p_port = port_allocate_port(dlci, bd_addr);
 163   if (p_port == NULL) {
 164     RFCOMM_TRACE_WARNING("RFCOMM_CreateConnection - no resources");
 165     return (PORT_NO_RESOURCES);
 166   }
 167   RFCOMM_TRACE_API(
 168       "RFCOMM_CreateConnection(): scn:%d, dlci:%d, is_server:%d mtu:%d, "
 169       "p_mcb:%p, p_port:%p",
 170       scn, dlci, is_server, mtu, p_mcb, p_port);
 171
 172   p_port->default_signal_state =
 173       (PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON);
 174
 175   switch (uuid) {
 176     case UUID_PROTOCOL_OBEX:
 177       p_port->default_signal_state = PORT_OBEX_DEFAULT_SIGNAL_STATE;
 178       break;
 179     case UUID_SERVCLASS_SERIAL_PORT:
 180       p_port->default_signal_state = PORT_SPP_DEFAULT_SIGNAL_STATE;
 181       break;
 182     case UUID_SERVCLASS_LAN_ACCESS_USING_PPP:
 183       p_port->default_signal_state = PORT_PPP_DEFAULT_SIGNAL_STATE;
 184       break;
 185     case UUID_SERVCLASS_DIALUP_NETWORKING:
 186     case UUID_SERVCLASS_FAX:
 187       p_port->default_signal_state = PORT_DUN_DEFAULT_SIGNAL_STATE;
 188       break;
 189   }
 190
 191   RFCOMM_TRACE_EVENT("RFCOMM_CreateConnection dlci:%d signal state:0x%x", dlci,
 192                      p_port->default_signal_state);
 193
 194   *p_handle = p_port->inx;
 195
 196   p_port->state = PORT_STATE_OPENING;
 197   p_port->uuid = uuid;
 198   p_port->is_server = is_server;
 199   p_port->scn = scn;
 200   p_port->ev_mask = 0;
 201
 202   /* If the MTU is not specified (0), keep MTU decision until the
 203    * PN frame has to be send
 204    * at that time connection should be established and we
 205    * will know for sure our prefered MTU
 206    */
 207
 208   rfcomm_mtu = L2CAP_MTU_SIZE - RFCOMM_DATA_OVERHEAD;
 209
 210   if (mtu)
 211     p_port->mtu = (mtu < rfcomm_mtu) ? mtu : rfcomm_mtu;
 212   else
 213     p_port->mtu = rfcomm_mtu;
 214
 215   /* server doesn't need to release port when closing */
 216   if (is_server) {
 217     p_port->keep_port_handle = true;
 218
 219     /* keep mtu that user asked, p_port->mtu could be updated during param
 220      * negotiation */
 221     p_port->keep_mtu = p_port->mtu;
 222   }
 223
 224   p_port->local_ctrl.modem_signal = p_port->default_signal_state;
 225   p_port->local_ctrl.fc = false;
 226
 227   p_port->p_mgmt_callback = p_mgmt_cb;
 228
 229   p_port->bd_addr = bd_addr;
 230
 231   /* If this is not initiator of the connection need to just wait */
 232   if (p_port->is_server) {
 233     return (PORT_SUCCESS);
 234   }
 235
 236   /* Open will be continued after security checks are passed */
 237   return port_open_continue(p_port);
 238 }
 239
 240 /*******************************************************************************
 241  *
 242  * Function         RFCOMM_RemoveConnection
 243  *
 244  * Description      This function is called to close the specified connection.
 245  *
 246  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 247  *
 248  ******************************************************************************/
 249 int RFCOMM_RemoveConnection(uint16_t handle) {
 250   tPORT* p_port;
 251
 252   RFCOMM_TRACE_API("RFCOMM_RemoveConnection() handle:%d", handle);
 253
 254   /* Check if handle is valid to avoid crashing */
 255   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 256     RFCOMM_TRACE_ERROR("RFCOMM_RemoveConnection() BAD handle:%d", handle);
 257     return (PORT_BAD_HANDLE);
 258   }
 259   p_port = &rfc_cb.port.port[handle - 1];
 260
 261   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 262     RFCOMM_TRACE_EVENT("RFCOMM_RemoveConnection() Not opened:%d", handle);
 263     return (PORT_SUCCESS);
 264   }
 265
 266   p_port->state = PORT_STATE_CLOSING;
 267
 268   port_start_close(p_port);
 269
 270   return (PORT_SUCCESS);
 271 }
 272
 273 /*******************************************************************************
 274  *
 275  * Function         RFCOMM_RemoveServer
 276  *
 277  * Description      This function is called to close the server port.
 278  *
 279  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 280  *
 281  ******************************************************************************/
 282 int RFCOMM_RemoveServer(uint16_t handle) {
 283   tPORT* p_port;
 284
 285   RFCOMM_TRACE_API("RFCOMM_RemoveServer() handle:%d", handle);
 286
 287   /* Check if handle is valid to avoid crashing */
 288   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 289     RFCOMM_TRACE_ERROR("RFCOMM_RemoveServer() BAD handle:%d", handle);
 290     return (PORT_BAD_HANDLE);
 291   }
 292   p_port = &rfc_cb.port.port[handle - 1];
 293
 294   /* Do not report any events to the client any more. */
 295   p_port->p_mgmt_callback = NULL;
 296
 297   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 298     RFCOMM_TRACE_EVENT("RFCOMM_RemoveServer() Not opened:%d", handle);
 299     return (PORT_SUCCESS);
 300   }
 301
 302   /* this port will be deallocated after closing */
 303   p_port->keep_port_handle = false;
 304   p_port->state = PORT_STATE_CLOSING;
 305
 306   port_start_close(p_port);
 307
 308   return (PORT_SUCCESS);
 309 }
 310
 311 /*******************************************************************************
 312  *
 313  * Function         PORT_SetEventCallback
 314  *
 315  * Description      This function is called to provide an address of the
 316  *                  function which will be called when one of the events
 317  *                  specified in the mask occures.
 318  *
 319  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 320  *                  p_callback - address of the callback function which should
 321  *                               be called from the RFCOMM when an event
 322  *                               specified in the mask occures.
 323  *
 324  *
 325  ******************************************************************************/
 326 int PORT_SetEventCallback(uint16_t port_handle, tPORT_CALLBACK* p_port_cb) {
 327   tPORT* p_port;
 328
 329   /* Check if handle is valid to avoid crashing */
 330   if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS)) {
 331     return (PORT_BAD_HANDLE);
 332   }
 333
 334   p_port = &rfc_cb.port.port[port_handle - 1];
 335
 336   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 337     return (PORT_NOT_OPENED);
 338   }
 339
 340   RFCOMM_TRACE_API("PORT_SetEventCallback() handle:%d", port_handle);
 341
 342   p_port->p_callback = p_port_cb;
 343
 344   return (PORT_SUCCESS);
 345 }
 346 /*******************************************************************************
 347  *
 348  * Function         PORT_ClearKeepHandleFlag
 349  *
 350  * Description      Clear the keep handle flag, which will cause not to keep the
 351  *                  port handle open when closed
 352  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 353  *
 354  ******************************************************************************/
 355
 356 int PORT_ClearKeepHandleFlag(uint16_t port_handle) {
 357   tPORT* p_port;
 358
 359   /* Check if handle is valid to avoid crashing */
 360   if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS)) {
 361     return (PORT_BAD_HANDLE);
 362   }
 363
 364   p_port = &rfc_cb.port.port[port_handle - 1];
 365   p_port->keep_port_handle = 0;
 366   return (PORT_SUCCESS);
 367 }
 368
 369 /*******************************************************************************
 370  *
 371  * Function         PORT_SetDataCallback
 372  *
 373  * Description      This function is when a data packet is received
 374  *
 375  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 376  *                  p_callback - address of the callback function which should
 377  *                               be called from the RFCOMM when data packet
 378  *                               is received.
 379  *
 380  *
 381  ******************************************************************************/
 382 int PORT_SetDataCallback(uint16_t port_handle, tPORT_DATA_CALLBACK* p_port_cb) {
 383   tPORT* p_port;
 384
 385   RFCOMM_TRACE_API("PORT_SetDataCallback() handle:%d cb 0x%x", port_handle,
 386                    p_port_cb);
 387
 388   /* Check if handle is valid to avoid crashing */
 389   if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS)) {
 390     return (PORT_BAD_HANDLE);
 391   }
 392
 393   p_port = &rfc_cb.port.port[port_handle - 1];
 394
 395   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 396     return (PORT_NOT_OPENED);
 397   }
 398
 399   p_port->p_data_callback = p_port_cb;
 400
 401   return (PORT_SUCCESS);
 402 }
 403 /*******************************************************************************
 404  *
 405  * Function         PORT_SetCODataCallback
 406  *
 407  * Description      This function is when a data packet is received
 408  *
 409  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 410  *                  p_callback - address of the callback function which should
 411  *                               be called from the RFCOMM when data packet
 412  *                               is received.
 413  *
 414  *
 415  ******************************************************************************/
 416 int PORT_SetDataCOCallback(uint16_t port_handle,
 417                            tPORT_DATA_CO_CALLBACK* p_port_cb) {
 418   tPORT* p_port;
 419
 420   RFCOMM_TRACE_API("PORT_SetDataCOCallback() handle:%d cb 0x%x", port_handle,
 421                    p_port_cb);
 422
 423   /* Check if handle is valid to avoid crashing */
 424   if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS)) {
 425     return (PORT_BAD_HANDLE);
 426   }
 427
 428   p_port = &rfc_cb.port.port[port_handle - 1];
 429
 430   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 431     return (PORT_NOT_OPENED);
 432   }
 433
 434   p_port->p_data_co_callback = p_port_cb;
 435
 436   return (PORT_SUCCESS);
 437 }
 438
 439 /*******************************************************************************
 440  *
 441  * Function         PORT_SetEventMask
 442  *
 443  * Description      This function is called to close the specified connection.
 444  *
 445  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 446  *                  mask   - Bitmask of the events the host is interested in
 447  *
 448  ******************************************************************************/
 449 int PORT_SetEventMask(uint16_t port_handle, uint32_t mask) {
 450   tPORT* p_port;
 451
 452   RFCOMM_TRACE_API("PORT_SetEventMask() handle:%d mask:0x%x", port_handle,
 453                    mask);
 454
 455   /* Check if handle is valid to avoid crashing */
 456   if ((port_handle == 0) || (port_handle > MAX_RFC_PORTS)) {
 457     return (PORT_BAD_HANDLE);
 458   }
 459
 460   p_port = &rfc_cb.port.port[port_handle - 1];
 461
 462   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 463     return (PORT_NOT_OPENED);
 464   }
 465
 466   p_port->ev_mask = mask;
 467
 468   return (PORT_SUCCESS);
 469 }
 470
 471 /*******************************************************************************
 472  *
 473  * Function         PORT_CheckConnection
 474  *
 475  * Description      This function returns PORT_SUCCESS if connection referenced
 476  *                  by handle is up and running
 477  *
 478  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 479  *                  bd_addr    - OUT bd_addr of the peer
 480  *                  p_lcid     - OUT L2CAP's LCID
 481  *
 482  ******************************************************************************/
 483 int PORT_CheckConnection(uint16_t handle, RawAddress& bd_addr,
 484                          uint16_t* p_lcid) {
 485   tPORT* p_port;
 486
 487   RFCOMM_TRACE_API("PORT_CheckConnection() handle:%d", handle);
 488
 489   /* Check if handle is valid to avoid crashing */
 490   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 491     return (PORT_BAD_HANDLE);
 492   }
 493
 494   p_port = &rfc_cb.port.port[handle - 1];
 495
 496   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 497     return (PORT_NOT_OPENED);
 498   }
 499
 500   if (!p_port->rfc.p_mcb || !p_port->rfc.p_mcb->peer_ready ||
 501       (p_port->rfc.state != RFC_STATE_OPENED)) {
 502     return (PORT_LINE_ERR);
 503   }
 504
 505   bd_addr = p_port->rfc.p_mcb->bd_addr;
 506   if (p_lcid) *p_lcid = p_port->rfc.p_mcb->lcid;
 507
 508   return (PORT_SUCCESS);
 509 }
 510
 511 /*******************************************************************************
 512  *
 513  * Function         PORT_IsOpening
 514  *
 515  * Description      This function returns true if there is any RFCOMM connection
 516  *                  opening in process.
 517  *
 518  * Parameters:      true if any connection opening is found
 519  *                  bd_addr    - bd_addr of the peer
 520  *
 521  ******************************************************************************/
 522 bool PORT_IsOpening(RawAddress& bd_addr) {
 523   uint8_t xx, yy;
 524   tRFC_MCB* p_mcb = NULL;
 525   tPORT* p_port;
 526   bool found_port;
 527
 528   /* Check for any rfc_mcb which is in the middle of opening. */
 529   for (xx = 0; xx < MAX_BD_CONNECTIONS; xx++) {
 530     if ((rfc_cb.port.rfc_mcb[xx].state > RFC_MX_STATE_IDLE) &&
 531         (rfc_cb.port.rfc_mcb[xx].state < RFC_MX_STATE_CONNECTED)) {
 532       bd_addr = rfc_cb.port.rfc_mcb[xx].bd_addr;
 533       return true;
 534     }
 535
 536     if (rfc_cb.port.rfc_mcb[xx].state == RFC_MX_STATE_CONNECTED) {
 537       found_port = false;
 538       p_mcb = &rfc_cb.port.rfc_mcb[xx];
 539       p_port = &rfc_cb.port.port[0];
 540
 541       for (yy = 0; yy < MAX_RFC_PORTS; yy++, p_port++) {
 542         if (p_port->rfc.p_mcb == p_mcb) {
 543           found_port = true;
 544           break;
 545         }
 546       }
 547
 548       if ((!found_port) ||
 549           (found_port && (p_port->rfc.state < RFC_STATE_OPENED))) {
 550         /* Port is not established yet. */
 551         bd_addr = rfc_cb.port.rfc_mcb[xx].bd_addr;
 552         return true;
 553       }
 554     }
 555   }
 556
 557   return false;
 558 }
 559
 560 /*******************************************************************************
 561  *
 562  * Function         PORT_SetState
 563  *
 564  * Description      This function configures connection according to the
 565  *                  specifications in the tPORT_STATE structure.
 566  *
 567  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 568  *                  p_settings - Pointer to a tPORT_STATE structure containing
 569  *                               configuration information for the connection.
 570  *
 571  *
 572  ******************************************************************************/
 573 int PORT_SetState(uint16_t handle, tPORT_STATE* p_settings) {
 574   tPORT* p_port;
 575   uint8_t baud_rate;
 576
 577   RFCOMM_TRACE_API("PORT_SetState() handle:%d", handle);
 578
 579   /* Check if handle is valid to avoid crashing */
 580   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 581     return (PORT_BAD_HANDLE);
 582   }
 583
 584   p_port = &rfc_cb.port.port[handle - 1];
 585
 586   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 587     return (PORT_NOT_OPENED);
 588   }
 589
 590   if (p_port->line_status) {
 591     return (PORT_LINE_ERR);
 592   }
 593
 594   RFCOMM_TRACE_API("PORT_SetState() handle:%d FC_TYPE:0x%x", handle,
 595                    p_settings->fc_type);
 596
 597   baud_rate = p_port->user_port_pars.baud_rate;
 598   p_port->user_port_pars = *p_settings;
 599
 600   /* for now we've been asked to pass only baud rate */
 601   if (baud_rate != p_settings->baud_rate) {
 602     port_start_par_neg(p_port);
 603   }
 604   return (PORT_SUCCESS);
 605 }
 606
 607 /*******************************************************************************
 608  *
 609  * Function         PORT_GetRxQueueCnt
 610  *
 611  * Description      This function return number of buffers on the rx queue.
 612  *
 613  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 614  *                  p_rx_queue_count - Pointer to return queue count in.
 615  *
 616  ******************************************************************************/
 617 int PORT_GetRxQueueCnt(uint16_t handle, uint16_t* p_rx_queue_count) {
 618   tPORT* p_port;
 619
 620   RFCOMM_TRACE_API("PORT_GetRxQueueCnt() handle:%d", handle);
 621
 622   /* Check if handle is valid to avoid crashing */
 623   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 624     return (PORT_BAD_HANDLE);
 625   }
 626
 627   p_port = &rfc_cb.port.port[handle - 1];
 628
 629   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 630     return (PORT_NOT_OPENED);
 631   }
 632
 633   if (p_port->line_status) {
 634     return (PORT_LINE_ERR);
 635   }
 636
 637   *p_rx_queue_count = p_port->rx.queue_size;
 638
 639   RFCOMM_TRACE_API(
 640       "PORT_GetRxQueueCnt() p_rx_queue_count:%d, p_port->rx.queue.count = %d",
 641       *p_rx_queue_count, p_port->rx.queue_size);
 642
 643   return (PORT_SUCCESS);
 644 }
 645
 646 /*******************************************************************************
 647  *
 648  * Function         PORT_GetState
 649  *
 650  * Description      This function is called to fill tPORT_STATE structure
 651  *                  with the curremt control settings for the port
 652  *
 653  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 654  *                  p_settings - Pointer to a tPORT_STATE structure in which
 655  *                               configuration information is returned.
 656  *
 657  ******************************************************************************/
 658 int PORT_GetState(uint16_t handle, tPORT_STATE* p_settings) {
 659   tPORT* p_port;
 660
 661   RFCOMM_TRACE_API("PORT_GetState() handle:%d", handle);
 662
 663   /* Check if handle is valid to avoid crashing */
 664   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 665     return (PORT_BAD_HANDLE);
 666   }
 667
 668   p_port = &rfc_cb.port.port[handle - 1];
 669
 670   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 671     return (PORT_NOT_OPENED);
 672   }
 673
 674   if (p_port->line_status) {
 675     return (PORT_LINE_ERR);
 676   }
 677
 678   *p_settings = p_port->user_port_pars;
 679   return (PORT_SUCCESS);
 680 }
 681
 682 /*******************************************************************************
 683  *
 684  * Function         PORT_Control
 685  *
 686  * Description      This function directs a specified connection to pass control
 687  *                  control information to the peer device.
 688  *
 689  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 690  *                  signal     = specify the function to be passed
 691  *
 692  ******************************************************************************/
 693 int PORT_Control(uint16_t handle, uint8_t signal) {
 694   tPORT* p_port;
 695   uint8_t old_modem_signal;
 696
 697   RFCOMM_TRACE_API("PORT_Control() handle:%d signal:0x%x", handle, signal);
 698
 699   /* Check if handle is valid to avoid crashing */
 700   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 701     return (PORT_BAD_HANDLE);
 702   }
 703
 704   p_port = &rfc_cb.port.port[handle - 1];
 705
 706   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 707     return (PORT_NOT_OPENED);
 708   }
 709
 710   old_modem_signal = p_port->local_ctrl.modem_signal;
 711   p_port->local_ctrl.break_signal = 0;
 712
 713   switch (signal) {
 714     case PORT_SET_CTSRTS:
 715       p_port->local_ctrl.modem_signal |= PORT_CTSRTS_ON;
 716       break;
 717
 718     case PORT_CLR_CTSRTS:
 719       p_port->local_ctrl.modem_signal &= ~PORT_CTSRTS_ON;
 720       break;
 721
 722     case PORT_SET_DTRDSR:
 723       p_port->local_ctrl.modem_signal |= PORT_DTRDSR_ON;
 724       break;
 725
 726     case PORT_CLR_DTRDSR:
 727       p_port->local_ctrl.modem_signal &= ~PORT_DTRDSR_ON;
 728       break;
 729
 730     case PORT_SET_RI:
 731       p_port->local_ctrl.modem_signal |= PORT_RING_ON;
 732       break;
 733
 734     case PORT_CLR_RI:
 735       p_port->local_ctrl.modem_signal &= ~PORT_RING_ON;
 736       break;
 737
 738     case PORT_SET_DCD:
 739       p_port->local_ctrl.modem_signal |= PORT_DCD_ON;
 740       break;
 741
 742     case PORT_CLR_DCD:
 743       p_port->local_ctrl.modem_signal &= ~PORT_DCD_ON;
 744       break;
 745   }
 746
 747   if (signal == PORT_BREAK)
 748     p_port->local_ctrl.break_signal = PORT_BREAK_DURATION;
 749   else if (p_port->local_ctrl.modem_signal == old_modem_signal)
 750     return (PORT_SUCCESS);
 751
 752   port_start_control(p_port);
 753
 754   RFCOMM_TRACE_EVENT(
 755       "PORT_Control DTR_DSR : %d, RTS_CTS : %d, RI : %d, DCD : %d",
 756       ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_DTRDSR) ? 1 : 0),
 757       ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_RTSCTS) ? 1 : 0),
 758       ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_RI) ? 1 : 0),
 759       ((p_port->local_ctrl.modem_signal & MODEM_SIGNAL_DCD) ? 1 : 0));
 760
 761   return (PORT_SUCCESS);
 762 }
 763
 764 /*******************************************************************************
 765  *
 766  * Function         PORT_FlowControl
 767  *
 768  * Description      This function directs a specified connection to pass
 769  *                  flow control message to the peer device.  Enable flag passed
 770  *                  shows if port can accept more data.
 771  *
 772  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 773  *                  enable     - enables data flow
 774  *
 775  ******************************************************************************/
 776 int PORT_FlowControl(uint16_t handle, bool enable) {
 777   tPORT* p_port;
 778   bool old_fc;
 779   uint32_t events;
 780
 781   RFCOMM_TRACE_API("PORT_FlowControl() handle:%d enable: %d", handle, enable);
 782
 783   /* Check if handle is valid to avoid crashing */
 784   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 785     return (PORT_BAD_HANDLE);
 786   }
 787
 788   p_port = &rfc_cb.port.port[handle - 1];
 789
 790   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 791     return (PORT_NOT_OPENED);
 792   }
 793
 794   if (!p_port->rfc.p_mcb) {
 795     return (PORT_NOT_OPENED);
 796   }
 797
 798   p_port->rx.user_fc = !enable;
 799
 800   if (p_port->rfc.p_mcb->flow == PORT_FC_CREDIT) {
 801     if (!p_port->rx.user_fc) {
 802       port_flow_control_peer(p_port, true, 0);
 803     }
 804   } else {
 805     old_fc = p_port->local_ctrl.fc;
 806
 807     /* FC is set if user is set or peer is set */
 808     p_port->local_ctrl.fc = (p_port->rx.user_fc | p_port->rx.peer_fc);
 809
 810     if (p_port->local_ctrl.fc != old_fc) port_start_control(p_port);
 811   }
 812
 813   /* Need to take care of the case when we could not deliver events */
 814   /* to the application because we were flow controlled */
 815   if (enable && (p_port->rx.queue_size != 0)) {
 816     events = PORT_EV_RXCHAR;
 817     if (p_port->rx_flag_ev_pending) {
 818       p_port->rx_flag_ev_pending = false;
 819       events |= PORT_EV_RXFLAG;
 820     }
 821
 822     events &= p_port->ev_mask;
 823     if (p_port->p_callback && events) {
 824       p_port->p_callback(events, p_port->inx);
 825     }
 826   }
 827   return (PORT_SUCCESS);
 828 }
 829 /*******************************************************************************
 830  *
 831  * Function         PORT_FlowControl_MaxCredit
 832  *
 833  * Description      This function directs a specified connection to pass
 834  *                  flow control message to the peer device.  Enable flag passed
 835  *                  shows if port can accept more data. It also sends max credit
 836  *                  when data flow enabled
 837  *
 838  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 839  *                  enable     - enables data flow
 840  *
 841  ******************************************************************************/
 842
 843 int PORT_FlowControl_MaxCredit(uint16_t handle, bool enable) {
 844   tPORT* p_port;
 845   bool old_fc;
 846   uint32_t events;
 847
 848   RFCOMM_TRACE_API("PORT_FlowControl() handle:%d enable: %d", handle, enable);
 849
 850   /* Check if handle is valid to avoid crashing */
 851   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 852     return (PORT_BAD_HANDLE);
 853   }
 854
 855   p_port = &rfc_cb.port.port[handle - 1];
 856
 857   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 858     return (PORT_NOT_OPENED);
 859   }
 860
 861   if (!p_port->rfc.p_mcb) {
 862     return (PORT_NOT_OPENED);
 863   }
 864
 865   p_port->rx.user_fc = !enable;
 866
 867   if (p_port->rfc.p_mcb->flow == PORT_FC_CREDIT) {
 868     if (!p_port->rx.user_fc) {
 869       port_flow_control_peer(p_port, true, p_port->credit_rx);
 870     }
 871   } else {
 872     old_fc = p_port->local_ctrl.fc;
 873
 874     /* FC is set if user is set or peer is set */
 875     p_port->local_ctrl.fc = (p_port->rx.user_fc | p_port->rx.peer_fc);
 876
 877     if (p_port->local_ctrl.fc != old_fc) port_start_control(p_port);
 878   }
 879
 880   /* Need to take care of the case when we could not deliver events */
 881   /* to the application because we were flow controlled */
 882   if (enable && (p_port->rx.queue_size != 0)) {
 883     events = PORT_EV_RXCHAR;
 884     if (p_port->rx_flag_ev_pending) {
 885       p_port->rx_flag_ev_pending = false;
 886       events |= PORT_EV_RXFLAG;
 887     }
 888
 889     events &= p_port->ev_mask;
 890     if (p_port->p_callback && events) {
 891       p_port->p_callback(events, p_port->inx);
 892     }
 893   }
 894   return (PORT_SUCCESS);
 895 }
 896
 897 /*******************************************************************************
 898  *
 899  * Function         PORT_GetModemStatus
 900  *
 901  * Description      This function retrieves modem control signals.  Normally
 902  *                  application will call this function after a callback
 903  *                  function is called with notification that one of signals
 904  *                  has been changed.
 905  *
 906  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 907  *                  p_signal   - specify the pointer to control signals info
 908  *
 909  ******************************************************************************/
 910 int PORT_GetModemStatus(uint16_t handle, uint8_t* p_signal) {
 911   tPORT* p_port;
 912
 913   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 914     return (PORT_BAD_HANDLE);
 915   }
 916
 917   p_port = &rfc_cb.port.port[handle - 1];
 918
 919   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 920     return (PORT_NOT_OPENED);
 921   }
 922
 923   *p_signal = p_port->peer_ctrl.modem_signal;
 924
 925   RFCOMM_TRACE_API("PORT_GetModemStatus() handle:%d signal:%x", handle,
 926                    *p_signal);
 927
 928   return (PORT_SUCCESS);
 929 }
 930
 931 /*******************************************************************************
 932  *
 933  * Function         PORT_ClearError
 934  *
 935  * Description      This function retreives information about a communications
 936  *                  error and reports current status of a connection.  The
 937  *                  function should be called when an error occures to clear
 938  *                  the connection error flag and to enable additional read
 939  *                  and write operations.
 940  *
 941  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 942  *                  p_errors   - pointer of the variable to receive error codes
 943  *                  p_status   - pointer to the tPORT_STATUS structur to receive
 944  *                               connection status
 945  *
 946  ******************************************************************************/
 947 int PORT_ClearError(uint16_t handle, uint16_t* p_errors,
 948                     tPORT_STATUS* p_status) {
 949   tPORT* p_port;
 950
 951   RFCOMM_TRACE_API("PORT_ClearError() handle:%d", handle);
 952
 953   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 954     return (PORT_BAD_HANDLE);
 955   }
 956
 957   p_port = &rfc_cb.port.port[handle - 1];
 958
 959   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 960     return (PORT_NOT_OPENED);
 961   }
 962
 963   *p_errors = p_port->line_status;
 964
 965   /* This is the only call to clear error status.  We can not clear */
 966   /* connection failed status.  To clean it port should be closed and reopened
 967    */
 968   p_port->line_status = (p_port->line_status & LINE_STATUS_FAILED);
 969
 970   PORT_GetQueueStatus(handle, p_status);
 971   return (PORT_SUCCESS);
 972 }
 973
 974 /*******************************************************************************
 975  *
 976  * Function         PORT_SendError
 977  *
 978  * Description      This function send a communications error to the peer device
 979  *
 980  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
 981  *                  errors     - receive error codes
 982  *
 983  ******************************************************************************/
 984 int PORT_SendError(uint16_t handle, uint8_t errors) {
 985   tPORT* p_port;
 986
 987   RFCOMM_TRACE_API("PORT_SendError() handle:%d errors:0x%x", handle, errors);
 988
 989   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
 990     return (PORT_BAD_HANDLE);
 991   }
 992
 993   p_port = &rfc_cb.port.port[handle - 1];
 994
 995   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
 996     return (PORT_NOT_OPENED);
 997   }
 998
 999   if (!p_port->rfc.p_mcb) {
1000     return (PORT_NOT_OPENED);
1001   }
1002
1003   RFCOMM_LineStatusReq(p_port->rfc.p_mcb, p_port->dlci, errors);
1004   return (PORT_SUCCESS);
1005 }
1006
1007 /*******************************************************************************
1008  *
1009  * Function         PORT_GetQueueStatus
1010  *
1011  * Description      This function reports current status of a connection.
1012  *
1013  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1014  *                  p_status   - pointer to the tPORT_STATUS structur to receive
1015  *                               connection status
1016  *
1017  ******************************************************************************/
1018 int PORT_GetQueueStatus(uint16_t handle, tPORT_STATUS* p_status) {
1019   tPORT* p_port;
1020
1021   /* RFCOMM_TRACE_API ("PORT_GetQueueStatus() handle:%d", handle); */
1022
1023   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1024     return (PORT_BAD_HANDLE);
1025   }
1026
1027   p_port = &rfc_cb.port.port[handle - 1];
1028
1029   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1030     return (PORT_NOT_OPENED);
1031   }
1032
1033   p_status->in_queue_size = (uint16_t)p_port->rx.queue_size;
1034   p_status->out_queue_size = (uint16_t)p_port->tx.queue_size;
1035
1036   p_status->mtu_size = (uint16_t)p_port->peer_mtu;
1037
1038   p_status->flags = 0;
1039
1040   if (!(p_port->peer_ctrl.modem_signal & PORT_CTSRTS_ON))
1041     p_status->flags |= PORT_FLAG_CTS_HOLD;
1042
1043   if (!(p_port->peer_ctrl.modem_signal & PORT_DTRDSR_ON))
1044     p_status->flags |= PORT_FLAG_DSR_HOLD;
1045
1046   if (!(p_port->peer_ctrl.modem_signal & PORT_DCD_ON))
1047     p_status->flags |= PORT_FLAG_RLSD_HOLD;
1048
1049   return (PORT_SUCCESS);
1050 }
1051
1052 /*******************************************************************************
1053  *
1054  * Function         PORT_Purge
1055  *
1056  * Description      This function discards all the data from the output or
1057  *                  input queues of the specified connection.
1058  *
1059  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1060  *                  purge_flags - specify the action to take.
1061  *
1062  ******************************************************************************/
1063 int PORT_Purge(uint16_t handle, uint8_t purge_flags) {
1064   tPORT* p_port;
1065   BT_HDR* p_buf;
1066   uint16_t count;
1067   uint32_t events;
1068
1069   RFCOMM_TRACE_API("PORT_Purge() handle:%d flags:0x%x", handle, purge_flags);
1070
1071   /* Check if handle is valid to avoid crashing */
1072   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1073     return (PORT_BAD_HANDLE);
1074   }
1075
1076   p_port = &rfc_cb.port.port[handle - 1];
1077
1078   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1079     return (PORT_NOT_OPENED);
1080   }
1081
1082   if (purge_flags & PORT_PURGE_RXCLEAR) {
1083     mutex_global_lock(); /* to prevent missing credit */
1084
1085     count = fixed_queue_length(p_port->rx.queue);
1086
1087     while ((p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_port->rx.queue)) != NULL)
1088       osi_free(p_buf);
1089
1090     p_port->rx.queue_size = 0;
1091
1092     mutex_global_unlock();
1093
1094     /* If we flowed controlled peer based on rx_queue size enable data again */
1095     if (count) port_flow_control_peer(p_port, true, count);
1096   }
1097
1098   if (purge_flags & PORT_PURGE_TXCLEAR) {
1099     mutex_global_lock(); /* to prevent tx.queue_size from being negative */
1100
1101     while ((p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_port->tx.queue)) != NULL)
1102       osi_free(p_buf);
1103
1104     p_port->tx.queue_size = 0;
1105
1106     mutex_global_unlock();
1107
1108     events = PORT_EV_TXEMPTY;
1109
1110     events |= port_flow_control_user(p_port);
1111
1112     events &= p_port->ev_mask;
1113
1114     if ((p_port->p_callback != NULL) && events)
1115       (p_port->p_callback)(events, p_port->inx);
1116   }
1117
1118   return (PORT_SUCCESS);
1119 }
1120
1121 /*******************************************************************************
1122  *
1123  * Function         PORT_ReadData
1124  *
1125  * Description      Normally not GKI aware application will call this function
1126  *                  after receiving PORT_EV_RXCHAR event.
1127  *
1128  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1129  *                  p_data      - Data area
1130  *                  max_len     - Byte count requested
1131  *                  p_len       - Byte count received
1132  *
1133  ******************************************************************************/
1134 int PORT_ReadData(uint16_t handle, char* p_data, uint16_t max_len,
1135                   uint16_t* p_len) {
1136   tPORT* p_port;
1137   BT_HDR* p_buf;
1138   uint16_t count;
1139
1140   RFCOMM_TRACE_API("PORT_ReadData() handle:%d max_len:%d", handle, max_len);
1141
1142   /* Initialize this in case of an error */
1143   *p_len = 0;
1144
1145   /* Check if handle is valid to avoid crashing */
1146   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1147     return (PORT_BAD_HANDLE);
1148   }
1149
1150   p_port = &rfc_cb.port.port[handle - 1];
1151
1152   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1153     return (PORT_NOT_OPENED);
1154   }
1155
1156   if (p_port->line_status) {
1157     return (PORT_LINE_ERR);
1158   }
1159
1160   if (fixed_queue_is_empty(p_port->rx.queue)) return (PORT_SUCCESS);
1161
1162   count = 0;
1163
1164   while (max_len) {
1165     p_buf = (BT_HDR*)fixed_queue_try_peek_first(p_port->rx.queue);
1166     if (p_buf == NULL) break;
1167
1168     if (p_buf->len > max_len) {
1169       memcpy(p_data, (uint8_t*)(p_buf + 1) + p_buf->offset, max_len);
1170       p_buf->offset += max_len;
1171       p_buf->len -= max_len;
1172
1173       *p_len += max_len;
1174
1175       mutex_global_lock();
1176
1177       p_port->rx.queue_size -= max_len;
1178
1179       mutex_global_unlock();
1180
1181       break;
1182     } else {
1183       memcpy(p_data, (uint8_t*)(p_buf + 1) + p_buf->offset, p_buf->len);
1184
1185       *p_len += p_buf->len;
1186       max_len -= p_buf->len;
1187
1188       mutex_global_lock();
1189
1190       p_port->rx.queue_size -= p_buf->len;
1191
1192       if (max_len) {
1193         p_data += p_buf->len;
1194       }
1195
1196       osi_free(fixed_queue_try_dequeue(p_port->rx.queue));
1197
1198       mutex_global_unlock();
1199
1200       count++;
1201     }
1202   }
1203
1204   if (*p_len == 1) {
1205     RFCOMM_TRACE_EVENT("PORT_ReadData queue:%d returned:%d %x",
1206                        p_port->rx.queue_size, *p_len, (p_data[0]));
1207   } else {
1208     RFCOMM_TRACE_EVENT("PORT_ReadData queue:%d returned:%d",
1209                        p_port->rx.queue_size, *p_len);
1210   }
1211
1212   /* If rfcomm suspended traffic from the peer based on the rx_queue_size */
1213   /* check if it can be resumed now */
1214   port_flow_control_peer(p_port, true, count);
1215
1216   return (PORT_SUCCESS);
1217 }
1218
1219 /*******************************************************************************
1220  *
1221  * Function         PORT_Read
1222  *
1223  * Description      Normally application will call this function after receiving
1224  *                  PORT_EV_RXCHAR event.
1225  *
1226  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1227  *                  pp_buf      - pointer to address of buffer with data,
1228  *
1229  ******************************************************************************/
1230 int PORT_Read(uint16_t handle, BT_HDR** pp_buf) {
1231   tPORT* p_port;
1232   BT_HDR* p_buf;
1233
1234   RFCOMM_TRACE_API("PORT_Read() handle:%d", handle);
1235
1236   /* Check if handle is valid to avoid crashing */
1237   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1238     return (PORT_BAD_HANDLE);
1239   }
1240   p_port = &rfc_cb.port.port[handle - 1];
1241
1242   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1243     return (PORT_NOT_OPENED);
1244   }
1245
1246   if (p_port->line_status) {
1247     return (PORT_LINE_ERR);
1248   }
1249
1250   mutex_global_lock();
1251
1252   p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_port->rx.queue);
1253   if (p_buf) {
1254     p_port->rx.queue_size -= p_buf->len;
1255
1256     mutex_global_unlock();
1257
1258     /* If rfcomm suspended traffic from the peer based on the rx_queue_size */
1259     /* check if it can be resumed now */
1260     port_flow_control_peer(p_port, true, 1);
1261   } else {
1262     mutex_global_unlock();
1263   }
1264
1265   *pp_buf = p_buf;
1266   return (PORT_SUCCESS);
1267 }
1268
1269 /*******************************************************************************
1270  *
1271  * Function         port_write
1272  *
1273  * Description      This function when a data packet is received from the apper
1274  *                  layer task.
1275  *
1276  * Parameters:      p_port     - pointer to address of port control block
1277  *                  p_buf      - pointer to address of buffer with data,
1278  *
1279  ******************************************************************************/
1280 static int port_write(tPORT* p_port, BT_HDR* p_buf) {
1281   /* We should not allow to write data in to server port when connection is not
1282    * opened */
1283   if (p_port->is_server && (p_port->rfc.state != RFC_STATE_OPENED)) {
1284     osi_free(p_buf);
1285     return (PORT_CLOSED);
1286   }
1287
1288   /* Keep the data in pending queue if peer does not allow data, or */
1289   /* Peer is not ready or Port is not yet opened or initial port control */
1290   /* command has not been sent */
1291   if (p_port->tx.peer_fc || !p_port->rfc.p_mcb ||
1292       !p_port->rfc.p_mcb->peer_ready ||
1293       (p_port->rfc.state != RFC_STATE_OPENED) ||
1294       ((p_port->port_ctrl & (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED)) !=
1295        (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED))) {
1296     if ((p_port->tx.queue_size > PORT_TX_CRITICAL_WM) ||
1297         (fixed_queue_length(p_port->tx.queue) > PORT_TX_BUF_CRITICAL_WM)) {
1298       RFCOMM_TRACE_WARNING("PORT_Write: Queue size: %d", p_port->tx.queue_size);
1299
1300       osi_free(p_buf);
1301
1302       if ((p_port->p_callback != NULL) && (p_port->ev_mask & PORT_EV_ERR))
1303         p_port->p_callback(PORT_EV_ERR, p_port->inx);
1304
1305       return (PORT_TX_FULL);
1306     }
1307
1308     RFCOMM_TRACE_EVENT(
1309         "PORT_Write : Data is enqued. flow disabled %d peer_ready %d state %d "
1310         "ctrl_state %x",
1311         p_port->tx.peer_fc,
1312         (p_port->rfc.p_mcb && p_port->rfc.p_mcb->peer_ready), p_port->rfc.state,
1313         p_port->port_ctrl);
1314
1315     fixed_queue_enqueue(p_port->tx.queue, p_buf);
1316     p_port->tx.queue_size += p_buf->len;
1317
1318     return (PORT_CMD_PENDING);
1319   } else {
1320     RFCOMM_TRACE_EVENT("PORT_Write : Data is being sent");
1321
1322     RFCOMM_DataReq(p_port->rfc.p_mcb, p_port->dlci, p_buf);
1323     return (PORT_SUCCESS);
1324   }
1325 }
1326
1327 /*******************************************************************************
1328  *
1329  * Function         PORT_Write
1330  *
1331  * Description      This function when a data packet is received from the apper
1332  *                  layer task.
1333  *
1334  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1335  *                  pp_buf      - pointer to address of buffer with data,
1336  *
1337  ******************************************************************************/
1338 int PORT_Write(uint16_t handle, BT_HDR* p_buf) {
1339   tPORT* p_port;
1340   uint32_t event = 0;
1341   int rc;
1342
1343   RFCOMM_TRACE_API("PORT_Write() handle:%d", handle);
1344
1345   /* Check if handle is valid to avoid crashing */
1346   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1347     osi_free(p_buf);
1348     return (PORT_BAD_HANDLE);
1349   }
1350
1351   p_port = &rfc_cb.port.port[handle - 1];
1352
1353   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1354     osi_free(p_buf);
1355     return (PORT_NOT_OPENED);
1356   }
1357
1358   if (p_port->line_status) {
1359     RFCOMM_TRACE_WARNING("PORT_Write: Data dropped line_status:0x%x",
1360                          p_port->line_status);
1361     osi_free(p_buf);
1362     return (PORT_LINE_ERR);
1363   }
1364
1365   rc = port_write(p_port, p_buf);
1366   event |= port_flow_control_user(p_port);
1367
1368   switch (rc) {
1369     case PORT_TX_FULL:
1370       event |= PORT_EV_ERR;
1371       break;
1372
1373     case PORT_SUCCESS:
1374       event |= (PORT_EV_TXCHAR | PORT_EV_TXEMPTY);
1375       break;
1376   }
1377   /* Mask out all events that are not of interest to user */
1378   event &= p_port->ev_mask;
1379
1380   /* Send event to the application */
1381   if (p_port->p_callback && event) (p_port->p_callback)(event, p_port->inx);
1382
1383   return (PORT_SUCCESS);
1384 }
1385 /*******************************************************************************
1386  *
1387  * Function         PORT_WriteDataCO
1388  *
1389  * Description      Normally not GKI aware application will call this function
1390  *                  to send data to the port by callout functions
1391  *
1392  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1393  *                  fd         - socket fd
1394  *                  p_len      - Byte count returned
1395  *
1396  ******************************************************************************/
1397 int PORT_WriteDataCO(uint16_t handle, int* p_len) {
1398   tPORT* p_port;
1399   BT_HDR* p_buf;
1400   uint32_t event = 0;
1401   int rc = 0;
1402   uint16_t length;
1403
1404   RFCOMM_TRACE_API("PORT_WriteDataCO() handle:%d", handle);
1405   *p_len = 0;
1406
1407   /* Check if handle is valid to avoid crashing */
1408   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1409     return (PORT_BAD_HANDLE);
1410   }
1411   p_port = &rfc_cb.port.port[handle - 1];
1412
1413   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1414     RFCOMM_TRACE_WARNING("PORT_WriteDataByFd() no port state:%d",
1415                          p_port->state);
1416     return (PORT_NOT_OPENED);
1417   }
1418
1419   if (!p_port->peer_mtu) {
1420     RFCOMM_TRACE_ERROR("PORT_WriteDataByFd() peer_mtu:%d", p_port->peer_mtu);
1421     return (PORT_UNKNOWN_ERROR);
1422   }
1423   int available = 0;
1424   // if(ioctl(fd, FIONREAD, &available) < 0)
1425   if (p_port->p_data_co_callback(
1426           handle, (uint8_t*)&available, sizeof(available),
1427           DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE) == false) {
1428     RFCOMM_TRACE_ERROR(
1429         "p_data_co_callback DATA_CO_CALLBACK_TYPE_INCOMING_SIZE failed, "
1430         "available:%d",
1431         available);
1432     return (PORT_UNKNOWN_ERROR);
1433   }
1434   if (available == 0) return PORT_SUCCESS;
1435   /* Length for each buffer is the smaller of GKI buffer, peer MTU, or max_len
1436    */
1437   length = RFCOMM_DATA_BUF_SIZE -
1438            (uint16_t)(sizeof(BT_HDR) + L2CAP_MIN_OFFSET + RFCOMM_DATA_OVERHEAD);
1439
1440   /* If there are buffers scheduled for transmission check if requested */
1441   /* data fits into the end of the queue */
1442   mutex_global_lock();
1443
1444   p_buf = (BT_HDR*)fixed_queue_try_peek_last(p_port->tx.queue);
1445   if ((p_buf != NULL) &&
1446       (((int)p_buf->len + available) <= (int)p_port->peer_mtu) &&
1447       (((int)p_buf->len + available) <= (int)length)) {
1448     // if(recv(fd, (uint8_t *)(p_buf + 1) + p_buf->offset + p_buf->len,
1449     // available, 0) != available)
1450     if (p_port->p_data_co_callback(
1451             handle, (uint8_t*)(p_buf + 1) + p_buf->offset + p_buf->len,
1452             available, DATA_CO_CALLBACK_TYPE_OUTGOING) == false)
1453
1454     {
1455       error(
1456           "p_data_co_callback DATA_CO_CALLBACK_TYPE_OUTGOING failed, "
1457           "available:%d",
1458           available);
1459       mutex_global_unlock();
1460       return (PORT_UNKNOWN_ERROR);
1461     }
1462     // memcpy ((uint8_t *)(p_buf + 1) + p_buf->offset + p_buf->len, p_data,
1463     // max_len);
1464     p_port->tx.queue_size += (uint16_t)available;
1465
1466     *p_len = available;
1467     p_buf->len += (uint16_t)available;
1468
1469     mutex_global_unlock();
1470
1471     return (PORT_SUCCESS);
1472   }
1473
1474   mutex_global_unlock();
1475
1476   // int max_read = length < p_port->peer_mtu ? length : p_port->peer_mtu;
1477
1478   // max_read = available < max_read ? available : max_read;
1479
1480   while (available) {
1481     /* if we're over buffer high water mark, we're done */
1482     if ((p_port->tx.queue_size > PORT_TX_HIGH_WM) ||
1483         (fixed_queue_length(p_port->tx.queue) > PORT_TX_BUF_HIGH_WM)) {
1484       port_flow_control_user(p_port);
1485       event |= PORT_EV_FC;
1486       RFCOMM_TRACE_EVENT(
1487           "tx queue is full,tx.queue_size:%d,tx.queue.count:%d,available:%d",
1488           p_port->tx.queue_size, fixed_queue_length(p_port->tx.queue),
1489           available);
1490       break;
1491     }
1492
1493     /* continue with rfcomm data write */
1494     p_buf = (BT_HDR*)osi_malloc(RFCOMM_DATA_BUF_SIZE);
1495     p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET;
1496     p_buf->layer_specific = handle;
1497
1498     if (p_port->peer_mtu < length) length = p_port->peer_mtu;
1499     if (available < (int)length) length = (uint16_t)available;
1500     p_buf->len = length;
1501     p_buf->event = BT_EVT_TO_BTU_SP_DATA;
1502
1503     // memcpy ((uint8_t *)(p_buf + 1) + p_buf->offset, p_data, length);
1504     // if(recv(fd, (uint8_t *)(p_buf + 1) + p_buf->offset, (int)length, 0) !=
1505     // (int)length)
1506     if (p_port->p_data_co_callback(
1507             handle, (uint8_t*)(p_buf + 1) + p_buf->offset, length,
1508             DATA_CO_CALLBACK_TYPE_OUTGOING) == false) {
1509       error(
1510           "p_data_co_callback DATA_CO_CALLBACK_TYPE_OUTGOING failed, length:%d",
1511           length);
1512       return (PORT_UNKNOWN_ERROR);
1513     }
1514
1515     RFCOMM_TRACE_EVENT("PORT_WriteData %d bytes", length);
1516
1517     rc = port_write(p_port, p_buf);
1518
1519     /* If queue went below the threashold need to send flow control */
1520     event |= port_flow_control_user(p_port);
1521
1522     if (rc == PORT_SUCCESS) event |= PORT_EV_TXCHAR;
1523
1524     if ((rc != PORT_SUCCESS) && (rc != PORT_CMD_PENDING)) break;
1525
1526     *p_len += length;
1527     available -= (int)length;
1528   }
1529   if (!available && (rc != PORT_CMD_PENDING) && (rc != PORT_TX_QUEUE_DISABLED))
1530     event |= PORT_EV_TXEMPTY;
1531
1532   /* Mask out all events that are not of interest to user */
1533   event &= p_port->ev_mask;
1534
1535   /* Send event to the application */
1536   if (p_port->p_callback && event) (p_port->p_callback)(event, p_port->inx);
1537
1538   return (PORT_SUCCESS);
1539 }
1540
1541 /*******************************************************************************
1542  *
1543  * Function         PORT_WriteData
1544  *
1545  * Description      Normally not GKI aware application will call this function
1546  *                  to send data to the port.
1547  *
1548  * Parameters:      handle     - Handle returned in the RFCOMM_CreateConnection
1549  *                  p_data      - Data area
1550  *                  max_len     - Byte count requested
1551  *                  p_len       - Byte count received
1552  *
1553  ******************************************************************************/
1554 int PORT_WriteData(uint16_t handle, const char* p_data, uint16_t max_len,
1555                    uint16_t* p_len) {
1556   tPORT* p_port;
1557   BT_HDR* p_buf;
1558   uint32_t event = 0;
1559   int rc = 0;
1560   uint16_t length;
1561
1562   RFCOMM_TRACE_API("PORT_WriteData() max_len:%d", max_len);
1563
1564   *p_len = 0;
1565
1566   /* Check if handle is valid to avoid crashing */
1567   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1568     return (PORT_BAD_HANDLE);
1569   }
1570   p_port = &rfc_cb.port.port[handle - 1];
1571
1572   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1573     RFCOMM_TRACE_WARNING("PORT_WriteData() no port state:%d", p_port->state);
1574     return (PORT_NOT_OPENED);
1575   }
1576
1577   if (!max_len || !p_port->peer_mtu) {
1578     RFCOMM_TRACE_ERROR("PORT_WriteData() peer_mtu:%d", p_port->peer_mtu);
1579     return (PORT_UNKNOWN_ERROR);
1580   }
1581
1582   /* Length for each buffer is the smaller of GKI buffer, peer MTU, or max_len
1583    */
1584   length = RFCOMM_DATA_BUF_SIZE -
1585            (uint16_t)(sizeof(BT_HDR) + L2CAP_MIN_OFFSET + RFCOMM_DATA_OVERHEAD);
1586
1587   /* If there are buffers scheduled for transmission check if requested */
1588   /* data fits into the end of the queue */
1589   mutex_global_lock();
1590
1591   p_buf = (BT_HDR*)fixed_queue_try_peek_last(p_port->tx.queue);
1592   if ((p_buf != NULL) && ((p_buf->len + max_len) <= p_port->peer_mtu) &&
1593       ((p_buf->len + max_len) <= length)) {
1594     memcpy((uint8_t*)(p_buf + 1) + p_buf->offset + p_buf->len, p_data, max_len);
1595     p_port->tx.queue_size += max_len;
1596
1597     *p_len = max_len;
1598     p_buf->len += max_len;
1599
1600     mutex_global_unlock();
1601
1602     return (PORT_SUCCESS);
1603   }
1604
1605   mutex_global_unlock();
1606
1607   while (max_len) {
1608     /* if we're over buffer high water mark, we're done */
1609     if ((p_port->tx.queue_size > PORT_TX_HIGH_WM) ||
1610         (fixed_queue_length(p_port->tx.queue) > PORT_TX_BUF_HIGH_WM))
1611       break;
1612
1613     /* continue with rfcomm data write */
1614     p_buf = (BT_HDR*)osi_malloc(RFCOMM_DATA_BUF_SIZE);
1615     p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET;
1616     p_buf->layer_specific = handle;
1617
1618     if (p_port->peer_mtu < length) length = p_port->peer_mtu;
1619     if (max_len < length) length = max_len;
1620     p_buf->len = length;
1621     p_buf->event = BT_EVT_TO_BTU_SP_DATA;
1622
1623     memcpy((uint8_t*)(p_buf + 1) + p_buf->offset, p_data, length);
1624
1625     RFCOMM_TRACE_EVENT("PORT_WriteData %d bytes", length);
1626
1627     rc = port_write(p_port, p_buf);
1628
1629     /* If queue went below the threashold need to send flow control */
1630     event |= port_flow_control_user(p_port);
1631
1632     if (rc == PORT_SUCCESS) event |= PORT_EV_TXCHAR;
1633
1634     if ((rc != PORT_SUCCESS) && (rc != PORT_CMD_PENDING)) break;
1635
1636     *p_len += length;
1637     max_len -= length;
1638     p_data += length;
1639   }
1640   if (!max_len && (rc != PORT_CMD_PENDING) && (rc != PORT_TX_QUEUE_DISABLED))
1641     event |= PORT_EV_TXEMPTY;
1642
1643   /* Mask out all events that are not of interest to user */
1644   event &= p_port->ev_mask;
1645
1646   /* Send event to the application */
1647   if (p_port->p_callback && event) (p_port->p_callback)(event, p_port->inx);
1648
1649   return (PORT_SUCCESS);
1650 }
1651
1652 /*******************************************************************************
1653  *
1654  * Function         PORT_Test
1655  *
1656  * Description      Application can call this function to send RFCOMM Test frame
1657  *
1658  * Parameters:      handle      - Handle returned in the RFCOMM_CreateConnection
1659  *                  p_data      - Data area
1660  *                  max_len     - Byte count requested
1661  *
1662  ******************************************************************************/
1663 int PORT_Test(uint16_t handle, uint8_t* p_data, uint16_t len) {
1664   tPORT* p_port;
1665
1666   RFCOMM_TRACE_API("PORT_Test() len:%d", len);
1667
1668   if ((handle == 0) || (handle > MAX_RFC_PORTS)) {
1669     return (PORT_BAD_HANDLE);
1670   }
1671   p_port = &rfc_cb.port.port[handle - 1];
1672
1673   if (!p_port->in_use || (p_port->state == PORT_STATE_CLOSED)) {
1674     return (PORT_NOT_OPENED);
1675   }
1676
1677   if (len > ((p_port->mtu == 0) ? RFCOMM_DEFAULT_MTU : p_port->mtu)) {
1678     return (PORT_UNKNOWN_ERROR);
1679   }
1680
1681   BT_HDR* p_buf = (BT_HDR*)osi_malloc(RFCOMM_CMD_BUF_SIZE);
1682   p_buf->offset = L2CAP_MIN_OFFSET + RFCOMM_MIN_OFFSET + 2;
1683   p_buf->len = len;
1684
1685   memcpy((uint8_t*)(p_buf + 1) + p_buf->offset, p_data, p_buf->len);
1686
1687   rfc_send_test(p_port->rfc.p_mcb, true, p_buf);
1688
1689   return (PORT_SUCCESS);
1690 }
1691
1692 /*******************************************************************************
1693  *
1694  * Function         RFCOMM_Init
1695  *
1696  * Description      This function is called to initialize RFCOMM layer
1697  *
1698  ******************************************************************************/
1699 void RFCOMM_Init(void) {
1700   memset(&rfc_cb, 0, sizeof(tRFC_CB)); /* Init RFCOMM control block */
1701
1702   rfc_cb.rfc.last_mux = MAX_BD_CONNECTIONS;
1703
1704 #if defined(RFCOMM_INITIAL_TRACE_LEVEL)
1705   rfc_cb.trace_level = RFCOMM_INITIAL_TRACE_LEVEL;
1706 #else
1707   rfc_cb.trace_level = BT_TRACE_LEVEL_NONE; /* No traces */
1708 #endif
1709
1710   rfcomm_l2cap_if_init();
1711 }
1712
1713 /*******************************************************************************
1714  *
1715  * Function         PORT_SetTraceLevel
1716  *
1717  * Description      Set the trace level for RFCOMM. If called with 0xFF, it
1718  *                  simply reads the current trace level.
1719  *
1720  * Returns          the new (current) trace level
1721  *
1722  ******************************************************************************/
1723 uint8_t PORT_SetTraceLevel(uint8_t new_level) {
1724   if (new_level != 0xFF) rfc_cb.trace_level = new_level;
1725
1726   return (rfc_cb.trace_level);
1727 }
1728
1729 /*******************************************************************************
1730  *
1731  * Function         PORT_GetResultString
1732  *
1733  * Description      This function returns the human-readable string for a given
1734  *                  result code.
1735  *
1736  * Returns          a pointer to the human-readable string for the given result.
1737  *
1738  ******************************************************************************/
1739 const char* PORT_GetResultString(const uint8_t result_code) {
1740   if (result_code > PORT_ERR_MAX) {
1741     return result_code_strings[PORT_ERR_MAX];
1742   }
1743
1744   return result_code_strings[result_code];
1745 }