btif/src/btif_sock_rfc.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2009-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  *  Filename:      btif_sock_rfc.c
  22  *
  23  *  Description:   Handsfree Profile Bluetooth Interface
  24  *
  25  ***********************************************************************************/
  26 #include <hardware/bluetooth.h>
  27 #include <hardware/bt_sock.h>
  28 #include <sys/types.h>
  29 #include <sys/socket.h>
  30 #include <errno.h>
  31 #include <sys/ioctl.h>
  32
  33 #define LOG_TAG "BTIF_SOCK"
  34 #include "btif_common.h"
  35 #include "btif_util.h"
  36
  37 #include "bd.h"
  38
  39 #include "bta_api.h"
  40 #include "btif_sock_thread.h"
  41 #include "btif_sock_sdp.h"
  42 #include "btif_sock_util.h"
  43
  44 #include "bt_target.h"
  45 #include "gki.h"
  46 #include "hcimsgs.h"
  47 #include "sdp_api.h"
  48 #include "btu.h"
  49 #include "btm_api.h"
  50 #include "btm_int.h"
  51 #include "bta_jv_api.h"
  52 #include "bta_jv_co.h"
  53 #include "port_api.h"
  54
  55 #include <cutils/log.h>
  56 #include <hardware/bluetooth.h>
  57 #define asrt(s) if(!(s)) APPL_TRACE_ERROR3("## %s assert %s failed at line:%d ##",__FUNCTION__, #s, __LINE__)
  58
  59 extern void uuid_to_string(bt_uuid_t *p_uuid, char *str);
  60 static inline void logu(const char* title, const uint8_t * p_uuid)
  61 {
  62     char uuids[128];
  63     uuid_to_string((bt_uuid_t*)p_uuid, uuids);
  64     ALOGD("%s: %s", title, uuids);
  65 }
  66
  67
  68
  69 #define MAX_RFC_CHANNEL 30
  70 #define MAX_RFC_SESSION BTA_JV_MAX_RFC_SR_SESSION //3 by default
  71 typedef struct {
  72     int outgoing_congest : 1;
  73     int pending_sdp_request : 1;
  74     int doing_sdp_request : 1;
  75     int server : 1;
  76     int connected : 1;
  77     int closing : 1;
  78 } flags_t;
  79
  80 typedef struct {
  81   flags_t f;
  82   uint32_t id;
  83   int security;
  84   int scn;
  85   bt_bdaddr_t addr;
  86   uint8_t service_uuid[16];
  87   char service_name[256];
  88   int fd, app_fd;
  89   int mtu;
  90   uint8_t* packet;
  91   int sdp_handle;
  92   int rfc_handle;
  93   int rfc_port_handle;
  94   int role;
  95   BUFFER_Q incoming_que;
  96 } rfc_slot_t;
  97
  98 static rfc_slot_t rfc_slots[MAX_RFC_CHANNEL];
  99 static uint32_t rfc_slot_id;
 100 static volatile int pth = -1; //poll thread handle
 101 static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data);
 102 static void cleanup_rfc_slot(rfc_slot_t* rs);
 103 static inline void close_rfc_connection(int rfc_handle, int server);
 104 static bt_status_t dm_get_remote_service_record(bt_bdaddr_t *remote_addr,
 105                                                     bt_uuid_t *uuid);
 106 static void *rfcomm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data);
 107 static inline BOOLEAN send_app_scn(rfc_slot_t* rs);
 108 static pthread_mutex_t slot_lock;
 109 #define is_init_done() (pth != -1)
 110 static inline void clear_slot_flag(flags_t* f)
 111 {
 112     memset(f, 0, sizeof(*f));
 113 }
 114
 115 static inline void bd_copy(UINT8* dest, UINT8* src, BOOLEAN swap)
 116 {
 117     if (swap)
 118     {
 119         int i;
 120         for (i =0; i < 6 ;i++)
 121             dest[i]= src[5-i];
 122     }
 123     else memcpy(dest, src, 6);
 124 }
 125 static inline void free_gki_que(BUFFER_Q* q)
 126 {
 127     while(!GKI_queue_is_empty(q))
 128            GKI_freebuf(GKI_dequeue(q));
 129 }
 130 static void init_rfc_slots()
 131 {
 132     int i;
 133     memset(rfc_slots, 0, sizeof(rfc_slot_t)*MAX_RFC_CHANNEL);
 134     for(i = 0; i < MAX_RFC_CHANNEL; i++)
 135     {
 136         rfc_slots[i].scn = -1;
 137         rfc_slots[i].sdp_handle = 0;
 138         rfc_slots[i].fd = rfc_slots[i].app_fd = -1;
 139         GKI_init_q(&rfc_slots[i].incoming_que);
 140     }
 141     BTA_JvEnable(jv_dm_cback);
 142     init_slot_lock(&slot_lock);
 143 }
 144 bt_status_t btsock_rfc_init(int poll_thread_handle)
 145 {
 146     pth = poll_thread_handle;
 147     init_rfc_slots();
 148     return BT_STATUS_SUCCESS;
 149 }
 150 void btsock_rfc_cleanup()
 151 {
 152     int curr_pth = pth;
 153     pth = -1;
 154     btsock_thread_exit(curr_pth);
 155     lock_slot(&slot_lock);
 156     int i;
 157     for(i = 0; i < MAX_RFC_CHANNEL; i++)
 158     {
 159         if(rfc_slots[i].id)
 160             cleanup_rfc_slot(&rfc_slots[i]);
 161     }
 162     unlock_slot(&slot_lock);
 163 }
 164 static inline rfc_slot_t* find_free_slot()
 165 {
 166     int i;
 167     for(i = 0; i < MAX_RFC_CHANNEL; i++)
 168     {
 169         if(rfc_slots[i].fd == -1)
 170         {
 171              return &rfc_slots[i];
 172         }
 173     }
 174     return NULL;
 175 }
 176 static inline rfc_slot_t* find_rfc_slot_by_id(uint32_t id, const char* label)
 177 {
 178     int i;
 179     if(id)
 180     {
 181         for(i = 0; i < MAX_RFC_CHANNEL; i++)
 182         {
 183             if(rfc_slots[i].id == id)
 184             {
 185                 return &rfc_slots[i];
 186             }
 187         }
 188     }
 189     APPL_TRACE_WARNING2("invalid rfc slot id: %d, %s", id, label);
 190     return NULL;
 191 }
 192 static inline rfc_slot_t* find_rfc_slot_by_pending_sdp()
 193 {
 194     uint32_t min_id = (uint32_t)-1;
 195     int slot = -1;
 196     int i;
 197     for(i = 0; i < MAX_RFC_CHANNEL; i++)
 198     {
 199         if(rfc_slots[i].id && rfc_slots[i].f.pending_sdp_request)
 200         {
 201             if(rfc_slots[i].id < min_id)
 202             {
 203                 min_id = rfc_slots[i].id;
 204                 slot = i;
 205             }
 206         }
 207     }
 208     if(0<= slot && slot < MAX_RFC_CHANNEL)
 209         return &rfc_slots[slot];
 210     return NULL;
 211 }
 212 static inline rfc_slot_t* find_rfc_slot_requesting_sdp()
 213 {
 214     int i;
 215     for(i = 0; i < MAX_RFC_CHANNEL; i++)
 216     {
 217         if(rfc_slots[i].id && rfc_slots[i].f.doing_sdp_request)
 218                 return &rfc_slots[i];
 219     }
 220     APPL_TRACE_DEBUG0("can not find any slot is requesting sdp");
 221     return NULL;
 222 }
 223
 224 static inline rfc_slot_t* find_rfc_slot_by_fd(int fd)
 225 {
 226     int i;
 227     if(fd >= 0)
 228     {
 229         for(i = 0; i < MAX_RFC_CHANNEL; i++)
 230         {
 231             if(rfc_slots[i].fd == fd)
 232             {
 233                 if(rfc_slots[i].id)
 234                     return &rfc_slots[i];
 235                 else
 236                 {
 237                     APPL_TRACE_ERROR0("invalid rfc slot id, cannot be 0");
 238                     break;
 239                 }
 240             }
 241         }
 242     }
 243     return NULL;
 244 }
 245 static rfc_slot_t* alloc_rfc_slot(const bt_bdaddr_t *addr, const char* name, const uint8_t* uuid, int channel, int flags, BOOLEAN server)
 246 {
 247     int security = 0;
 248     if(flags & BTSOCK_FLAG_ENCRYPT)
 249         security |= server ? BTM_SEC_IN_ENCRYPT : BTM_SEC_OUT_ENCRYPT;
 250     if(flags & BTSOCK_FLAG_AUTH)
 251         security |= server ? BTM_SEC_IN_AUTHENTICATE : BTM_SEC_OUT_AUTHENTICATE;
 252
 253     rfc_slot_t* rs = find_free_slot();
 254     if(rs)
 255     {
 256         int fds[2] = {-1, -1};
 257         if(socketpair(AF_LOCAL, SOCK_STREAM, 0, fds))
 258         {
 259             APPL_TRACE_ERROR1("socketpair failed, errno:%d", errno);
 260             return NULL;
 261         }
 262         rs->fd = fds[0];
 263         rs->app_fd = fds[1];
 264         rs->security = security;
 265         rs->scn = channel;
 266         if(uuid)
 267             memcpy(rs->service_uuid, uuid, sizeof(rs->service_uuid));
 268         else memset(rs->service_uuid, 0, sizeof(rs->service_uuid));
 269         if(name && *name)
 270             strncpy(rs->service_name, name, sizeof(rs->service_name) -1);
 271         if(addr)
 272             rs->addr = *addr;
 273         ++rfc_slot_id;
 274         if(rfc_slot_id == 0)
 275             rfc_slot_id = 1; //skip 0 when wrapped
 276         rs->id = rfc_slot_id;
 277         rs->f.server = server;
 278     }
 279     return rs;
 280 }
 281 // rfc_slot_t* accept_rs = create_srv_accept_rfc_slot(srv_rs, p_open->rem_bda,p_opne->handle,  p_open->new_listen_handle);
 282 static inline rfc_slot_t* create_srv_accept_rfc_slot(rfc_slot_t* srv_rs, const bt_bdaddr_t* addr,
 283                                         int open_handle, int new_listen_handle)
 284 {
 285     rfc_slot_t *accept_rs = alloc_rfc_slot(addr, srv_rs->service_name, srv_rs->service_uuid, srv_rs->scn, 0, FALSE);
 286     if( accept_rs)
 287     {
 288         clear_slot_flag(&accept_rs->f);
 289         accept_rs->f.server = FALSE;
 290         accept_rs->f.connected = TRUE;
 291         accept_rs->security = srv_rs->security;
 292         accept_rs->mtu = srv_rs->mtu;
 293         accept_rs->role = srv_rs->role;
 294         accept_rs->rfc_handle = open_handle;
 295         accept_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(open_handle);
 296         //now update listen rfc_handle of server slot
 297         srv_rs->rfc_handle = new_listen_handle;
 298         srv_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(new_listen_handle);
 299         BTIF_TRACE_DEBUG4("create_srv_accept__rfc_slot(open_handle: 0x%x, new_listen_handle:"
 300                 "0x%x) accept_rs->rfc_handle:0x%x, srv_rs_listen->rfc_handle:0x%x"
 301                 ,open_handle, new_listen_handle, accept_rs->rfc_port_handle, srv_rs->rfc_port_handle);
 302         asrt(accept_rs->rfc_port_handle != srv_rs->rfc_port_handle);
 303         //now swap the slot id
 304         uint32_t new_listen_id = accept_rs->id;
 305         accept_rs->id = srv_rs->id;
 306         srv_rs->id = new_listen_id;
 307
 308         return accept_rs;
 309     }
 310     else
 311     {
 312         APPL_TRACE_ERROR1(" accept_rs is NULL %s", __FUNCTION__);
 313         return NULL;
 314     }
 315 }
 316 bt_status_t btsock_rfc_listen(const char* service_name, const uint8_t* service_uuid, int channel,
 317                             int* sock_fd, int flags)
 318 {
 319
 320     APPL_TRACE_DEBUG1("btsock_rfc_listen, service_name:%s", service_name);
 321     if(sock_fd == NULL || (service_uuid == NULL && (channel < 1 || channel > 30)))
 322     {
 323         APPL_TRACE_ERROR3("invalid rfc channel:%d or sock_fd:%p, uuid:%p", channel, sock_fd, service_uuid);
 324         return BT_STATUS_PARM_INVALID;
 325     }
 326     *sock_fd = -1;
 327     if(!is_init_done())
 328         return BT_STATUS_NOT_READY;
 329     if(is_uuid_empty(service_uuid))
 330         service_uuid = UUID_SPP; //use serial port profile to listen to specified channel
 331     else
 332     {
 333         //Check the service_uuid. overwrite the channel # if reserved
 334         int reserved_channel = get_reserved_rfc_channel(service_uuid);
 335         if(reserved_channel > 0)
 336         {
 337             channel = reserved_channel;
 338         }
 339     }
 340     int status = BT_STATUS_FAIL;
 341     lock_slot(&slot_lock);
 342     rfc_slot_t* rs = alloc_rfc_slot(NULL, service_name, service_uuid, channel, flags, TRUE);
 343     if(rs)
 344     {
 345         APPL_TRACE_DEBUG1("BTA_JvCreateRecordByUser:%s", service_name);
 346         BTA_JvCreateRecordByUser((void *)(intptr_t)rs->id);
 347         *sock_fd = rs->app_fd;
 348         rs->app_fd = -1; //the fd ownership is transferred to app
 349         status = BT_STATUS_SUCCESS;
 350         btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, rs->id);
 351     }
 352     unlock_slot(&slot_lock);
 353     return status;
 354 }
 355 bt_status_t btsock_rfc_connect(const bt_bdaddr_t *bd_addr, const uint8_t* service_uuid,
 356         int channel, int* sock_fd, int flags)
 357 {
 358     if(sock_fd == NULL || (service_uuid == NULL && (channel < 1 || channel > 30)))
 359     {
 360         APPL_TRACE_ERROR3("invalid rfc channel:%d or sock_fd:%p, uuid:%p", channel, sock_fd,
 361                           service_uuid);
 362         return BT_STATUS_PARM_INVALID;
 363     }
 364     *sock_fd = -1;
 365     if(!is_init_done())
 366         return BT_STATUS_NOT_READY;
 367     int status = BT_STATUS_FAIL;
 368     lock_slot(&slot_lock);
 369     rfc_slot_t* rs = alloc_rfc_slot(bd_addr, NULL, service_uuid, channel, flags, FALSE);
 370     if(rs)
 371     {
 372         if(is_uuid_empty(service_uuid))
 373         {
 374             APPL_TRACE_DEBUG1("connecting to rfcomm channel:%d without service discovery", channel);
 375             if(BTA_JvRfcommConnect(rs->security, rs->role, rs->scn, rs->addr.address,
 376                         rfcomm_cback, (void*)(intptr_t)rs->id) == BTA_JV_SUCCESS)
 377             {
 378                 if(send_app_scn(rs))
 379                 {
 380                     btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM,
 381                                                         SOCK_THREAD_FD_RD, rs->id);
 382                     *sock_fd = rs->app_fd;
 383                     rs->app_fd = -1; //the fd ownership is transferred to app
 384                     status = BT_STATUS_SUCCESS;
 385                 }
 386                 else cleanup_rfc_slot(rs);
 387             }
 388             else cleanup_rfc_slot(rs);
 389         }
 390         else
 391         {
 392             tSDP_UUID sdp_uuid;
 393             sdp_uuid.len = 16;
 394             memcpy(sdp_uuid.uu.uuid128, service_uuid, sizeof(sdp_uuid.uu.uuid128));
 395             logu("service_uuid", service_uuid);
 396             *sock_fd = rs->app_fd;
 397             rs->app_fd = -1; //the fd ownership is transferred to app
 398             status = BT_STATUS_SUCCESS;
 399             rfc_slot_t* rs_doing_sdp = find_rfc_slot_requesting_sdp();
 400             if(rs_doing_sdp == NULL)
 401             {
 402                 BTA_JvStartDiscovery((UINT8*)bd_addr->address, 1, &sdp_uuid, (void*)(intptr_t)rs->id);
 403                 rs->f.pending_sdp_request = FALSE;
 404                 rs->f.doing_sdp_request = TRUE;
 405             }
 406             else
 407             {
 408                 rs->f.pending_sdp_request = TRUE;
 409                 rs->f.doing_sdp_request = FALSE;
 410             }
 411             btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
 412         }
 413     }
 414     unlock_slot(&slot_lock);
 415     return status;
 416 }
 417
 418 static int create_server_sdp_record(rfc_slot_t* rs)
 419 {
 420     int scn = rs->scn;
 421     if(rs->scn > 0)
 422     {
 423         if(BTM_TryAllocateSCN(rs->scn) == FALSE)
 424         {
 425             APPL_TRACE_ERROR1("rfc channel:%d already in use", scn);
 426             return FALSE;
 427         }
 428     }
 429     else if((rs->scn = BTM_AllocateSCN()) == 0)
 430     {
 431         APPL_TRACE_ERROR0("run out of rfc channels");
 432         return FALSE;
 433     }
 434     if((rs->sdp_handle = add_rfc_sdp_rec(rs->service_name, rs->service_uuid, rs->scn)) <= 0)
 435     {
 436         return FALSE;
 437     }
 438     return TRUE;
 439 }
 440 const char * jv_evt[] = {
 441     "BTA_JV_ENABLE_EVT",
 442     "BTA_JV_SET_DISCOVER_EVT",
 443     "BTA_JV_LOCAL_ADDR_EVT",
 444     "BTA_JV_LOCAL_NAME_EVT",
 445     "BTA_JV_REMOTE_NAME_EVT",
 446     "BTA_JV_SET_ENCRYPTION_EVT",
 447     "BTA_JV_GET_SCN_EVT",
 448     "BTA_JV_GET_PSM_EVT",
 449     "BTA_JV_DISCOVERY_COMP_EVT",
 450     "BTA_JV_SERVICES_LEN_EVT",
 451     "BTA_JV_SERVICE_SEL_EVT",
 452     "BTA_JV_CREATE_RECORD_EVT",
 453     "BTA_JV_UPDATE_RECORD_EVT",
 454     "BTA_JV_ADD_ATTR_EVT",
 455     "BTA_JV_DELETE_ATTR_EVT",
 456     "BTA_JV_CANCEL_DISCVRY_EVT",
 457
 458     "BTA_JV_L2CAP_OPEN_EVT",
 459     "BTA_JV_L2CAP_CLOSE_EVT",
 460     "BTA_JV_L2CAP_START_EVT",
 461     "BTA_JV_L2CAP_CL_INIT_EVT",
 462     "BTA_JV_L2CAP_DATA_IND_EVT",
 463     "BTA_JV_L2CAP_CONG_EVT",
 464     "BTA_JV_L2CAP_READ_EVT",
 465     "BTA_JV_L2CAP_RECEIVE_EVT",
 466     "BTA_JV_L2CAP_WRITE_EVT",
 467
 468     "BTA_JV_RFCOMM_OPEN_EVT",
 469     "BTA_JV_RFCOMM_CLOSE_EVT",
 470     "BTA_JV_RFCOMM_START_EVT",
 471     "BTA_JV_RFCOMM_CL_INIT_EVT",
 472     "BTA_JV_RFCOMM_DATA_IND_EVT",
 473     "BTA_JV_RFCOMM_CONG_EVT",
 474     "BTA_JV_RFCOMM_READ_EVT",
 475     "BTA_JV_RFCOMM_WRITE_EVT",
 476     "BTA_JV_RFCOMM_SRV_OPEN_EVT", //  33 /* open status of Server RFCOMM connection */
 477     "BTA_JV_MAX_EVT"
 478 };
 479 static inline void free_rfc_slot_scn(rfc_slot_t* rs)
 480 {
 481     if(rs->scn > 0)
 482     {
 483         if(rs->f.server && !rs->f.closing && rs->rfc_handle)
 484         {
 485             BTA_JvRfcommStopServer(rs->rfc_handle, (void*)(uintptr_t)rs->id);
 486             rs->rfc_handle = 0;
 487         }
 488         if(rs->f.server)
 489             BTM_FreeSCN(rs->scn);
 490         rs->scn = 0;
 491     }
 492 }
 493 static void cleanup_rfc_slot(rfc_slot_t* rs)
 494 {
 495     APPL_TRACE_DEBUG4("cleanup slot:%d, fd:%d, scn:%d, sdp_handle:0x%x", rs->id, rs->fd, rs->scn, rs->sdp_handle);
 496     if(rs->fd != -1)
 497     {
 498         shutdown(rs->fd, 2);
 499         close(rs->fd);
 500         rs->fd = -1;
 501     }
 502     if(rs->app_fd != -1)
 503     {
 504         close(rs->app_fd);
 505         rs->app_fd = -1;
 506     }
 507     if(rs->sdp_handle > 0)
 508     {
 509         del_rfc_sdp_rec(rs->sdp_handle);
 510         rs->sdp_handle = 0;
 511     }
 512     if(rs->rfc_handle && !rs->f.closing && !rs->f.server)
 513     {
 514         APPL_TRACE_DEBUG1("closing rfcomm connection, rfc_handle:0x%x", rs->rfc_handle);
 515         BTA_JvRfcommClose(rs->rfc_handle, (void*)(uintptr_t)rs->id);
 516         rs->rfc_handle = 0;
 517     }
 518     free_rfc_slot_scn(rs);
 519     free_gki_que(&rs->incoming_que);
 520
 521     rs->rfc_port_handle = 0;
 522     //cleanup the flag
 523     memset(&rs->f, 0, sizeof(rs->f));
 524     rs->id = 0;
 525 }
 526 static inline BOOLEAN send_app_scn(rfc_slot_t* rs)
 527 {
 528     if(sock_send_all(rs->fd, (const uint8_t*)&rs->scn, sizeof(rs->scn)) == sizeof(rs->scn))
 529     {
 530         return TRUE;
 531     }
 532
 533     return FALSE;
 534 }
 535 static BOOLEAN send_app_connect_signal(int fd, const bt_bdaddr_t* addr, int channel, int status, int send_fd)
 536 {
 537 /*
 538     typedef struct {
 539     short size;
 540     bt_bdaddr_t bd_addr;
 541     int channel;
 542     int status;
 543 } __attribute__((packed)) sock_connect_signal_t;
 544 */
 545     sock_connect_signal_t cs;
 546     cs.size = sizeof(cs);
 547     cs.bd_addr = *addr;
 548     cs.channel = channel;
 549     cs.status = status;
 550     if(send_fd != -1)
 551     {
 552         if(sock_send_fd(fd, (const uint8_t*)&cs, sizeof(cs), send_fd) == sizeof(cs))
 553             return TRUE;
 554         else APPL_TRACE_ERROR2("sock_send_fd failed, fd:%d, send_fd:%d", fd, send_fd);
 555     }
 556     else if(sock_send_all(fd, (const uint8_t*)&cs, sizeof(cs)) == sizeof(cs))
 557     {
 558         return TRUE;
 559     }
 560     return FALSE;
 561 }
 562 static void on_cl_rfc_init(tBTA_JV_RFCOMM_CL_INIT *p_init, uint32_t id)
 563 {
 564     lock_slot(&slot_lock);
 565     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_cl_rfc_init");
 566     if(rs)
 567     {
 568         if (p_init->status != BTA_JV_SUCCESS)
 569             cleanup_rfc_slot(rs);
 570         else
 571         {
 572             rs->rfc_handle = p_init->handle;
 573         }
 574     }
 575     unlock_slot(&slot_lock);
 576 }
 577 static void  on_srv_rfc_listen_started(tBTA_JV_RFCOMM_START *p_start, uint32_t id)
 578 {
 579     lock_slot(&slot_lock);
 580     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_srv_rfc_listen_started");
 581     if(rs)
 582     {
 583         if (p_start->status != BTA_JV_SUCCESS)
 584             cleanup_rfc_slot(rs);
 585         else
 586         {
 587             rs->rfc_handle = p_start->handle;
 588
 589             if(!send_app_scn(rs))
 590             {
 591                 //closed
 592                 APPL_TRACE_DEBUG1("send_app_scn() failed, close rs->id:%d", rs->id);
 593                 cleanup_rfc_slot(rs);
 594             }
 595         }
 596     }
 597     unlock_slot(&slot_lock);
 598 }
 599 static uint32_t on_srv_rfc_connect(tBTA_JV_RFCOMM_SRV_OPEN *p_open, uint32_t id)
 600 {
 601     uint32_t new_listen_slot_id = 0;
 602     lock_slot(&slot_lock);
 603     rfc_slot_t* srv_rs = find_rfc_slot_by_id(id, "on_srv_rfc_connect");
 604     if(srv_rs)
 605     {
 606         rfc_slot_t* accept_rs = create_srv_accept_rfc_slot(srv_rs, (const bt_bdaddr_t*)p_open->rem_bda,
 607                                                            p_open->handle, p_open->new_listen_handle);
 608         if(accept_rs)
 609         {
 610             //start monitor the socket
 611             btsock_thread_add_fd(pth, srv_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, srv_rs->id);
 612             btsock_thread_add_fd(pth, accept_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, accept_rs->id);
 613             APPL_TRACE_DEBUG1("sending connect signal & app fd:%dto app server to accept() the connection",
 614                              accept_rs->app_fd);
 615             APPL_TRACE_DEBUG2("server fd:%d, scn:%d", srv_rs->fd, srv_rs->scn);
 616             send_app_connect_signal(srv_rs->fd, &accept_rs->addr, srv_rs->scn, 0, accept_rs->app_fd);
 617             accept_rs->app_fd = -1; //the fd is closed after sent to app
 618             new_listen_slot_id = srv_rs->id;
 619         }
 620     }
 621     unlock_slot(&slot_lock);
 622     return new_listen_slot_id;
 623 }
 624 static void on_cli_rfc_connect(tBTA_JV_RFCOMM_OPEN *p_open, uint32_t id)
 625 {
 626     lock_slot(&slot_lock);
 627     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_cli_rfc_connect");
 628     if(rs && p_open->status == BTA_JV_SUCCESS)
 629     {
 630         rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(p_open->handle);
 631         bd_copy(rs->addr.address, p_open->rem_bda, 0);
 632         //notify app rfc is connected
 633         APPL_TRACE_DEBUG4("call send_app_connect_signal, slot id:%d, fd:%d, rfc scn:%d, server:%d",
 634                          rs->id, rs->fd, rs->scn, rs->f.server);
 635         if(send_app_connect_signal(rs->fd, &rs->addr, rs->scn, 0, -1))
 636         {
 637             //start monitoring the socketpair to get call back when app writing data
 638             APPL_TRACE_DEBUG3("on_rfc_connect_ind, connect signal sent, slot id:%d, rfc scn:%d, server:%d",
 639                              rs->id, rs->scn, rs->f.server);
 640             rs->f.connected = TRUE;
 641         }
 642         else APPL_TRACE_ERROR0("send_app_connect_signal failed");
 643     }
 644     else if(rs)
 645         cleanup_rfc_slot(rs);
 646     unlock_slot(&slot_lock);
 647 }
 648 static void on_rfc_close(tBTA_JV_RFCOMM_CLOSE * p_close, uint32_t id)
 649 {
 650     UNUSED(p_close);
 651     lock_slot(&slot_lock);
 652     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_rfc_close");
 653     if(rs)
 654     {
 655         APPL_TRACE_DEBUG4("on_rfc_close, slot id:%d, fd:%d, rfc scn:%d, server:%d",
 656                          rs->id, rs->fd, rs->scn, rs->f.server);
 657         free_rfc_slot_scn(rs);
 658         // rfc_handle already closed when receiving rfcomm close event from stack.
 659         rs->f.connected = FALSE;
 660         cleanup_rfc_slot(rs);
 661     }
 662     unlock_slot(&slot_lock);
 663 }
 664 static void on_rfc_write_done(tBTA_JV_RFCOMM_WRITE *p, uint32_t id)
 665 {
 666     UNUSED(p);
 667
 668     lock_slot(&slot_lock);
 669     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_rfc_write_done");
 670     if(rs && !rs->f.outgoing_congest)
 671     {
 672         //mointer the fd for any outgoing data
 673         btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
 674     }
 675     unlock_slot(&slot_lock);
 676 }
 677 static void on_rfc_outgoing_congest(tBTA_JV_RFCOMM_CONG *p, uint32_t id)
 678 {
 679     lock_slot(&slot_lock);
 680     rfc_slot_t* rs = find_rfc_slot_by_id(id, "on_rfc_outgoing_congest");
 681     if(rs)
 682     {
 683         rs->f.outgoing_congest = p->cong ? 1 : 0;
 684         //mointer the fd for any outgoing data
 685         if(!rs->f.outgoing_congest)
 686             btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
 687     }
 688     unlock_slot(&slot_lock);
 689 }
 690
 691 static void *rfcomm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data)
 692 {
 693     int rc;
 694     void* new_user_data = NULL;
 695     APPL_TRACE_DEBUG1("event=%s", jv_evt[event]);
 696
 697     switch (event)
 698     {
 699     case BTA_JV_RFCOMM_START_EVT:
 700         on_srv_rfc_listen_started(&p_data->rfc_start, (uintptr_t)user_data);
 701         break;
 702
 703     case BTA_JV_RFCOMM_CL_INIT_EVT:
 704         on_cl_rfc_init(&p_data->rfc_cl_init, (uintptr_t)user_data);
 705         break;
 706
 707     case BTA_JV_RFCOMM_OPEN_EVT:
 708         BTA_JvSetPmProfile(p_data->rfc_open.handle,BTA_JV_PM_ID_1,BTA_JV_CONN_OPEN);
 709         on_cli_rfc_connect(&p_data->rfc_open, (uintptr_t)user_data);
 710         break;
 711     case BTA_JV_RFCOMM_SRV_OPEN_EVT:
 712         BTA_JvSetPmProfile(p_data->rfc_srv_open.handle,BTA_JV_PM_ALL,BTA_JV_CONN_OPEN);
 713         new_user_data = (void*)(intptr_t)on_srv_rfc_connect(&p_data->rfc_srv_open, (uintptr_t)user_data);
 714         break;
 715
 716     case BTA_JV_RFCOMM_CLOSE_EVT:
 717         APPL_TRACE_DEBUG1("BTA_JV_RFCOMM_CLOSE_EVT: user_data:%d", (uintptr_t)user_data);
 718         on_rfc_close(&p_data->rfc_close, (uintptr_t)user_data);
 719         break;
 720
 721     case BTA_JV_RFCOMM_READ_EVT:
 722         APPL_TRACE_DEBUG0("BTA_JV_RFCOMM_READ_EVT not used");
 723         break;
 724
 725     case BTA_JV_RFCOMM_WRITE_EVT:
 726         on_rfc_write_done(&p_data->rfc_write, (uintptr_t)user_data);
 727         break;
 728
 729     case BTA_JV_RFCOMM_DATA_IND_EVT:
 730         APPL_TRACE_DEBUG0("BTA_JV_RFCOMM_DATA_IND_EVT not used");
 731         break;
 732
 733     case BTA_JV_RFCOMM_CONG_EVT:
 734         //on_rfc_cong(&p_data->rfc_cong);
 735         on_rfc_outgoing_congest(&p_data->rfc_cong, (uintptr_t)user_data);
 736         break;
 737     default:
 738         APPL_TRACE_ERROR2("unhandled event %d, slot id:%d", event, (uintptr_t)user_data);
 739         break;
 740     }
 741     return new_user_data;
 742 }
 743
 744 static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data)
 745 {
 746     uint32_t id = (uintptr_t)user_data;
 747     APPL_TRACE_DEBUG2("jv_dm_cback: event:%d, slot id:%d", event, id);
 748     switch(event)
 749     {
 750         case BTA_JV_CREATE_RECORD_EVT:
 751             {
 752                 lock_slot(&slot_lock);
 753                 rfc_slot_t* rs = find_rfc_slot_by_id(id, "jv_dm_cback: BTA_JV_CREATE_RECORD_EVT");
 754                 if(rs && create_server_sdp_record(rs))
 755                 {
 756                     //now start the rfcomm server after sdp & channel # assigned
 757                     BTA_JvRfcommStartServer(rs->security, rs->role, rs->scn, MAX_RFC_SESSION, rfcomm_cback,
 758                                             (void*)(uintptr_t)rs->id);
 759                 }
 760                 else if(rs)
 761                 {
 762                     APPL_TRACE_ERROR1("jv_dm_cback: cannot start server, slot found:%p", rs);
 763                     cleanup_rfc_slot(rs);
 764                 }
 765                 unlock_slot(&slot_lock);
 766                 break;
 767             }
 768         case BTA_JV_DISCOVERY_COMP_EVT:
 769             {
 770                 rfc_slot_t* rs = NULL;
 771                 lock_slot(&slot_lock);
 772                 if(p_data->disc_comp.status == BTA_JV_SUCCESS && p_data->disc_comp.scn)
 773                 {
 774                     APPL_TRACE_DEBUG3("BTA_JV_DISCOVERY_COMP_EVT, slot id:%d, status:%d, scn:%d",
 775                                       id, p_data->disc_comp.status, p_data->disc_comp.scn);
 776
 777                     rs = find_rfc_slot_by_id(id, "jv_dm_cback: BTA_JV_DISCOVERY_COMP_EVT");
 778                     if(rs && rs->f.doing_sdp_request)
 779                     {
 780                         if(BTA_JvRfcommConnect(rs->security, rs->role, p_data->disc_comp.scn, rs->addr.address,
 781                                     rfcomm_cback, (void*)(uintptr_t)rs->id) == BTA_JV_SUCCESS)
 782                         {
 783                             rs->scn = p_data->disc_comp.scn;
 784                             rs->f.doing_sdp_request = FALSE;
 785                             if(!send_app_scn(rs))
 786                                 cleanup_rfc_slot(rs);
 787                         }
 788                         else cleanup_rfc_slot(rs);
 789                     }
 790                     else if(rs)
 791                     {
 792                         APPL_TRACE_ERROR3("DISCOVERY_COMP_EVT no pending sdp request, slot id:%d, \
 793                                 flag sdp pending:%d, flag sdp doing:%d",
 794                                 id, rs->f.pending_sdp_request, rs->f.doing_sdp_request);
 795                     }
 796                 }
 797                 else
 798                 {
 799                     APPL_TRACE_ERROR3("DISCOVERY_COMP_EVT slot id:%d, failed to find channel, \
 800                                       status:%d, scn:%d", id, p_data->disc_comp.status,
 801                                       p_data->disc_comp.scn);
 802                     rs = find_rfc_slot_by_id(id, "jv_dm_cback: BTA_JV_DISCOVERY_COMP_EVT, no channel");
 803                     if(rs)
 804                         cleanup_rfc_slot(rs);
 805                 }
 806                 rs = find_rfc_slot_by_pending_sdp();
 807                 if(rs)
 808                 {
 809                     APPL_TRACE_DEBUG0("BTA_JV_DISCOVERY_COMP_EVT, start another pending scn sdp request");
 810                     tSDP_UUID sdp_uuid;
 811                     sdp_uuid.len = 16;
 812                     memcpy(sdp_uuid.uu.uuid128, rs->service_uuid, sizeof(sdp_uuid.uu.uuid128));
 813                     BTA_JvStartDiscovery((UINT8*)rs->addr.address, 1, &sdp_uuid, (void*)(uintptr_t)rs->id);
 814                     rs->f.pending_sdp_request = FALSE;
 815                     rs->f.doing_sdp_request = TRUE;
 816                 }
 817                 unlock_slot(&slot_lock);
 818                 break;
 819             }
 820         default:
 821             APPL_TRACE_DEBUG2("unhandled event:%d, slot id:%d", event, id);
 822             break;
 823     }
 824
 825 }
 826 #define SENT_ALL 2
 827 #define SENT_PARTIAL 1
 828 #define SENT_NONE 0
 829 #define SENT_FAILED (-1)
 830 static int send_data_to_app(int fd, BT_HDR *p_buf)
 831 {
 832     if(p_buf->len == 0)
 833         return SENT_ALL;
 834     int sent = send(fd, (UINT8 *)(p_buf + 1) + p_buf->offset,  p_buf->len, MSG_DONTWAIT);
 835     if(sent == p_buf->len)
 836         return SENT_ALL;
 837
 838     if(sent > 0 && sent < p_buf->len)
 839     {
 840         //sent partial
 841         APPL_TRACE_ERROR2("send partial, sent:%d, p_buf->len:%d", sent, p_buf->len);
 842         p_buf->offset += sent;
 843         p_buf->len -= sent;
 844         return SENT_PARTIAL;
 845
 846     }
 847     if(sent < 0 &&
 848         (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR))
 849     {
 850         APPL_TRACE_ERROR1("send none, EAGAIN or EWOULDBLOCK, errno:%d", errno);
 851         return SENT_NONE;
 852     }
 853     APPL_TRACE_ERROR3("unknown send() error, sent:%d, p_buf->len:%d,  errno:%d", sent, p_buf->len, errno);
 854     return SENT_FAILED;
 855 }
 856 static BOOLEAN flush_incoming_que_on_wr_signal(rfc_slot_t* rs)
 857 {
 858     while(!GKI_queue_is_empty(&rs->incoming_que))
 859     {
 860         BT_HDR *p_buf = GKI_dequeue(&rs->incoming_que);
 861         int sent = send_data_to_app(rs->fd, p_buf);
 862         switch(sent)
 863         {
 864             case SENT_NONE:
 865             case SENT_PARTIAL:
 866                 //add it back to the queue at same position
 867                 GKI_enqueue_head (&rs->incoming_que, p_buf);
 868                 //monitor the fd to get callback when app is ready to receive data
 869                 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, rs->id);
 870                 return TRUE;
 871             case SENT_ALL:
 872                 GKI_freebuf(p_buf);
 873                 break;
 874             case SENT_FAILED:
 875                 GKI_freebuf(p_buf);
 876                 return FALSE;
 877         }
 878     }
 879
 880     //app is ready to receive data, tell stack to start the data flow
 881     //fix me: need a jv flow control api to serialize the call in stack
 882     APPL_TRACE_DEBUG3("enable data flow, rfc_handle:0x%x, rfc_port_handle:0x%x, user_id:%d",
 883                         rs->rfc_handle, rs->rfc_port_handle, rs->id);
 884     extern int PORT_FlowControl_MaxCredit(UINT16 handle, BOOLEAN enable);
 885     PORT_FlowControl_MaxCredit(rs->rfc_port_handle, TRUE);
 886     return TRUE;
 887 }
 888 void btsock_rfc_signaled(int fd, int flags, uint32_t user_id)
 889 {
 890     lock_slot(&slot_lock);
 891     rfc_slot_t* rs = find_rfc_slot_by_id(user_id, "btsock_rfc_signaled");
 892     if(rs)
 893     {
 894         APPL_TRACE_DEBUG3("rfc slot id:%d, fd:%d, flags:%x", rs->id, fd, flags);
 895         BOOLEAN need_close = FALSE;
 896         if(flags & SOCK_THREAD_FD_RD)
 897         {
 898             //data available from app, tell stack we have outgoing data
 899             if(!rs->f.server)
 900             {
 901                 if(rs->f.connected)
 902                 {
 903                     int size = 0;
 904                     //make sure there's data pending in case the peer closed the socket
 905                     if(!(flags & SOCK_THREAD_FD_EXCEPTION) ||
 906                                 (ioctl(rs->fd, FIONREAD, &size) == 0 && size))
 907                         BTA_JvRfcommWrite(rs->rfc_handle, (UINT32)rs->id);
 908                 }
 909                 else
 910                 {
 911                     APPL_TRACE_ERROR2("SOCK_THREAD_FD_RD signaled when rfc is not connected, \
 912                                       slot id:%d, channel:%d", rs->id, rs->scn);
 913                     need_close = TRUE;
 914                 }
 915             }
 916         }
 917         if(flags & SOCK_THREAD_FD_WR)
 918         {
 919             //app is ready to receive more data, tell stack to enable the data flow
 920             if(!rs->f.connected || !flush_incoming_que_on_wr_signal(rs))
 921             {
 922                 need_close = TRUE;
 923                 APPL_TRACE_ERROR2("SOCK_THREAD_FD_WR signaled when rfc is not connected \
 924                                   or app closed fd, slot id:%d, channel:%d", rs->id, rs->scn);
 925             }
 926
 927         }
 928         if(need_close || (flags & SOCK_THREAD_FD_EXCEPTION))
 929         {
 930             int size = 0;
 931             if(need_close || ioctl(rs->fd, FIONREAD, &size) != 0 || size == 0 )
 932             {
 933                 //cleanup when no data pending
 934                 APPL_TRACE_DEBUG3("SOCK_THREAD_FD_EXCEPTION, cleanup, flags:%x, need_close:%d, pending size:%d",
 935                                 flags, need_close, size);
 936                 cleanup_rfc_slot(rs);
 937             }
 938             else
 939                 APPL_TRACE_DEBUG3("SOCK_THREAD_FD_EXCEPTION, cleanup pending, flags:%x, need_close:%d, pending size:%d",
 940                                 flags, need_close, size);
 941         }
 942     }
 943     unlock_slot(&slot_lock);
 944 }
 945
 946 int bta_co_rfc_data_incoming(void *user_data, BT_HDR *p_buf)
 947 {
 948     uint32_t id = (uintptr_t)user_data;
 949     int ret = 0;
 950     lock_slot(&slot_lock);
 951     rfc_slot_t* rs = find_rfc_slot_by_id(id, "bta_co_rfc_data_incoming");
 952     if(rs)
 953     {
 954         if(!GKI_queue_is_empty(&rs->incoming_que))
 955             GKI_enqueue(&rs->incoming_que, p_buf);
 956         else
 957         {
 958             int sent = send_data_to_app(rs->fd, p_buf);
 959             switch(sent)
 960             {
 961                 case SENT_NONE:
 962                 case SENT_PARTIAL:
 963                     //add it to the end of the queue
 964                     GKI_enqueue(&rs->incoming_que, p_buf);
 965                     //monitor the fd to get callback when app is ready to receive data
 966                     btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, rs->id);
 967                     break;
 968                 case SENT_ALL:
 969                     GKI_freebuf(p_buf);
 970                     ret = 1;//enable the data flow
 971                     break;
 972                 case SENT_FAILED:
 973                     GKI_freebuf(p_buf);
 974                     cleanup_rfc_slot(rs);
 975                     break;
 976             }
 977         }
 978      }
 979     unlock_slot(&slot_lock);
 980     return ret;//return 0 to disable data flow
 981 }
 982 int bta_co_rfc_data_outgoing_size(void *user_data, int *size)
 983 {
 984     uint32_t id = (uintptr_t)user_data;
 985     int ret = FALSE;
 986     *size = 0;
 987     lock_slot(&slot_lock);
 988     rfc_slot_t* rs = find_rfc_slot_by_id(id, "bta_co_rfc_data_outgoing_size");
 989     if(rs)
 990     {
 991         if(ioctl(rs->fd, FIONREAD, size) == 0)
 992         {
 993             APPL_TRACE_DEBUG2("ioctl read avaiable size:%d, fd:%d", *size, rs->fd);
 994             ret = TRUE;
 995         }
 996         else
 997         {
 998             APPL_TRACE_ERROR2("ioctl FIONREAD error, errno:%d, fd:%d", errno, rs->fd);
 999             cleanup_rfc_slot(rs);
1000         }
1001     }
1002     else APPL_TRACE_ERROR1("bta_co_rfc_data_outgoing_size, invalid slot id:%d", id);
1003     unlock_slot(&slot_lock);
1004     return ret;
1005 }
1006 int bta_co_rfc_data_outgoing(void *user_data, UINT8* buf, UINT16 size)
1007 {
1008     uint32_t id = (uintptr_t)user_data;
1009     int ret = FALSE;
1010     lock_slot(&slot_lock);
1011     rfc_slot_t* rs = find_rfc_slot_by_id(id, "bta_co_rfc_data_outgoing");
1012     if(rs)
1013     {
1014         int received = recv(rs->fd, buf, size, 0);
1015         if(received == size)
1016             ret = TRUE;
1017         else
1018         {
1019             APPL_TRACE_ERROR4("recv error, errno:%d, fd:%d, size:%d, received:%d",
1020                              errno, rs->fd, size, received);
1021             cleanup_rfc_slot(rs);
1022         }
1023     }
1024     else APPL_TRACE_ERROR1("bta_co_rfc_data_outgoing, invalid slot id:%d", id);
1025     unlock_slot(&slot_lock);
1026     return ret;
1027 }