stack/mcap/mca_l2c.cc

/******************************************************************************
 *
 *  Copyright 2009-2012 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *  This is the implementation file for the MCAP at L2CAP Interface.
 *
 ******************************************************************************/
#include <string.h>

#include "bt_target.h"
#include "bt_utils.h"
#include "btm_api.h"
#include "btm_int.h"
#include "mca_api.h"
#include "mca_defs.h"
#include "mca_int.h"
#include "osi/include/osi.h"

/* L2CAP callback function structure */
const tL2CAP_APPL_INFO mca_l2c_int_appl = {
    NULL,
    mca_l2c_connect_cfm_cback,
    NULL,
    mca_l2c_config_ind_cback,
    mca_l2c_config_cfm_cback,
    mca_l2c_disconnect_ind_cback,
    mca_l2c_disconnect_cfm_cback,
    NULL,
    mca_l2c_data_ind_cback,
    mca_l2c_congestion_ind_cback,
    NULL,
    NULL /* tL2CA_CREDITS_RECEIVED_CB */};

/* Control channel eL2CAP default options */
const tL2CAP_FCR_OPTS mca_l2c_fcr_opts_def = {
    L2CAP_FCR_ERTM_MODE,          /* Mandatory for MCAP */
    MCA_FCR_OPT_TX_WINDOW_SIZE,   /* Tx window size */
    MCA_FCR_OPT_MAX_TX_B4_DISCNT, /* Maximum transmissions before
                                     disconnecting */
    MCA_FCR_OPT_RETX_TOUT,        /* Retransmission timeout (2 secs) */
    MCA_FCR_OPT_MONITOR_TOUT,     /* Monitor timeout (12 secs) */
    MCA_FCR_OPT_MPS_SIZE          /* MPS segment size */
};

/*******************************************************************************
 *
 * Function         mca_sec_check_complete_term
 *
 * Description      The function called when Security Manager finishes
 *                  verification of the service side connection
 *
 * Returns          void
 *
 ******************************************************************************/
static void mca_sec_check_complete_term(const RawAddress* bd_addr,
                                        UNUSED_ATTR tBT_TRANSPORT transport,
                                        void* p_ref_data, uint8_t res) {
  tMCA_TC_TBL* p_tbl = (tMCA_TC_TBL*)p_ref_data;
  tL2CAP_CFG_INFO cfg;
  tL2CAP_ERTM_INFO ertm_info;

  MCA_TRACE_DEBUG("mca_sec_check_complete_term res: %d", res);

  if (res == BTM_SUCCESS) {
    MCA_TRACE_DEBUG("lcid:x%x id:x%x", p_tbl->lcid, p_tbl->id);
    /* Set the FCR options: control channel mandates ERTM */
    ertm_info.preferred_mode = mca_l2c_fcr_opts_def.mode;
    ertm_info.allowed_modes = L2CAP_FCR_CHAN_OPT_ERTM;
    ertm_info.user_rx_buf_size = MCA_USER_RX_BUF_SIZE;
    ertm_info.user_tx_buf_size = MCA_USER_TX_BUF_SIZE;
    ertm_info.fcr_rx_buf_size = MCA_FCR_RX_BUF_SIZE;
    ertm_info.fcr_tx_buf_size = MCA_FCR_TX_BUF_SIZE;
    /* Send response to the L2CAP layer. */
    L2CA_ErtmConnectRsp(*bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_OK,
                        L2CAP_CONN_OK, &ertm_info);

    /* transition to configuration state */
    p_tbl->state = MCA_TC_ST_CFG;

    /* Send L2CAP config req */
    mca_set_cfg_by_tbl(&cfg, p_tbl);
    L2CA_ConfigReq(p_tbl->lcid, &cfg);
  } else {
    L2CA_ConnectRsp(*bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_SECURITY_BLOCK,
                    L2CAP_CONN_OK);
    mca_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
  }
}

/*******************************************************************************
 *
 * Function         mca_sec_check_complete_orig
 *
 * Description      The function called when Security Manager finishes
 *                  verification of the service side connection
 *
 * Returns          void
 *
 ******************************************************************************/
static void mca_sec_check_complete_orig(UNUSED_ATTR const RawAddress* bd_addr,
                                        UNUSED_ATTR tBT_TRANSPORT transport,
                                        void* p_ref_data, uint8_t res) {
  tMCA_TC_TBL* p_tbl = (tMCA_TC_TBL*)p_ref_data;
  tL2CAP_CFG_INFO cfg;

  MCA_TRACE_DEBUG("mca_sec_check_complete_orig res: %d", res);

  if (res == BTM_SUCCESS) {
    /* set channel state */
    p_tbl->state = MCA_TC_ST_CFG;

    /* Send L2CAP config req */
    mca_set_cfg_by_tbl(&cfg, p_tbl);
    L2CA_ConfigReq(p_tbl->lcid, &cfg);
  } else {
    L2CA_DisconnectReq(p_tbl->lcid);
    mca_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
  }
}
/*******************************************************************************
 *
 * Function         mca_l2c_cconn_ind_cback
 *
 * Description      This is the L2CAP connect indication callback function.
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_cconn_ind_cback(const RawAddress& bd_addr, uint16_t lcid,
                             uint16_t psm, uint8_t id) {
  tMCA_HANDLE handle = mca_handle_by_cpsm(psm);
  tMCA_CCB* p_ccb;
  tMCA_TC_TBL* p_tbl = NULL;
  uint16_t result = L2CAP_CONN_NO_RESOURCES;
  tBTM_STATUS rc;
  tL2CAP_ERTM_INFO ertm_info, *p_ertm_info = NULL;
  tL2CAP_CFG_INFO cfg;

  MCA_TRACE_EVENT("mca_l2c_cconn_ind_cback: lcid:x%x psm:x%x id:x%x", lcid, psm,
                  id);

  /* do we already have a control channel for this peer? */
  p_ccb = mca_ccb_by_bd(handle, bd_addr);
  if (p_ccb == NULL) {
    /* no, allocate ccb */
    p_ccb = mca_ccb_alloc(handle, bd_addr);
    if (p_ccb != NULL) {
      /* allocate and set up entry */
      p_ccb->lcid = lcid;
      p_tbl = mca_tc_tbl_calloc(p_ccb);
      p_tbl->id = id;
      p_tbl->cfg_flags = MCA_L2C_CFG_CONN_ACP;
      /* proceed with connection */
      /* Check the security */
      rc = btm_sec_mx_access_request(bd_addr, psm, false, BTM_SEC_PROTO_MCA, 0,
                                     &mca_sec_check_complete_term, p_tbl);
      if (rc == BTM_CMD_STARTED) {
        /* Set the FCR options: control channel mandates ERTM */
        ertm_info.preferred_mode = mca_l2c_fcr_opts_def.mode;
        ertm_info.allowed_modes = L2CAP_FCR_CHAN_OPT_ERTM;
        ertm_info.user_rx_buf_size = MCA_USER_RX_BUF_SIZE;
        ertm_info.user_tx_buf_size = MCA_USER_TX_BUF_SIZE;
        ertm_info.fcr_rx_buf_size = MCA_FCR_RX_BUF_SIZE;
        ertm_info.fcr_tx_buf_size = MCA_FCR_TX_BUF_SIZE;
        p_ertm_info = &ertm_info;
        result = L2CAP_CONN_PENDING;
      } else
        result = L2CAP_CONN_OK;
    }

    /*  deal with simultaneous control channel connect case */
  }
  /* else reject their connection */

  if (!p_tbl || (p_tbl->state != MCA_TC_ST_CFG)) {
    /* Send L2CAP connect rsp */
    L2CA_ErtmConnectRsp(bd_addr, id, lcid, result, L2CAP_CONN_OK, p_ertm_info);

    /* if result ok, proceed with connection and send L2CAP
       config req */
    if (result == L2CAP_CONN_OK) {
      /* set channel state */
      p_tbl->state = MCA_TC_ST_CFG;

      /* Send L2CAP config req */
      mca_set_cfg_by_tbl(&cfg, p_tbl);
      L2CA_ConfigReq(p_tbl->lcid, &cfg);
    }
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_dconn_ind_cback
 *
 * Description      This is the L2CAP connect indication callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_dconn_ind_cback(const RawAddress& bd_addr, uint16_t lcid,
                             uint16_t psm, uint8_t id) {
  tMCA_HANDLE handle = mca_handle_by_dpsm(psm);
  tMCA_CCB* p_ccb;
  tMCA_DCB* p_dcb;
  tMCA_TC_TBL* p_tbl = NULL;
  uint16_t result;
  tL2CAP_CFG_INFO cfg;
  tL2CAP_ERTM_INFO *p_ertm_info = NULL, ertm_info;
  const tMCA_CHNL_CFG* p_chnl_cfg;

  MCA_TRACE_EVENT("mca_l2c_dconn_ind_cback: lcid:x%x psm:x%x ", lcid, psm);

  if (((p_ccb = mca_ccb_by_bd(handle, bd_addr)) != NULL) && /* find the CCB */
      (p_ccb->status ==
       MCA_CCB_STAT_PENDING) && /* this CCB is expecting a MDL */
      (p_ccb->p_tx_req &&
       (p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx)) != NULL)) {
    /* found the associated dcb in listening mode */
    /* proceed with connection */
    p_dcb->lcid = lcid;
    p_tbl = mca_tc_tbl_dalloc(p_dcb);
    p_tbl->id = id;
    p_tbl->cfg_flags = MCA_L2C_CFG_CONN_ACP;
    p_chnl_cfg = p_dcb->p_chnl_cfg;
    /* assume that control channel has verified the security requirement */
    /* Set the FCR options: control channel mandates ERTM */
    ertm_info.preferred_mode = p_chnl_cfg->fcr_opt.mode;
    ertm_info.allowed_modes = (1 << p_chnl_cfg->fcr_opt.mode);
    ertm_info.user_rx_buf_size = p_chnl_cfg->user_rx_buf_size;
    ertm_info.user_tx_buf_size = p_chnl_cfg->user_tx_buf_size;
    ertm_info.fcr_rx_buf_size = p_chnl_cfg->fcr_rx_buf_size;
    ertm_info.fcr_tx_buf_size = p_chnl_cfg->fcr_tx_buf_size;
    p_ertm_info = &ertm_info;
    result = L2CAP_CONN_OK;
  } else {
    /* else we're not listening for traffic channel; reject
     * (this error code is specified by MCAP spec) */
    result = L2CAP_CONN_NO_RESOURCES;
  }

  /* Send L2CAP connect rsp */
  L2CA_ErtmConnectRsp(bd_addr, id, lcid, result, result, p_ertm_info);

  /* if result ok, proceed with connection */
  if (result == L2CAP_CONN_OK) {
    /* transition to configuration state */
    p_tbl->state = MCA_TC_ST_CFG;

    /* Send L2CAP config req */
    mca_set_cfg_by_tbl(&cfg, p_tbl);
    L2CA_ConfigReq(lcid, &cfg);
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_connect_cfm_cback
 *
 * Description      This is the L2CAP connect confirm callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_connect_cfm_cback(uint16_t lcid, uint16_t result) {
  tMCA_TC_TBL* p_tbl;
  tL2CAP_CFG_INFO cfg;
  tMCA_CCB* p_ccb;

  MCA_TRACE_DEBUG("mca_l2c_connect_cfm_cback lcid: x%x, result: %d", lcid,
                  result);
  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    MCA_TRACE_DEBUG("p_tbl state: %d, tcid: %d", p_tbl->state, p_tbl->tcid);
    /* if in correct state */
    if (p_tbl->state == MCA_TC_ST_CONN) {
      /* if result successful */
      if (result == L2CAP_CONN_OK) {
        if (p_tbl->tcid != 0) {
          /* set channel state */
          p_tbl->state = MCA_TC_ST_CFG;

          /* Send L2CAP config req */
          mca_set_cfg_by_tbl(&cfg, p_tbl);
          L2CA_ConfigReq(lcid, &cfg);
        } else {
          p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
          if (p_ccb == NULL) {
            result = L2CAP_CONN_NO_RESOURCES;
          } else {
            /* set channel state */
            p_tbl->state = MCA_TC_ST_SEC_INT;
            p_tbl->lcid = lcid;
            p_tbl->cfg_flags = MCA_L2C_CFG_CONN_INT;

            /* Check the security */
            btm_sec_mx_access_request(p_ccb->peer_addr, p_ccb->ctrl_vpsm, true,
                                      BTM_SEC_PROTO_MCA, p_tbl->tcid,
                                      &mca_sec_check_complete_orig, p_tbl);
          }
        }
      }

      /* failure; notify adaption that channel closed */
      if (result != L2CAP_CONN_OK) {
        p_tbl->cfg_flags |= MCA_L2C_CFG_DISCN_INT;
        mca_tc_close_ind(p_tbl, result);
      }
    }
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_config_cfm_cback
 *
 * Description      This is the L2CAP config confirm callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_config_cfm_cback(uint16_t lcid, tL2CAP_CFG_INFO* p_cfg) {
  tMCA_TC_TBL* p_tbl;

  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    /* if in correct state */
    if (p_tbl->state == MCA_TC_ST_CFG) {
      /* if result successful */
      if (p_cfg->result == L2CAP_CONN_OK) {
        /* update cfg_flags */
        p_tbl->cfg_flags |= MCA_L2C_CFG_CFM_DONE;

        /* if configuration complete */
        if (p_tbl->cfg_flags & MCA_L2C_CFG_IND_DONE) {
          mca_tc_open_ind(p_tbl);
        }
      }
      /* else failure */
      else {
        /* Send L2CAP disconnect req */
        L2CA_DisconnectReq(lcid);
      }
    }
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_config_ind_cback
 *
 * Description      This is the L2CAP config indication callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_config_ind_cback(uint16_t lcid, tL2CAP_CFG_INFO* p_cfg) {
  tMCA_TC_TBL* p_tbl;
  uint16_t result = L2CAP_CFG_OK;

  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    /* store the mtu in tbl */
    if (p_cfg->mtu_present) {
      p_tbl->peer_mtu = p_cfg->mtu;
      if (p_tbl->peer_mtu < MCA_MIN_MTU) {
        result = L2CAP_CFG_UNACCEPTABLE_PARAMS;
      }
    } else {
      p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
    }
    MCA_TRACE_DEBUG("peer_mtu: %d, lcid: x%x mtu_present:%d", p_tbl->peer_mtu,
                    lcid, p_cfg->mtu_present);

    /* send L2CAP configure response */
    memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
    p_cfg->result = result;
    L2CA_ConfigRsp(lcid, p_cfg);

    /* if first config ind */
    if ((p_tbl->cfg_flags & MCA_L2C_CFG_IND_DONE) == 0) {
      /* update cfg_flags */
      p_tbl->cfg_flags |= MCA_L2C_CFG_IND_DONE;

      /* if configuration complete */
      if (p_tbl->cfg_flags & MCA_L2C_CFG_CFM_DONE) {
        mca_tc_open_ind(p_tbl);
      }
    }
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_disconnect_ind_cback
 *
 * Description      This is the L2CAP disconnect indication callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_disconnect_ind_cback(uint16_t lcid, bool ack_needed) {
  tMCA_TC_TBL* p_tbl;
  uint16_t reason = L2CAP_DISC_TIMEOUT;

  MCA_TRACE_DEBUG("mca_l2c_disconnect_ind_cback lcid: %d, ack_needed: %d", lcid,
                  ack_needed);
  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    if (ack_needed) {
      /* send L2CAP disconnect response */
      L2CA_DisconnectRsp(lcid);
    }

    p_tbl->cfg_flags = MCA_L2C_CFG_DISCN_ACP;
    if (ack_needed) reason = L2CAP_DISC_OK;
    mca_tc_close_ind(p_tbl, reason);
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_disconnect_cfm_cback
 *
 * Description      This is the L2CAP disconnect confirm callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_disconnect_cfm_cback(uint16_t lcid, uint16_t result) {
  tMCA_TC_TBL* p_tbl;

  MCA_TRACE_DEBUG("mca_l2c_disconnect_cfm_cback lcid: x%x, result: %d", lcid,
                  result);
  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    p_tbl->cfg_flags = MCA_L2C_CFG_DISCN_INT;
    mca_tc_close_ind(p_tbl, result);
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_congestion_ind_cback
 *
 * Description      This is the L2CAP congestion indication callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_congestion_ind_cback(uint16_t lcid, bool is_congested) {
  tMCA_TC_TBL* p_tbl;

  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    mca_tc_cong_ind(p_tbl, is_congested);
  }
}

/*******************************************************************************
 *
 * Function         mca_l2c_data_ind_cback
 *
 * Description      This is the L2CAP data indication callback function.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_l2c_data_ind_cback(uint16_t lcid, BT_HDR* p_buf) {
  tMCA_TC_TBL* p_tbl;

  /* look up info for this channel */
  p_tbl = mca_tc_tbl_by_lcid(lcid);
  if (p_tbl != NULL) {
    mca_tc_data_ind(p_tbl, p_buf);
  } else /* prevent buffer leak */
    osi_free(p_buf);
}

/*******************************************************************************
 *
 * Function         mca_l2c_open_req
 *
 * Description      This function calls L2CA_ConnectReq() to initiate a L2CAP
 *                  channel.
 *
 * Returns          void.
 *
 ******************************************************************************/
uint16_t mca_l2c_open_req(const RawAddress& bd_addr, uint16_t psm,
                          const tMCA_CHNL_CFG* p_chnl_cfg) {
  tL2CAP_ERTM_INFO ertm_info;

  if (p_chnl_cfg) {
    ertm_info.preferred_mode = p_chnl_cfg->fcr_opt.mode;
    ertm_info.allowed_modes = (1 << p_chnl_cfg->fcr_opt.mode);
    ertm_info.user_rx_buf_size = p_chnl_cfg->user_rx_buf_size;
    ertm_info.user_tx_buf_size = p_chnl_cfg->user_tx_buf_size;
    ertm_info.fcr_rx_buf_size = p_chnl_cfg->fcr_rx_buf_size;
    ertm_info.fcr_tx_buf_size = p_chnl_cfg->fcr_tx_buf_size;
  } else {
    ertm_info.preferred_mode = mca_l2c_fcr_opts_def.mode;
    ertm_info.allowed_modes = L2CAP_FCR_CHAN_OPT_ERTM;
    ertm_info.user_rx_buf_size = MCA_USER_RX_BUF_SIZE;
    ertm_info.user_tx_buf_size = MCA_USER_TX_BUF_SIZE;
    ertm_info.fcr_rx_buf_size = MCA_FCR_RX_BUF_SIZE;
    ertm_info.fcr_tx_buf_size = MCA_FCR_TX_BUF_SIZE;
  }
  return L2CA_ErtmConnectReq(psm, bd_addr, &ertm_info);
}