static int generateDeviceName(IOTHUB_ACCOUNT_INFO* accountInfo)
{
int result;
char deviceGuid[DEVICE_GUID_SIZE];
if (UniqueId_Generate(deviceGuid, DEVICE_GUID_SIZE) != UNIQUEID_OK)
{
LogError("Unable to generate unique Id.\r\n");
result = __LINE__;
}
else
{
size_t len = strlen(DEVICE_PREFIX_FMT) + DEVICE_GUID_SIZE;
accountInfo->deviceId = (char*)malloc(len + 1);
if (accountInfo->deviceId == NULL)
{
LogError("Failure allocating device ID.\r\n");
result = __LINE__;
}
else
{
if (sprintf_s(accountInfo->deviceId, len + 1, DEVICE_PREFIX_FMT, deviceGuid) <= 0)
{
LogError("Failure constructing device ID.\r\n");
free(accountInfo->deviceId);
result = __LINE__;
}
else
{
LogInfo("Created Device %s.", accountInfo->deviceId);
result = 0;
}
}
}
return result;
}
static STRING_HANDLE construct_url()
{
STRING_HANDLE result;
/*Codes_SRS_BROKER_17_002: [ Broker_Create shall create a unique id. ]*/
char uuid[BROKER_GUID_SIZE];
memset(uuid, 0, BROKER_GUID_SIZE);
if (UniqueId_Generate(uuid, BROKER_GUID_SIZE) != UNIQUEID_OK)
{
LogError("Unable to generate unique Id.");
result = NULL;
}
else
{
/*Codes_SRS_BROKER_17_003: [ Broker_Create shall initialize a url consisting of "inproc://" + unique id. ]*/
result = STRING_construct(INPROC_URL_HEAD);
if (result == NULL)
{
LogError("Unable to construct url.");
}
else
{
if (STRING_concat(result, uuid) != 0)
{
/*Codes_SRS_BROKER_13_003: [ This function shall return NULL if an underlying API call to the platform causes an error. ]*/
STRING_delete(result);
LogError("Unable to append uuid to url.");
result = NULL;
}
}
}
return result;
}
int construct_device_id(const char* prefix, char** device_name)
{
int result;
char deviceGuid[DEVICE_GUID_SIZE];
if (UniqueId_Generate(deviceGuid, DEVICE_GUID_SIZE) != UNIQUEID_OK)
{
LogError("Unable to generate unique Id.\r\n");
result = MU_FAILURE;
}
else
{
size_t len = strlen(prefix) + DEVICE_GUID_SIZE;
*device_name = (char*)malloc(len + 1);
if (*device_name == NULL)
{
LogError("Failure allocating device ID.\r\n");
result = MU_FAILURE;
}
else
{
if (sprintf_s(*device_name, len + 1, prefix, deviceGuid) <= 0)
{
LogError("Failure constructing device ID.\r\n");
free(*device_name);
result = MU_FAILURE;
}
else
{
LogInfo("Created Device %s.", *device_name);
result = 0;
}
}
}
return result;
}
static void sendHttpRequestMethodExpectedCalls()
{
STRICT_EXPECTED_CALL(environment_get_variable(IGNORED_PTR_ARG)).CallCannotFail();
STRICT_EXPECTED_CALL(HTTPHeaders_Alloc());
STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
STRICT_EXPECTED_CALL(UniqueId_Generate(IGNORED_PTR_ARG, IGNORED_NUM_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(IoTHubClient_Auth_Get_SasToken(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPAPIEX_Create(IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(IoTHubClient_Auth_Get_TrustBundle(IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPAPIEX_SetOption(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(IGNORED_PTR_ARG, HTTPAPI_REQUEST_POST, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, NULL, IGNORED_PTR_ARG));
STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(HTTPAPIEX_Destroy(IGNORED_PTR_ARG)); //cannot fail
STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail
}
static BROKER_RESULT init_module(BROKER_MODULEINFO* module_info, const MODULE* module)
{
BROKER_RESULT result;
/*Codes_SRS_BROKER_13_107: The function shall assign the `module` handle to `BROKER_MODULEINFO::module`.*/
module_info->module = (MODULE*)malloc(sizeof(MODULE));
if (module_info->module == NULL)
{
LogError("Allocate module failed");
result = BROKER_ERROR;
}
else
{
module_info->module->module_apis = module->module_apis;
module_info->module->module_handle = module->module_handle;
/*Codes_SRS_BROKER_13_099: [The function shall initialize BROKER_MODULEINFO::socket_lock with a valid lock handle.]*/
module_info->socket_lock = Lock_Init();
if (module_info->socket_lock == NULL)
{
/*Codes_SRS_BROKER_13_047: [ This function shall return BROKER_ERROR if an underlying API call to the platform causes an error or BROKER_OK otherwise. ]*/
LogError("Lock_Init for socket lock failed");
result = BROKER_ERROR;
}
else
{
char uuid[BROKER_GUID_SIZE];
memset(uuid, 0, BROKER_GUID_SIZE);
/*Codes_SRS_BROKER_17_020: [ The function shall create a unique ID used as a quit signal. ]*/
if (UniqueId_Generate(uuid, BROKER_GUID_SIZE) != UNIQUEID_OK)
{
/*Codes_SRS_BROKER_13_047: [ This function shall return BROKER_ERROR if an underlying API call to the platform causes an error or BROKER_OK otherwise. ]*/
LogError("Lock_Init for socket lock failed");
Lock_Deinit(module_info->socket_lock);
result = BROKER_ERROR;
}
else
{
module_info->quit_message_guid = STRING_construct(uuid);
if (module_info->quit_message_guid == NULL)
{
/*Codes_SRS_BROKER_13_047: [ This function shall return BROKER_ERROR if an underlying API call to the platform causes an error or BROKER_OK otherwise. ]*/
LogError("String construct failed for module guid");
Lock_Deinit(module_info->socket_lock);
result = BROKER_ERROR;
}
else
{
result = BROKER_OK;
}
}
}
}
return result;
}
static const char* generateGuid(void)
{
char* result;
if ((result = malloc(UID_LENGTH)) != NULL)
{
result[0] = '\0';
if (UniqueId_Generate(result, UID_LENGTH) != UNIQUEID_OK)
{
LogError("UniqueId_Generate failed");
free((void*)result);
result = NULL;
}
}
return (const char*)result;
}
static int create_connection_handle(AMQP_CONNECTION_INSTANCE* instance)
{
int result;
char* unique_container_id = NULL;
XIO_HANDLE connection_io_transport;
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_007: [If `instance->sasl_io` is defined it shall be used as parameter `xio` in connection_create2()]
if (instance->sasl_io != NULL)
{
connection_io_transport = instance->sasl_io;
}
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_018: [If `instance->sasl_io` is not defined, `instance->underlying_io_transport` shall be used as parameter `xio` in connection_create2()]
else
{
connection_io_transport = instance->underlying_io_transport;
}
if ((unique_container_id = (char*)malloc(sizeof(char) * DEFAULT_UNIQUE_ID_LENGTH + 1)) == NULL)
{
result = __LINE__;
LogError("Failed creating the AMQP connection (failed creating unique ID container)");
}
else
{
memset(unique_container_id, 0, sizeof(char) * DEFAULT_UNIQUE_ID_LENGTH + 1);
if (UniqueId_Generate(unique_container_id, DEFAULT_UNIQUE_ID_LENGTH) != UNIQUEID_OK)
{
result = __FAILURE__;
LogError("Failed creating the AMQP connection (UniqueId_Generate failed)");
}
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_019: [`instance->connection_handle` shall be created using connection_create2(), passing the `connection_underlying_io`, `instance->iothub_host_fqdn` and an unique string as container ID]
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_020: [connection_create2() shall also receive `on_connection_state_changed` and `on_connection_error` callback functions]
else if ((instance->connection_handle = connection_create2(connection_io_transport, STRING_c_str(instance->iothub_fqdn), unique_container_id, NULL, NULL, on_connection_state_changed, (void*)instance, on_connection_io_error, (void*)instance)) == NULL)
{
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_021: [If connection_create2() fails, amqp_connection_create() shall fail and return NULL]
result = __FAILURE__;
LogError("Failed creating the AMQP connection (connection_create2 failed)");
}
else if (connection_set_idle_timeout(instance->connection_handle, 1000 * instance->svc2cl_keep_alive_timeout_secs) != RESULT_OK)
{
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_074: [If connection_set_idle_timeout() fails, amqp_connection_create() shall fail and return NULL]
result = __FAILURE__;
LogError("Failed creating the AMQP connection (connection_set_idle_timeout failed)");
}
else if (connection_set_remote_idle_timeout_empty_frame_send_ratio(instance->connection_handle, instance->cl2svc_keep_alive_send_ratio) != RESULT_OK)
{
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_99_001: [If connection_set_remote_idle_timeout_empty_frame_send_ratio fails, amqp_connection_create() shall fail and return NULL]
result = __FAILURE__;
LogError("Failed creating the AMQP connection (connection_set_remote_idle_timeout_empty_frame_send_ratio)");
}
else
{
// Codes_SRS_IOTHUBTRANSPORT_AMQP_CONNECTION_09_023: [The connection tracing shall be set using connection_set_trace(), passing `instance->is_trace_on`]
connection_set_trace(instance->connection_handle, instance->is_trace_on);
result = RESULT_OK;
}
}
if (unique_container_id != NULL)
{
free(unique_container_id);
}
return result;
}
