void TEE_SESessionClose(TEE_SESessionHandle seSessionHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seSessionHandle,
utee_se_session_close(seSessionHandle));
}
static void gatts_send_indication_p(int argc, const char *argv[])
{
int server_if;
int attr_handle;
int conn_id;
int confirm;
char data[200];
int len = 0;
RETURN_IF_NULL(if_gatt);
VERIFY_SERVER_IF(2, server_if);
VERIFY_HANDLE(3, attr_handle);
VERIFY_CONN_ID(4, conn_id);
/* confirm */
if (argc <= 5) {
haltest_error("No transport specified\n");
return;
}
confirm = atoi(argv[5]);
if (argc > 6) {
len = strlen(argv[6]);
scan_field(argv[6], len, (uint8_t *) data, sizeof(data));
}
EXEC(if_gatt->server->send_indication, server_if, attr_handle, conn_id,
len, confirm, data);
}
void TEE_SEChannelClose(TEE_SEChannelHandle seChannelHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seChannelHandle,
utee_se_channel_close(seChannelHandle));
}
TEE_Result TEE_SEChannelSelectNext(TEE_SEChannelHandle seChannelHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seChannelHandle,
utee_se_channel_select_next(seChannelHandle));
return ret;
}
void TEE_SEReaderGetProperties(TEE_SEReaderHandle seReaderHandle,
TEE_SEReaderProperties *readerProperties)
{
TEE_Result ret;
VERIFY_HANDLE(seReaderHandle,
utee_se_reader_get_prop(seReaderHandle, readerProperties));
}
TEE_Result TEE_SESessionIsClosed(TEE_SESessionHandle seSessionHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seSessionHandle,
utee_se_session_is_closed(seSessionHandle));
return ret;
}
void TEE_SEReaderCloseSessions(
TEE_SEReaderHandle seReaderHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seReaderHandle,
utee_se_reader_close_sessions(seReaderHandle));
}
RTCORE_API void rtcCommit (RTCScene scene)
{
CATCH_BEGIN;
TRACE(rtcCommit);
VERIFY_HANDLE(scene);
((Scene*)scene)->build();
CATCH_END;
}
void TEE_SEServiceClose(
TEE_SEServiceHandle seServiceHandle)
{
TEE_Result ret;
VERIFY_HANDLE(seServiceHandle,
utee_se_service_close(seServiceHandle));
}
extern "C" void ispcSetOccludedFunction16 (RTCScene scene, unsigned geomID, RTCOccludedFunc16 occluded)
{
CATCH_BEGIN;
TRACE(rtcSetOccludedFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get(geomID)->setOccludedFunction16(occluded,true);
CATCH_END;
}
extern "C" void ispcSetOcclusionFilterFunction16 (RTCScene scene, unsigned geomID, RTCFilterFunc16 filter)
{
CATCH_BEGIN;
TRACE(rtcSetOcclusionFilterFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get(geomID)->setOcclusionFilterFunction16(filter,true);
CATCH_END;
}
extern "C" void ispcSetUserData (RTCScene scene, unsigned geomID, void* ptr)
{
CATCH_BEGIN;
TRACE(rtcSetUserData);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get(geomID)->setUserData(ptr,true);
CATCH_END;
}
extern "C" void ispcSetIntersectFunction16 (RTCScene scene, unsigned geomID, RTCIntersectFunc16 intersect)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get(geomID)->setIntersectFunction16(intersect,true);
CATCH_END;
}
TEE_Result TEE_SEChannelGetSelectResponse(TEE_SEChannelHandle seChannelHandle,
void *response, size_t *responseLen)
{
TEE_Result ret;
VERIFY_HANDLE(seChannelHandle,
utee_se_channel_get_select_resp(seChannelHandle,
response, responseLen));
return ret;
}
RTCORE_API void rtcCommit (RTCScene scene)
{
cout << "in rtcCommit " << endl;
CATCH_BEGIN;
TRACE(rtcCommit);
VERIFY_HANDLE(scene);
((Scene*)scene)->build();
printSettings();
cout << "end rtcCommit " << endl;
CATCH_END;
}
TEE_Result TEE_SEChannelTransmit(TEE_SEChannelHandle seChannelHandle,
void *command, size_t commandLen,
void *response, size_t *responseLen)
{
TEE_Result ret;
VERIFY_HANDLE(seChannelHandle,
utee_se_channel_transmit(seChannelHandle,
command, commandLen, response, responseLen));
return ret;
}
TEE_Result TEE_SESessionGetATR(TEE_SESessionHandle seSessionHandle,
void *atr, size_t *atrLen)
{
TEE_Result ret;
if (atr == NULL || atrLen == NULL || *atrLen == 0)
TEE_Panic(0);
VERIFY_HANDLE(seSessionHandle,
utee_se_session_get_atr(seSessionHandle, atr, atrLen));
return ret;
}
TEE_Result TEE_SESessionOpenLogicalChannel(TEE_SESessionHandle seSessionHandle,
TEE_SEAID *seAID, TEE_SEChannelHandle *seChannelHandle)
{
TEE_Result ret;
if (seChannelHandle == NULL)
TEE_Panic(0);
VERIFY_HANDLE(seSessionHandle,
utee_se_session_open_channel(seSessionHandle, true,
seAID, seChannelHandle));
return ret;
}
TEE_Result TEE_SEReaderOpenSession(TEE_SEReaderHandle seReaderHandle,
TEE_SESessionHandle *seSessionHandle)
{
TEE_Result ret;
if (seSessionHandle == NULL)
TEE_Panic(0);
VERIFY_HANDLE(seReaderHandle,
utee_se_reader_open_session(seReaderHandle,
seSessionHandle));
return ret;
}
static void gatts_add_included_service_p(int argc, const char *argv[])
{
int server_if;
int service_handle;
int included_handle;
RETURN_IF_NULL(if_gatt);
VERIFY_SERVER_IF(2, server_if);
VERIFY_SERVICE_HANDLE(3, service_handle);
VERIFY_HANDLE(4, included_handle);
EXEC(if_gatt->server->add_included_service, server_if, service_handle,
included_handle);
}
TEE_Result TEE_SEReaderGetName(TEE_SEReaderHandle seReaderHandle,
char *readerName, size_t *readerNameLen)
{
TEE_Result ret;
if (readerName == NULL || readerNameLen == NULL ||
*readerNameLen == 0)
TEE_Panic(0);
VERIFY_HANDLE(seReaderHandle,
utee_se_reader_get_name(seReaderHandle,
readerName, readerNameLen));
return ret;
}
TEE_Result TEE_SEServiceGetReaders(
TEE_SEServiceHandle seServiceHandle,
TEE_SEReaderHandle *seReaderHandleList,
size_t *seReaderHandleListLen)
{
TEE_Result ret;
if (seReaderHandleList == NULL ||
seReaderHandleListLen == NULL)
TEE_Panic(0);
VERIFY_HANDLE(seServiceHandle,
utee_se_service_get_readers(seServiceHandle,
seReaderHandleList,
seReaderHandleListLen));
return ret;
}
static void gatts_send_response_p(int argc, const char *argv[])
{
int conn_id;
int trans_id;
int status;
btgatt_response_t data;
memset(&data, 0, sizeof(data));
RETURN_IF_NULL(if_gatt);
VERIFY_CONN_ID(2, conn_id);
VERIFY_TRANS_ID(3, trans_id);
VERIFY_STATUS(4, status);
VERIFY_HANDLE(5, data.attr_value.handle);
VERIFY_OFFSET(6, data.attr_value.offset);
data.attr_value.auth_req = 0;
data.attr_value.len = 0;
if (argc > 7) {
const char *str;
if (strncmp(argv[7], "0X", 2) && strncmp(argv[7], "0x", 2)) {
haltest_error("Value must be hex string");
return;
}
str = argv[7] + 2;
data.attr_value.len = fill_buffer(str, data.attr_value.value,
sizeof(data.attr_value.value));
if (data.attr_value.len == 0) {
haltest_error("Failed to parse response value");
return;
}
}
haltest_info("conn_id %d, trans_id %d, status %d", conn_id, trans_id,
status);
EXEC(if_gatt->server->send_response, conn_id, trans_id, status, &data);
}
