static IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA_HANDLE CloneDiagnosticPropertyData(const IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA* source) { IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA_HANDLE result = NULL; if (source == NULL) { LogError("Invalid argument - source is NULL"); } else { result = (IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA_HANDLE)malloc(sizeof(IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA)); if (result == NULL) { LogError("malloc failed"); } else { result->diagnosticCreationTimeUtc = NULL; result->diagnosticId = NULL; if (source->diagnosticCreationTimeUtc != NULL && mallocAndStrcpy_s(&result->diagnosticCreationTimeUtc, source->diagnosticCreationTimeUtc) != 0) { LogError("mallocAndStrcpy_s for diagnosticCreationTimeUtc failed"); free(result); result = NULL; } else if (source->diagnosticId != NULL && mallocAndStrcpy_s(&result->diagnosticId, source->diagnosticId) != 0) { LogError("mallocAndStrcpy_s for diagnosticId failed"); free(result->diagnosticCreationTimeUtc); free(result); result = NULL; } } } return result; }
static int insertNewKeyValue(MAP_HANDLE_DATA* handleData, const char* key, const char* value) { int result; if (Map_IncreaseStorageKeysValues(handleData) != 0) /*this increases handleData->count*/ { result = __LINE__; } else { if (mallocAndStrcpy_s(&(handleData->keys[handleData->count - 1]), key) != 0) { Map_DecreaseStorageKeysValues(handleData); LogError("unable to mallocAndStrcpy_s\r\n"); result = __LINE__; } else { if (mallocAndStrcpy_s(&(handleData->values[handleData->count - 1]), value) != 0) { free(handleData->keys[handleData->count - 1]); Map_DecreaseStorageKeysValues(handleData); LogError("unable to mallocAndStrcpy_s\r\n"); result = __LINE__; } else { result = 0; } } } return result; }
static JVM_OPTIONS* options_copy(JVM_OPTIONS* options) { //Copy the VECTOR_HANDLE JVM_OPTIONS* new_options = (JVM_OPTIONS*)malloc(sizeof(JVM_OPTIONS)); if (new_options == NULL) { LogError("Failed to allocate memory for JVM_OPTIONS structure."); } else { new_options->additional_options = NULL; if (options->additional_options != NULL) { new_options->additional_options = VECTOR_copy(options->additional_options); } if (options->additional_options != NULL && new_options->additional_options == NULL) { LogError("Failed to copy additional_options VECTOR_HANDLE."); free(new_options); new_options = NULL; } else { //Copy the class path int status = mallocAndStrcpy_s((char**)(&new_options->class_path), options->class_path); if (status != 0) { LogError("Failed to allocate class_path."); VECTOR_destroy(new_options->additional_options); free(new_options); new_options = NULL; } else { //Copy the library path status = mallocAndStrcpy_s((char**)(&new_options->library_path), options->library_path); if (status != 0) { LogError("Failed to allocate library_path."); free((void*)new_options->class_path); VECTOR_destroy(new_options->additional_options); free(new_options); new_options = NULL; } else { new_options->debug = options->debug; new_options->debug_port = options->debug_port; new_options->verbose = options->verbose; new_options->version = options->version; } } } } return new_options; }
IOTHUB_AUTHORIZATION_HANDLE IoTHubClient_Auth_Create(const char* device_key, const char* device_id, const char* device_sas_token, const char *module_id) { IOTHUB_AUTHORIZATION_DATA* result; /* Codes_SRS_IoTHub_Authorization_07_001: [if device_id is NULL IoTHubClient_Auth_Create, shall return NULL. ] */ if (device_id == NULL) { LogError("Invalid Parameter device_id: %p", device_id); result = NULL; } else { result = initialize_auth_client(device_id, module_id); if (result == NULL) { LogError("Failure initializing auth client"); } else if (device_key != NULL && mallocAndStrcpy_s(&result->device_key, device_key) != 0) { /* Codes_SRS_IoTHub_Authorization_07_019: [ On error IoTHubClient_Auth_Create shall return NULL. ] */ LogError("Failed allocating device_key"); free(result->device_id); free(result->module_id); free(result); result = NULL; } else { if (device_key != NULL) { /* Codes_SRS_IoTHub_Authorization_07_003: [ IoTHubClient_Auth_Create shall set the credential type to IOTHUB_CREDENTIAL_TYPE_DEVICE_KEY if the device_sas_token is NULL. ]*/ result->cred_type = IOTHUB_CREDENTIAL_TYPE_DEVICE_KEY; } else if (device_sas_token != NULL) { /* Codes_SRS_IoTHub_Authorization_07_020: [ else IoTHubClient_Auth_Create shall set the credential type to IOTHUB_CREDENTIAL_TYPE_SAS_TOKEN. ] */ result->cred_type = IOTHUB_CREDENTIAL_TYPE_SAS_TOKEN; if (mallocAndStrcpy_s(&result->device_sas_token, device_sas_token) != 0) { /* Codes_SRS_IoTHub_Authorization_07_019: [ On error IoTHubClient_Auth_Create shall return NULL. ] */ LogError("Failed allocating device_key"); free(result->device_key); free(result->device_id); free(result->module_id); free(result); result = NULL; } } else { /* Codes_SRS_IoTHub_Authorization_07_024: [ if device_sas_token and device_key are NULL IoTHubClient_Auth_Create shall set the credential type to IOTHUB_CREDENTIAL_TYPE_UNKNOWN. ] */ result->cred_type = IOTHUB_CREDENTIAL_TYPE_UNKNOWN; } } } /* Codes_SRS_IoTHub_Authorization_07_004: [ If successful IoTHubClient_Auth_Create shall return a IOTHUB_AUTHORIZATION_HANDLE value. ] */ return result; }
int IoTHubClient_Auth_Get_x509_info(IOTHUB_AUTHORIZATION_HANDLE handle, char** x509_cert, char** x509_key) { int result; if (handle == NULL || x509_cert == NULL || x509_key == NULL) { LogError("Invalid Parameter handle: %p, x509_cert: %p, x509_key: %p", handle, x509_cert, x509_key); result = __FAILURE__; } else if (handle->cred_type != IOTHUB_CREDENTIAL_TYPE_X509_ECC) { LogError("Invalid credential types for this operation"); result = __FAILURE__; } else { #ifdef USE_PROV_MODULE CREDENTIAL_RESULT* cred_result = iothub_device_auth_generate_credentials(handle->device_auth_handle, NULL); if (cred_result == NULL) { LogError("Failure generating credentials"); result = __FAILURE__; } else { if (mallocAndStrcpy_s(x509_cert, cred_result->auth_cred_result.x509_result.x509_cert) != 0) { LogError("Failure copying certificate"); result = __FAILURE__; } else if (mallocAndStrcpy_s(x509_key, cred_result->auth_cred_result.x509_result.x509_alias_key) != 0) { LogError("Failure copying private key"); result = __FAILURE__; free(*x509_cert); } else { result = 0; } free(cred_result); } #else LogError("Failed HSM module is not supported"); result = __FAILURE__; #endif } return result; }
static void setup_dev_auth_emulator_generate_credentials_mocks(const char* token_scope) { STRICT_EXPECTED_CALL(STRING_new()); STRICT_EXPECTED_CALL(get_time(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(STRING_construct(token_scope)); STRICT_EXPECTED_CALL(STRING_construct(IGNORED_PTR_ARG)) .IgnoreArgument_psz(); STRICT_EXPECTED_CALL(SASToken_Create(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG)) .IgnoreArgument_scope() .IgnoreArgument_keyName() .IgnoreArgument_expiry() .IgnoreArgument_key(); STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)) .IgnoreArgument_destination() .IgnoreArgument_source(); STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); }
IOTHUB_MESSAGE_RESULT IoTHubMessage_SetMessageId(IOTHUB_MESSAGE_HANDLE iotHubMessageHandle, const char* messageId) { IOTHUB_MESSAGE_RESULT result; /* Codes_SRS_IOTHUBMESSAGE_07_012: [if any of the parameters are NULL then IoTHubMessage_SetMessageId shall return a IOTHUB_MESSAGE_INVALID_ARG value.] */ if (iotHubMessageHandle == NULL || messageId == NULL) { LogError("invalid arg (NULL) passed to IoTHubMessage_SetMessageId\r\n"); result = IOTHUB_MESSAGE_INVALID_ARG; } else { IOTHUB_MESSAGE_HANDLE_DATA* handleData = iotHubMessageHandle; /* Codes_SRS_IOTHUBMESSAGE_07_013: [If the IOTHUB_MESSAGE_HANDLE messageId is not NULL, then the IOTHUB_MESSAGE_HANDLE messageId will be freed] */ if (handleData->messageId != NULL) { free(handleData->messageId); } /* Codes_SRS_IOTHUBMESSAGE_07_014: [If the allocation or the copying of the messageId fails, then IoTHubMessage_SetMessageId shall return IOTHUB_MESSAGE_ERROR.] */ if (mallocAndStrcpy_s(&handleData->messageId, messageId) != 0) { result = IOTHUB_MESSAGE_ERROR; } else { result = IOTHUB_MESSAGE_OK; } } return result; }
int prov_auth_set_registration_id(PROV_AUTH_HANDLE handle, const char* registration_id) { int result; if (handle == NULL || registration_id == NULL) { LogError("Invalid parameter handle: %p, registration_id: %p", handle, registration_id); result = MU_FAILURE; } else { if (handle->registration_id != NULL) { LogError("Registration_id has been previously set, registration can not be changed"); result = MU_FAILURE; } else if (mallocAndStrcpy_s(&handle->registration_id, registration_id) != 0) { LogError("Failed allocating registration key"); result = MU_FAILURE; } else { result = 0; } } return result; }
int prov_transport_common_mqtt_set_trusted_cert(PROV_DEVICE_TRANSPORT_HANDLE handle, const char* certificate) { int result; if (handle == NULL || certificate == NULL) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_030: [ If handle or certificate is NULL, prov_transport_common_mqtt_set_trusted_cert shall return a non-zero value. ] */ LogError("Invalid parameter specified handle: %p, certificate: %p", handle, certificate); result = __FAILURE__; } else { PROV_TRANSPORT_MQTT_INFO* mqtt_info = (PROV_TRANSPORT_MQTT_INFO*)handle; if (mqtt_info->certificate != NULL) { free(mqtt_info->certificate); mqtt_info->certificate = NULL; } /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_031: [ prov_transport_common_mqtt_set_trusted_cert shall copy the certificate value. ] */ if (mallocAndStrcpy_s(&mqtt_info->certificate, certificate) != 0) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_032: [ On any failure prov_transport_common_mqtt_set_trusted_cert, shall return a non-zero value. ] */ result = __FAILURE__; LogError("failure allocating certificate"); } else { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_033: [ On success prov_transport_common_mqtt_set_trusted_cert shall return a zero value. ] */ result = 0; } } return result; }
static char* encode_value(const uint8_t* msg_digest, size_t digest_len) { char* result; char* encoded_hash = Base32_Encode_Bytes(msg_digest, digest_len); if (encoded_hash == NULL) { LogError("Failure encoded Base32"); result = NULL; } else { size_t encode_len = strlen(encoded_hash); char* iterator = encoded_hash + encode_len - 1; while (iterator != encoded_hash) { if (*iterator != '=') { *(iterator+1) = '\0'; break; } iterator--; } if (mallocAndStrcpy_s(&result, encoded_hash) != 0) { LogError("Failure allocating encoded base32 result"); result = NULL; } free(encoded_hash); } return result; }
STRING_TOKENIZER_HANDLE STRING_TOKENIZER_create(STRING_HANDLE handle) { STRING_TOKEN *result; char* inputStringToMalloc; /* Codes_SRS_STRING_04_001: [STRING_TOKENIZER_create shall return an NULL STRING_TOKENIZER_HANDLE if parameter handle is NULL] */ if (handle == NULL) { LogError("Invalid Argument. Handle cannot be NULL.\r\n"); result = NULL; } /* Codes_SRS_STRING_04_002: [STRING_TOKENIZER_create shall allocate a new STRING_TOKENIZER_HANDLE having the content of the STRING_HANDLE copied and current position pointing at the beginning of the string] */ else if((result = (STRING_TOKEN *)malloc(sizeof(STRING_TOKEN))) == NULL) { LogError("Memory Allocation failed. Cannot allocate STRING_TOKENIZER.\r\n"); } else if ((mallocAndStrcpy_s(&inputStringToMalloc, STRING_c_str(handle))) != 0) { LogError("Memory Allocation Failed. Cannot allocate and copy string Content.\r\n"); free(result); result = NULL; } else { result->inputString = inputStringToMalloc; result->currentPos = result->inputString; //Current Pos will point to the initial position of Token. result->sizeOfinputString = strlen(result->inputString); //Calculate Size of Current String } return (STRING_TOKENIZER_HANDLE)result; }
IOTHUB_MESSAGE_RESULT IoTHubMessage_SetCorrelationId(IOTHUB_MESSAGE_HANDLE iotHubMessageHandle, const char* correlationId) { IOTHUB_MESSAGE_RESULT result; /* Codes_SRS_IOTHUBMESSAGE_07_018: [if any of the parameters are NULL then IoTHubMessage_SetCorrelationId shall return a IOTHUB_MESSAGE_INVALID_ARG value.]*/ if (iotHubMessageHandle == NULL || correlationId == NULL) { LogError("invalid arg (NULL) passed to IoTHubMessage_SetCorrelationId\r\n"); result = IOTHUB_MESSAGE_INVALID_ARG; } else { IOTHUB_MESSAGE_HANDLE_DATA* handleData = iotHubMessageHandle; /* Codes_SRS_IOTHUBMESSAGE_07_019: [If the IOTHUB_MESSAGE_HANDLE correlationId is not NULL, then the IOTHUB_MESSAGE_HANDLE correlationId will be deallocated.] */ if (handleData->correlationId != NULL) { free(handleData->correlationId); } if (mallocAndStrcpy_s(&handleData->correlationId, correlationId) != 0) { /* Codes_SRS_IOTHUBMESSAGE_07_020: [If the allocation or the copying of the correlationId fails, then IoTHubMessage_SetCorrelationId shall return IOTHUB_MESSAGE_ERROR.] */ result = IOTHUB_MESSAGE_ERROR; } else { /* Codes_SRS_IOTHUBMESSAGE_07_021: [IoTHubMessage_SetCorrelationId finishes successfully it shall return IOTHUB_MESSAGE_OK.] */ result = IOTHUB_MESSAGE_OK; } } return result; }
int prov_transport_common_mqtt_x509_cert(PROV_DEVICE_TRANSPORT_HANDLE handle, const char* certificate, const char* private_key) { int result; if (handle == NULL || certificate == NULL) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_026: [ If handle or certificate is NULL, prov_transport_common_mqtt_x509_cert shall return a non-zero value. ] */ LogError("Invalid parameter specified handle: %p, certificate: %p", handle, certificate); result = __FAILURE__; } else { PROV_TRANSPORT_MQTT_INFO* mqtt_info = (PROV_TRANSPORT_MQTT_INFO*)handle; if (mqtt_info->x509_cert != NULL) { free(mqtt_info->x509_cert); mqtt_info->x509_cert = NULL; } if (mqtt_info->private_key != NULL) { free(mqtt_info->private_key); mqtt_info->private_key = NULL; } /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_027: [ prov_transport_common_mqtt_x509_cert shall copy the certificate and private_key values. ] */ if (mallocAndStrcpy_s(&mqtt_info->x509_cert, certificate) != 0) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_028: [ On any failure prov_transport_common_mqtt_x509_cert, shall return a non-zero value. ] */ result = __FAILURE__; LogError("failure allocating certificate"); } else if (mallocAndStrcpy_s(&mqtt_info->private_key, private_key) != 0) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_028: [ On any failure prov_transport_common_mqtt_x509_cert, shall return a non-zero value. ] */ LogError("failure allocating certificate"); free(mqtt_info->x509_cert); mqtt_info->x509_cert = NULL; result = __FAILURE__; } else { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_029: [ On success prov_transport_common_mqtt_x509_cert shall return a zero value. ] */ result = 0; } } return result; }
static MODULE_HANDLE SimulatorModule_Create(BROKER_HANDLE broker, const void* configuration) { SIMULATOR_MODULE_HANDLE * module; if ((broker == NULL) || (configuration == NULL)) { LogError("Simulator had a null input. broker: [%p], configuration: [%p]", broker, configuration); module = NULL; } else { SIMULATOR_MODULE_CONFIG * conf = (SIMULATOR_MODULE_CONFIG *)configuration; module = (SIMULATOR_MODULE_HANDLE*)malloc(sizeof(SIMULATOR_MODULE_HANDLE)); if (module == NULL) { LogError("Could not allocate memory for module handle"); } else { if (mallocAndStrcpy_s(&(module->device_id), conf->device_id) != 0) { LogError("could not allocate memory for deviceID string"); free(module); module = NULL; } else { module->broker = broker; module->message_delay = conf->message_delay; module->message_size = conf->message_size; module->properties_count = conf->properties_count; module->properties_size = conf->properties_size; size_t max_buffer = std::max(module->properties_size, module->message_size); module->psuedo_random_buffer = (char*)malloc(max_buffer + 1); if (module->psuedo_random_buffer == NULL) { LogError("could not allocate memory for deviceID string"); free(module->device_id); free(module); module = NULL; } else { std::default_random_engine generator; std::uniform_int_distribution<int> distribution(' ', 'z'); for (size_t i = 0; i < max_buffer; i++) { (module->psuedo_random_buffer)[i] = distribution(generator); } (module->psuedo_random_buffer)[max_buffer] = '\0'; } } } } return (MODULE_HANDLE)module; }
/* Codes_SRS_TLSIO_SSL_ESP8266_99_017: [ The tlsio_openssl_create shall receive the connection configuration (TLSIO_CONFIG). ]*/ CONCRETE_IO_HANDLE tlsio_openssl_create(void* io_create_parameters) { //LogInfo("tlsio_openssl_create begin: %d", system_get_free_heap_size()); /* Codes_SRS_TLSIO_SSL_ESP8266_99_005: [ The tlsio_ssl_esp8266 shall received the connection information using the TLSIO_CONFIG structure defined in `tlsio.h`. ]*/ /* Codes_SRS_TLSIO_SSL_ESP8266_99_017: [ The tlsio_openssl_create shall receive the connection configuration (TLSIO_CONFIG). ]*/ TLSIO_CONFIG* tls_io_config = (TLSIO_CONFIG*)io_create_parameters; TLS_IO_INSTANCE* result; /* Codes_SRS_TLSIO_SSL_ESP8266_99_013: [ The tlsio_openssl_create shall return NULL when io_create_parameters is NULL. ]*/ if (tls_io_config == NULL) { result = NULL; LogError("NULL tls_io_config."); } else { /* Codes_SRS_TLSIO_SSL_ESP8266_99_011: [ The tlsio_openssl_create shall allocate memory to control the tlsio instance. ]*/ result = (TLS_IO_INSTANCE*) malloc(sizeof(TLS_IO_INSTANCE)); if (result == NULL) { /* Codes_SRS_TLSIO_SSL_ESP8266_99_012: [ If there is not enough memory to create the tlsio, the tlsio_openssl_create shall return NULL as the handle. ]*/ LogError("Failed allocating TLSIO instance."); } else { memset(result, 0, sizeof(TLS_IO_INSTANCE)); mallocAndStrcpy_s(&result->hostname, tls_io_config->hostname); result->port = (int)tls_io_config->port; result->ssl_context = NULL; result->ssl = NULL; result->certificate = NULL; /* Codes_SRS_TLSIO_SSL_ESP8266_99_016: [ The tlsio_openssl_create shall initialize all callback pointers as NULL. ]*/ result->on_bytes_received = NULL; result->on_bytes_received_context = NULL; result->on_io_open_complete = NULL; result->on_io_open_complete_context = NULL; result->on_io_close_complete = NULL; result->on_io_close_complete_context = NULL; result->on_io_error = NULL; result->on_io_error_context = NULL; /* Codes_SRS_TLSIO_SSL_ESP8266_99_020: [ If tlsio_openssl_create get success to create the tlsio instance, it shall set the tlsio state as TLSIO_STATE_NOT_OPEN. ]*/ result->tlsio_state = TLSIO_STATE_NOT_OPEN; result->x509certificate = NULL; result->x509privatekey = NULL; } } /* Codes_SRS_TLSIO_SSL_ESP8266_99_010: [ The tlsio_openssl_create shall return a non-NULL handle on success. ]*/ return (CONCRETE_IO_HANDLE)result; }
/*this function will clone an option given by name and value*/ static void* tlsio_schannel_CloneOption(const char* name, const void* value) { void* result; if ( (name == NULL) || (value == NULL) ) { LogError("invalid parameter detected: const char* name=%p, const void* value=%p", name, value); result = NULL; } else { if (strcmp(name, "x509certificate") == 0) { if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0) { LogError("unable to mallocAndStrcpy_s x509certificate value"); result = NULL; } else { /*return as is*/ } } else if (strcmp(name, "x509privatekey") == 0) { if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0) { LogError("unable to mallocAndStrcpy_s x509privatekey value"); result = NULL; } else { /*return as is*/ } } else { LogError("not handled option : %s", name); result = NULL; } } return result; }
/* * @brief Duplicate and copy all fields in the IDENTITY_MAP_CONFIG struct. * Forces MAC address to be all upper case (to guarantee comparisons are consistent). */ static IDENTITYMAP_RESULT IdentityMapConfig_CopyDeep(IDENTITY_MAP_CONFIG * dest, IDENTITY_MAP_CONFIG * source) { IDENTITYMAP_RESULT result; int status; dest->macAddress = IdentityMapConfig_ToUpperCase(source->macAddress); if (dest->macAddress == NULL) { LogError("Unable to allocate macAddress"); result = IDENTITYMAP_MEMORY; } else { char * temp; status = mallocAndStrcpy_s(&temp, source->deviceId); if (status != 0) { LogError("Unable to allocate deviceId"); free((void*)dest->macAddress); dest->macAddress = NULL; result = IDENTITYMAP_MEMORY; } else { dest->deviceId = temp; status = mallocAndStrcpy_s(&temp, source->deviceKey); if (status != 0) { LogError("Unable to allocate deviceKey"); free((void*)dest->deviceId); dest->deviceId = NULL; free((void*)dest->macAddress); dest->macAddress = NULL; result = IDENTITYMAP_MEMORY; } else { dest->deviceKey = temp; result = IDENTITYMAP_OK; } } } return result; }
static JAVA_MODULE_HOST_CONFIG* config_copy(JAVA_MODULE_HOST_CONFIG* config) { JAVA_MODULE_HOST_CONFIG* new_config = malloc(sizeof(JAVA_MODULE_HOST_CONFIG)); if (new_config == NULL) { LogError("Failed to allocate memory for JAVA_MODULE_HOST_CONFIG structure."); } else { //Copy the class name int status = mallocAndStrcpy_s((char**)(&new_config->class_name), config->class_name); if (status != 0) { LogError("Failed to allocate class_name."); free(new_config); new_config = NULL; } else { //Copy the configuration status = mallocAndStrcpy_s((char**)(&new_config->configuration_json), config->configuration_json); if (status != 0) { LogError("Failed to allocate configuration_json."); free((void*)new_config->class_name); free(new_config); new_config = NULL; } else { new_config->options = options_copy(config->options); if (new_config->options == NULL) { free((void*)new_config->class_name); free((void*)new_config->configuration_json); free(new_config); new_config = NULL; } } } } return new_config; }
static void iothub_prov_register_device(PROV_DEVICE_RESULT register_result, const char* iothub_uri, const char* device_id, void* user_context) { if (user_context == NULL) { ASSERT_FAIL("User Context is NULL iothub_prov_register_device"); } else { PROV_CLIENT_E2E_INFO* prov_info = (PROV_CLIENT_E2E_INFO*)user_context; if (register_result == PROV_DEVICE_RESULT_OK) { (void)mallocAndStrcpy_s(&prov_info->iothub_uri, iothub_uri); (void)mallocAndStrcpy_s(&prov_info->device_id, device_id); prov_info->reg_result = REG_RESULT_COMPLETE; } else { prov_info->reg_result = REG_RESULT_FAILED; } } }
int prov_transport_common_mqtt_open(PROV_DEVICE_TRANSPORT_HANDLE handle, const char* registration_id, BUFFER_HANDLE ek, BUFFER_HANDLE srk, PROV_DEVICE_TRANSPORT_REGISTER_CALLBACK data_callback, void* user_ctx, PROV_DEVICE_TRANSPORT_STATUS_CALLBACK status_cb, void* status_ctx) { int result; PROV_TRANSPORT_MQTT_INFO* mqtt_info = (PROV_TRANSPORT_MQTT_INFO*)handle; if (mqtt_info == NULL || data_callback == NULL || status_cb == NULL || registration_id == NULL) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_007: [ If handle, data_callback, or status_cb is NULL, prov_transport_common_mqtt_open shall return a non-zero value. ] */ LogError("Invalid parameter specified handle: %p, data_callback: %p, status_cb: %p, registration_id: %p", handle, data_callback, status_cb, registration_id); result = __FAILURE__; } else if ( (mqtt_info->hsm_type == TRANSPORT_HSM_TYPE_TPM) && (ek == NULL || srk == NULL) ) { /* Codes_PROV_TRANSPORT_MQTT_COMMON_07_008: [ If hsm_type is TRANSPORT_HSM_TYPE_TPM and ek or srk is NULL, prov_transport_common_mqtt_open shall return a non-zero value. ] */ LogError("Invalid parameter specified ek: %p, srk: %p", ek, srk); result = __FAILURE__; } /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_009: [ prov_transport_common_mqtt_open shall clone the ek and srk values.] */ else if (ek != NULL && (mqtt_info->ek = BUFFER_clone(ek)) == NULL) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_041: [ If a failure is encountered, prov_transport_common_mqtt_open shall return a non-zero value. ] */ LogError("Unable to allocate endorsement key"); result = __FAILURE__; } else if (srk != NULL && (mqtt_info->srk = BUFFER_clone(srk)) == NULL) { /* Tests_PROV_TRANSPORT_MQTT_COMMON_07_041: [ If a failure is encountered, prov_transport_common_mqtt_open shall return a non-zero value. ] */ LogError("Unable to allocate storage root key"); BUFFER_delete(mqtt_info->ek); mqtt_info->ek = NULL; result = __FAILURE__; } else if (mallocAndStrcpy_s(&mqtt_info->registration_id, registration_id) != 0) { /* Codes_PROV_TRANSPORT_HTTP_CLIENT_07_003: [ If any error is encountered prov_transport_http_create shall return NULL. ] */ LogError("failure constructing registration Id"); BUFFER_delete(mqtt_info->ek); mqtt_info->ek = NULL; BUFFER_delete(mqtt_info->srk); mqtt_info->srk = NULL; result = __FAILURE__; } else { mqtt_info->register_data_cb = data_callback; mqtt_info->user_ctx = user_ctx; mqtt_info->status_cb = status_cb; mqtt_info->status_ctx = status_ctx; mqtt_info->mqtt_state = MQTT_STATE_DISCONNECTED; result = 0; } return result; }
const char* IoTHubAccount_GetSharedAccessSignature(IOTHUB_ACCOUNT_INFO_HANDLE acctHandle) { const char* result = NULL; IOTHUB_ACCOUNT_INFO* acctInfo = (IOTHUB_ACCOUNT_INFO*)acctHandle; if (acctInfo != NULL) { if (acctInfo->sharedAccessToken != NULL) { // Reuse the sharedAccessToken if it's been created already result = acctInfo->sharedAccessToken; } else { time_t currentTime = time(NULL); size_t expiry_time = (size_t)(currentTime + 3600); STRING_HANDLE accessKey = STRING_construct(acctInfo->sharedAccessKey); STRING_HANDLE iotName = STRING_construct(acctInfo->hostname); STRING_HANDLE keyName = STRING_construct(acctInfo->keyName); if (accessKey != NULL && iotName != NULL && keyName != NULL) { STRING_HANDLE sasHandle = SASToken_Create(accessKey, iotName, keyName, expiry_time); if (sasHandle == NULL) { result = NULL; } else { if (mallocAndStrcpy_s(&acctInfo->sharedAccessToken, STRING_c_str(sasHandle)) != 0) { result = NULL; } else { result = acctInfo->sharedAccessToken; } STRING_delete(sasHandle); } } STRING_delete(accessKey); STRING_delete(iotName); STRING_delete(keyName); } } else { result = NULL; } return result; }
static IOTHUB_AUTHORIZATION_DATA* initialize_auth_client(const char* device_id, const char* module_id) { IOTHUB_AUTHORIZATION_DATA* result; /* Codes_SRS_IoTHub_Authorization_07_002: [IoTHubClient_Auth_Create shall allocate a IOTHUB_AUTHORIZATION_HANDLE that is needed for subsequent calls. ] */ result = (IOTHUB_AUTHORIZATION_DATA*)malloc(sizeof(IOTHUB_AUTHORIZATION_DATA) ); if (result == NULL) { /* Codes_SRS_IoTHub_Authorization_07_019: [ On error IoTHubClient_Auth_Create shall return NULL. ] */ LogError("Failed allocating IOTHUB_AUTHORIZATION_DATA"); result = NULL; } else { memset(result, 0, sizeof(IOTHUB_AUTHORIZATION_DATA) ); if (mallocAndStrcpy_s(&result->device_id, device_id) != 0) { /* Codes_SRS_IoTHub_Authorization_07_019: [ On error IoTHubClient_Auth_Create shall return NULL. ] */ LogError("Failed allocating device_key"); free(result); result = NULL; } else if (module_id != NULL && mallocAndStrcpy_s(&result->module_id, module_id) != 0) { /* Codes_SRS_IoTHub_Authorization_07_019: [ On error IoTHubClient_Auth_Create shall return NULL. ] */ LogError("Failed allocating module_id"); free(result->device_id); free(result); result = NULL; } else { result->token_expiry_time_sec = DEFAULT_SAS_TOKEN_EXPIRY_TIME_SECS; } } return result; }
char* prov_auth_get_registration_id(PROV_AUTH_HANDLE handle) { char* result; if (handle == NULL) { /* Codes_SRS_PROV_AUTH_CLIENT_07_010: [ if handle is NULL prov_auth_get_registration_id shall return NULL. ] */ LogError("Invalid handle parameter"); result = NULL; } else { int load_result = 0; int reg_id_allocated = 0; if (handle->registration_id == NULL) { /* Codes_SRS_PROV_AUTH_CLIENT_07_011: [ prov_auth_get_registration_id shall load the registration id if it has not been previously loaded. ] */ load_result = load_registration_id(handle); if (load_result == 0) { reg_id_allocated = 1; } } if (load_result != 0) { /* Codes_SRS_PROV_AUTH_CLIENT_07_012: [ If a failure is encountered, prov_auth_get_registration_id shall return NULL. ] */ LogError("Failed loading registration key"); result = NULL; } /* Codes_SRS_PROV_AUTH_CLIENT_07_013: [ Upon success prov_auth_get_registration_id shall return the registration id of the secure enclave. ] */ else if (mallocAndStrcpy_s(&result, handle->registration_id) != 0) { /* Codes_SRS_PROV_AUTH_CLIENT_07_012: [ If a failure is encountered, prov_auth_get_registration_id shall return NULL. ] */ LogError("Failed allocating registration key"); if (reg_id_allocated == 1) { free(handle->registration_id); handle->registration_id = NULL; } result = NULL; } } return result; }
char* secure_dev_tpm_get_storage_key(SEC_DEVICE_HANDLE handle) { char* result; if (handle == NULL) { /* Codes_SRS_SECURE_DEVICE_TPM_07_016: [ If handle is NULL, secure_dev_tpm_get_storage_key shall return NULL. ] */ LogError("Invalid handle value specified"); result = NULL; } else if (handle->srk_pub.publicArea.unique.rsa.t.size == 0) { /* Codes_SRS_SECURE_DEVICE_TPM_07_017: [ If the srk_public value was not initialized, secure_dev_tpm_get_storage_key shall return NULL. ] */ LogError("storage root key is invalid"); result = NULL; } else { unsigned char data_bytes[1024]; unsigned char* data_pos = data_bytes; /* Codes_SRS_SECURE_DEVICE_TPM_07_018: [ secure_dev_tpm_get_storage_key shall allocate and return the Storage Root Key. ] */ uint32_t data_length = TPM2B_PUBLIC_Marshal(&handle->srk_pub, &data_pos, NULL); STRING_HANDLE encoded_srk = Azure_Base64_Encode_Bytes(data_bytes, data_length); if (encoded_srk == NULL) { /* Codes_SRS_SECURE_DEVICE_TPM_07_019: [ If any failure is encountered, secure_dev_tpm_get_storage_key shall return NULL. ] */ LogError("Failure encoding storage root key"); result = NULL; } else { if (mallocAndStrcpy_s(&result, STRING_c_str(encoded_srk)) != 0) { /* Codes_SRS_SECURE_DEVICE_TPM_07_019: [ If any failure is encountered, secure_dev_tpm_get_storage_key shall return NULL. ] */ LogError("Failure allocating storage root key"); result = NULL; } STRING_delete(encoded_srk); } } return result; }
static void* NativeModuleHost_ParseConfigurationFromJson(const char* configuration) { char* config_str; if (configuration == NULL) { /*Codes_SRS_NATIVEMODULEHOST_17_003: [ NativeModuleHost_ParseConfigurationFromJson shall return NULL if configuration is NULL. ]*/ LogError("NULL configuration given, this isn't correct for Native Module Host."); config_str = NULL; } else { /*Codes_SRS_NATIVEMODULEHOST_17_004: [ On success, NativeModuleHost_ParseConfigurationFromJson shall return a valid copy of the configuration string given. ]*/ if (mallocAndStrcpy_s(&config_str, configuration) != 0) { /*Codes_SRS_NATIVEMODULEHOST_17_005: [ NativeModuleHost_ParseConfigurationFromJson shall return NULL if any system call fails. ]*/ LogError("Unable to copy the configuration, returning NULL"); config_str = NULL; } } return config_str; }
/* * @brief duplicate a string and convert to upper case. New string must be released * no longer needed. */ static const char * IdentityMapConfig_ToUpperCase(const char * string) { char * result; int status; status = mallocAndStrcpy_s(&result, string); if (status != 0) // failure { result = NULL; } else { char * temp = result; while (*temp) { *temp = toupper(*temp); temp++; } } return result; }
/*obs: value is already cloned at the time of calling this function */ static int createOrUpdateOption(HTTPAPIEX_HANDLE_DATA* handleData, const char* optionName, const void* value) { /*this function is called after the option value has been saved (cloned)*/ int result; /*decide bwtween update or create*/ HTTPAPIEX_SAVED_OPTION* whereIsIt = VECTOR_find_if(handleData->savedOptions, sameName, optionName); if (whereIsIt != NULL) { free((void*)(whereIsIt->value)); whereIsIt->value = value; result = 0; } else { HTTPAPIEX_SAVED_OPTION newOption; if (mallocAndStrcpy_s((char**)&(newOption.optionName), optionName) != 0) { free((void*)value); result = __LINE__; } else { newOption.value = value; if (VECTOR_push_back(handleData->savedOptions, &newOption, 1) != 0) { LogError("unable to VECTOR_push_back\r\n"); free((void*)newOption.optionName); free((void*)value); result = __LINE__; } else { result = 0; } } } return result; }
char* querySpecification_serializeToJson(const PROVISIONING_QUERY_SPECIFICATION* query_spec) { char* result = NULL; char* serialized_string = NULL; JSON_Value* root_value = NULL; if (query_spec == NULL) { LogError("Invalid query specification"); } else if (query_spec->version != PROVISIONING_QUERY_SPECIFICATION_VERSION_1) { LogError("Invalid version"); } else if ((root_value = querySpecification_toJson(query_spec)) == NULL) { LogError("Creating json object failed"); } else if ((serialized_string = json_serialize_to_string(root_value)) == NULL) { LogError("Failed to serialize to JSON"); } else if (mallocAndStrcpy_s(&result, serialized_string) != 0) { LogError("Failed to copy serialized string"); } if (root_value != NULL) { json_value_free(root_value); root_value = NULL; } if (serialized_string != NULL) { json_free_serialized_string(serialized_string); serialized_string = NULL; } return result; }
DNS_ASYNC_HANDLE dns_async_create(const char* hostname, DNS_ASYNC_OPTIONS* options) { /* Codes_SRS_DNS_ASYNC_30_012: [ The optional options parameter shall be ignored. ]*/ DNS_ASYNC_INSTANCE* result; (void)options; if (hostname == NULL) { /* Codes_SRS_DNS_ASYNC_30_011: [ If the hostname parameter is NULL, dns_async_create shall log an error and return NULL. ]*/ LogError("NULL hostname"); result = NULL; } else { result = malloc(sizeof(DNS_ASYNC_INSTANCE)); if (result == NULL) { /* Codes_SRS_DNS_ASYNC_30_014: [ On any failure, dns_async_create shall log an error and return NULL. ]*/ LogError("malloc instance failed"); result = NULL; } else { int ms_result; result->is_complete = false; result->is_failed = false; result->ip_v4 = 0; /* Codes_SRS_DNS_ASYNC_30_010: [ dns_async_create shall make a copy of the hostname parameter to allow immediate deletion by the caller. ]*/ ms_result = mallocAndStrcpy_s(&result->hostname, hostname); if (ms_result != 0) { /* Codes_SRS_DNS_ASYNC_30_014: [ On any failure, dns_async_create shall log an error and return NULL. ]*/ free(result); result = NULL; } } } return result; }
static void expected_calls_deviceRegistrationState_fromJson() { STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_REGISTRATION_ID); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_CREATED_DATE_TIME_UTC); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_DEVICE_ID); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(REGISTRATION_STATUS_JSON_VALUE_ASSIGNED); //can't "fail" STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_UPDATED_DATE_TIME_UTC); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_ERROR_MESSAGE); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_string(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_ETAG); //can't "fail" STRICT_EXPECTED_CALL(mallocAndStrcpy_s(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_number(IGNORED_PTR_ARG, IGNORED_PTR_ARG)).SetReturn(DUMMY_ERROR_CODE); //can't "fail" }