stack/sdp/sdp_main.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 1999-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This file contains the main SDP functions
  22  *
  23  ******************************************************************************/
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28
  29 #include "bt_target.h"
  30 #include "bt_utils.h"
  31 #include "bt_common.h"
  32 #include "l2cdefs.h"
  33 #include "hcidefs.h"
  34 #include "hcimsgs.h"
  35
  36 #include "l2c_api.h"
  37 #include "l2cdefs.h"
  38
  39 #include "btu.h"
  40 #include "btm_api.h"
  41
  42 #include "sdp_api.h"
  43 #include "sdpint.h"
  44
  45
  46 extern fixed_queue_t *btu_general_alarm_queue;
  47
  48 /********************************************************************************/
  49 /*                       G L O B A L      S D P       D A T A                   */
  50 /********************************************************************************/
  51 #if SDP_DYNAMIC_MEMORY == FALSE
  52 tSDP_CB  sdp_cb;
  53 #endif
  54
  55 /********************************************************************************/
  56 /*              L O C A L    F U N C T I O N     P R O T O T Y P E S            */
  57 /********************************************************************************/
  58 static void sdp_connect_ind (BD_ADDR  bd_addr, UINT16 l2cap_cid, UINT16 psm,
  59                              UINT8 l2cap_id);
  60 static void sdp_config_ind (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
  61 static void sdp_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
  62 static void sdp_disconnect_ind (UINT16 l2cap_cid, BOOLEAN ack_needed);
  63 static void sdp_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg);
  64
  65 #if SDP_CLIENT_ENABLED == TRUE
  66 static void sdp_connect_cfm (UINT16 l2cap_cid, UINT16 result);
  67 static void sdp_disconnect_cfm (UINT16 l2cap_cid, UINT16 result);
  68 #else
  69 #define sdp_connect_cfm     NULL
  70 #define sdp_disconnect_cfm  NULL
  71 #endif
  72
  73
  74 /*******************************************************************************
  75 **
  76 ** Function         sdp_init
  77 **
  78 ** Description      This function initializes the SDP unit.
  79 **
  80 ** Returns          void
  81 **
  82 *******************************************************************************/
  83 void sdp_init (void)
  84 {
  85     /* Clears all structures and local SDP database (if Server is enabled) */
  86     memset (&sdp_cb, 0, sizeof (tSDP_CB));
  87
  88     /* Initialize the L2CAP configuration. We only care about MTU and flush */
  89     sdp_cb.l2cap_my_cfg.mtu_present       = TRUE;
  90     sdp_cb.l2cap_my_cfg.mtu               = SDP_MTU_SIZE;
  91     sdp_cb.l2cap_my_cfg.flush_to_present  = TRUE;
  92     sdp_cb.l2cap_my_cfg.flush_to          = SDP_FLUSH_TO;
  93
  94     sdp_cb.max_attr_list_size             = SDP_MTU_SIZE - 16;
  95     sdp_cb.max_recs_per_search            = SDP_MAX_DISC_SERVER_RECS;
  96
  97 #if SDP_SERVER_ENABLED == TRUE
  98     /* Register with Security Manager for the specific security level */
  99     if (!BTM_SetSecurityLevel (FALSE, SDP_SERVICE_NAME, BTM_SEC_SERVICE_SDP_SERVER,
 100                                SDP_SECURITY_LEVEL, SDP_PSM, 0, 0))
 101     {
 102         SDP_TRACE_ERROR ("Security Registration Server failed");
 103         return;
 104     }
 105 #endif
 106
 107 #if SDP_CLIENT_ENABLED == TRUE
 108     /* Register with Security Manager for the specific security level */
 109     if (!BTM_SetSecurityLevel (TRUE, SDP_SERVICE_NAME, BTM_SEC_SERVICE_SDP_SERVER,
 110                                SDP_SECURITY_LEVEL, SDP_PSM, 0, 0))
 111     {
 112         SDP_TRACE_ERROR ("Security Registration for Client failed");
 113         return;
 114     }
 115 #endif
 116
 117 #if defined(SDP_INITIAL_TRACE_LEVEL)
 118     sdp_cb.trace_level = SDP_INITIAL_TRACE_LEVEL;
 119 #else
 120     sdp_cb.trace_level = BT_TRACE_LEVEL_NONE;    /* No traces */
 121 #endif
 122
 123     sdp_cb.reg_info.pL2CA_ConnectInd_Cb = sdp_connect_ind;
 124     sdp_cb.reg_info.pL2CA_ConnectCfm_Cb = sdp_connect_cfm;
 125     sdp_cb.reg_info.pL2CA_ConnectPnd_Cb = NULL;
 126     sdp_cb.reg_info.pL2CA_ConfigInd_Cb  = sdp_config_ind;
 127     sdp_cb.reg_info.pL2CA_ConfigCfm_Cb  = sdp_config_cfm;
 128     sdp_cb.reg_info.pL2CA_DisconnectInd_Cb = sdp_disconnect_ind;
 129     sdp_cb.reg_info.pL2CA_DisconnectCfm_Cb = sdp_disconnect_cfm;
 130     sdp_cb.reg_info.pL2CA_QoSViolationInd_Cb = NULL;
 131     sdp_cb.reg_info.pL2CA_DataInd_Cb = sdp_data_ind;
 132     sdp_cb.reg_info.pL2CA_CongestionStatus_Cb = NULL;
 133     sdp_cb.reg_info.pL2CA_TxComplete_Cb       = NULL;
 134
 135     /* Now, register with L2CAP */
 136     if (!L2CA_Register (SDP_PSM, &sdp_cb.reg_info))
 137     {
 138         SDP_TRACE_ERROR ("SDP Registration failed");
 139     }
 140 }
 141
 142 #if (defined(SDP_DEBUG) && SDP_DEBUG == TRUE)
 143 /*******************************************************************************
 144 **
 145 ** Function         sdp_set_max_attr_list_size
 146 **
 147 ** Description      This function sets the max attribute list size to use
 148 **
 149 ** Returns          void
 150 **
 151 *******************************************************************************/
 152 UINT16 sdp_set_max_attr_list_size (UINT16 max_size)
 153 {
 154     if (max_size > (sdp_cb.l2cap_my_cfg.mtu - 16) )
 155         max_size = sdp_cb.l2cap_my_cfg.mtu - 16;
 156
 157     sdp_cb.max_attr_list_size  = max_size;
 158
 159     return sdp_cb.max_attr_list_size;
 160 }
 161 #endif
 162
 163 /*******************************************************************************
 164 **
 165 ** Function         sdp_connect_ind
 166 **
 167 ** Description      This function handles an inbound connection indication
 168 **                  from L2CAP. This is the case where we are acting as a
 169 **                  server.
 170 **
 171 ** Returns          void
 172 **
 173 *******************************************************************************/
 174 static void sdp_connect_ind (BD_ADDR  bd_addr, UINT16 l2cap_cid, UINT16 psm, UINT8 l2cap_id)
 175 {
 176     UNUSED(psm);
 177 #if SDP_SERVER_ENABLED == TRUE
 178     tCONN_CB    *p_ccb;
 179
 180     /* Allocate a new CCB. Return if none available. */
 181     if ((p_ccb = sdpu_allocate_ccb()) == NULL)
 182         return;
 183
 184     /* Transition to the next appropriate state, waiting for config setup. */
 185     p_ccb->con_state = SDP_STATE_CFG_SETUP;
 186
 187     /* Save the BD Address and Channel ID. */
 188     memcpy (&p_ccb->device_address[0], bd_addr, sizeof (BD_ADDR));
 189     p_ccb->connection_id = l2cap_cid;
 190
 191     /* Send response to the L2CAP layer. */
 192     L2CA_ConnectRsp (bd_addr, l2cap_id, l2cap_cid, L2CAP_CONN_OK, L2CAP_CONN_OK);
 193     {
 194         tL2CAP_CFG_INFO cfg = sdp_cb.l2cap_my_cfg;
 195
 196         if (cfg.fcr_present)
 197         {
 198             SDP_TRACE_DEBUG("sdp_connect_ind:  mode %u, txwinsz %u, max_trans %u, rtrans_tout %u, mon_tout %u, mps %u",
 199                         cfg.fcr.mode, cfg.fcr.tx_win_sz, cfg.fcr.max_transmit,
 200                         cfg.fcr.rtrans_tout,cfg.fcr.mon_tout, cfg.fcr.mps);
 201         }
 202
 203         if ((!L2CA_ConfigReq (l2cap_cid, &cfg)) && cfg.fcr_present
 204              && cfg.fcr.mode != L2CAP_FCR_BASIC_MODE)
 205         {
 206             /* FCR not desired; try again in basic mode */
 207             cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
 208             cfg.fcr_present = FALSE;
 209             L2CA_ConfigReq (l2cap_cid, &cfg);
 210         }
 211     }
 212
 213     SDP_TRACE_EVENT ("SDP - Rcvd L2CAP conn ind, sent config req, CID 0x%x", p_ccb->connection_id);
 214 #else   /* No server */
 215     /* Reject the connection */
 216     L2CA_ConnectRsp (bd_addr, l2cap_id, l2cap_cid, L2CAP_CONN_NO_PSM, 0);
 217 #endif
 218 }
 219
 220 #if SDP_CLIENT_ENABLED == TRUE
 221 /*******************************************************************************
 222 **
 223 ** Function         sdp_connect_cfm
 224 **
 225 ** Description      This function handles the connect confirm events
 226 **                  from L2CAP. This is the case when we are acting as a
 227 **                  client and have sent a connect request.
 228 **
 229 ** Returns          void
 230 **
 231 *******************************************************************************/
 232 static void sdp_connect_cfm (UINT16 l2cap_cid, UINT16 result)
 233 {
 234     tCONN_CB    *p_ccb;
 235     tL2CAP_CFG_INFO cfg;
 236
 237     /* Find CCB based on CID */
 238     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) == NULL)
 239     {
 240         SDP_TRACE_WARNING ("SDP - Rcvd conn cnf for unknown CID 0x%x", l2cap_cid);
 241         return;
 242     }
 243
 244     /* If the connection response contains success status, then */
 245     /* Transition to the next state and startup the timer.      */
 246     if ((result == L2CAP_CONN_OK) && (p_ccb->con_state == SDP_STATE_CONN_SETUP))
 247     {
 248         p_ccb->con_state = SDP_STATE_CFG_SETUP;
 249
 250         cfg = sdp_cb.l2cap_my_cfg;
 251
 252         if (cfg.fcr_present)
 253         {
 254             SDP_TRACE_DEBUG("sdp_connect_cfm:  mode %u, txwinsz %u, max_trans %u, rtrans_tout %u, mon_tout %u, mps %u",
 255                         cfg.fcr.mode, cfg.fcr.tx_win_sz, cfg.fcr.max_transmit,
 256                         cfg.fcr.rtrans_tout,cfg.fcr.mon_tout, cfg.fcr.mps);
 257         }
 258
 259         if ((!L2CA_ConfigReq (l2cap_cid, &cfg)) && cfg.fcr_present
 260              && cfg.fcr.mode != L2CAP_FCR_BASIC_MODE)
 261         {
 262             /* FCR not desired; try again in basic mode */
 263             cfg.fcr_present = FALSE;
 264             cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
 265             L2CA_ConfigReq (l2cap_cid, &cfg);
 266         }
 267
 268         SDP_TRACE_EVENT ("SDP - got conn cnf, sent cfg req, CID: 0x%x", p_ccb->connection_id);
 269     }
 270     else
 271     {
 272         SDP_TRACE_WARNING ("SDP - Rcvd conn cnf with error: 0x%x  CID 0x%x", result, p_ccb->connection_id);
 273
 274         /* Tell the user if he has a callback */
 275         if (p_ccb->p_cb || p_ccb->p_cb2)
 276         {
 277             UINT16 err = -1;
 278             if ((result == HCI_ERR_HOST_REJECT_SECURITY)
 279              || (result == HCI_ERR_AUTH_FAILURE)
 280              || (result == HCI_ERR_PAIRING_NOT_ALLOWED)
 281              || (result == HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED)
 282              || (result == HCI_ERR_KEY_MISSING))
 283                 err = SDP_SECURITY_ERR;
 284             else if (result == HCI_ERR_HOST_REJECT_DEVICE)
 285                 err = SDP_CONN_REJECTED;
 286             else
 287                 err = SDP_CONN_FAILED;
 288             if(p_ccb->p_cb)
 289                 (*p_ccb->p_cb)(err);
 290             else if(p_ccb->p_cb2)
 291                 (*p_ccb->p_cb2)(err, p_ccb->user_data);
 292
 293         }
 294         sdpu_release_ccb (p_ccb);
 295     }
 296 }
 297 #endif  /* SDP_CLIENT_ENABLED == TRUE */
 298
 299
 300 /*******************************************************************************
 301 **
 302 ** Function         sdp_config_ind
 303 **
 304 ** Description      This function processes the L2CAP configuration indication
 305 **                  event.
 306 **
 307 ** Returns          void
 308 **
 309 *******************************************************************************/
 310 static void sdp_config_ind (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
 311 {
 312     tCONN_CB    *p_ccb;
 313
 314     /* Find CCB based on CID */
 315     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) == NULL)
 316     {
 317         SDP_TRACE_WARNING ("SDP - Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
 318         return;
 319     }
 320
 321     /* Remember the remote MTU size */
 322     if (!p_cfg->mtu_present)
 323     {
 324         /* use min(L2CAP_DEFAULT_MTU,SDP_MTU_SIZE) for GKI buffer size reasons */
 325         p_ccb->rem_mtu_size = (L2CAP_DEFAULT_MTU > SDP_MTU_SIZE)?SDP_MTU_SIZE:L2CAP_DEFAULT_MTU;
 326     }
 327     else
 328     {
 329         if (p_cfg->mtu > SDP_MTU_SIZE)
 330             p_ccb->rem_mtu_size = SDP_MTU_SIZE;
 331         else
 332             p_ccb->rem_mtu_size = p_cfg->mtu;
 333     }
 334
 335     /* For now, always accept configuration from the other side */
 336     p_cfg->flush_to_present = FALSE;
 337     p_cfg->mtu_present      = FALSE;
 338     p_cfg->result           = L2CAP_CFG_OK;
 339
 340     /* Check peer config request against our rfcomm configuration */
 341     if (p_cfg->fcr_present)
 342     {
 343         /* Reject the window size if it is bigger than we want it to be */
 344         if (p_cfg->fcr.mode != L2CAP_FCR_BASIC_MODE)
 345         {
 346             if (sdp_cb.l2cap_my_cfg.fcr.mode != L2CAP_FCR_BASIC_MODE
 347                 && p_cfg->fcr.tx_win_sz > sdp_cb.l2cap_my_cfg.fcr.tx_win_sz)
 348             {
 349                 p_cfg->fcr.tx_win_sz = sdp_cb.l2cap_my_cfg.fcr.tx_win_sz;
 350                 p_cfg->result = L2CAP_CFG_UNACCEPTABLE_PARAMS;
 351                 SDP_TRACE_DEBUG("sdp_config_ind(CONFIG) -> Please try again with SMALLER TX WINDOW");
 352             }
 353
 354             /* Reject if locally we want basic and they don't */
 355             if (sdp_cb.l2cap_my_cfg.fcr.mode == L2CAP_FCR_BASIC_MODE)
 356             {
 357                 /* Ask for a new setup */
 358                 p_cfg->fcr.mode = L2CAP_FCR_BASIC_MODE;
 359                 p_cfg->result = L2CAP_CFG_UNACCEPTABLE_PARAMS;
 360                 SDP_TRACE_DEBUG("sdp_config_ind(CONFIG) -> Please try again with BASIC mode");
 361             }
 362             /* Remain in configure state and give the peer our desired configuration */
 363             if (p_cfg->result != L2CAP_CFG_OK)
 364             {
 365                 SDP_TRACE_WARNING ("SDP - Rcvd cfg ind, Unacceptable Parameters sent cfg cfm, CID: 0x%x", l2cap_cid);
 366                 L2CA_ConfigRsp (l2cap_cid, p_cfg);
 367                 return;
 368             }
 369         }
 370         else    /* We agree with peer's request */
 371             p_cfg->fcr_present = FALSE;
 372     }
 373
 374     L2CA_ConfigRsp (l2cap_cid, p_cfg);
 375
 376     SDP_TRACE_EVENT ("SDP - Rcvd cfg ind, sent cfg cfm, CID: 0x%x", l2cap_cid);
 377
 378     p_ccb->con_flags |= SDP_FLAGS_HIS_CFG_DONE;
 379
 380     if (p_ccb->con_flags & SDP_FLAGS_MY_CFG_DONE)
 381     {
 382         p_ccb->con_state = SDP_STATE_CONNECTED;
 383
 384         if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG) {
 385             sdp_disc_connected (p_ccb);
 386         } else {
 387             /* Start inactivity timer */
 388             alarm_set_on_queue(p_ccb->sdp_conn_timer, SDP_INACT_TIMEOUT_MS,
 389                                sdp_conn_timer_timeout, p_ccb,
 390                                btu_general_alarm_queue);
 391         }
 392     }
 393 }
 394
 395 /*******************************************************************************
 396 **
 397 ** Function         sdp_config_cfm
 398 **
 399 ** Description      This function processes the L2CAP configuration confirmation
 400 **                  event.
 401 **
 402 ** Returns          void
 403 **
 404 *******************************************************************************/
 405 static void sdp_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
 406 {
 407     tCONN_CB    *p_ccb;
 408
 409     SDP_TRACE_EVENT ("SDP - Rcvd cfg cfm, CID: 0x%x  Result: %d", l2cap_cid, p_cfg->result);
 410
 411     /* Find CCB based on CID */
 412     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) == NULL)
 413     {
 414         SDP_TRACE_WARNING ("SDP - Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
 415         return;
 416     }
 417
 418     /* For now, always accept configuration from the other side */
 419     if (p_cfg->result == L2CAP_CFG_OK)
 420     {
 421         p_ccb->con_flags |= SDP_FLAGS_MY_CFG_DONE;
 422
 423         if (p_ccb->con_flags & SDP_FLAGS_HIS_CFG_DONE)
 424         {
 425             p_ccb->con_state = SDP_STATE_CONNECTED;
 426
 427             if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG) {
 428                 sdp_disc_connected (p_ccb);
 429             } else {
 430                 /* Start inactivity timer */
 431                 alarm_set_on_queue(p_ccb->sdp_conn_timer, SDP_INACT_TIMEOUT_MS,
 432                                    sdp_conn_timer_timeout, p_ccb,
 433                                    btu_general_alarm_queue);
 434             }
 435         }
 436     }
 437     else
 438     {
 439         /* If peer has rejected FCR and suggested basic then try basic */
 440         if (p_cfg->fcr_present)
 441         {
 442             tL2CAP_CFG_INFO cfg = sdp_cb.l2cap_my_cfg;
 443             cfg.fcr_present = FALSE;
 444             L2CA_ConfigReq (l2cap_cid, &cfg);
 445
 446             /* Remain in configure state */
 447             return;
 448         }
 449
 450 #if SDP_CLIENT_ENABLED == TRUE
 451         sdp_disconnect(p_ccb, SDP_CFG_FAILED);
 452 #endif
 453     }
 454 }
 455
 456 /*******************************************************************************
 457 **
 458 ** Function         sdp_disconnect_ind
 459 **
 460 ** Description      This function handles a disconnect event from L2CAP. If
 461 **                  requested to, we ack the disconnect before dropping the CCB
 462 **
 463 ** Returns          void
 464 **
 465 *******************************************************************************/
 466 static void sdp_disconnect_ind (UINT16 l2cap_cid, BOOLEAN ack_needed)
 467 {
 468     tCONN_CB    *p_ccb;
 469
 470     /* Find CCB based on CID */
 471     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) == NULL)
 472     {
 473         SDP_TRACE_WARNING ("SDP - Rcvd L2CAP disc, unknown CID: 0x%x", l2cap_cid);
 474         return;
 475     }
 476
 477     if (ack_needed)
 478         L2CA_DisconnectRsp (l2cap_cid);
 479
 480     SDP_TRACE_EVENT ("SDP - Rcvd L2CAP disc, CID: 0x%x", l2cap_cid);
 481 #if SDP_CLIENT_ENABLED == TRUE
 482     /* Tell the user if he has a callback */
 483     if (p_ccb->p_cb)
 484         (*p_ccb->p_cb) ((UINT16) ((p_ccb->con_state == SDP_STATE_CONNECTED) ?
 485                         SDP_SUCCESS : SDP_CONN_FAILED));
 486     else if (p_ccb->p_cb2)
 487         (*p_ccb->p_cb2) ((UINT16) ((p_ccb->con_state == SDP_STATE_CONNECTED) ?
 488                         SDP_SUCCESS : SDP_CONN_FAILED), p_ccb->user_data);
 489
 490 #endif
 491     sdpu_release_ccb (p_ccb);
 492 }
 493
 494 /*******************************************************************************
 495 **
 496 ** Function         sdp_data_ind
 497 **
 498 ** Description      This function is called when data is received from L2CAP.
 499 **                  if we are the originator of the connection, we are the SDP
 500 **                  client, and the received message is queued up for the client.
 501 **
 502 **                  If we are the destination of the connection, we are the SDP
 503 **                  server, so the message is passed to the server processing
 504 **                  function.
 505 **
 506 ** Returns          void
 507 **
 508 *******************************************************************************/
 509 static void sdp_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg)
 510 {
 511     tCONN_CB    *p_ccb;
 512
 513     /* Find CCB based on CID */
 514     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) != NULL)
 515     {
 516         if (p_ccb->con_state == SDP_STATE_CONNECTED)
 517         {
 518             if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)
 519                 sdp_disc_server_rsp (p_ccb, p_msg);
 520             else
 521                 sdp_server_handle_client_req (p_ccb, p_msg);
 522         }
 523         else
 524         {
 525             SDP_TRACE_WARNING ("SDP - Ignored L2CAP data while in state: %d, CID: 0x%x",
 526                                 p_ccb->con_state, l2cap_cid);
 527         }
 528     }
 529     else
 530     {
 531         SDP_TRACE_WARNING ("SDP - Rcvd L2CAP data, unknown CID: 0x%x", l2cap_cid);
 532     }
 533
 534     osi_free(p_msg);
 535 }
 536
 537
 538 #if SDP_CLIENT_ENABLED == TRUE
 539 /*******************************************************************************
 540 **
 541 ** Function         sdp_conn_originate
 542 **
 543 ** Description      This function is called from the API to originate a
 544 **                  connection.
 545 **
 546 ** Returns          void
 547 **
 548 *******************************************************************************/
 549 tCONN_CB* sdp_conn_originate (UINT8 *p_bd_addr)
 550 {
 551     tCONN_CB              *p_ccb;
 552     UINT16                cid;
 553
 554     /* Allocate a new CCB. Return if none available. */
 555     if ((p_ccb = sdpu_allocate_ccb()) == NULL)
 556     {
 557         SDP_TRACE_WARNING ("SDP - no spare CCB for orig");
 558         return (NULL);
 559     }
 560
 561     SDP_TRACE_EVENT ("SDP - Originate started");
 562
 563     /* We are the originator of this connection */
 564     p_ccb->con_flags |= SDP_FLAGS_IS_ORIG;
 565
 566     /* Save the BD Address and Channel ID. */
 567     memcpy (&p_ccb->device_address[0], p_bd_addr, sizeof (BD_ADDR));
 568
 569     /* Transition to the next appropriate state, waiting for connection confirm. */
 570     p_ccb->con_state = SDP_STATE_CONN_SETUP;
 571
 572     cid = L2CA_ConnectReq (SDP_PSM, p_bd_addr);
 573
 574     /* Check if L2CAP started the connection process */
 575     if (cid != 0)
 576     {
 577         p_ccb->connection_id = cid;
 578
 579         return (p_ccb);
 580     }
 581     else
 582     {
 583         SDP_TRACE_WARNING ("SDP - Originate failed");
 584         sdpu_release_ccb (p_ccb);
 585         return (NULL);
 586     }
 587 }
 588
 589 /*******************************************************************************
 590 **
 591 ** Function         sdp_disconnect
 592 **
 593 ** Description      This function disconnects a connection.
 594 **
 595 ** Returns          void
 596 **
 597 *******************************************************************************/
 598 void sdp_disconnect (tCONN_CB*p_ccb, UINT16 reason)
 599 {
 600 #if (defined(SDP_BROWSE_PLUS) && SDP_BROWSE_PLUS == TRUE)
 601
 602     /* If we are browsing for multiple UUIDs ... */
 603     if ((p_ccb->con_state == SDP_STATE_CONNECTED)
 604      && (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)
 605      && ((reason == SDP_SUCCESS) || (reason == SDP_NO_RECS_MATCH)))
 606     {
 607         /* If the browse found something, do no more searching */
 608         if ((p_ccb->cur_uuid_idx == 0) && (p_ccb->p_db->p_first_rec))
 609             p_ccb->cur_uuid_idx = p_ccb->p_db->num_uuid_filters;
 610
 611         while (++p_ccb->cur_uuid_idx < p_ccb->p_db->num_uuid_filters)
 612         {
 613             /* Check we have not already found the UUID (maybe through browse) */
 614             if ((p_ccb->p_db->uuid_filters[p_ccb->cur_uuid_idx].len == 2)
 615                 && (SDP_FindServiceInDb (p_ccb->p_db,
 616                         p_ccb->p_db->uuid_filters[p_ccb->cur_uuid_idx].uu.uuid16,
 617                         NULL)))
 618                 continue;
 619
 620             if ((p_ccb->p_db->uuid_filters[p_ccb->cur_uuid_idx].len > 2)
 621                 && (SDP_FindServiceUUIDInDb (p_ccb->p_db,
 622                         &p_ccb->p_db->uuid_filters[p_ccb->cur_uuid_idx], NULL)))
 623                 continue;
 624
 625             p_ccb->cur_handle = 0;
 626
 627             SDP_TRACE_EVENT ("SDP - looking for for more,  CID: 0x%x",
 628                               p_ccb->connection_id);
 629
 630             sdp_disc_connected (p_ccb);
 631             return;
 632         }
 633     }
 634
 635     if ((reason == SDP_NO_RECS_MATCH) && (p_ccb->p_db->p_first_rec))
 636         reason = SDP_SUCCESS;
 637
 638 #endif
 639
 640     SDP_TRACE_EVENT ("SDP - disconnect  CID: 0x%x", p_ccb->connection_id);
 641
 642     /* Check if we have a connection ID */
 643     if (p_ccb->connection_id != 0)
 644     {
 645         L2CA_DisconnectReq (p_ccb->connection_id);
 646         p_ccb->disconnect_reason = reason;
 647     }
 648
 649     /* If at setup state, we may not get callback ind from L2CAP */
 650     /* Call user callback immediately */
 651     if (p_ccb->con_state == SDP_STATE_CONN_SETUP)
 652     {
 653         /* Tell the user if he has a callback */
 654         if (p_ccb->p_cb)
 655             (*p_ccb->p_cb) (reason);
 656         else if (p_ccb->p_cb2)
 657             (*p_ccb->p_cb2) (reason, p_ccb->user_data);
 658
 659         sdpu_release_ccb (p_ccb);
 660     }
 661
 662 }
 663
 664 /*******************************************************************************
 665 **
 666 ** Function         sdp_disconnect_cfm
 667 **
 668 ** Description      This function handles a disconnect confirm event from L2CAP.
 669 **
 670 ** Returns          void
 671 **
 672 *******************************************************************************/
 673 static void sdp_disconnect_cfm (UINT16 l2cap_cid, UINT16 result)
 674 {
 675     tCONN_CB    *p_ccb;
 676     UNUSED(result);
 677
 678     /* Find CCB based on CID */
 679     if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) == NULL)
 680     {
 681         SDP_TRACE_WARNING ("SDP - Rcvd L2CAP disc cfm, unknown CID: 0x%x", l2cap_cid);
 682         return;
 683     }
 684
 685     SDP_TRACE_EVENT ("SDP - Rcvd L2CAP disc cfm, CID: 0x%x", l2cap_cid);
 686
 687     /* Tell the user if he has a callback */
 688     if (p_ccb->p_cb)
 689         (*p_ccb->p_cb) (p_ccb->disconnect_reason);
 690     else if (p_ccb->p_cb2)
 691         (*p_ccb->p_cb2) (p_ccb->disconnect_reason, p_ccb->user_data);
 692
 693
 694     sdpu_release_ccb (p_ccb);
 695 }
 696
 697 #endif  /* SDP_CLIENT_ENABLED == TRUE */
 698
 699 /*******************************************************************************
 700 **
 701 ** Function         sdp_conn_timer_timeout
 702 **
 703 ** Description      This function processes a timeout. Currently, we simply send
 704 **                  a disconnect request to L2CAP.
 705 **
 706 ** Returns          void
 707 **
 708 *******************************************************************************/
 709 void sdp_conn_timer_timeout(void *data)
 710 {
 711     tCONN_CB *p_ccb = (tCONN_CB *)data;
 712
 713     SDP_TRACE_EVENT ("SDP - CCB timeout in state: %d  CID: 0x%x",
 714                       p_ccb->con_state, p_ccb->connection_id);
 715
 716     L2CA_DisconnectReq (p_ccb->connection_id);
 717 #if SDP_CLIENT_ENABLED == TRUE
 718     /* Tell the user if he has a callback */
 719     if (p_ccb->p_cb)
 720         (*p_ccb->p_cb) (SDP_CONN_FAILED);
 721     else if (p_ccb->p_cb2)
 722         (*p_ccb->p_cb2) (SDP_CONN_FAILED, p_ccb->user_data);
 723 #endif
 724     sdpu_release_ccb (p_ccb);
 725 }
 726
 727
 728
 729