/*******************************************************************************
**
** Function hidh_sec_check_complete_orig
**
** Description This function checks to see if security procedures are being
** carried out or not..
**
** Returns void
**
*******************************************************************************/
void hidh_sec_check_complete_orig (BD_ADDR bd_addr, void *p_ref_data, UINT8 res)
{
tHID_HOST_DEV_CTB *p_dev = (tHID_HOST_DEV_CTB *) p_ref_data;
UINT8 dhandle;
#if (HID_HOST_MAX_CONN_RETRY > 0)
UINT32 cb_res = HID_ERR_AUTH_FAILED;
#endif
UINT32 reason;
dhandle = ((UINT32)p_dev - (UINT32)&(hh_cb.devices[0]))/ sizeof(tHID_HOST_DEV_CTB);
if( res == BTM_SUCCESS && p_dev->conn.conn_state == HID_CONN_STATE_SECURITY )
{
HIDH_TRACE_EVENT0 ("HID-Host Originator security pass.");
p_dev->conn.disc_reason = HID_SUCCESS; /* Authentication passed. Reset disc_reason (from HID_ERR_AUTH_FAILED) */
/* Check if L2CAP started the connection process for interrupt channel */
if ((p_dev->conn.intr_cid = L2CA_ConnectReq (HID_PSM_INTERRUPT, hh_cb.devices[dhandle].addr)) == 0)
{
HIDH_TRACE_WARNING0 ("HID-Host INTR Originate failed");
reason = HID_L2CAP_REQ_FAIL ;
hidh_conn_disconnect (dhandle);
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
return;
}
else
{
/* Transition to the next appropriate state, waiting for connection confirm on control channel. */
p_dev->conn.conn_state = HID_CONN_STATE_CONNECTING_INTR;
}
}
if( res != BTM_SUCCESS && p_dev->conn.conn_state == HID_CONN_STATE_SECURITY )
{
#if (HID_HOST_MAX_CONN_RETRY > 0)
if( res == BTM_DEVICE_TIMEOUT )
{
if( p_dev->conn_tries <= HID_HOST_MAX_CONN_RETRY )
{
hidh_conn_retry (dhandle);
return;
}
else
cb_res = HID_L2CAP_CONN_FAIL | HCI_ERR_PAGE_TIMEOUT ;
}
#endif
p_dev->conn.disc_reason = HID_ERR_AUTH_FAILED; /* Save reason for disconnecting */
hidh_conn_disconnect(dhandle);
}
}
/*******************************************************************************
**
** Function HID_HostCloseDev
**
** Description This function disconnects the device.
**
** Returns void
**
*******************************************************************************/
tHID_STATUS HID_HostCloseDev( UINT8 dev_handle )
{
if( !hh_cb.reg_flag )
return (HID_ERR_NOT_REGISTERED);
if( (dev_handle >= HID_HOST_MAX_DEVICES) || (!hh_cb.devices[dev_handle].in_use) )
return HID_ERR_INVALID_PARAM;
hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1;
btu_stop_timer( &(hh_cb.devices[dev_handle].conn.timer_entry) ) ;
if( hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED )
return HID_ERR_NO_CONNECTION;
hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY+1;
return hidh_conn_disconnect( dev_handle );
}
/*******************************************************************************
**
** Function hidh_l2cif_config_cfm
**
** Description This function processes the L2CAP configuration confirmation
** event.
**
** Returns void
**
*******************************************************************************/
static void hidh_l2cif_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
{
UINT8 dhandle;
tHID_CONN *p_hcon = NULL;
UINT32 reason;
HIDH_TRACE_EVENT2 ("HID-Host Rcvd cfg cfm, CID: 0x%x Result: %d", l2cap_cid, p_cfg->result);
/* Find CCB based on CID */
if( (dhandle = find_conn_by_cid(l2cap_cid)) < HID_HOST_MAX_DEVICES )
p_hcon = &hh_cb.devices[dhandle].conn;
if (p_hcon == NULL)
{
HIDH_TRACE_WARNING1 ("HID-Host Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
return;
}
/* If configuration failed, disconnect the channel(s) */
if (p_cfg->result != L2CAP_CFG_OK)
{
hidh_conn_disconnect (dhandle);
reason = HID_L2CAP_CFG_FAIL | (UINT32) p_cfg->result ;
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
return;
}
if (l2cap_cid == p_hcon->ctrl_cid)
p_hcon->conn_flags |= HID_CONN_FLAGS_MY_CTRL_CFG_DONE;
else
p_hcon->conn_flags |= HID_CONN_FLAGS_MY_INTR_CFG_DONE;
/* If all configuration is complete, change state and tell management we are up */
if (((p_hcon->conn_flags & HID_CONN_FLAGS_ALL_CONFIGURED) == HID_CONN_FLAGS_ALL_CONFIGURED)
&& (p_hcon->conn_state == HID_CONN_STATE_CONFIG))
{
p_hcon->conn_state = HID_CONN_STATE_CONNECTED;
hh_cb.devices[dhandle].state = HID_DEV_CONNECTED;
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_OPEN, 0, NULL ) ;
}
}
/*******************************************************************************
**
** Function hidh_sec_check_complete_orig
**
** Description This function checks to see if security procedures are being
** carried out or not..
**
** Returns void
**
*******************************************************************************/
void hidh_sec_check_complete_orig (BD_ADDR bd_addr, tBT_TRANSPORT transport, void *p_ref_data, UINT8 res)
{
tHID_HOST_DEV_CTB *p_dev = (tHID_HOST_DEV_CTB *) p_ref_data;
UINT8 dhandle;
UNUSED(bd_addr);
UNUSED (transport);
// TODO(armansito): This kind of math to determine a device handle is way
// too dirty and unnecessary. Why can't |p_dev| store it's handle?
dhandle = (PTR_TO_UINT(p_dev) - PTR_TO_UINT(&(hh_cb.devices[0])))/ sizeof(tHID_HOST_DEV_CTB);
if( res == BTM_SUCCESS && p_dev->conn.conn_state == HID_CONN_STATE_SECURITY )
{
HIDH_TRACE_EVENT ("HID-Host Originator security pass.");
p_dev->conn.disc_reason = HID_SUCCESS; /* Authentication passed. Reset disc_reason (from HID_ERR_AUTH_FAILED) */
/* Transition to the next appropriate state, configuration */
p_dev->conn.conn_state = HID_CONN_STATE_CONFIG;
L2CA_ConfigReq (p_dev->conn.ctrl_cid, &hh_cb.l2cap_cfg);
HIDH_TRACE_EVENT ("HID-Host Got Control conn cnf, sent cfg req, CID: 0x%x", p_dev->conn.ctrl_cid);
}
if( res != BTM_SUCCESS && p_dev->conn.conn_state == HID_CONN_STATE_SECURITY )
{
#if (HID_HOST_MAX_CONN_RETRY > 0)
if( res == BTM_DEVICE_TIMEOUT )
{
if( p_dev->conn_tries <= HID_HOST_MAX_CONN_RETRY )
{
hidh_conn_retry (dhandle);
return;
}
}
#endif
p_dev->conn.disc_reason = HID_ERR_AUTH_FAILED; /* Save reason for disconnecting */
hidh_conn_disconnect(dhandle);
}
}
/*******************************************************************************
**
** Function hidh_l2cif_data_ind
**
** Description This function is called when data is received from L2CAP.
** if we are the originator of the connection, we are the SDP
** client, and the received message is queued up for the client.
**
** If we are the destination of the connection, we are the SDP
** server, so the message is passed to the server processing
** function.
**
** Returns void
**
*******************************************************************************/
static void hidh_l2cif_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg)
{
UINT8 *p_data = (UINT8 *)(p_msg + 1) + p_msg->offset;
UINT8 ttype, param, rep_type, evt;
UINT8 dhandle;
tHID_CONN *p_hcon = NULL;
HIDH_TRACE_DEBUG ("HID-Host hidh_l2cif_data_ind [l2cap_cid=0x%04x]", l2cap_cid);
/* Find CCB based on CID */
if ((dhandle = find_conn_by_cid(l2cap_cid)) < HID_HOST_MAX_DEVICES)
p_hcon = &hh_cb.devices[dhandle].conn;
if (p_hcon == NULL)
{
HIDH_TRACE_WARNING ("HID-Host Rcvd L2CAP data, unknown CID: 0x%x", l2cap_cid);
GKI_freebuf (p_msg);
return;
}
ttype = HID_GET_TRANS_FROM_HDR(*p_data);
param = HID_GET_PARAM_FROM_HDR(*p_data);
rep_type = param & HID_PAR_REP_TYPE_MASK;
p_data++;
/* Get rid of the data type */
p_msg->len--;
p_msg->offset++;
switch (ttype)
{
case HID_TRANS_HANDSHAKE:
hh_cb.callback(dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_HANDSHAKE, param, NULL);
GKI_freebuf (p_msg);
break;
case HID_TRANS_CONTROL:
switch (param)
{
case HID_PAR_CONTROL_VIRTUAL_CABLE_UNPLUG:
hidh_conn_disconnect( dhandle ) ;
/* Device is unplugging from us. Tell USB */
hh_cb.callback(dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_VC_UNPLUG, 0, NULL);
break;
default:
break;
}
GKI_freebuf (p_msg);
break;
case HID_TRANS_DATA:
HIDH_TRACE_VERBOSE ("HID-Host hidh_l2cif_data_ind [l2cap_cid=0x%04x], ttype=%02x]", l2cap_cid, ttype);
evt = (hh_cb.devices[dhandle].conn.intr_cid == l2cap_cid) ?
HID_HDEV_EVT_INTR_DATA : HID_HDEV_EVT_CTRL_DATA;
hh_cb.callback(dhandle, hh_cb.devices[dhandle].addr, evt, rep_type, p_msg);
break;
case HID_TRANS_DATAC:
evt = (hh_cb.devices[dhandle].conn.intr_cid == l2cap_cid) ?
HID_HDEV_EVT_INTR_DATC : HID_HDEV_EVT_CTRL_DATC;
hh_cb.callback(dhandle, hh_cb.devices[dhandle].addr, evt, rep_type, p_msg);
break;
default:
GKI_freebuf (p_msg);
break;
}
}
/*******************************************************************************
**
** Function hidh_l2cif_config_cfm
**
** Description This function processes the L2CAP configuration confirmation
** event.
**
** Returns void
**
*******************************************************************************/
static void hidh_l2cif_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
{
UINT8 dhandle;
tHID_CONN *p_hcon = NULL;
UINT32 reason;
HIDH_TRACE_EVENT ("HID-Host Rcvd cfg cfm, CID: 0x%x Result: %d", l2cap_cid, p_cfg->result);
/* Find CCB based on CID */
if( (dhandle = find_conn_by_cid(l2cap_cid)) < HID_HOST_MAX_DEVICES )
p_hcon = &hh_cb.devices[dhandle].conn;
if (p_hcon == NULL)
{
HIDH_TRACE_WARNING ("HID-Host Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
return;
}
/* If configuration failed, disconnect the channel(s) */
if (p_cfg->result != L2CAP_CFG_OK)
{
hidh_conn_disconnect (dhandle);
reason = HID_L2CAP_CFG_FAIL | (UINT32) p_cfg->result ;
HIDH_TRACE_WARNING ("HID-Host: l2cap config ind failed, reason = %d", reason);
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
return;
}
if (l2cap_cid == p_hcon->ctrl_cid)
{
p_hcon->conn_flags |= HID_CONN_FLAGS_MY_CTRL_CFG_DONE;
if ((p_hcon->conn_flags & HID_CONN_FLAGS_IS_ORIG) &&
(p_hcon->conn_flags & HID_CONN_FLAGS_HIS_CTRL_CFG_DONE))
{
/* Connect interrupt channel */
p_hcon->disc_reason = HID_L2CAP_CONN_FAIL; /* Reset initial reason for CLOSE_EVT: Connection Attempt was made but failed */
if ((p_hcon->intr_cid = L2CA_ConnectReq (HID_PSM_INTERRUPT, hh_cb.devices[dhandle].addr)) == 0)
{
HIDH_TRACE_WARNING ("HID-Host INTR Originate failed");
reason = HID_L2CAP_REQ_FAIL ;
p_hcon->conn_state = HID_CONN_STATE_UNUSED;
hidh_conn_disconnect (dhandle);
HIDH_TRACE_WARNING ("HID-Host: l2cap config ind failed 2, reason = %d", reason);
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
return;
}
else
{
/* Transition to the next appropriate state, waiting for connection confirm on interrupt channel. */
p_hcon->conn_state = HID_CONN_STATE_CONNECTING_INTR;
}
}
}
else
p_hcon->conn_flags |= HID_CONN_FLAGS_MY_INTR_CFG_DONE;
/* If all configuration is complete, change state and tell management we are up */
if (((p_hcon->conn_flags & HID_CONN_FLAGS_ALL_CONFIGURED) == HID_CONN_FLAGS_ALL_CONFIGURED)
&& (p_hcon->conn_state == HID_CONN_STATE_CONFIG))
{
p_hcon->conn_state = HID_CONN_STATE_CONNECTED;
/* Reset disconnect reason to success, as connection successful */
p_hcon->disc_reason = HID_SUCCESS;
hh_cb.devices[dhandle].state = HID_DEV_CONNECTED;
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_OPEN, 0, NULL ) ;
}
}
/*******************************************************************************
**
** Function hidh_l2cif_connect_cfm
**
** Description This function handles the connect confirm events
** from L2CAP. This is the case when we are acting as a
** client and have sent a connect request.
**
** Returns void
**
*******************************************************************************/
static void hidh_l2cif_connect_cfm (UINT16 l2cap_cid, UINT16 result)
{
UINT8 dhandle;
tHID_CONN *p_hcon = NULL;
UINT32 reason;
tHID_HOST_DEV_CTB *p_dev = NULL;
/* Find CCB based on CID, and verify we are in a state to accept this message */
if( (dhandle = find_conn_by_cid(l2cap_cid)) < HID_HOST_MAX_DEVICES )
{
p_dev = &hh_cb.devices[dhandle];
p_hcon = &hh_cb.devices[dhandle].conn;
}
if ((p_hcon == NULL)
|| (!(p_hcon->conn_flags & HID_CONN_FLAGS_IS_ORIG))
|| ((l2cap_cid == p_hcon->ctrl_cid) && (p_hcon->conn_state != HID_CONN_STATE_CONNECTING_CTRL))
|| ((l2cap_cid == p_hcon->intr_cid) && (p_hcon->conn_state != HID_CONN_STATE_CONNECTING_INTR)
&& (p_hcon->conn_state != HID_CONN_STATE_DISCONNECTING)))
{
HIDH_TRACE_WARNING ("HID-Host Rcvd unexpected conn cnf, CID 0x%x ", l2cap_cid);
return;
}
if (result != L2CAP_CONN_OK)
{
if (l2cap_cid == p_hcon->ctrl_cid)
p_hcon->ctrl_cid = 0;
else
p_hcon->intr_cid = 0;
hidh_conn_disconnect(dhandle);
#if (HID_HOST_MAX_CONN_RETRY > 0)
if( (hh_cb.devices[dhandle].conn_tries <= HID_HOST_MAX_CONN_RETRY) &&
(result == HCI_ERR_CONNECTION_TOUT || result == HCI_ERR_UNSPECIFIED ||
result == HCI_ERR_PAGE_TIMEOUT) )
{
hidh_conn_retry(dhandle);
}
else
#endif
{
reason = HID_L2CAP_CONN_FAIL | (UINT32) result ;
HIDH_TRACE_WARNING ("HID-Host: l2cap connect failed, reason = %d", reason);
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
}
return;
}
/* receive Control Channel connect confirmation */
if (l2cap_cid == p_hcon->ctrl_cid)
{
/* check security requirement */
p_hcon->conn_state = HID_CONN_STATE_SECURITY;
p_hcon->disc_reason = HID_L2CAP_CONN_FAIL; /* In case disconnection occurs before security is completed, then set CLOSE_EVT reason code to "connection failure" */
if (!interop_addr_match(INTEROP_DISABLE_AUTH_FOR_HID_POINTING, (bt_bdaddr_t *)p_dev->addr))
{
btm_sec_mx_access_request (p_dev->addr, HID_PSM_CONTROL,
TRUE, BTM_SEC_PROTO_HID,
(p_dev->attr_mask & HID_SEC_REQUIRED) ? HID_SEC_CHN : HID_NOSEC_CHN,
&hidh_sec_check_complete_orig, p_dev);
}
else
{
/* device is blacklisted, don't perform authentication */
hidh_sec_check_complete_orig(p_dev->addr, BT_TRANSPORT_BR_EDR,
p_dev, BTM_SUCCESS);
}
}
else
{
p_hcon->conn_state = HID_CONN_STATE_CONFIG;
/* Send a Configuration Request. */
L2CA_ConfigReq (l2cap_cid, &hh_cb.l2cap_cfg);
HIDH_TRACE_EVENT ("HID-Host got Interrupt conn cnf, sent cfg req, CID: 0x%x", l2cap_cid);
}
return;
}
/*******************************************************************************
**
** Function hidh_l2cif_config_ind
**
** Description This function processes the L2CAP configuration indication
** event.
**
** Returns void
**
*******************************************************************************/
static void hidh_l2cif_config_ind (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
{
UINT8 dhandle;
tHID_CONN *p_hcon = NULL;
UINT32 reason;
/* Find CCB based on CID */
if( (dhandle = find_conn_by_cid(l2cap_cid)) < HID_HOST_MAX_DEVICES )
{
p_hcon = &hh_cb.devices[dhandle].conn;
}
if (p_hcon == NULL)
{
HIDH_TRACE_WARNING ("HID-Host Rcvd L2CAP cfg ind, unknown CID: 0x%x", l2cap_cid);
return;
}
HIDH_TRACE_EVENT ("HID-Host Rcvd cfg ind, sent cfg cfm, CID: 0x%x", l2cap_cid);
/* Remember the remote MTU size */
if ((!p_cfg->mtu_present) || (p_cfg->mtu > HID_HOST_MTU))
p_hcon->rem_mtu_size = HID_HOST_MTU;
else
p_hcon->rem_mtu_size = p_cfg->mtu;
/* For now, always accept configuration from the other side */
p_cfg->flush_to_present = FALSE;
p_cfg->mtu_present = FALSE;
p_cfg->result = L2CAP_CFG_OK;
L2CA_ConfigRsp (l2cap_cid, p_cfg);
if (l2cap_cid == p_hcon->ctrl_cid)
{
p_hcon->conn_flags |= HID_CONN_FLAGS_HIS_CTRL_CFG_DONE;
if ((p_hcon->conn_flags & HID_CONN_FLAGS_IS_ORIG) &&
(p_hcon->conn_flags & HID_CONN_FLAGS_MY_CTRL_CFG_DONE))
{
/* Connect interrupt channel */
p_hcon->disc_reason = HID_L2CAP_CONN_FAIL; /* Reset initial reason for CLOSE_EVT: Connection Attempt was made but failed */
if ((p_hcon->intr_cid = L2CA_ConnectReq (HID_PSM_INTERRUPT, hh_cb.devices[dhandle].addr)) == 0)
{
HIDH_TRACE_WARNING ("HID-Host INTR Originate failed");
reason = HID_L2CAP_REQ_FAIL ;
p_hcon->conn_state = HID_CONN_STATE_UNUSED;
hidh_conn_disconnect (dhandle);
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_CLOSE, reason, NULL ) ;
return;
}
else
{
/* Transition to the next appropriate state, waiting for connection confirm on interrupt channel. */
p_hcon->conn_state = HID_CONN_STATE_CONNECTING_INTR;
}
}
}
else
p_hcon->conn_flags |= HID_CONN_FLAGS_HIS_INTR_CFG_DONE;
/* If all configuration is complete, change state and tell management we are up */
if (((p_hcon->conn_flags & HID_CONN_FLAGS_ALL_CONFIGURED) == HID_CONN_FLAGS_ALL_CONFIGURED)
&& (p_hcon->conn_state == HID_CONN_STATE_CONFIG))
{
p_hcon->conn_state = HID_CONN_STATE_CONNECTED;
/* Reset disconnect reason to success, as connection successful */
p_hcon->disc_reason = HID_SUCCESS;
hh_cb.devices[dhandle].state = HID_DEV_CONNECTED;
hh_cb.callback( dhandle, hh_cb.devices[dhandle].addr, HID_HDEV_EVT_OPEN, 0, NULL ) ;
}
}
