bta/jv/bta_jv_act.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2006-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 action functions for BTA JV APIs.
  22  *
  23  ******************************************************************************/
  24 #include <hardware/bluetooth.h>
  25 #include <arpa/inet.h>
  26
  27 #include "bt_types.h"
  28 #include "gki.h"
  29 #include "bd.h"
  30 #include "utl.h"
  31 #include "bta_sys.h"
  32 #include "bta_api.h"
  33 #include "bta_jv_api.h"
  34 #include "bta_jv_int.h"
  35 #include "bta_jv_co.h"
  36 #include "btm_api.h"
  37 #include "btm_int.h"
  38 #include "sdp_api.h"
  39 #include "l2c_api.h"
  40 #include "port_api.h"
  41 #include <string.h>
  42 #include "rfcdefs.h"
  43 #include "avct_api.h"
  44 #include "avdt_api.h"
  45 #include "gap_api.h"
  46
  47
  48 #define HDL2CB(handle) \
  49     UINT32  __hi = ((handle) & BTA_JV_RFC_HDL_MASK) - 1; \
  50     UINT32  __si = BTA_JV_RFC_HDL_TO_SIDX(handle); \
  51     tBTA_JV_RFC_CB  *p_cb = &bta_jv_cb.rfc_cb[__hi]; \
  52     tBTA_JV_PCB   *p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[__si] - 1]
  53
  54 extern void uuid_to_string(bt_uuid_t *p_uuid, char *str);
  55 static inline void logu(const char* title, const uint8_t * p_uuid)
  56 {
  57     char uuids[128];
  58     uuid_to_string((bt_uuid_t*)p_uuid, uuids);
  59     APPL_TRACE_DEBUG("%s: %s", title, uuids);
  60 }
  61
  62
  63 static tBTA_JV_PCB * bta_jv_add_rfc_port(tBTA_JV_RFC_CB *p_cb, tBTA_JV_PCB *p_pcb_open);
  64 static tBTA_JV_STATUS bta_jv_free_set_pm_profile_cb(UINT32 jv_handle);
  65 static void bta_jv_pm_conn_busy(tBTA_JV_PM_CB *p_cb);
  66 static void bta_jv_pm_conn_idle(tBTA_JV_PM_CB *p_cb);
  67 static void bta_jv_pm_state_change(tBTA_JV_PM_CB *p_cb, const tBTA_JV_CONN_STATE state);
  68 tBTA_JV_STATUS bta_jv_set_pm_conn_state(tBTA_JV_PM_CB *p_cb, const tBTA_JV_CONN_STATE
  69         new_st);
  70
  71 /*******************************************************************************
  72 **
  73 ** Function     bta_jv_get_local_device_addr_cback
  74 **
  75 ** Description  Callback from btm after local bdaddr is read
  76 **
  77 ** Returns      void
  78 **
  79 *******************************************************************************/
  80 static void bta_jv_get_local_device_addr_cback(BD_ADDR bd_addr)
  81 {
  82     if(bta_jv_cb.p_dm_cback)
  83         bta_jv_cb.p_dm_cback(BTA_JV_LOCAL_ADDR_EVT, (tBTA_JV *)bd_addr, 0);
  84 }
  85
  86 /*******************************************************************************
  87 **
  88 ** Function     bta_jv_get_remote_device_name_cback
  89 **
  90 ** Description  Callback from btm after remote name is read
  91 **
  92 ** Returns      void
  93 **
  94 *******************************************************************************/
  95 static void bta_jv_get_remote_device_name_cback(tBTM_REMOTE_DEV_NAME *p_name)
  96 {
  97     tBTA_JV evt_data;
  98     evt_data.p_name = p_name->remote_bd_name;
  99     if(bta_jv_cb.p_dm_cback)
 100         bta_jv_cb.p_dm_cback(BTA_JV_REMOTE_NAME_EVT, &evt_data, 0);
 101 }
 102
 103 /*******************************************************************************
 104 **
 105 ** Function     bta_jv_alloc_sec_id
 106 **
 107 ** Description  allocate a security id
 108 **
 109 ** Returns
 110 **
 111 *******************************************************************************/
 112 UINT8 bta_jv_alloc_sec_id(void)
 113 {
 114     UINT8 ret = 0;
 115     int i;
 116     for(i=0; i<BTA_JV_NUM_SERVICE_ID; i++)
 117     {
 118         if(0 == bta_jv_cb.sec_id[i])
 119         {
 120             bta_jv_cb.sec_id[i] = BTA_JV_FIRST_SERVICE_ID + i;
 121             ret = bta_jv_cb.sec_id[i];
 122             break;
 123         }
 124     }
 125     return ret;
 126
 127 }
 128 static int get_sec_id_used(void)
 129 {
 130     int i;
 131     int used = 0;
 132     for(i=0; i<BTA_JV_NUM_SERVICE_ID; i++)
 133     {
 134         if(bta_jv_cb.sec_id[i])
 135             used++;
 136     }
 137     if (used == BTA_JV_NUM_SERVICE_ID)
 138         APPL_TRACE_ERROR("get_sec_id_used, sec id exceeds the limit:%d",
 139                 BTA_JV_NUM_SERVICE_ID);
 140     return used;
 141 }
 142 static int get_rfc_cb_used(void)
 143 {
 144     int i;
 145     int used = 0;
 146     for(i=0; i<BTA_JV_MAX_RFC_CONN; i++)
 147     {
 148         if(bta_jv_cb.rfc_cb[i].handle )
 149             used++;
 150     }
 151     if (used == BTA_JV_MAX_RFC_CONN)
 152         APPL_TRACE_ERROR("get_sec_id_used, rfc ctrl block exceeds the limit:%d",
 153                 BTA_JV_MAX_RFC_CONN);
 154     return used;
 155 }
 156
 157 /*******************************************************************************
 158 **
 159 ** Function     bta_jv_free_sec_id
 160 **
 161 ** Description  free the given security id
 162 **
 163 ** Returns
 164 **
 165 *******************************************************************************/
 166 static void bta_jv_free_sec_id(UINT8 *p_sec_id)
 167 {
 168     UINT8 sec_id = *p_sec_id;
 169     *p_sec_id = 0;
 170     if(sec_id >= BTA_JV_FIRST_SERVICE_ID && sec_id <= BTA_JV_LAST_SERVICE_ID)
 171     {
 172         BTM_SecClrService(sec_id);
 173         bta_jv_cb.sec_id[sec_id - BTA_JV_FIRST_SERVICE_ID] = 0;
 174     }
 175 }
 176
 177 /*******************************************************************************
 178 **
 179 ** Function     bta_jv_alloc_rfc_cb
 180 **
 181 ** Description  allocate a control block for the given port handle
 182 **
 183 ** Returns
 184 **
 185 *******************************************************************************/
 186 tBTA_JV_RFC_CB * bta_jv_alloc_rfc_cb(UINT16 port_handle, tBTA_JV_PCB **pp_pcb)
 187 {
 188     tBTA_JV_RFC_CB *p_cb = NULL;
 189     tBTA_JV_PCB *p_pcb;
 190     int i, j;
 191     for(i=0; i<BTA_JV_MAX_RFC_CONN; i++)
 192     {
 193         if (0 == bta_jv_cb.rfc_cb[i].handle )
 194         {
 195             p_cb = &bta_jv_cb.rfc_cb[i];
 196             /* mask handle to distinguish it with L2CAP handle */
 197             p_cb->handle = (i + 1) | BTA_JV_RFCOMM_MASK;
 198
 199             p_cb->max_sess          = 1;
 200             p_cb->curr_sess         = 1;
 201             for (j = 0; j < BTA_JV_MAX_RFC_SR_SESSION; j++)
 202                 p_cb->rfc_hdl[j] = 0;
 203             p_cb->rfc_hdl[0]        = port_handle;
 204             APPL_TRACE_DEBUG( "bta_jv_alloc_rfc_cb port_handle:%d handle:0x%2x",
 205                     port_handle, p_cb->handle);
 206
 207             p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
 208             p_pcb->handle = p_cb->handle;
 209             p_pcb->port_handle = port_handle;
 210             p_pcb->p_pm_cb = NULL;
 211             *pp_pcb = p_pcb;
 212             break;
 213         }
 214     }
 215     if(p_cb == NULL)
 216     {
 217         APPL_TRACE_ERROR( "bta_jv_alloc_rfc_cb: port_handle:%d, ctrl block exceeds "
 218                 "limit:%d", port_handle, BTA_JV_MAX_RFC_CONN);
 219     }
 220     return p_cb;
 221 }
 222
 223 /*******************************************************************************
 224 **
 225 ** Function     bta_jv_rfc_port_to_pcb
 226 **
 227 ** Description  find the port control block associated with the given port handle
 228 **
 229 ** Returns
 230 **
 231 *******************************************************************************/
 232 tBTA_JV_PCB * bta_jv_rfc_port_to_pcb(UINT16 port_handle)
 233 {
 234     tBTA_JV_PCB *p_pcb = NULL;
 235
 236     if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS)
 237             && bta_jv_cb.port_cb[port_handle - 1].handle)
 238     {
 239         p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
 240     }
 241
 242     return p_pcb;
 243 }
 244
 245 /*******************************************************************************
 246 **
 247 ** Function     bta_jv_rfc_port_to_cb
 248 **
 249 ** Description  find the RFCOMM control block associated with the given port handle
 250 **
 251 ** Returns
 252 **
 253 *******************************************************************************/
 254 tBTA_JV_RFC_CB * bta_jv_rfc_port_to_cb(UINT16 port_handle)
 255 {
 256     tBTA_JV_RFC_CB *p_cb = NULL;
 257     UINT32 handle;
 258
 259     if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS)
 260             && bta_jv_cb.port_cb[port_handle - 1].handle)
 261     {
 262         handle = bta_jv_cb.port_cb[port_handle - 1].handle;
 263         handle &= BTA_JV_RFC_HDL_MASK;
 264         handle &= ~BTA_JV_RFCOMM_MASK;
 265         if (handle)
 266             p_cb = &bta_jv_cb.rfc_cb[handle - 1];
 267     }
 268     else
 269     {
 270         APPL_TRACE_WARNING("bta_jv_rfc_port_to_cb(port_handle:0x%x):jv handle:0x%x not"
 271                 " FOUND", port_handle, bta_jv_cb.port_cb[port_handle - 1].handle);
 272     }
 273     return p_cb;
 274 }
 275
 276 static tBTA_JV_STATUS bta_jv_free_rfc_cb(tBTA_JV_RFC_CB *p_cb, tBTA_JV_PCB *p_pcb)
 277 {
 278     tBTA_JV_STATUS status = BTA_JV_SUCCESS;
 279     BOOLEAN remove_server = FALSE;
 280     int close_pending = 0;
 281
 282     if (!p_cb || !p_pcb)
 283     {
 284         APPL_TRACE_ERROR("bta_jv_free_sr_rfc_cb, p_cb or p_pcb cannot be null");
 285         return BTA_JV_FAILURE;
 286     }
 287     APPL_TRACE_DEBUG("bta_jv_free_sr_rfc_cb: max_sess:%d, curr_sess:%d, p_pcb:%p, user:"
 288             "%p, state:%d, jv handle: 0x%x" ,p_cb->max_sess, p_cb->curr_sess, p_pcb,
 289             p_pcb->user_data, p_pcb->state, p_pcb->handle);
 290
 291     if (p_cb->curr_sess <= 0)
 292         return BTA_JV_SUCCESS;
 293
 294     switch (p_pcb->state)
 295     {
 296     case BTA_JV_ST_CL_CLOSING:
 297     case BTA_JV_ST_SR_CLOSING:
 298         APPL_TRACE_WARNING("bta_jv_free_sr_rfc_cb: return on closing, port state:%d, "
 299                 "scn:%d, p_pcb:%p, user_data:%p", p_pcb->state, p_cb->scn, p_pcb,
 300                 p_pcb->user_data);
 301         status = BTA_JV_FAILURE;
 302         return status;
 303     case BTA_JV_ST_CL_OPEN:
 304     case BTA_JV_ST_CL_OPENING:
 305         APPL_TRACE_DEBUG("bta_jv_free_sr_rfc_cb: state: %d, scn:%d,"
 306                           " user_data:%p", p_pcb->state, p_cb->scn, p_pcb->user_data);
 307         p_pcb->state = BTA_JV_ST_CL_CLOSING;
 308         break;
 309     case BTA_JV_ST_SR_LISTEN:
 310         p_pcb->state = BTA_JV_ST_SR_CLOSING;
 311         remove_server = TRUE;
 312         APPL_TRACE_DEBUG("bta_jv_free_sr_rfc_cb: state: BTA_JV_ST_SR_LISTEN, scn:%d,"
 313                 " user_data:%p", p_cb->scn, p_pcb->user_data);
 314         break;
 315     case BTA_JV_ST_SR_OPEN:
 316         p_pcb->state = BTA_JV_ST_SR_CLOSING;
 317         APPL_TRACE_DEBUG("bta_jv_free_sr_rfc_cb: state: BTA_JV_ST_SR_OPEN, scn:%d,"
 318                 " user_data:%p", p_cb->scn, p_pcb->user_data);
 319         break;
 320     default:
 321         APPL_TRACE_WARNING("bta_jv_free_sr_rfc_cb():failed, ignore port state:%d, scn:"
 322                 "%d, p_pcb:%p, jv handle: 0x%x, port_handle: %d, user_data:%p",
 323                 p_pcb->state, p_cb->scn, p_pcb, p_pcb->handle, p_pcb->port_handle,
 324                 p_pcb->user_data);
 325         status = BTA_JV_FAILURE;
 326         break;
 327     }
 328     if (BTA_JV_SUCCESS == status)
 329     {
 330         int port_status;
 331
 332         if (!remove_server)
 333             port_status = RFCOMM_RemoveConnection(p_pcb->port_handle);
 334         else
 335             port_status = RFCOMM_RemoveServer(p_pcb->port_handle);
 336         if (port_status != PORT_SUCCESS)
 337         {
 338             status = BTA_JV_FAILURE;
 339             APPL_TRACE_WARNING("bta_jv_free_rfc_cb(jv handle: 0x%x, state %d)::"
 340                     "port_status: %d, port_handle: %d, close_pending: %d:Remove",
 341                     p_pcb->handle, p_pcb->state, port_status, p_pcb->port_handle,
 342                     close_pending);
 343         }
 344     }
 345     if (!close_pending)
 346     {
 347         p_pcb->port_handle = 0;
 348         p_pcb->state = BTA_JV_ST_NONE;
 349         bta_jv_free_set_pm_profile_cb(p_pcb->handle);
 350
 351         //Initialize congestion flags
 352         p_pcb->cong = FALSE;
 353         p_pcb->user_data = 0;
 354         int si = BTA_JV_RFC_HDL_TO_SIDX(p_pcb->handle);
 355         if (0 <= si && si < BTA_JV_MAX_RFC_SR_SESSION)
 356             p_cb->rfc_hdl[si] = 0;
 357         p_pcb->handle = 0;
 358         p_cb->curr_sess--;
 359         if (p_cb->curr_sess == 0)
 360         {
 361             p_cb->scn = 0;
 362             bta_jv_free_sec_id(&p_cb->sec_id);
 363             p_cb->p_cback = NULL;
 364             p_cb->handle = 0;
 365             p_cb->curr_sess = -1;
 366         }
 367     }
 368     return status;
 369 }
 370
 371 /*******************************************************************************
 372 **
 373 ** Function     bta_jv_free_l2c_cb
 374 **
 375 ** Description  free the given L2CAP control block
 376 **
 377 ** Returns
 378 **
 379 *******************************************************************************/
 380 tBTA_JV_STATUS bta_jv_free_l2c_cb(tBTA_JV_L2C_CB *p_cb)
 381 {
 382     UNUSED(p_cb);
 383 #if 0
 384     tBTA_JV_STATUS status = BTA_JV_SUCCESS;
 385
 386     if(BTA_JV_ST_NONE != p_cb->state)
 387     {
 388 #if SDP_FOR_JV_INCLUDED == TRUE
 389         if(BTA_JV_L2C_FOR_SDP_HDL == p_cb->handle)
 390         {
 391             bta_jv_cb.sdp_data_size = 0;
 392             if(SDP_ConnClose(bta_jv_cb.sdp_for_jv))
 393             {
 394                 bta_jv_cb.sdp_for_jv = 0;
 395             }
 396             else
 397                 status = BTA_JV_FAILURE;
 398         }
 399         else
 400 #endif
 401         {
 402             bta_jv_free_set_pm_profile_cb((UINT32)p_cb->handle);
 403             if (GAP_ConnClose(p_cb->handle) != BT_PASS)
 404                 status = BTA_JV_FAILURE;
 405         }
 406     }
 407     p_cb->psm = 0;
 408     p_cb->state = BTA_JV_ST_NONE;
 409     bta_jv_free_sec_id(&p_cb->sec_id);
 410     p_cb->p_cback = NULL;
 411     return status;
 412 #endif
 413     return 0;
 414 }
 415
 416 /*******************************************************************************
 417  **
 418  ** Function    bta_jv_clear_pm_cb
 419  **
 420  ** Description clears jv pm control block and optionally calls bta_sys_conn_close()
 421  **             In general close_conn should be set to TRUE to remove registering with
 422  **             dm pm!
 423  **
 424  ** WARNING:    Make sure to clear pointer form port or l2c to this control block too!
 425  **
 426  *******************************************************************************/
 427 static void bta_jv_clear_pm_cb(tBTA_JV_PM_CB *p_pm_cb, BOOLEAN close_conn)
 428 {
 429     /* needs to be called if registered with bta pm, otherwise we may run out of dm pm slots! */
 430     if (close_conn)
 431         bta_sys_conn_close(BTA_ID_JV, p_pm_cb->app_id, p_pm_cb->peer_bd_addr);
 432     p_pm_cb->state = BTA_JV_PM_FREE_ST;
 433     p_pm_cb->app_id = BTA_JV_PM_ALL;
 434     p_pm_cb->handle = BTA_JV_PM_HANDLE_CLEAR;
 435     bdcpy(p_pm_cb->peer_bd_addr, bd_addr_null);
 436 }
 437
 438 /*******************************************************************************
 439  **
 440  ** Function     bta_jv_free_set_pm_profile_cb
 441  **
 442  ** Description  free pm profile control block
 443  **
 444  ** Returns     BTA_JV_SUCCESS if cb has been freed correctly,
 445  **             BTA_JV_FAILURE in case of no profile has been registered or already freed
 446  **
 447  *******************************************************************************/
 448 static tBTA_JV_STATUS bta_jv_free_set_pm_profile_cb(UINT32 jv_handle)
 449 {
 450     tBTA_JV_STATUS status = BTA_JV_FAILURE;
 451     tBTA_JV_PM_CB  **p_cb;
 452     int i, j, bd_counter = 0, appid_counter = 0;
 453
 454     for (i = 0; i < BTA_JV_PM_MAX_NUM; i++)
 455     {
 456         p_cb = NULL;
 457         if ((bta_jv_cb.pm_cb[i].state != BTA_JV_PM_FREE_ST) &&
 458                 (jv_handle == bta_jv_cb.pm_cb[i].handle))
 459         {
 460             for (j = 0; j < BTA_JV_PM_MAX_NUM; j++)
 461             {
 462                 if (bdcmp(bta_jv_cb.pm_cb[j].peer_bd_addr, bta_jv_cb.pm_cb[i].peer_bd_addr) == 0)
 463                     bd_counter++;
 464                 if (bta_jv_cb.pm_cb[j].app_id == bta_jv_cb.pm_cb[i].app_id)
 465                     appid_counter++;
 466             }
 467
 468             APPL_TRACE_API("bta_jv_free_set_pm_profile_cb(jv_handle: 0x%2x), idx: %d, "
 469                     "app_id: 0x%x", jv_handle, i, bta_jv_cb.pm_cb[i].app_id);
 470             APPL_TRACE_API("bta_jv_free_set_pm_profile_cb, bd_counter = %d, "
 471                     "appid_counter = %d", bd_counter, appid_counter);
 472             if (bd_counter > 1)
 473             {
 474                 bta_jv_pm_conn_idle(&bta_jv_cb.pm_cb[i]);
 475             }
 476
 477             if (bd_counter <= 1 || (appid_counter <= 1))
 478             {
 479                 bta_jv_clear_pm_cb(&bta_jv_cb.pm_cb[i], TRUE);
 480             }
 481             else
 482             {
 483                 bta_jv_clear_pm_cb(&bta_jv_cb.pm_cb[i], FALSE);
 484             }
 485
 486             if (BTA_JV_RFCOMM_MASK & jv_handle)
 487             {
 488                 UINT32 hi = ((jv_handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
 489                 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(jv_handle);
 490                 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback && si
 491                         < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si])
 492                 {
 493                     tBTA_JV_PCB *p_pcb = bta_jv_rfc_port_to_pcb(bta_jv_cb.rfc_cb[hi].rfc_hdl[si]);
 494                     if (p_pcb)
 495                     {
 496                         if (NULL == p_pcb->p_pm_cb)
 497                             APPL_TRACE_WARNING("bta_jv_free_set_pm_profile_cb(jv_handle:"
 498                                     " 0x%x):port_handle: 0x%x, p_pm_cb: %d: no link to "
 499                                     "pm_cb?", jv_handle, p_pcb->port_handle, i);
 500                         p_cb = &p_pcb->p_pm_cb;
 501                     }
 502                 }
 503             }
 504             else
 505             {
 506                 if (jv_handle < BTA_JV_MAX_L2C_CONN)
 507                 {
 508                     tBTA_JV_L2C_CB *p_l2c_cb = &bta_jv_cb.l2c_cb[jv_handle];
 509                     if (NULL == p_l2c_cb->p_pm_cb)
 510                         APPL_TRACE_WARNING("bta_jv_free_set_pm_profile_cb(jv_handle: "
 511                                 "0x%x): p_pm_cb: %d: no link to pm_cb?", jv_handle, i);
 512                     p_cb = &p_l2c_cb->p_pm_cb;
 513                 }
 514             }
 515             if (p_cb)
 516             {
 517                 *p_cb = NULL;
 518                 status = BTA_JV_SUCCESS;
 519             }
 520         }
 521     }
 522     return status;
 523 }
 524
 525 /*******************************************************************************
 526  **
 527  ** Function    bta_jv_alloc_set_pm_profile_cb
 528  **
 529  ** Description set PM profile control block
 530  **
 531  ** Returns     pointer to allocated cb or NULL in case of failure
 532  **
 533  *******************************************************************************/
 534 static tBTA_JV_PM_CB *bta_jv_alloc_set_pm_profile_cb(UINT32 jv_handle, tBTA_JV_PM_ID app_id)
 535 {
 536     BOOLEAN bRfcHandle = (jv_handle & BTA_JV_RFCOMM_MASK) != 0;
 537     BD_ADDR peer_bd_addr;
 538     int i, j;
 539     tBTA_JV_PM_CB **pp_cb;
 540
 541     for (i = 0; i < BTA_JV_PM_MAX_NUM; i++)
 542     {
 543         pp_cb = NULL;
 544         if (bta_jv_cb.pm_cb[i].state == BTA_JV_PM_FREE_ST)
 545         {
 546             /* rfc handle bd addr retrieval requires core stack handle */
 547             if (bRfcHandle)
 548             {
 549                 UINT32 hi = ((jv_handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
 550                 UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(jv_handle);
 551                 for (j = 0; j < BTA_JV_MAX_RFC_CONN; j++)
 552                 {
 553                     if (jv_handle == bta_jv_cb.port_cb[j].handle)
 554                     {
 555                         pp_cb = &bta_jv_cb.port_cb[j].p_pm_cb;
 556                         if (PORT_SUCCESS != PORT_CheckConnection(
 557                                 bta_jv_cb.port_cb[j].port_handle, peer_bd_addr, NULL))
 558                             i = BTA_JV_PM_MAX_NUM;
 559                         break;
 560                     }
 561                 }
 562             }
 563             else
 564             {
 565                 /* use jv handle for l2cap bd address retrieval */
 566                 for (j = 0; j < BTA_JV_MAX_L2C_CONN; j++)
 567                 {
 568                     if (jv_handle == bta_jv_cb.l2c_cb[j].handle)
 569                     {
 570                         pp_cb = &bta_jv_cb.l2c_cb[j].p_pm_cb;
 571                         UINT8 *p_bd_addr = GAP_ConnGetRemoteAddr((UINT16)jv_handle);
 572                         if (NULL != p_bd_addr)
 573                             bdcpy(peer_bd_addr, p_bd_addr);
 574                         else
 575                             i = BTA_JV_PM_MAX_NUM;
 576                         break;
 577                     }
 578                 }
 579             }
 580             APPL_TRACE_API("bta_jv_alloc_set_pm_profile_cb(handle 0x%2x, app_id %d): "
 581                     "idx: %d, (BTA_JV_PM_MAX_NUM: %d), pp_cb: 0x%x", jv_handle, app_id,
 582                     i, BTA_JV_PM_MAX_NUM, pp_cb);
 583             break;
 584         }
 585     }
 586
 587     if ((i != BTA_JV_PM_MAX_NUM) && (NULL != pp_cb))
 588     {
 589         *pp_cb = &bta_jv_cb.pm_cb[i];
 590         bta_jv_cb.pm_cb[i].handle = jv_handle;
 591         bta_jv_cb.pm_cb[i].app_id = app_id;
 592         bdcpy(bta_jv_cb.pm_cb[i].peer_bd_addr, peer_bd_addr);
 593         bta_jv_cb.pm_cb[i].state = BTA_JV_PM_IDLE_ST;
 594         return &bta_jv_cb.pm_cb[i];
 595     }
 596     APPL_TRACE_WARNING("bta_jv_alloc_set_pm_profile_cb(jv_handle: 0x%x, app_id: %d) "
 597             "return NULL", jv_handle, app_id);
 598     return (tBTA_JV_PM_CB *)NULL;
 599 }
 600
 601 /*******************************************************************************
 602  **
 603  ** Function     bta_jv_alloc_sdp_id
 604  **
 605  ** Description  allocate a SDP id for the given SDP record handle
 606  **
 607  ** Returns
 608  **
 609  *******************************************************************************/
 610 UINT32 bta_jv_alloc_sdp_id(UINT32 sdp_handle)
 611 {
 612     int j;
 613     UINT32 id = 0;
 614
 615     /* find a free entry */
 616     for (j = 0; j < BTA_JV_MAX_SDP_REC; j++)
 617     {
 618         if (bta_jv_cb.sdp_handle[j] == 0)
 619         {
 620             bta_jv_cb.sdp_handle[j] = sdp_handle;
 621             id = (UINT32)(j + 1);
 622             break;
 623         }
 624     }
 625     /* the SDP record handle reported is the (index + 1) to control block */
 626     return id;
 627 }
 628
 629 /*******************************************************************************
 630 **
 631 ** Function     bta_jv_free_sdp_id
 632 **
 633 ** Description  free the sdp id
 634 **
 635 ** Returns
 636 **
 637 *******************************************************************************/
 638 void bta_jv_free_sdp_id(UINT32 sdp_id)
 639 {
 640     if(sdp_id > 0 && sdp_id <= BTA_JV_MAX_SDP_REC)
 641     {
 642         bta_jv_cb.sdp_handle[sdp_id - 1] = 0;
 643     }
 644 }
 645
 646 /*******************************************************************************
 647 **
 648 ** Function     bta_jv_get_sdp_handle
 649 **
 650 ** Description  find the SDP handle associated with the given sdp id
 651 **
 652 ** Returns
 653 **
 654 *******************************************************************************/
 655 UINT32 bta_jv_get_sdp_handle(UINT32 sdp_id)
 656 {
 657     UINT32 sdp_handle = 0;
 658
 659     if(sdp_id > 0 && sdp_id <= BTA_JV_MAX_SDP_REC)
 660     {
 661         sdp_handle = bta_jv_cb.sdp_handle[sdp_id - 1];
 662     }
 663     return sdp_handle;
 664 }
 665
 666 /*******************************************************************************
 667 **
 668 ** Function     bta_jv_check_psm
 669 **
 670 ** Description  for now use only the legal PSM per JSR82 spec
 671 **
 672 ** Returns      TRUE, if allowed
 673 **
 674 *******************************************************************************/
 675 BOOLEAN bta_jv_check_psm(UINT16 psm)
 676 {
 677     BOOLEAN ret = FALSE;
 678
 679     if(L2C_IS_VALID_PSM(psm) )
 680     {
 681         if(psm < 0x1001)
 682         {
 683             /* see if this is defined by spec */
 684             switch(psm)
 685             {
 686             case SDP_PSM:           /* 1 */
 687             case BT_PSM_RFCOMM:     /* 3 */
 688                 /* do not allow java app to use these 2 PSMs */
 689                 break;
 690
 691             case TCS_PSM_INTERCOM:  /* 5 */
 692             case TCS_PSM_CORDLESS:  /* 7 */
 693                 if( FALSE == bta_sys_is_register(BTA_ID_CT) &&
 694                     FALSE == bta_sys_is_register(BTA_ID_CG) )
 695                     ret = TRUE;
 696                 break;
 697
 698             case BT_PSM_BNEP:       /* F */
 699                 if(FALSE == bta_sys_is_register(BTA_ID_PAN))
 700                     ret = TRUE;
 701                 break;
 702
 703             case HID_PSM_CONTROL:   /* 0x11 */
 704             case HID_PSM_INTERRUPT: /* 0x13 */
 705                 //FIX: allow HID Device and HID Host to coexist
 706                 if( FALSE == bta_sys_is_register(BTA_ID_HD) ||
 707                     FALSE == bta_sys_is_register(BTA_ID_HH) )
 708                     ret = TRUE;
 709                 break;
 710
 711             case AVCT_PSM:          /* 0x17 */
 712             case AVDT_PSM:          /* 0x19 */
 713                 if ((FALSE == bta_sys_is_register(BTA_ID_AV)) &&
 714                    (FALSE == bta_sys_is_register(BTA_ID_AVK)))
 715                     ret = TRUE;
 716                 break;
 717
 718             default:
 719                 ret = TRUE;
 720                 break;
 721             }
 722         }
 723         else
 724             ret = TRUE;
 725     }
 726     return ret;
 727
 728 }
 729
 730 /*******************************************************************************
 731 **
 732 ** Function     bta_jv_enable
 733 **
 734 ** Description  Initialises the JAVA I/F
 735 **
 736 ** Returns      void
 737 **
 738 *******************************************************************************/
 739 void bta_jv_enable(tBTA_JV_MSG *p_data)
 740 {
 741     tBTA_JV_STATUS status = BTA_JV_SUCCESS;
 742     bta_jv_cb.p_dm_cback = p_data->enable.p_cback;
 743     bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, (tBTA_JV *)&status, 0);
 744 }
 745
 746 /*******************************************************************************
 747 **
 748 ** Function     bta_jv_disable
 749 **
 750 ** Description  Disables the BT device manager
 751 **              free the resources used by java
 752 **
 753 ** Returns      void
 754 **
 755 *******************************************************************************/
 756 void bta_jv_disable (tBTA_JV_MSG *p_data)
 757 {
 758     UNUSED(p_data);
 759
 760     APPL_TRACE_ERROR("bta_jv_disable not used");
 761 #if 0
 762     int i;
 763
 764     bta_jv_cb.p_dm_cback = NULL;
 765     /* delete the SDP records created by java apps */
 766     for(i=0; i<BTA_JV_MAX_SDP_REC; i++)
 767     {
 768         if(bta_jv_cb.sdp_handle[i])
 769         {
 770             APPL_TRACE_DEBUG( "delete SDP record: %d", bta_jv_cb.sdp_handle[i]);
 771             SDP_DeleteRecord(bta_jv_cb.sdp_handle[i]);
 772             bta_jv_cb.sdp_handle[i] = 0;
 773         }
 774     }
 775
 776     /* free the SCNs allocated by java apps */
 777     for(i=0; i<BTA_JV_MAX_SCN; i++)
 778     {
 779         if(bta_jv_cb.scn[i])
 780         {
 781             APPL_TRACE_DEBUG( "free scn: %d", (i+1));
 782             BTM_FreeSCN((UINT8)(i+1));
 783             bta_jv_cb.scn[i] = FALSE;
 784         }
 785     }
 786
 787     /* disconnect L2CAP connections */
 788     for(i=0; i<BTA_JV_MAX_L2C_CONN; i++)
 789     {
 790         bta_jv_free_l2c_cb(&bta_jv_cb.l2c_cb[i]);
 791     }
 792
 793     /* disconnect RFCOMM connections */
 794     for(i=0; i<BTA_JV_MAX_RFC_CONN; i++)
 795     {
 796         bta_jv_free_rfc_cb(&bta_jv_cb.rfc_cb[i]);
 797     }
 798
 799     /* free the service records allocated by java apps */
 800     for(i=0; i<BTA_JV_NUM_SERVICE_ID; i++)
 801     {
 802         if(bta_jv_cb.sec_id[i])
 803         {
 804             BTM_SecClrService(bta_jv_cb.sec_id[i]);
 805             bta_jv_cb.sec_id[i] = 0;
 806         }
 807     }
 808 #endif
 809 }
 810
 811 /*******************************************************************************
 812 **
 813 ** Function     bta_jv_set_discoverability
 814 **
 815 ** Description  Sets discoverability
 816 **
 817 ** Returns      void
 818 **
 819 *******************************************************************************/
 820 void bta_jv_set_discoverability (tBTA_JV_MSG *p_data)
 821 {
 822     tBTA_JV     evt_data;
 823
 824     evt_data.set_discover.status = BTA_JV_FAILURE;
 825     /* initialize the default value for the event as the current mode */
 826     evt_data.set_discover.disc_mode = BTM_ReadDiscoverability(NULL, NULL);
 827
 828     if(BTM_SUCCESS == BTM_SetDiscoverability((UINT8)p_data->set_discoverability.disc_mode, 0, 0))
 829     {
 830         evt_data.set_discover.status     = BTA_JV_SUCCESS;
 831         /* update the mode, after BTM_SetDiscoverability() is successful */
 832         evt_data.set_discover.disc_mode  = p_data->set_discoverability.disc_mode;
 833     }
 834
 835     if(bta_jv_cb.p_dm_cback)
 836         bta_jv_cb.p_dm_cback(BTA_JV_SET_DISCOVER_EVT, &evt_data, 0);
 837 }
 838
 839 /*******************************************************************************
 840 **
 841 ** Function     bta_jv_get_local_device_addr
 842 **
 843 ** Description  Reads the local Bluetooth device address
 844 **
 845 ** Returns      void
 846 **
 847 *******************************************************************************/
 848 void bta_jv_get_local_device_addr(tBTA_JV_MSG *p_data)
 849 {
 850     UNUSED(p_data);
 851
 852     BTM_ReadLocalDeviceAddr((tBTM_CMPL_CB *)bta_jv_get_local_device_addr_cback);
 853 }
 854
 855 /*******************************************************************************
 856 **
 857 ** Function     bta_jv_get_local_device_name
 858 **
 859 ** Description  Reads the local Bluetooth device name
 860 **
 861 ** Returns      void
 862 **
 863 *******************************************************************************/
 864 void bta_jv_get_local_device_name(tBTA_JV_MSG *p_data)
 865 {
 866     tBTA_JV evt_data;
 867     char *name;
 868     UNUSED(p_data);
 869
 870     BTM_ReadLocalDeviceName(&name);
 871     evt_data.p_name = (UINT8*)name;
 872     if(bta_jv_cb.p_dm_cback)
 873         bta_jv_cb.p_dm_cback(BTA_JV_LOCAL_NAME_EVT, &evt_data, 0);
 874 }
 875
 876 /*******************************************************************************
 877 **
 878 ** Function     bta_jv_get_remote_device_name
 879 **
 880 ** Description  Reads the local Bluetooth device name
 881 **
 882 ** Returns      void
 883 **
 884 *******************************************************************************/
 885 void bta_jv_get_remote_device_name(tBTA_JV_MSG *p_data)
 886 {
 887
 888     BTM_ReadRemoteDeviceName(p_data->get_rmt_name.bd_addr,
 889         (tBTM_CMPL_CB *)bta_jv_get_remote_device_name_cback, BT_TRANSPORT_BR_EDR);
 890 }
 891
 892 /*******************************************************************************
 893 **
 894 ** Function     bta_jv_set_service_class
 895 **
 896 ** Description  update the service class field of device class
 897 **
 898 ** Returns      void
 899 **
 900 *******************************************************************************/
 901 void bta_jv_set_service_class (tBTA_JV_MSG *p_data)
 902 {
 903     tBTA_UTL_COD cod;
 904
 905     /* set class of device */
 906     /*
 907     BTA_JvSetServiceClass(UINT32 service) assumes that the service class passed to the
 908     API function as defined in the assigned number page.
 909     For example: the object transfer bit is bit 20 of the 24-bit Class of device;
 910     the value of this bit is 0x00100000 (value 1)
 911     Our btm_api.h defines this bit as #define BTM_COD_SERVICE_OBJ_TRANSFER        0x1000  (value 2)
 912     This reflects that the service class defined at btm is UINT16,
 913     which starts at bit 8 of the 24 bit Class of Device
 914     The following statement converts from (value 1) into (value 2)
 915     */
 916     cod.service = (p_data->set_service.service >> 8);
 917     utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS);
 918 }
 919
 920 /*******************************************************************************
 921 **
 922 ** Function     bta_jv_sec_cback
 923 **
 924 ** Description  callback function to handle set encryption complete event
 925 **
 926 ** Returns      void
 927 **
 928 *******************************************************************************/
 929 static void bta_jv_sec_cback (BD_ADDR bd_addr, tBTA_TRANSPORT transport,
 930                                     void *p_ref_data, tBTM_STATUS result)
 931 {
 932     UNUSED(p_ref_data);
 933     UNUSED(transport);
 934
 935     tBTA_JV_SET_ENCRYPTION  set_enc;
 936     if(bta_jv_cb.p_dm_cback)
 937     {
 938         bdcpy(set_enc.bd_addr, bd_addr);
 939         set_enc.status = result;
 940         if (result > BTA_JV_BUSY)
 941             set_enc.status = BTA_JV_FAILURE;
 942         bta_jv_cb.p_dm_cback(BTA_JV_SET_ENCRYPTION_EVT, (tBTA_JV *)&set_enc, 0);
 943     }
 944 }
 945
 946 /*******************************************************************************
 947 **
 948 ** Function     bta_jv_set_encryption
 949 **
 950 ** Description  Reads the local Bluetooth device name
 951 **
 952 ** Returns      void
 953 **
 954 *******************************************************************************/
 955 void bta_jv_set_encryption(tBTA_JV_MSG *p_data)
 956 {
 957     BTM_SetEncryption(p_data->set_encrypt.bd_addr, BTA_TRANSPORT_BR_EDR, bta_jv_sec_cback, NULL);
 958 }
 959
 960 /*******************************************************************************
 961 **
 962 ** Function     bta_jv_get_scn
 963 **
 964 ** Description  obtain a free SCN
 965 **
 966 ** Returns      void
 967 **
 968 *******************************************************************************/
 969 void bta_jv_get_scn(tBTA_JV_MSG *p_data)
 970 {
 971     UNUSED(p_data);
 972 #if 0
 973     UINT8   scn;
 974     scn = BTM_AllocateSCN();
 975     if(scn)
 976         bta_jv_cb.scn[scn-1] = TRUE;
 977     if(bta_jv_cb.p_dm_cback)
 978         bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV *)&scn);
 979 #endif
 980 }
 981
 982 /*******************************************************************************
 983 **
 984 ** Function     bta_jv_free_scn
 985 **
 986 ** Description  free a SCN
 987 **
 988 ** Returns      void
 989 **
 990 *******************************************************************************/
 991 void bta_jv_free_scn(tBTA_JV_MSG *p_data)
 992 {
 993     UINT8   scn = p_data->free_scn.scn;
 994
 995     if (scn > 0 && scn <= BTA_JV_MAX_SCN && bta_jv_cb.scn[scn-1])
 996     {
 997         /* this scn is used by JV */
 998         bta_jv_cb.scn[scn-1] = FALSE;
 999         BTM_FreeSCN(scn);
1000     }
1001 }
1002 static inline tBT_UUID shorten_sdp_uuid(const tBT_UUID* u)
1003 {
1004     static uint8_t bt_base_uuid[] =
1005        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
1006
1007     logu("in, uuid:", u->uu.uuid128);
1008     APPL_TRACE_DEBUG("uuid len:%d", u->len);
1009     if(u->len == 16)
1010     {
1011         if(memcmp(&u->uu.uuid128[4], &bt_base_uuid[4], 12) == 0)
1012         {
1013             tBT_UUID su;
1014             memset(&su, 0, sizeof(su));
1015             if(u->uu.uuid128[0] == 0 && u->uu.uuid128[1] == 0)
1016             {
1017                 su.len = 2;
1018                 uint16_t u16;
1019                 memcpy(&u16, &u->uu.uuid128[2], sizeof(u16));
1020                 su.uu.uuid16 = ntohs(u16);
1021                 APPL_TRACE_DEBUG("shorten to 16 bits uuid: %x", su.uu.uuid16);
1022             }
1023             else
1024             {
1025                 su.len = 4;
1026                 uint32_t u32;
1027                 memcpy(&u32, &u->uu.uuid128[0], sizeof(u32));
1028                 su.uu.uuid32 = ntohl(u32);
1029                 APPL_TRACE_DEBUG("shorten to 32 bits uuid: %x", su.uu.uuid32);
1030             }
1031             return su;
1032         }
1033     }
1034     APPL_TRACE_DEBUG("cannot shorten none-reserved 128 bits uuid");
1035     return *u;
1036 }
1037
1038 /*******************************************************************************
1039 **
1040 ** Function     bta_jv_start_discovery_cback
1041 **
1042 ** Description  Callback for Start Discovery
1043 **
1044 ** Returns      void
1045 **
1046 *******************************************************************************/
1047 static void bta_jv_start_discovery_cback(UINT16 result, void * user_data)
1048 {
1049     tBTA_JV_STATUS status;
1050     UINT8          old_sdp_act = bta_jv_cb.sdp_active;
1051
1052     APPL_TRACE_DEBUG("bta_jv_start_discovery_cback res: 0x%x", result);
1053
1054     bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
1055     if(bta_jv_cb.p_dm_cback)
1056     {
1057         if (old_sdp_act == BTA_JV_SDP_ACT_CANCEL)
1058         {
1059             APPL_TRACE_DEBUG("BTA_JV_SDP_ACT_CANCEL");
1060             status = BTA_JV_SUCCESS;
1061             bta_jv_cb.p_dm_cback(BTA_JV_CANCEL_DISCVRY_EVT, (tBTA_JV *)&status, user_data);
1062         }
1063         else
1064         {
1065             tBTA_JV_DISCOVERY_COMP dcomp;
1066             dcomp.scn = 0;
1067             status = BTA_JV_FAILURE;
1068             if (result == SDP_SUCCESS || result == SDP_DB_FULL)
1069             {
1070                 tSDP_DISC_REC       *p_sdp_rec = NULL;
1071                 tSDP_PROTOCOL_ELEM  pe;
1072                 logu("bta_jv_cb.uuid", bta_jv_cb.uuid.uu.uuid128);
1073                 tBT_UUID su = shorten_sdp_uuid(&bta_jv_cb.uuid);
1074                 logu("shorten uuid:", su.uu.uuid128);
1075                 p_sdp_rec = SDP_FindServiceUUIDInDb(p_bta_jv_cfg->p_sdp_db, &su, p_sdp_rec);
1076                 APPL_TRACE_DEBUG("p_sdp_rec:%p", p_sdp_rec);
1077                 if(p_sdp_rec && SDP_FindProtocolListElemInRec(p_sdp_rec, UUID_PROTOCOL_RFCOMM, &pe))
1078                 {
1079                     dcomp.scn = (UINT8) pe.params[0];
1080                     status = BTA_JV_SUCCESS;
1081                 }
1082             }
1083
1084             dcomp.status = status;
1085             bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&dcomp, user_data);
1086         }
1087         //free sdp db
1088         //utl_freebuf(&(p_bta_jv_cfg->p_sdp_db));
1089     }
1090 }
1091
1092 /*******************************************************************************
1093 **
1094 ** Function     bta_jv_start_discovery
1095 **
1096 ** Description  Discovers services on a remote device
1097 **
1098 ** Returns      void
1099 **
1100 *******************************************************************************/
1101 void bta_jv_start_discovery(tBTA_JV_MSG *p_data)
1102 {
1103     tBTA_JV_STATUS status = BTA_JV_FAILURE;
1104     APPL_TRACE_DEBUG("bta_jv_start_discovery in, sdp_active:%d", bta_jv_cb.sdp_active);
1105     if (bta_jv_cb.sdp_active != BTA_JV_SDP_ACT_NONE)
1106     {
1107         /* SDP is still in progress */
1108         status = BTA_JV_BUSY;
1109         if(bta_jv_cb.p_dm_cback)
1110             bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&status, p_data->start_discovery.user_data);
1111         return;
1112     }
1113 /*
1114     if(p_data->start_discovery.num_uuid == 0)
1115     {
1116         p_data->start_discovery.num_uuid = 1;
1117         p_data->start_discovery.uuid_list[0].len       = 2;
1118         p_data->start_discovery.uuid_list[0].uu.uuid16 = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP;
1119     }
1120 */
1121     /* init the database/set up the filter */
1122     APPL_TRACE_DEBUG("call SDP_InitDiscoveryDb, p_data->start_discovery.num_uuid:%d",
1123         p_data->start_discovery.num_uuid);
1124     SDP_InitDiscoveryDb (p_bta_jv_cfg->p_sdp_db, p_bta_jv_cfg->sdp_db_size,
1125                     p_data->start_discovery.num_uuid, p_data->start_discovery.uuid_list, 0, NULL);
1126
1127     /* tell SDP to keep the raw data */
1128     p_bta_jv_cfg->p_sdp_db->raw_data = p_bta_jv_cfg->p_sdp_raw_data;
1129     p_bta_jv_cfg->p_sdp_db->raw_size = p_bta_jv_cfg->sdp_raw_size;
1130
1131     bta_jv_cb.p_sel_raw_data     = 0;
1132     bta_jv_cb.uuid = p_data->start_discovery.uuid_list[0];
1133
1134     bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_YES;
1135     if (!SDP_ServiceSearchAttributeRequest2(p_data->start_discovery.bd_addr,
1136                                    p_bta_jv_cfg->p_sdp_db,
1137                                    bta_jv_start_discovery_cback, p_data->start_discovery.user_data))
1138     {
1139         bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
1140         /* failed to start SDP. report the failure right away */
1141         if(bta_jv_cb.p_dm_cback)
1142             bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV *)&status, p_data->start_discovery.user_data);
1143     }
1144     /*
1145     else report the result when the cback is called
1146     */
1147 }
1148
1149 /*******************************************************************************
1150 **
1151 ** Function     bta_jv_cancel_discovery
1152 **
1153 ** Description  Cancels an active discovery
1154 **
1155 ** Returns      void
1156 **
1157 *******************************************************************************/
1158 void bta_jv_cancel_discovery(tBTA_JV_MSG *p_data)
1159 {
1160     tBTA_JV_STATUS status = BTA_JV_SUCCESS;
1161     if (bta_jv_cb.sdp_active == BTA_JV_SDP_ACT_YES)
1162     {
1163         if (SDP_CancelServiceSearch (p_bta_jv_cfg->p_sdp_db))
1164         {
1165             bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_CANCEL;
1166             return;
1167         }
1168     }
1169     if(bta_jv_cb.p_dm_cback)
1170         bta_jv_cb.p_dm_cback(BTA_JV_CANCEL_DISCVRY_EVT, (tBTA_JV *)&status, p_data->cancel_discovery.user_data);
1171 }
1172
1173 /*******************************************************************************
1174 **
1175 ** Function     bta_jv_get_services_length
1176 **
1177 ** Description  Obtain the length of each record in the SDP DB.
1178 **
1179 ** Returns      void
1180 **
1181 *******************************************************************************/
1182 void bta_jv_get_services_length(tBTA_JV_MSG *p_data)
1183 {
1184     UNUSED(p_data);
1185 #if 0
1186     tBTA_JV_SERVICES_LEN    evt_data;
1187     UINT8   *p, *np, *op, type;
1188     UINT32  raw_used, raw_cur;
1189     UINT32  len;
1190
1191     evt_data.num_services = -1;
1192     evt_data.p_services_len = p_data->get_services_length.p_services_len;
1193     if(p_bta_jv_cfg->p_sdp_db->p_first_rec)
1194     {
1195         /* the database is valid */
1196         evt_data.num_services = 0;
1197         p = p_bta_jv_cfg->p_sdp_db->raw_data;
1198         raw_used = p_bta_jv_cfg->p_sdp_db->raw_used;
1199         while(raw_used && p)
1200         {
1201             op = p;
1202             type = *p++;
1203             np = sdpu_get_len_from_type(p, type, &len);
1204             p = np + len;
1205             raw_cur = p - op;
1206             if(raw_used >= raw_cur)
1207             {
1208                 raw_used -= raw_cur;
1209             }
1210             else
1211             {
1212                 /* error. can not continue */
1213                 break;
1214             }
1215             if(p_data->get_services_length.inc_hdr)
1216             {
1217                 evt_data.p_services_len[evt_data.num_services++] = len + np - op;
1218             }
1219             else
1220             {
1221                 evt_data.p_services_len[evt_data.num_services++] = len;
1222             }
1223         } /* end of while */
1224     }
1225
1226     if(bta_jv_cb.p_dm_cback)
1227         bta_jv_cb.p_dm_cback(BTA_JV_SERVICES_LEN_EVT, (tBTA_JV *)&evt_data);
1228 #endif
1229 }
1230
1231 /*******************************************************************************
1232 **
1233 ** Function     bta_jv_service_select
1234 **
1235 ** Description  Obtain the length of given UUID in the SDP DB.
1236 **
1237 ** Returns      void
1238 **
1239 *******************************************************************************/
1240 void bta_jv_service_select(tBTA_JV_MSG *p_data)
1241 {
1242     UNUSED(p_data);
1243 #if 0
1244     tBTA_JV_SERVICE_SEL     serv_sel;
1245     tSDP_DISC_REC *p_rec, *p_tmp;
1246     UINT8   *p, *np, *op, type;
1247     UINT32  raw_used, raw_cur;
1248     UINT32  len;
1249
1250     serv_sel.service_len = 0;
1251     bta_jv_cb.p_sel_raw_data     = 0;
1252     p_rec = SDP_FindServiceInDb (p_bta_jv_cfg->p_sdp_db, p_data->service_select.uuid, NULL);
1253     if(p_rec)
1254     {
1255         /* found the record in the database */
1256         /* the database must be valid */
1257         p = p_bta_jv_cfg->p_sdp_db->raw_data;
1258         raw_used = p_bta_jv_cfg->p_sdp_db->raw_used;
1259         p_tmp = p_bta_jv_cfg->p_sdp_db->p_first_rec;
1260         while(raw_used && p && p_tmp)
1261         {
1262             op = p;
1263             type = *p++;
1264             np = sdpu_get_len_from_type(p, type, &len);
1265             if(p_tmp == p_rec)
1266             {
1267                 bta_jv_cb.p_sel_raw_data = op;
1268                 bta_jv_cb.sel_len = len;
1269                 serv_sel.service_len = len;
1270                 bdcpy(serv_sel.bd_addr, p_rec->remote_bd_addr);
1271                 APPL_TRACE_DEBUG( "bta_jv_service_select found uuid: 0x%x",
1272                     p_data->service_select.uuid);
1273                 break;
1274             }
1275             p = np + len;
1276             raw_cur = p - op;
1277             if(raw_used >= raw_cur)
1278             {
1279                 raw_used -= raw_cur;
1280             }
1281             else
1282             {
1283                 /* error. can not continue */
1284                 break;
1285             }
1286             p_tmp = p_tmp->p_next_rec;
1287         } /* end of while */
1288     }
1289     APPL_TRACE_DEBUG( "service_len: %d", serv_sel.service_len);
1290     if(bta_jv_cb.p_dm_cback)
1291         bta_jv_cb.p_dm_cback(BTA_JV_SERVICE_SEL_EVT, (tBTA_JV *)&serv_sel);
1292 #endif
1293 }
1294
1295 /*******************************************************************************
1296 **
1297 ** Function     bta_jv_create_record
1298 **
1299 ** Description  Create an SDP record with the given attributes
1300 **
1301 ** Returns      void
1302 **
1303 *******************************************************************************/
1304 void bta_jv_create_record(tBTA_JV_MSG *p_data)
1305 {
1306     tBTA_JV_API_CREATE_RECORD *cr = &(p_data->create_record);
1307     tBTA_JV_CREATE_RECORD   evt_data;
1308     evt_data.status = BTA_JV_SUCCESS;
1309     if(bta_jv_cb.p_dm_cback)
1310         //callback user immediately to create his own sdp record in stack thread context
1311         bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, (tBTA_JV *)&evt_data, cr->user_data);
1312 }
1313
1314 /*******************************************************************************
1315 **
1316 ** Function     bta_jv_update_record
1317 **
1318 ** Description  Update an SDP record with the given attributes
1319 **
1320 ** Returns      void
1321 **
1322 *******************************************************************************/
1323 void bta_jv_update_record(tBTA_JV_MSG *p_data)
1324 {
1325     UNUSED(p_data);
1326 #if 0
1327     tBTA_JV_API_UPDATE_RECORD *ur = &(p_data->update_record);
1328     tBTA_JV_UPDATE_RECORD   evt_data;
1329     UINT32 handle;
1330     INT32 i;
1331     UINT8 *ptr;
1332     UINT8 *next_ptr;
1333     UINT8 *end;
1334     UINT32 len;
1335     UINT8 type;
1336
1337     evt_data.status = BTA_JV_FAILURE;
1338     evt_data.handle = ur->handle;
1339
1340     handle = bta_jv_get_sdp_handle(ur->handle);
1341
1342     if(handle)
1343     {
1344         /* this is a record created by JV */
1345         for (i = 0; i < ur->array_len; i++)
1346         {
1347             ptr = ur->p_values[i];
1348             end = ptr + ur->p_value_sizes[i];
1349
1350             while (ptr < end)
1351             {
1352                 type = *ptr;
1353                 next_ptr = sdpu_get_len_from_type(ptr + 1, *ptr, &len);
1354
1355                 if(ATTR_ID_SERVICE_RECORD_HDL != ur->p_ids[i])
1356                 {
1357                 if (!SDP_AddAttribute(handle, ur->p_ids[i], (UINT8)((type >> 3) & 0x1f),
1358                     len, next_ptr))
1359                 {
1360                     /* failed on updating attributes.  */
1361                     if(bta_jv_cb.p_dm_cback)
1362                         bta_jv_cb.p_dm_cback(BTA_JV_UPDATE_RECORD_EVT, (tBTA_JV *)&evt_data);
1363                     return;
1364                 }
1365                 }
1366
1367                 ptr = next_ptr + len;
1368             } /* end of while */
1369         } /* end of for */
1370         evt_data.status = BTA_JV_SUCCESS;
1371     }
1372
1373     if(bta_jv_cb.p_dm_cback)
1374         bta_jv_cb.p_dm_cback(BTA_JV_UPDATE_RECORD_EVT, (tBTA_JV *)&evt_data);
1375 #endif
1376 }
1377
1378 /*******************************************************************************
1379 **
1380 ** Function     bta_jv_add_attribute
1381 **
1382 ** Description  Add an attribute to an SDP record
1383 **
1384 ** Returns      void
1385 **
1386 *******************************************************************************/
1387 void bta_jv_add_attribute(tBTA_JV_MSG *p_data)
1388 {
1389     UNUSED(p_data);
1390 #if 0
1391     tBTA_JV_API_ADD_ATTRIBUTE *aa = &(p_data->add_attr);
1392     tBTA_JV_ADD_ATTR   evt_data;
1393     UINT32 handle;
1394     UINT8 type;
1395     UINT32 len;
1396     UINT8 *ptr;
1397     UINT8 *next_ptr;
1398
1399     evt_data.status = BTA_JV_FAILURE;
1400     evt_data.handle = aa->handle;
1401     handle = bta_jv_get_sdp_handle(aa->handle);
1402
1403     if(handle)
1404     {
1405         /* this is a record created by JV */
1406         ptr = aa->p_value;
1407         type = *ptr;
1408         next_ptr = sdpu_get_len_from_type(ptr + 1, *ptr, &len);
1409         APPL_TRACE_DEBUG( "bta_jv_add_attribute: ptr chg:%d len:%d, size:%d",
1410             (next_ptr - ptr), len, aa->value_size);
1411         if(ATTR_ID_SERVICE_RECORD_HDL != aa->attr_id && /* do not allow the SDP record handle to be updated */
1412             ((INT32)(next_ptr - ptr + len) == aa->value_size) && /* double check data size */
1413             SDP_AddAttribute(handle, aa->attr_id, (UINT8)((type >> 3) & 0x1f),
1414                     len, next_ptr))
1415         {
1416             evt_data.status = BTA_JV_SUCCESS;
1417         }
1418     }
1419
1420     if(bta_jv_cb.p_dm_cback)
1421         bta_jv_cb.p_dm_cback(BTA_JV_ADD_ATTR_EVT, (tBTA_JV *)&evt_data);
1422 #endif
1423 }
1424
1425 /*******************************************************************************
1426 **
1427 ** Function     bta_jv_delete_attribute
1428 **
1429 ** Description  Delete an attribute from the given SDP record
1430 **
1431 ** Returns      void
1432 **
1433 *******************************************************************************/
1434 void bta_jv_delete_attribute(tBTA_JV_MSG *p_data)
1435 {
1436     UNUSED(p_data);
1437 #if 0
1438     tBTA_JV_API_ADD_ATTRIBUTE *da = &(p_data->add_attr);
1439     tBTA_JV_DELETE_ATTR   evt_data;
1440     UINT32 handle;
1441
1442     evt_data.status = BTA_JV_FAILURE;
1443     evt_data.handle = da->handle;
1444     handle = bta_jv_get_sdp_handle(da->handle);
1445
1446     if(handle)
1447     {
1448         /* this is a record created by JV */
1449         if(SDP_DeleteAttribute(handle, da->attr_id))
1450             evt_data.status = BTA_JV_SUCCESS;
1451     }
1452
1453     if(bta_jv_cb.p_dm_cback)
1454         bta_jv_cb.p_dm_cback(BTA_JV_DELETE_ATTR_EVT, (tBTA_JV *)&evt_data);
1455 #endif
1456 }
1457
1458 /*******************************************************************************
1459 **
1460 ** Function     bta_jv_delete_record
1461 **
1462 ** Description  Delete an SDP record
1463 **
1464 **
1465 ** Returns      void
1466 **
1467 *******************************************************************************/
1468 void bta_jv_delete_record(tBTA_JV_MSG *p_data)
1469 {
1470     tBTA_JV_API_ADD_ATTRIBUTE *dr = &(p_data->add_attr);
1471     if(dr->handle)
1472     {
1473         /* this is a record created by btif layer*/
1474         SDP_DeleteRecord(dr->handle);
1475     }
1476 }
1477
1478 #if SDP_FOR_JV_INCLUDED == TRUE
1479 /*******************************************************************************
1480 **
1481 ** Function     bta_jv_sdp_res_cback
1482 **
1483 ** Description  Callback for Start Discovery
1484 **
1485 ** Returns      void
1486 **
1487 *******************************************************************************/
1488 void bta_jv_sdp_res_cback (UINT16 event, tSDP_DATA *p_data)
1489 {
1490     tBTA_JV evt_data;
1491     tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[BTA_JV_L2C_FOR_SDP_HDL];
1492
1493     APPL_TRACE_DEBUG( "bta_jv_sdp_res_cback: %d evt:x%x",
1494         bta_jv_cb.sdp_for_jv, event);
1495
1496     if(!bta_jv_cb.sdp_for_jv)
1497         return;
1498
1499     evt_data.l2c_open.status = BTA_JV_SUCCESS;
1500     evt_data.l2c_open.handle = BTA_JV_L2C_FOR_SDP_HDL;
1501
1502     switch(event)
1503     {
1504     case SDP_EVT_OPEN:
1505         bdcpy(evt_data.l2c_open.rem_bda, p_data->open.peer_addr);
1506         evt_data.l2c_open.tx_mtu = p_data->open.peer_mtu;
1507         p_cb->state = BTA_JV_ST_SR_OPEN;
1508         p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data);
1509         break;
1510     case SDP_EVT_DATA_IND:
1511         evt_data.handle = BTA_JV_L2C_FOR_SDP_HDL;
1512         memcpy(p_bta_jv_cfg->p_sdp_raw_data, p_data->data.p_data, p_data->data.data_len);
1513         APPL_TRACE_DEBUG( "data size: %d/%d ", bta_jv_cb.sdp_data_size, p_data->data.data_len);
1514         bta_jv_cb.sdp_data_size = p_data->data.data_len;
1515         p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data);
1516         break;
1517     }
1518 }
1519
1520 /*******************************************************************************
1521 **
1522 ** Function     bta_jv_sdp_cback
1523 **
1524 ** Description  Callback for Start Discovery
1525 **
1526 ** Returns      void
1527 **
1528 *******************************************************************************/
1529 static void bta_jv_sdp_cback(UINT16 result)
1530 {
1531     tBTA_JV_L2CAP_CLOSE close;
1532     tBTA_JV_L2C_CB  *p_cb = &bta_jv_cb.l2c_cb[BTA_JV_L2C_FOR_SDP_HDL];
1533     APPL_TRACE_DEBUG( "bta_jv_sdp_cback: result:x%x", result);
1534
1535     if(p_cb->p_cback)
1536     {
1537         close.handle    = BTA_JV_L2C_FOR_SDP_HDL;
1538         close.async     = FALSE;
1539         close.status    = BTA_JV_SUCCESS;
1540         bta_jv_free_sec_id(&p_cb->sec_id);
1541         p_cb->p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&close);
1542     }
1543
1544     bta_jv_cb.sdp_for_jv = 0;
1545     p_cb->p_cback = NULL;
1546
1547 }
1548 #endif
1549
1550 /*******************************************************************************
1551 **
1552 ** Function     bta_jv_l2cap_connect
1553 **
1554 ** Description  makes an l2cap client connection
1555 **
1556 ** Returns      void
1557 **
1558 *******************************************************************************/
1559 void bta_jv_l2cap_connect(tBTA_JV_MSG *p_data)
1560 {
1561     UNUSED(p_data);
1562 #if 0
1563     tBTA_JV_L2C_CB      *p_cb;
1564     tBTA_JV_L2CAP_CL_INIT  evt_data;
1565     UINT16  handle=GAP_INVALID_HANDLE;
1566     UINT8   sec_id;
1567     tL2CAP_CFG_INFO cfg;
1568     tBTA_JV_API_L2CAP_CONNECT *cc = &(p_data->l2cap_connect);
1569
1570     memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
1571     cfg.mtu_present = TRUE;
1572     cfg.mtu = cc->rx_mtu;
1573     /* TODO: DM role manager
1574     L2CA_SetDesireRole(cc->role);
1575     */
1576
1577     sec_id = bta_jv_alloc_sec_id();
1578     evt_data.sec_id = sec_id;
1579     evt_data.status = BTA_JV_FAILURE;
1580     if (sec_id)
1581     {
1582 #if SDP_FOR_JV_INCLUDED == TRUE
1583         if(SDP_PSM == cc->remote_psm && 0 == bta_jv_cb.sdp_for_jv)
1584         {
1585             bta_jv_cb.sdp_for_jv = SDP_ConnOpen(cc->peer_bd_addr,
1586                                        bta_jv_sdp_res_cback,
1587                                        bta_jv_sdp_cback);
1588             if(bta_jv_cb.sdp_for_jv)
1589             {
1590                 bta_jv_cb.sdp_data_size = 0;
1591                 handle = BTA_JV_L2C_FOR_SDP_HDL;
1592                 evt_data.status = BTA_JV_SUCCESS;
1593             }
1594         }
1595         else
1596 #endif
1597         if(bta_jv_check_psm(cc->remote_psm)) /* allowed */
1598         {
1599             if( (handle = GAP_ConnOpen("", sec_id, 0, cc->peer_bd_addr, cc->remote_psm,
1600                 &cfg, cc->sec_mask, GAP_FCR_CHAN_OPT_BASIC,
1601                 bta_jv_l2cap_client_cback)) != GAP_INVALID_HANDLE )
1602             {
1603                 evt_data.status = BTA_JV_SUCCESS;
1604             }
1605         }
1606     }
1607
1608     if (evt_data.status == BTA_JV_SUCCESS)
1609     {
1610         p_cb = &bta_jv_cb.l2c_cb[handle];
1611         p_cb->handle = handle;
1612         p_cb->p_cback = cc->p_cback;
1613         p_cb->psm = 0;  /* not a server */
1614         p_cb->sec_id = sec_id;
1615         p_cb->state = BTA_JV_ST_CL_OPENING;
1616     }
1617     else
1618     {
1619         bta_jv_free_sec_id(&sec_id);
1620     }
1621     evt_data.handle = handle;
1622     cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, (tBTA_JV *)&evt_data);
1623 #endif
1624 }
1625
1626 /*******************************************************************************
1627 **
1628 ** Function     bta_jv_l2cap_close
1629 **
1630 ** Description  Close an L2CAP client connection
1631 **
1632 ** Returns      void
1633 **
1634 *******************************************************************************/
1635 void bta_jv_l2cap_close(tBTA_JV_MSG *p_data)
1636 {
1637     UNUSED(p_data);
1638 #if 0
1639     tBTA_JV_L2CAP_CLOSE  evt_data;
1640     tBTA_JV_API_L2CAP_CLOSE *cc = &(p_data->l2cap_close);
1641     tBTA_JV_L2CAP_CBACK *p_cback = cc->p_cb->p_cback;
1642
1643     evt_data.handle = cc->handle;
1644     evt_data.status = bta_jv_free_l2c_cb(cc->p_cb);
1645     evt_data.async = FALSE;
1646
1647     if (p_cback)
1648         p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&evt_data);
1649     else
1650         APPL_TRACE_ERROR("### NO CALLBACK SET !!! ###");
1651 #endif
1652 }
1653
1654 /*******************************************************************************
1655 **
1656 ** Function     bta_jv_l2cap_start_server
1657 **
1658 ** Description  starts an L2CAP server
1659 **
1660 ** Returns      void
1661 **
1662 *******************************************************************************/
1663 void bta_jv_l2cap_start_server(tBTA_JV_MSG *p_data)
1664 {
1665     UNUSED(p_data);
1666 #if 0
1667     tBTA_JV_L2C_CB      *p_cb;
1668     UINT8   sec_id;
1669     UINT16  handle;
1670     tL2CAP_CFG_INFO cfg;
1671     tBTA_JV_L2CAP_START evt_data;
1672     tBTA_JV_API_L2CAP_SERVER *ls = &(p_data->l2cap_server);
1673
1674     memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
1675
1676     //FIX: MTU=0 means not present
1677     if (ls->rx_mtu >0)
1678     {
1679         cfg.mtu_present = TRUE;
1680         cfg.mtu = ls->rx_mtu;
1681     }
1682     else
1683     {
1684         cfg.mtu_present = FALSE;
1685         cfg.mtu = 0;
1686     }
1687
1688     /* TODO DM role manager
1689     L2CA_SetDesireRole(ls->role);
1690     */
1691
1692     sec_id = bta_jv_alloc_sec_id();
1693     if (0 == sec_id || (FALSE == bta_jv_check_psm(ls->local_psm)) ||
1694         (handle = GAP_ConnOpen("JV L2CAP", sec_id, 1, 0, ls->local_psm, &cfg,
1695             ls->sec_mask, GAP_FCR_CHAN_OPT_BASIC, bta_jv_l2cap_server_cback)) == GAP_INVALID_HANDLE)
1696     {
1697         bta_jv_free_sec_id(&sec_id);
1698         evt_data.status = BTA_JV_FAILURE;
1699     }
1700     else
1701     {
1702         /* default JV implementation requires explicit call
1703            to allow incoming connections when ready*/
1704
1705         GAP_SetAcceptReady(handle, FALSE);
1706
1707         p_cb = &bta_jv_cb.l2c_cb[handle];
1708         evt_data.status = BTA_JV_SUCCESS;
1709         evt_data.handle = handle;
1710         evt_data.sec_id = sec_id;
1711         p_cb->p_cback = ls->p_cback;
1712         p_cb->handle = handle;
1713         p_cb->sec_id = sec_id;
1714         p_cb->state = BTA_JV_ST_SR_LISTEN;
1715         p_cb->psm = ls->local_psm;
1716     }
1717     ls->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV *)&evt_data);
1718 #endif
1719 }
1720
1721 /*******************************************************************************
1722 **
1723 ** Function     bta_jv_l2cap_stop_server
1724 **
1725 ** Description  stops an L2CAP server
1726 **
1727 ** Returns      void
1728 **
1729 *******************************************************************************/
1730 void bta_jv_l2cap_stop_server(tBTA_JV_MSG *p_data)
1731 {
1732     UNUSED(p_data);
1733 #if 0
1734     tBTA_JV_L2C_CB      *p_cb;
1735     tBTA_JV_L2CAP_CLOSE  evt_data;
1736     tBTA_JV_API_L2CAP_SERVER *ls = &(p_data->l2cap_server);
1737     tBTA_JV_L2CAP_CBACK *p_cback;
1738     int i;
1739
1740     for(i=0; i<BTA_JV_MAX_L2C_CONN; i++)
1741     {
1742         if(bta_jv_cb.l2c_cb[i].psm == ls->local_psm)
1743         {
1744             p_cb = &bta_jv_cb.l2c_cb[i];
1745             p_cback = p_cb->p_cback;
1746             evt_data.handle = p_cb->handle;
1747             evt_data.status = bta_jv_free_l2c_cb(p_cb);
1748             evt_data.async = FALSE;
1749             p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV *)&evt_data);
1750             break;
1751         }
1752     }
1753 #endif
1754 }
1755
1756 /*******************************************************************************
1757 **
1758 ** Function     bta_jv_l2cap_read
1759 **
1760 ** Description  Read data from an L2CAP connection
1761 **
1762 ** Returns      void
1763 **
1764 *******************************************************************************/
1765 void bta_jv_l2cap_read(tBTA_JV_MSG *p_data)
1766 {
1767     UNUSED(p_data);
1768 #if 0
1769     tBTA_JV_L2CAP_READ evt_data;
1770     tBTA_JV_API_L2CAP_READ *rc = &(p_data->l2cap_read);
1771
1772     evt_data.status = BTA_JV_FAILURE;
1773     evt_data.handle = rc->handle;
1774     evt_data.req_id = rc->req_id;
1775     evt_data.p_data = rc->p_data;
1776     evt_data.len    = 0;
1777 #if SDP_FOR_JV_INCLUDED == TRUE
1778     if(BTA_JV_L2C_FOR_SDP_HDL == rc->handle)
1779     {
1780         evt_data.len = rc->len;
1781         if(evt_data.len > bta_jv_cb.sdp_data_size)
1782             evt_data.len = bta_jv_cb.sdp_data_size;
1783
1784         memcpy(rc->p_data, p_bta_jv_cfg->p_sdp_raw_data, evt_data.len);
1785         bta_jv_cb.sdp_data_size = 0;
1786         evt_data.status = BTA_JV_SUCCESS;
1787     }
1788     else
1789 #endif
1790     if (BT_PASS == GAP_ConnReadData(rc->handle, rc->p_data, rc->len, &evt_data.len))
1791     {
1792         evt_data.status = BTA_JV_SUCCESS;
1793     }
1794
1795     rc->p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV *)&evt_data);
1796 #endif
1797 }
1798
1799
1800 /*******************************************************************************
1801 **
1802 ** Function     bta_jv_l2cap_write
1803 **
1804 ** Description  Write data to an L2CAP connection
1805 **
1806 ** Returns      void
1807 **
1808 *******************************************************************************/
1809 void bta_jv_l2cap_write(tBTA_JV_MSG *p_data)
1810 {
1811     UNUSED(p_data);
1812 #if 0
1813     tBTA_JV_L2CAP_WRITE evt_data;
1814     tBTA_JV_API_L2CAP_WRITE *ls = &(p_data->l2cap_write);
1815
1816     evt_data.status = BTA_JV_FAILURE;
1817     evt_data.handle = ls->handle;
1818     evt_data.req_id = ls->req_id;
1819     evt_data.cong   = ls->p_cb->cong;
1820     evt_data.len    = 0;
1821 #if SDP_FOR_JV_INCLUDED == TRUE
1822     if(BTA_JV_L2C_FOR_SDP_HDL == ls->handle)
1823     {
1824         UINT8   *p;
1825         BT_HDR  *p_msg = (BT_HDR *) GKI_getbuf ((UINT16)(ls->len + BT_HDR_SIZE + L2CAP_MIN_OFFSET));
1826         if(p_msg)
1827         {
1828             p_msg->offset = L2CAP_MIN_OFFSET;
1829             p = (UINT8 *)(p_msg + 1) + L2CAP_MIN_OFFSET;
1830             p_msg->len = ls->len;
1831             memcpy(p, ls->p_data, p_msg->len);
1832             bta_jv_pm_conn_busy(ls->p_cb->p_pm_cb);
1833             if(SDP_WriteData (bta_jv_cb.sdp_for_jv, p_msg))
1834             {
1835                 evt_data.len    = ls->len;
1836                 evt_data.status = BTA_JV_SUCCESS;
1837             }
1838         }
1839     }
1840     else
1841 #endif
1842     {
1843         bta_jv_pm_conn_busy(ls->p_cb->p_pm_cb);
1844         if (!evt_data.cong &&
1845            BT_PASS == GAP_ConnWriteData(ls->handle, ls->p_data, ls->len, &evt_data.len))
1846         {
1847            evt_data.status = BTA_JV_SUCCESS;
1848         }
1849     }
1850     ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, (tBTA_JV *)&evt_data);
1851         bta_jv_set_pm_conn_state(ls->p_cb->p_pm_cb, BTA_JV_CONN_IDLE);
1852 #endif
1853 }
1854
1855 /*******************************************************************************
1856 **
1857 ** Function     bta_jv_port_data_co_cback
1858 **
1859 ** Description  port data callback function of rfcomm
1860 **              connections
1861 **
1862 ** Returns      void
1863 **
1864 *******************************************************************************/
1865 /*
1866 #define DATA_CO_CALLBACK_TYPE_INCOMING          1
1867 #define DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE     2
1868 #define DATA_CO_CALLBACK_TYPE_OUTGOING          3
1869 */
1870 static int bta_jv_port_data_co_cback(UINT16 port_handle, UINT8 *buf, UINT16 len, int type)
1871 {
1872     tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
1873     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1874     int ret = 0;
1875     APPL_TRACE_DEBUG("bta_jv_port_data_co_cback, p_cb:%p, p_pcb:%p, len:%d, type:%d",
1876                         p_cb, p_pcb, len, type);
1877     if (p_pcb != NULL)
1878     {
1879         switch(type)
1880         {
1881             case DATA_CO_CALLBACK_TYPE_INCOMING:
1882                 bta_jv_pm_conn_busy(p_pcb->p_pm_cb);
1883                 ret = bta_co_rfc_data_incoming(p_pcb->user_data, (BT_HDR*)buf);
1884                 bta_jv_pm_conn_idle(p_pcb->p_pm_cb);
1885                 return ret;
1886             case DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE:
1887                 return bta_co_rfc_data_outgoing_size(p_pcb->user_data, (int*)buf);
1888             case DATA_CO_CALLBACK_TYPE_OUTGOING:
1889                 return bta_co_rfc_data_outgoing(p_pcb->user_data, buf, len);
1890             default:
1891                 APPL_TRACE_ERROR("unknown callout type:%d", type);
1892                 break;
1893         }
1894     }
1895     return 0;
1896 }
1897
1898 /*******************************************************************************
1899 **
1900 ** Function     bta_jv_port_mgmt_cl_cback
1901 **
1902 ** Description  callback for port mamangement function of rfcomm
1903 **              client connections
1904 **
1905 ** Returns      void
1906 **
1907 *******************************************************************************/
1908 static void bta_jv_port_mgmt_cl_cback(UINT32 code, UINT16 port_handle)
1909 {
1910     tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
1911     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1912     tBTA_JV evt_data;
1913     BD_ADDR rem_bda;
1914     UINT16 lcid;
1915     tBTA_JV_RFCOMM_CBACK *p_cback;  /* the callback function */
1916
1917     APPL_TRACE_DEBUG( "bta_jv_port_mgmt_cl_cback:code:%d, port_handle%d", code, port_handle);
1918     if(NULL == p_cb || NULL == p_cb->p_cback)
1919         return;
1920
1921     APPL_TRACE_DEBUG( "bta_jv_port_mgmt_cl_cback code=%d port_handle:%d handle:%d",
1922         code, port_handle, p_cb->handle);
1923
1924     PORT_CheckConnection(port_handle, rem_bda, &lcid);
1925
1926     if(code == PORT_SUCCESS)
1927     {
1928         evt_data.rfc_open.handle = p_cb->handle;
1929         evt_data.rfc_open.status = BTA_JV_SUCCESS;
1930         bdcpy(evt_data.rfc_open.rem_bda, rem_bda);
1931         p_pcb->state = BTA_JV_ST_CL_OPEN;
1932         p_cb->p_cback(BTA_JV_RFCOMM_OPEN_EVT, &evt_data, p_pcb->user_data);
1933     }
1934     else
1935     {
1936         evt_data.rfc_close.handle = p_cb->handle;
1937         evt_data.rfc_close.status = BTA_JV_FAILURE;
1938         evt_data.rfc_close.port_status = code;
1939         evt_data.rfc_close.async = TRUE;
1940         if (p_pcb->state == BTA_JV_ST_CL_CLOSING)
1941         {
1942             evt_data.rfc_close.async = FALSE;
1943         }
1944         //p_pcb->state = BTA_JV_ST_NONE;
1945         //p_pcb->cong = FALSE;
1946         p_cback = p_cb->p_cback;
1947         p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, p_pcb->user_data);
1948         //bta_jv_free_rfc_cb(p_cb, p_pcb);
1949     }
1950
1951 }
1952
1953 /*******************************************************************************
1954 **
1955 ** Function     bta_jv_port_event_cl_cback
1956 **
1957 ** Description  Callback for RFCOMM client port events
1958 **
1959 ** Returns      void
1960 **
1961 *******************************************************************************/
1962 static void bta_jv_port_event_cl_cback(UINT32 code, UINT16 port_handle)
1963 {
1964     tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
1965     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1966     tBTA_JV evt_data;
1967
1968     APPL_TRACE_DEBUG( "bta_jv_port_event_cl_cback:%d", port_handle);
1969     if(NULL == p_cb || NULL == p_cb->p_cback)
1970         return;
1971
1972     APPL_TRACE_DEBUG( "bta_jv_port_event_cl_cback code=x%x port_handle:%d handle:%d",
1973         code, port_handle, p_cb->handle);
1974     if (code & PORT_EV_RXCHAR)
1975     {
1976         evt_data.data_ind.handle = p_cb->handle;
1977         p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, p_pcb->user_data);
1978     }
1979
1980     if (code & PORT_EV_FC)
1981     {
1982         p_pcb->cong = (code & PORT_EV_FCS) ? FALSE : TRUE;
1983         evt_data.rfc_cong.cong = p_pcb->cong;
1984         evt_data.rfc_cong.handle = p_cb->handle;
1985         evt_data.rfc_cong.status = BTA_JV_SUCCESS;
1986         p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, p_pcb->user_data);
1987     }
1988
1989     if (code & PORT_EV_TXEMPTY)
1990     {
1991         bta_jv_pm_conn_idle(p_pcb->p_pm_cb);
1992     }
1993 }
1994
1995 /*******************************************************************************
1996 **
1997 ** Function     bta_jv_rfcomm_connect
1998 **
1999 ** Description  Client initiates an RFCOMM connection
2000 **
2001 ** Returns      void
2002 **
2003 *******************************************************************************/
2004 void bta_jv_rfcomm_connect(tBTA_JV_MSG *p_data)
2005 {
2006     UINT16 handle = 0;
2007     UINT32 event_mask = BTA_JV_RFC_EV_MASK;
2008     tPORT_STATE port_state;
2009     UINT8   sec_id = 0;
2010     tBTA_JV_RFC_CB  *p_cb = NULL;
2011     tBTA_JV_PCB     *p_pcb;
2012     tBTA_JV_API_RFCOMM_CONNECT *cc = &(p_data->rfcomm_connect);
2013     tBTA_JV_RFCOMM_CL_INIT      evt_data = {0};
2014
2015     /* TODO DM role manager
2016     L2CA_SetDesireRole(cc->role);
2017     */
2018
2019     sec_id = bta_jv_alloc_sec_id();
2020     evt_data.sec_id = sec_id;
2021     evt_data.status = BTA_JV_SUCCESS;
2022     if (0 == sec_id ||
2023         BTM_SetSecurityLevel(TRUE, "", sec_id,  cc->sec_mask, BT_PSM_RFCOMM,
2024                 BTM_SEC_PROTO_RFCOMM, cc->remote_scn) == FALSE)
2025     {
2026         evt_data.status = BTA_JV_FAILURE;
2027         APPL_TRACE_ERROR("sec_id:%d is zero or BTM_SetSecurityLevel failed, remote_scn:%d", sec_id, cc->remote_scn);
2028     }
2029
2030     if (evt_data.status == BTA_JV_SUCCESS &&
2031         RFCOMM_CreateConnection(UUID_SERVCLASS_SERIAL_PORT, cc->remote_scn, FALSE,
2032         BTA_JV_DEF_RFC_MTU, cc->peer_bd_addr, &handle, bta_jv_port_mgmt_cl_cback) != PORT_SUCCESS)
2033     {
2034         APPL_TRACE_ERROR("bta_jv_rfcomm_connect, RFCOMM_CreateConnection failed");
2035         evt_data.status = BTA_JV_FAILURE;
2036     }
2037     if (evt_data.status == BTA_JV_SUCCESS)
2038     {
2039         p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
2040         if(p_cb)
2041         {
2042             p_cb->p_cback = cc->p_cback;
2043             p_cb->sec_id = sec_id;
2044             p_cb->scn = 0;
2045             p_pcb->state = BTA_JV_ST_CL_OPENING;
2046             p_pcb->user_data = cc->user_data;
2047             evt_data.use_co = TRUE;
2048
2049             PORT_SetEventCallback(handle, bta_jv_port_event_cl_cback);
2050             PORT_SetEventMask(handle, event_mask);
2051             PORT_SetDataCOCallback (handle, bta_jv_port_data_co_cback);
2052
2053             PORT_GetState(handle, &port_state);
2054
2055             port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
2056
2057             /* coverity[uninit_use_in_call]
2058                FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
2059             PORT_SetState(handle, &port_state);
2060
2061             evt_data.handle = p_cb->handle;
2062         }
2063         else
2064         {
2065             evt_data.status = BTA_JV_FAILURE;
2066             APPL_TRACE_ERROR("run out of rfc control block");
2067         }
2068     }
2069     cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV *)&evt_data, cc->user_data);
2070     if(evt_data.status == BTA_JV_FAILURE)
2071     {
2072         if(sec_id)
2073             bta_jv_free_sec_id(&sec_id);
2074         if(handle)
2075             RFCOMM_RemoveConnection(handle);
2076     }
2077  }
2078
2079 static int find_rfc_pcb(void* user_data, tBTA_JV_RFC_CB **cb, tBTA_JV_PCB **pcb)
2080 {
2081     *cb = NULL;
2082     *pcb = NULL;
2083     int i;
2084     for (i = 0; i < MAX_RFC_PORTS; i++)
2085     {
2086         UINT32 rfc_handle = bta_jv_cb.port_cb[i].handle & BTA_JV_RFC_HDL_MASK;
2087         rfc_handle &= ~BTA_JV_RFCOMM_MASK;
2088         if (rfc_handle && bta_jv_cb.port_cb[i].user_data == user_data)
2089         {
2090             *pcb = &bta_jv_cb.port_cb[i];
2091             *cb = &bta_jv_cb.rfc_cb[rfc_handle - 1];
2092             APPL_TRACE_DEBUG("find_rfc_pcb(): FOUND rfc_cb_handle 0x%x, port.jv_handle:"
2093                     " 0x%x, state: %d, rfc_cb->handle: 0x%x", rfc_handle, (*pcb)->handle,
2094                     (*pcb)->state, (*cb)->handle);
2095             return 1;
2096         }
2097     }
2098     APPL_TRACE_DEBUG("find_rfc_pcb: cannot find rfc_cb from user data:%d", (UINT32)user_data);
2099     return 0;
2100 }
2101
2102 /*******************************************************************************
2103 **
2104 ** Function     bta_jv_rfcomm_close
2105 **
2106 ** Description  Close an RFCOMM connection
2107 **
2108 ** Returns      void
2109 **
2110 *******************************************************************************/
2111 void bta_jv_rfcomm_close(tBTA_JV_MSG *p_data)
2112 {
2113     tBTA_JV_API_RFCOMM_CLOSE *cc = &(p_data->rfcomm_close);
2114     tBTA_JV_RFC_CB           *p_cb = NULL;
2115     tBTA_JV_PCB              *p_pcb = NULL;
2116     APPL_TRACE_DEBUG("bta_jv_rfcomm_close, rfc handle:%d", cc->handle);
2117     if (!cc->handle)
2118     {
2119         APPL_TRACE_ERROR("bta_jv_rfcomm_close, rfc handle is null");
2120         return;
2121     }
2122
2123     void* user_data = cc->user_data;
2124     if (!find_rfc_pcb(user_data, &p_cb, &p_pcb))
2125         return;
2126     bta_jv_free_rfc_cb(p_cb, p_pcb);
2127     APPL_TRACE_DEBUG("bta_jv_rfcomm_close: sec id in use:%d, rfc_cb in use:%d",
2128                 get_sec_id_used(), get_rfc_cb_used());
2129 }
2130
2131 /*******************************************************************************
2132 **
2133 ** Function     bta_jv_port_mgmt_sr_cback
2134 **
2135 ** Description  callback for port mamangement function of rfcomm
2136 **              server connections
2137 **
2138 ** Returns      void
2139 **
2140 *******************************************************************************/
2141 static void bta_jv_port_mgmt_sr_cback(UINT32 code, UINT16 port_handle)
2142 {
2143     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
2144     tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
2145     tBTA_JV evt_data;
2146     BD_ADDR rem_bda;
2147     UINT16 lcid;
2148     UINT8  num;
2149     UINT32  si;
2150     APPL_TRACE_DEBUG("bta_jv_port_mgmt_sr_cback, code:%d, port_handle:%d", code, port_handle);
2151     if(NULL == p_cb || NULL == p_cb->p_cback)
2152     {
2153         APPL_TRACE_ERROR("bta_jv_port_mgmt_sr_cback, p_cb:%p, p_cb->p_cback%p",
2154                 p_cb, p_cb ? p_cb->p_cback : NULL);
2155         return;
2156     }
2157     void *user_data = p_pcb->user_data;
2158     APPL_TRACE_DEBUG( "bta_jv_port_mgmt_sr_cback code=%d port_handle:0x%x handle:0x%x, p_pcb:%p, user:%d",
2159         code, port_handle, p_cb->handle, p_pcb, p_pcb->user_data);
2160
2161     PORT_CheckConnection(port_handle, rem_bda, &lcid);
2162     int failed = TRUE;
2163     if (code == PORT_SUCCESS)
2164     {
2165         evt_data.rfc_srv_open.handle = p_pcb->handle;
2166         evt_data.rfc_srv_open.status = BTA_JV_SUCCESS;
2167         bdcpy(evt_data.rfc_srv_open.rem_bda, rem_bda);
2168         tBTA_JV_PCB *p_pcb_new_listen  = bta_jv_add_rfc_port(p_cb, p_pcb);
2169         if (p_pcb_new_listen)
2170         {
2171             evt_data.rfc_srv_open.new_listen_handle = p_pcb_new_listen->handle;
2172             p_pcb_new_listen->user_data = p_cb->p_cback(BTA_JV_RFCOMM_SRV_OPEN_EVT, &evt_data, user_data);
2173             APPL_TRACE_DEBUG("PORT_SUCCESS: curr_sess:%d, max_sess:%d", p_cb->curr_sess, p_cb->max_sess);
2174             failed = FALSE;
2175         }
2176         else
2177             APPL_TRACE_ERROR("bta_jv_add_rfc_port failed to create new listen port");
2178     }
2179     if (failed)
2180     {
2181         evt_data.rfc_close.handle = p_cb->handle;
2182         evt_data.rfc_close.status = BTA_JV_FAILURE;
2183         evt_data.rfc_close.async = TRUE;
2184         evt_data.rfc_close.port_status = code;
2185         p_pcb->cong = FALSE;
2186
2187         tBTA_JV_RFCOMM_CBACK    *p_cback = p_cb->p_cback;
2188         APPL_TRACE_DEBUG("PORT_CLOSED before BTA_JV_RFCOMM_CLOSE_EVT: curr_sess:%d, max_sess:%d",
2189                             p_cb->curr_sess, p_cb->max_sess);
2190         if(BTA_JV_ST_SR_CLOSING == p_pcb->state)
2191         {
2192             evt_data.rfc_close.async = FALSE;
2193             evt_data.rfc_close.status = BTA_JV_SUCCESS;
2194         }
2195         //p_pcb->state = BTA_JV_ST_NONE;
2196         p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, user_data);
2197         //bta_jv_free_rfc_cb(p_cb, p_pcb);
2198
2199         APPL_TRACE_DEBUG("PORT_CLOSED after BTA_JV_RFCOMM_CLOSE_EVT: curr_sess:%d, max_sess:%d",
2200                 p_cb->curr_sess, p_cb->max_sess);
2201      }
2202 }
2203
2204 /*******************************************************************************
2205 **
2206 ** Function     bta_jv_port_event_sr_cback
2207 **
2208 ** Description  Callback for RFCOMM server port events
2209 **
2210 ** Returns      void
2211 **
2212 *******************************************************************************/
2213 static void bta_jv_port_event_sr_cback(UINT32 code, UINT16 port_handle)
2214 {
2215     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
2216     tBTA_JV_RFC_CB  *p_cb = bta_jv_rfc_port_to_cb(port_handle);
2217     tBTA_JV evt_data;
2218
2219     if(NULL == p_cb || NULL == p_cb->p_cback)
2220         return;
2221
2222     APPL_TRACE_DEBUG( "bta_jv_port_event_sr_cback code=x%x port_handle:%d handle:%d",
2223         code, port_handle, p_cb->handle);
2224
2225     void *user_data = p_pcb->user_data;
2226     if (code & PORT_EV_RXCHAR)
2227     {
2228         evt_data.data_ind.handle = p_cb->handle;
2229         p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, user_data);
2230     }
2231
2232     if (code & PORT_EV_FC)
2233     {
2234         p_pcb->cong = (code & PORT_EV_FCS) ? FALSE : TRUE;
2235         evt_data.rfc_cong.cong = p_pcb->cong;
2236         evt_data.rfc_cong.handle = p_cb->handle;
2237         evt_data.rfc_cong.status = BTA_JV_SUCCESS;
2238         p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, user_data);
2239     }
2240
2241     if (code & PORT_EV_TXEMPTY)
2242     {
2243         bta_jv_pm_conn_idle(p_pcb->p_pm_cb);
2244     }
2245 }
2246
2247 /*******************************************************************************
2248 **
2249 ** Function     bta_jv_add_rfc_port
2250 **
2251 ** Description  add a port for server when the existing posts is open
2252 **
2253 ** Returns   return a pointer to tBTA_JV_PCB just added
2254 **
2255 *******************************************************************************/
2256 static tBTA_JV_PCB * bta_jv_add_rfc_port(tBTA_JV_RFC_CB *p_cb, tBTA_JV_PCB *p_pcb_open)
2257 {
2258     UINT8   used = 0, i, listen=0;
2259     UINT32  si = 0;
2260     tPORT_STATE port_state;
2261     UINT32 event_mask = BTA_JV_RFC_EV_MASK;
2262     tBTA_JV_PCB *p_pcb = NULL;
2263     if (p_cb->max_sess > 1)
2264     {
2265         for (i=0; i < p_cb->max_sess; i++)
2266         {
2267             if (p_cb->rfc_hdl[i] != 0)
2268             {
2269                 p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
2270                 if (p_pcb->state == BTA_JV_ST_SR_LISTEN)
2271                 {
2272                     listen++;
2273                     if(p_pcb_open == p_pcb)
2274                     {
2275                         APPL_TRACE_DEBUG("bta_jv_add_rfc_port, port_handle:%d, change the listen port to open state",
2276                                               p_pcb->port_handle);
2277                         p_pcb->state = BTA_JV_ST_SR_OPEN;
2278
2279                     }
2280                     else
2281                     {
2282                         APPL_TRACE_ERROR("bta_jv_add_rfc_port, open pcb not matching listen one,"
2283                             "listen count:%d, listen pcb handle:%d, open pcb:%d",
2284                                listen, p_pcb->port_handle, p_pcb_open->handle);
2285                         return NULL;
2286                     }
2287                 }
2288                 used++;
2289             }
2290             else if (si == 0)
2291             {
2292                 si = i + 1;
2293             }
2294         }
2295
2296         APPL_TRACE_DEBUG("bta_jv_add_rfc_port max_sess=%d used:%d curr_sess:%d, listen:%d si:%d",
2297                     p_cb->max_sess, used, p_cb->curr_sess, listen, si);
2298         if (used < p_cb->max_sess && listen == 1 && si)
2299         {
2300             si--;
2301             if (RFCOMM_CreateConnection(p_cb->sec_id, p_cb->scn, TRUE,
2302                 BTA_JV_DEF_RFC_MTU, (UINT8 *) bd_addr_any, &(p_cb->rfc_hdl[si]), bta_jv_port_mgmt_sr_cback) == PORT_SUCCESS)
2303             {
2304                 p_cb->curr_sess++;
2305                 p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1];
2306                 p_pcb->state = BTA_JV_ST_SR_LISTEN;
2307                 p_pcb->port_handle = p_cb->rfc_hdl[si];
2308                 p_pcb->user_data = p_pcb_open->user_data;
2309
2310                 PORT_ClearKeepHandleFlag(p_pcb->port_handle);
2311                 PORT_SetEventCallback(p_pcb->port_handle, bta_jv_port_event_sr_cback);
2312                 PORT_SetDataCOCallback (p_pcb->port_handle, bta_jv_port_data_co_cback);
2313                 PORT_SetEventMask(p_pcb->port_handle, event_mask);
2314                 PORT_GetState(p_pcb->port_handle, &port_state);
2315
2316                 port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
2317
2318 /* coverity[uninit_use_in_call]
2319 FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
2320                 PORT_SetState(p_pcb->port_handle, &port_state);
2321                 p_pcb->handle = BTA_JV_RFC_H_S_TO_HDL(p_cb->handle, si);
2322                 APPL_TRACE_DEBUG("bta_jv_add_rfc_port: p_pcb->handle:0x%x, curr_sess:%d",
2323                                     p_pcb->handle, p_cb->curr_sess);
2324             }
2325         }
2326         else
2327             APPL_TRACE_ERROR("bta_jv_add_rfc_port, cannot create new rfc listen port");
2328     }
2329     APPL_TRACE_DEBUG("bta_jv_add_rfc_port: sec id in use:%d, rfc_cb in use:%d",
2330                 get_sec_id_used(), get_rfc_cb_used());
2331     return p_pcb;
2332 }
2333
2334 /*******************************************************************************
2335 **
2336 ** Function     bta_jv_rfcomm_start_server
2337 **
2338 ** Description  waits for an RFCOMM client to connect
2339 **
2340 **
2341 ** Returns      void
2342 **
2343 *******************************************************************************/
2344 void bta_jv_rfcomm_start_server(tBTA_JV_MSG *p_data)
2345 {
2346     UINT16 handle = 0;
2347     UINT32 event_mask = BTA_JV_RFC_EV_MASK;
2348     tPORT_STATE port_state;
2349     UINT8   sec_id = 0;
2350     tBTA_JV_RFC_CB  *p_cb = NULL;
2351     tBTA_JV_PCB     *p_pcb;
2352     tBTA_JV_API_RFCOMM_SERVER *rs = &(p_data->rfcomm_server);
2353     tBTA_JV_RFCOMM_START        evt_data = {0};
2354     /* TODO DM role manager
2355     L2CA_SetDesireRole(rs->role);
2356     */
2357     evt_data.status = BTA_JV_FAILURE;
2358     APPL_TRACE_DEBUG("bta_jv_rfcomm_start_server: sec id in use:%d, rfc_cb in use:%d",
2359                 get_sec_id_used(), get_rfc_cb_used());
2360
2361     do
2362     {
2363         sec_id = bta_jv_alloc_sec_id();
2364
2365         if (0 == sec_id ||
2366             BTM_SetSecurityLevel(FALSE, "JV PORT", sec_id,  rs->sec_mask,
2367                 BT_PSM_RFCOMM, BTM_SEC_PROTO_RFCOMM, rs->local_scn) == FALSE)
2368         {
2369             APPL_TRACE_ERROR("bta_jv_rfcomm_start_server, run out of sec_id");
2370             break;
2371         }
2372
2373         if (RFCOMM_CreateConnection(sec_id, rs->local_scn, TRUE,
2374             BTA_JV_DEF_RFC_MTU, (UINT8 *) bd_addr_any, &handle, bta_jv_port_mgmt_sr_cback) != PORT_SUCCESS)
2375         {
2376             APPL_TRACE_ERROR("bta_jv_rfcomm_start_server, RFCOMM_CreateConnection failed");
2377             break;
2378         }
2379
2380
2381         p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
2382         if(!p_cb)
2383         {
2384             APPL_TRACE_ERROR("bta_jv_rfcomm_start_server, run out of rfc control block");
2385             break;
2386         }
2387
2388         p_cb->max_sess = rs->max_session;
2389         p_cb->p_cback = rs->p_cback;
2390         p_cb->sec_id = sec_id;
2391         p_cb->scn = rs->local_scn;
2392         p_pcb->state = BTA_JV_ST_SR_LISTEN;
2393         p_pcb->user_data = rs->user_data;
2394         evt_data.status = BTA_JV_SUCCESS;
2395         evt_data.handle = p_cb->handle;
2396         evt_data.sec_id = sec_id;
2397         evt_data.use_co = TRUE; //FALSE;
2398
2399         PORT_ClearKeepHandleFlag(handle);
2400         PORT_SetEventCallback(handle, bta_jv_port_event_sr_cback);
2401         PORT_SetEventMask(handle, event_mask);
2402         PORT_GetState(handle, &port_state);
2403
2404         port_state.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
2405
2406 /* coverity[uninit_use_in_call]
2407 FALSE-POSITIVE: port_state is initialized at PORT_GetState() */
2408         PORT_SetState(handle, &port_state);
2409     } while (0);
2410     rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV *)&evt_data, rs->user_data);
2411     if(evt_data.status == BTA_JV_SUCCESS)
2412     {
2413         PORT_SetDataCOCallback (handle, bta_jv_port_data_co_cback);
2414     }
2415     else
2416     {
2417         if(sec_id)
2418             bta_jv_free_sec_id(&sec_id);
2419         if(handle)
2420             RFCOMM_RemoveConnection(handle);
2421     }
2422 }
2423
2424 /*******************************************************************************
2425 **
2426 ** Function     bta_jv_rfcomm_stop_server
2427 **
2428 ** Description  stops an RFCOMM server
2429 **
2430 ** Returns      void
2431 **
2432 *******************************************************************************/
2433
2434 void bta_jv_rfcomm_stop_server(tBTA_JV_MSG *p_data)
2435 {
2436     tBTA_JV_API_RFCOMM_SERVER *ls = &(p_data->rfcomm_server);
2437     tBTA_JV_RFC_CB           *p_cb = NULL;
2438     tBTA_JV_PCB              *p_pcb = NULL;
2439     APPL_TRACE_DEBUG("bta_jv_rfcomm_stop_server");
2440     if(!ls->handle)
2441     {
2442         APPL_TRACE_ERROR("bta_jv_rfcomm_stop_server, jv handle is null");
2443         return;
2444     }
2445     void* user_data = ls->user_data;
2446     if(!find_rfc_pcb(user_data, &p_cb, &p_pcb))
2447         return;
2448     APPL_TRACE_DEBUG("bta_jv_rfcomm_stop_server: p_pcb:%p, p_pcb->port_handle:%d",
2449                         p_pcb, p_pcb->port_handle);
2450     bta_jv_free_rfc_cb(p_cb, p_pcb);
2451     APPL_TRACE_DEBUG("bta_jv_rfcomm_stop_server: sec id in use:%d, rfc_cb in use:%d",
2452                 get_sec_id_used(), get_rfc_cb_used());
2453 }
2454
2455 /*******************************************************************************
2456 **
2457 ** Function     bta_jv_rfcomm_read
2458 **
2459 ** Description  Read data from an RFCOMM connection
2460 **
2461 ** Returns      void
2462 **
2463 *******************************************************************************/
2464 void bta_jv_rfcomm_read(tBTA_JV_MSG *p_data)
2465 {
2466     tBTA_JV_API_RFCOMM_READ *rc = &(p_data->rfcomm_read);
2467     tBTA_JV_RFC_CB  *p_cb = rc->p_cb;
2468     tBTA_JV_PCB     *p_pcb = rc->p_pcb;
2469     tBTA_JV_RFCOMM_READ    evt_data;
2470
2471     evt_data.status = BTA_JV_FAILURE;
2472     evt_data.handle = p_cb->handle;
2473     evt_data.req_id = rc->req_id;
2474     evt_data.p_data = rc->p_data;
2475     if (PORT_ReadData(rc->p_pcb->port_handle, (char *)rc->p_data, rc->len, &evt_data.len) ==
2476         PORT_SUCCESS)
2477     {
2478         evt_data.status = BTA_JV_SUCCESS;
2479     }
2480
2481     p_cb->p_cback(BTA_JV_RFCOMM_READ_EVT, (tBTA_JV *)&evt_data, p_pcb->user_data);
2482 }
2483
2484 /*******************************************************************************
2485 **
2486 ** Function     bta_jv_rfcomm_write
2487 **
2488 ** Description  write data to an RFCOMM connection
2489 **
2490 ** Returns      void
2491 **
2492 *******************************************************************************/
2493 void bta_jv_rfcomm_write(tBTA_JV_MSG *p_data)
2494 {
2495     tBTA_JV_API_RFCOMM_WRITE *wc = &(p_data->rfcomm_write);
2496     tBTA_JV_RFC_CB  *p_cb = wc->p_cb;
2497     tBTA_JV_PCB     *p_pcb = wc->p_pcb;
2498     tBTA_JV_RFCOMM_WRITE    evt_data;
2499
2500     evt_data.status = BTA_JV_FAILURE;
2501     evt_data.handle = p_cb->handle;
2502     evt_data.req_id = wc->req_id;
2503     evt_data.cong   = p_pcb->cong;
2504     evt_data.len    = 0;
2505     bta_jv_pm_conn_busy(p_pcb->p_pm_cb);
2506     if (!evt_data.cong &&
2507         PORT_WriteDataCO(p_pcb->port_handle, &evt_data.len) ==
2508         PORT_SUCCESS)
2509     {
2510         evt_data.status = BTA_JV_SUCCESS;
2511     }
2512     //update congestion flag
2513     evt_data.cong   = p_pcb->cong;
2514     if (p_cb->p_cback)
2515     {
2516         p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, (tBTA_JV *)&evt_data, p_pcb->user_data);
2517     }
2518     else
2519     {
2520         APPL_TRACE_ERROR("bta_jv_rfcomm_write :: WARNING ! No JV callback set");
2521     }
2522 }
2523
2524 /*******************************************************************************
2525  **
2526  ** Function     bta_jv_set_pm_profile
2527  **
2528  ** Description  Set or free power mode profile for a JV application
2529  **
2530  ** Returns      void
2531  **
2532  *******************************************************************************/
2533 void bta_jv_set_pm_profile(tBTA_JV_MSG *p_data)
2534 {
2535     tBTA_JV_STATUS status;
2536     tBTA_JV_PM_CB *p_cb;
2537
2538     APPL_TRACE_API("bta_jv_set_pm_profile(handle: 0x%x, app_id: %d, init_st: %d)",
2539             p_data->set_pm.handle, p_data->set_pm.app_id, p_data->set_pm.init_st);
2540
2541     /* clear PM control block */
2542     if (p_data->set_pm.app_id == BTA_JV_PM_ID_CLEAR)
2543     {
2544         status = bta_jv_free_set_pm_profile_cb(p_data->set_pm.handle);
2545
2546         if (status != BTA_JV_SUCCESS)
2547         {
2548             APPL_TRACE_WARNING("bta_jv_set_pm_profile() free pm cb failed: reason %d",
2549                     status);
2550         }
2551     }
2552     else /* set PM control block */
2553     {
2554         p_cb = bta_jv_alloc_set_pm_profile_cb(p_data->set_pm.handle,
2555                 p_data->set_pm.app_id);
2556
2557         if (NULL != p_cb)
2558             bta_jv_pm_state_change(p_cb, p_data->set_pm.init_st);
2559         else
2560             APPL_TRACE_WARNING("bta_jv_alloc_set_pm_profile_cb() failed");
2561     }
2562 }
2563
2564 /*******************************************************************************
2565  **
2566  ** Function     bta_jv_change_pm_state
2567  **
2568  ** Description  change jv pm connect state, used internally
2569  **
2570  ** Returns      void
2571  **
2572  *******************************************************************************/
2573 void bta_jv_change_pm_state(tBTA_JV_MSG *p_data)
2574 {
2575     tBTA_JV_API_PM_STATE_CHANGE *p_msg = (tBTA_JV_API_PM_STATE_CHANGE *)p_data;
2576
2577     if (p_msg->p_cb)
2578         bta_jv_pm_state_change(p_msg->p_cb, p_msg->state);
2579 }
2580
2581
2582 /*******************************************************************************
2583  **
2584  ** Function    bta_jv_set_pm_conn_state
2585  **
2586  ** Description Send pm event state change to jv state machine to serialize jv pm changes
2587  **             in relation to other jv messages. internal API use mainly.
2588  **
2589  ** Params:     p_cb: jv pm control block, NULL pointer returns failure
2590  **             new_state: new PM connections state, setting is forced by action function
2591  **
2592  ** Returns     BTA_JV_SUCCESS, BTA_JV_FAILURE (buffer allocation, or NULL ptr!)
2593  **
2594  *******************************************************************************/
2595 tBTA_JV_STATUS bta_jv_set_pm_conn_state(tBTA_JV_PM_CB *p_cb, const tBTA_JV_CONN_STATE
2596         new_st)
2597 {
2598     tBTA_JV_STATUS status = BTA_JV_FAILURE;
2599     tBTA_JV_API_PM_STATE_CHANGE *p_msg;
2600
2601     if (NULL == p_cb)
2602         return status;
2603
2604     APPL_TRACE_API("bta_jv_set_pm_conn_state(handle:0x%x, state: %d)", p_cb->handle,
2605             new_st);
2606     if ((p_msg = (tBTA_JV_API_PM_STATE_CHANGE *)GKI_getbuf(
2607             sizeof(tBTA_JV_API_PM_STATE_CHANGE))) != NULL)
2608     {
2609         p_msg->hdr.event = BTA_JV_API_PM_STATE_CHANGE_EVT;
2610         p_msg->p_cb = p_cb;
2611         p_msg->state = new_st;
2612         bta_sys_sendmsg(p_msg);
2613         status = BTA_JV_SUCCESS;
2614     }
2615     return (status);
2616 }
2617
2618 /*******************************************************************************
2619  **
2620  ** Function    bta_jv_pm_conn_busy
2621  **
2622  ** Description set pm connection busy state (input param safe)
2623  **
2624  ** Params      p_cb: pm control block of jv connection
2625  **
2626  ** Returns     void
2627  **
2628  *******************************************************************************/
2629 static void bta_jv_pm_conn_busy(tBTA_JV_PM_CB *p_cb)
2630 {
2631     if ((NULL != p_cb) && (BTA_JV_PM_IDLE_ST == p_cb->state))
2632         bta_jv_pm_state_change(p_cb, BTA_JV_CONN_BUSY);
2633 }
2634
2635 /*******************************************************************************
2636  **
2637  ** Function    bta_jv_pm_conn_busy
2638  **
2639  ** Description set pm connection busy state (input param safe)
2640  **
2641  ** Params      p_cb: pm control block of jv connection
2642  **
2643  ** Returns     void
2644  **
2645  *******************************************************************************/
2646 static void bta_jv_pm_conn_idle(tBTA_JV_PM_CB *p_cb)
2647 {
2648     if ((NULL != p_cb) && (BTA_JV_PM_IDLE_ST != p_cb->state))
2649         bta_jv_pm_state_change(p_cb, BTA_JV_CONN_IDLE);
2650 }
2651
2652 /*******************************************************************************
2653  **
2654  ** Function     bta_jv_pm_state_change
2655  **
2656  ** Description  Notify power manager there is state change
2657  **
2658  ** Params      p_cb: must be NONE NULL
2659  **
2660  ** Returns      void
2661  **
2662  *******************************************************************************/
2663 static void bta_jv_pm_state_change(tBTA_JV_PM_CB *p_cb, const tBTA_JV_CONN_STATE state)
2664 {
2665     APPL_TRACE_API("bta_jv_pm_state_change(p_cb: 0x%x, handle: 0x%x, busy/idle_state: %d"
2666             ", app_id: %d, conn_state: %d)", p_cb, p_cb->handle, p_cb->state,
2667             p_cb->app_id, state);
2668
2669     switch (state)
2670     {
2671     case BTA_JV_CONN_OPEN:
2672         bta_sys_conn_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2673         break;
2674
2675     case BTA_JV_CONN_CLOSE:
2676         bta_sys_conn_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2677         break;
2678
2679     case BTA_JV_APP_OPEN:
2680         bta_sys_app_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2681         break;
2682
2683     case BTA_JV_APP_CLOSE:
2684         bta_sys_app_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2685         break;
2686
2687     case BTA_JV_SCO_OPEN:
2688         bta_sys_sco_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2689         break;
2690
2691     case BTA_JV_SCO_CLOSE:
2692         bta_sys_sco_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2693         break;
2694
2695     case BTA_JV_CONN_IDLE:
2696         p_cb->state = BTA_JV_PM_IDLE_ST;
2697         bta_sys_idle(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2698         break;
2699
2700     case BTA_JV_CONN_BUSY:
2701         p_cb->state = BTA_JV_PM_BUSY_ST;
2702         bta_sys_busy(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2703         break;
2704
2705     default:
2706         APPL_TRACE_WARNING("bta_jv_pm_state_change(state: %d): Invalid state", state);
2707         break;
2708     }
2709 }