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; }