const char* IoTHubAccount_GetEventhubAccessKey(void) { char *iothub_connection_string; static char access_key[128]; if ((iothub_connection_string = IoTHubAccount_GetIoTHubConnString()) != NULL) { STRING_HANDLE iothub_connection_string_str; if((iothub_connection_string_str = STRING_construct(iothub_connection_string)) != NULL) { STRING_TOKENIZER_HANDLE tokenizer; if ((tokenizer = STRING_TOKENIZER_create(iothub_connection_string_str)) != NULL) { STRING_HANDLE tokenString; if ((tokenString = STRING_new()) != NULL) { STRING_HANDLE valueString; if ((valueString = STRING_new()) != NULL) { while ((STRING_TOKENIZER_get_next_token(tokenizer, tokenString, "=") == 0)) { char tokenValue[128]; strcpy(tokenValue, STRING_c_str(tokenString)); if (STRING_TOKENIZER_get_next_token(tokenizer, tokenString, ";") != 0) { break; } if (strcmp(tokenValue, "SharedAccessKey") == 0) { strcpy(access_key, STRING_c_str(tokenString)); break; } } STRING_delete(valueString); } STRING_delete(tokenString); } STRING_TOKENIZER_destroy(tokenizer); } STRING_delete(iothub_connection_string_str); } } return access_key; }
IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) { IOTHUB_CLIENT_LL_HANDLE result = NULL; /*Codes_SRS_IOTHUBCLIENT_LL_05_001: [IoTHubClient_LL_CreateFromConnectionString shall obtain the version string by a call to IoTHubClient_GetVersionString.]*/ /*Codes_SRS_IOTHUBCLIENT_LL_05_002: [IoTHubClient_LL_CreateFromConnectionString shall print the version string to standard output.]*/ LogInfo("IoT Hub SDK for C, version %s", IoTHubClient_GetVersionString()); /* Codes_SRS_IOTHUBCLIENT_LL_12_003: [IoTHubClient_LL_CreateFromConnectionString shall verify the input parameter and if it is NULL then return NULL] */ if (connectionString == NULL) { LogError("Input parameter is NULL: connectionString"); } else if (protocol == NULL) { LogError("Input parameter is NULL: protocol"); } else { /* Codes_SRS_IOTHUBCLIENT_LL_12_004: [IoTHubClient_LL_CreateFromConnectionString shall allocate IOTHUB_CLIENT_CONFIG structure] */ IOTHUB_CLIENT_CONFIG* config = malloc(sizeof(IOTHUB_CLIENT_CONFIG)); if (config == NULL) { /* Codes_SRS_IOTHUBCLIENT_LL_12_012: [If the allocation failed IoTHubClient_LL_CreateFromConnectionString returns NULL] */ LogError("Malloc failed"); return NULL; } else { STRING_TOKENIZER_HANDLE tokenizer1 = NULL; STRING_HANDLE connString = NULL; STRING_HANDLE tokenString = NULL; STRING_HANDLE valueString = NULL; STRING_HANDLE hostNameString = NULL; STRING_HANDLE hostSuffixString = NULL; STRING_HANDLE deviceIdString = NULL; STRING_HANDLE deviceKeyString = NULL; STRING_HANDLE deviceSasTokenString = NULL; STRING_HANDLE protocolGateway = NULL; config->protocol = protocol; config->iotHubName = NULL; config->iotHubSuffix = NULL; config->deviceId = NULL; config->deviceKey = NULL; config->deviceSasToken = NULL; /* Codes_SRS_IOTHUBCLIENT_LL_04_002: [If it does not, it shall pass the protocolGatewayHostName NULL.] */ config->protocolGatewayHostName = NULL; if ((connString = STRING_construct(connectionString)) == NULL) { LogError("Error constructing connectiong String"); } else if ((tokenizer1 = STRING_TOKENIZER_create(connString)) == NULL) { LogError("Error creating Tokenizer"); } else if ((tokenString = STRING_new()) == NULL) { LogError("Error creating Token String"); } else if ((valueString = STRING_new()) == NULL) { LogError("Error creating Value String"); } else if ((hostNameString = STRING_new()) == NULL) { LogError("Error creating HostName String"); } else if ((hostSuffixString = STRING_new()) == NULL) { LogError("Error creating HostSuffix String"); } /* Codes_SRS_IOTHUBCLIENT_LL_12_005: [IoTHubClient_LL_CreateFromConnectionString shall try to parse the connectionString input parameter for the following structure: "Key1=value1;key2=value2;key3=value3..."] */ /* Codes_SRS_IOTHUBCLIENT_LL_12_006: [IoTHubClient_LL_CreateFromConnectionString shall verify the existence of the following Key/Value pairs in the connection string: HostName, DeviceId, SharedAccessKey or SharedAccessSignature.] */ else { while ((STRING_TOKENIZER_get_next_token(tokenizer1, tokenString, "=") == 0)) { if (STRING_TOKENIZER_get_next_token(tokenizer1, valueString, ";") != 0) { LogError("Tokenizer error"); break; } else { if (tokenString != NULL) { /* Codes_SRS_IOTHUBCLIENT_LL_12_010: [IoTHubClient_LL_CreateFromConnectionString shall fill up the IOTHUB_CLIENT_CONFIG structure using the following mapping: iotHubName = Name, iotHubSuffix = Suffix, deviceId = DeviceId, deviceKey = SharedAccessKey or deviceSasToken = SharedAccessSignature] */ const char* s_token = STRING_c_str(tokenString); if (strcmp(s_token, HOSTNAME_TOKEN) == 0) { /* Codes_SRS_IOTHUBCLIENT_LL_12_009: [IoTHubClient_LL_CreateFromConnectionString shall split the value of HostName to Name and Suffix using the first "." as a separator] */ STRING_TOKENIZER_HANDLE tokenizer2 = NULL; if ((tokenizer2 = STRING_TOKENIZER_create(valueString)) == NULL) { LogError("Error creating Tokenizer"); break; } else { /* Codes_SRS_IOTHUBCLIENT_LL_12_015: [If the string split failed, IoTHubClient_LL_CreateFromConnectionString returns NULL ] */ if (STRING_TOKENIZER_get_next_token(tokenizer2, hostNameString, ".") != 0) { LogError("Tokenizer error"); STRING_TOKENIZER_destroy(tokenizer2); break; } else { config->iotHubName = STRING_c_str(hostNameString); if (STRING_TOKENIZER_get_next_token(tokenizer2, hostSuffixString, ";") != 0) { LogError("Tokenizer error"); STRING_TOKENIZER_destroy(tokenizer2); break; } else { config->iotHubSuffix = STRING_c_str(hostSuffixString); } } STRING_TOKENIZER_destroy(tokenizer2); } } else if (strcmp(s_token, DEVICEID_TOKEN) == 0) { deviceIdString = STRING_clone(valueString); if (deviceIdString != NULL) { config->deviceId = STRING_c_str(deviceIdString); } } else if (strcmp(s_token, DEVICEKEY_TOKEN) == 0) { deviceKeyString = STRING_clone(valueString); if (deviceKeyString != NULL) { config->deviceKey = STRING_c_str(deviceKeyString); } } else if (strcmp(s_token, DEVICESAS_TOKEN) == 0) { deviceSasTokenString = STRING_clone(valueString); if (deviceSasTokenString != NULL) { config->deviceSasToken = STRING_c_str(deviceSasTokenString); } } /* Codes_SRS_IOTHUBCLIENT_LL_04_001: [IoTHubClient_LL_CreateFromConnectionString shall verify the existence of key/value pair GatewayHostName. If it does exist it shall pass the value to IoTHubClient_LL_Create API.] */ else if (strcmp(s_token, PROTOCOL_GATEWAY_HOST) == 0) { protocolGateway = STRING_clone(valueString); if (protocolGateway != NULL) { config->protocolGatewayHostName = STRING_c_str(protocolGateway); } } } } } /* parsing is done - check the result */ if (config->iotHubName == NULL) { LogError("iotHubName is not found"); } else if (config->iotHubSuffix == NULL) { LogError("iotHubSuffix is not found"); } else if (config->deviceId == NULL) { LogError("deviceId is not found"); } else if (config->deviceKey == NULL && config->deviceSasToken == NULL) { LogError("deviceKey/deviceSasToken not found"); } else if (config->deviceKey != NULL && config->deviceSasToken != NULL) { LogError("Both device Key & SAS token are defined. Only one should be provided."); } else { /* Codes_SRS_IOTHUBCLIENT_LL_12_011: [IoTHubClient_LL_CreateFromConnectionString shall call into the IoTHubClient_LL_Create API with the current structure and returns with the return value of it] */ result = IoTHubClient_LL_Create(config); if (result == NULL) { LogError("IoTHubClient_LL_Create failed"); } else { /*return as is*/ } } } if (deviceSasTokenString != NULL) STRING_delete(deviceSasTokenString); if (deviceKeyString != NULL) STRING_delete(deviceKeyString); if (deviceIdString != NULL) STRING_delete(deviceIdString); if (hostSuffixString != NULL) STRING_delete(hostSuffixString); if (hostNameString != NULL) STRING_delete(hostNameString); if (valueString != NULL) STRING_delete(valueString); if (tokenString != NULL) STRING_delete(tokenString); if (connString != NULL) STRING_delete(connString); if (protocolGateway != NULL) STRING_delete(protocolGateway); if (tokenizer1 != NULL) STRING_TOKENIZER_destroy(tokenizer1); free(config); } } return result; }
/* Codes_SRS_CONNECTIONSTRINGPARSER_01_001: [connectionstringparser_parse shall parse all key value pairs from the connection_string passed in as argument and return a new map that holds the key/value pairs.] */ MAP_HANDLE connectionstringparser_parse(STRING_HANDLE connection_string) { MAP_HANDLE result; if (connection_string == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_002: [If connection_string is NULL then connectionstringparser_parse shall fail and return NULL.] */ result = NULL; LogError("NULL connection string passed to tokenizer."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_003: [connectionstringparser_parse shall create a STRING tokenizer to be used for parsing the connection string, by calling STRING_TOKENIZER_create.] */ /* Codes_SRS_CONNECTIONSTRINGPARSER_01_004: [connectionstringparser_parse shall start scanning at the beginning of the connection string.] */ STRING_TOKENIZER_HANDLE tokenizer = STRING_TOKENIZER_create(connection_string); if (tokenizer == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_015: [If STRING_TOKENIZER_create fails, connectionstringparser_parse shall fail and return NULL.] */ result = NULL; LogError("Error creating STRING tokenizer."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_016: [2 STRINGs shall be allocated in order to hold the to be parsed key and value tokens.] */ STRING_HANDLE token_key_string = STRING_new(); if (token_key_string == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_017: [If allocating the STRINGs fails connectionstringparser_parse shall fail and return NULL.] */ result = NULL; LogError("Error creating key token STRING."); } else { STRING_HANDLE token_value_string = STRING_new(); if (token_value_string == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_017: [If allocating the STRINGs fails connectionstringparser_parse shall fail and return NULL.] */ result = NULL; LogError("Error creating value token STRING."); } else { result = Map_Create(NULL); if (result == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_018: [If creating the result map fails, then connectionstringparser_parse shall return NULL.] */ LogError("Error creating Map."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_005: [The following actions shall be repeated until parsing is complete:] */ /* Codes_SRS_CONNECTIONSTRINGPARSER_01_006: [connectionstringparser_parse shall find a token (the key of the key/value pair) delimited by the `=` character, by calling STRING_TOKENIZER_get_next_token.] */ /* Codes_SRS_CONNECTIONSTRINGPARSER_01_007: [If STRING_TOKENIZER_get_next_token fails, parsing shall be considered complete.] */ while (STRING_TOKENIZER_get_next_token(tokenizer, token_key_string, "=") == 0) { bool is_error = false; /* Codes_SRS_CONNECTIONSTRINGPARSER_01_008: [connectionstringparser_parse shall find a token (the value of the key/value pair) delimited by the `;` character, by calling STRING_TOKENIZER_get_next_token.] */ if (STRING_TOKENIZER_get_next_token(tokenizer, token_value_string, ";") != 0) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_009: [If STRING_TOKENIZER_get_next_token fails, connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */ is_error = true; LogError("Error reading value token from the connection string."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_011: [The C strings for the key and value shall be extracted from the previously parsed STRINGs by using STRING_c_str.] */ const char* token = STRING_c_str(token_key_string); /* Codes_SRS_CONNECTIONSTRINGPARSER_01_013: [If STRING_c_str fails then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */ if ((token == NULL) || /* Codes_SRS_CONNECTIONSTRINGPARSER_01_019: [If the key length is zero then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */ (strlen(token) == 0)) { is_error = true; LogError("The key token is NULL or empty."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_011: [The C strings for the key and value shall be extracted from the previously parsed STRINGs by using STRING_c_str.] */ const char* value = STRING_c_str(token_value_string); if (value == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_013: [If STRING_c_str fails then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */ is_error = true; LogError("Could not get C string for value token."); } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_010: [The key and value shall be added to the result map by using Map_Add.] */ if (Map_Add(result, token, value) != 0) { /* Codes_SRS_CONNECTIONSTRINGPARSER_01_012: [If Map_Add fails connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */ is_error = true; LogError("Could not add the key/value pair to the result map."); } } } } if (is_error) { LogError("Error parsing connection string."); Map_Destroy(result); result = NULL; break; } } } STRING_delete(token_value_string); } STRING_delete(token_key_string); } /* Codes_SRS_CONNECTIONSTRINGPARSER_01_014: [After the parsing is complete the previously allocated STRINGs and STRING tokenizer shall be freed by calling STRING_TOKENIZER_destroy.] */ STRING_TOKENIZER_destroy(tokenizer); } } return result; }
IOTHUB_SERVICE_CLIENT_AUTH_HANDLE IoTHubServiceClientAuth_CreateFromConnectionString(const char* connectionString) { IOTHUB_SERVICE_CLIENT_AUTH_HANDLE result; /*Codes_SRS_IOTHUBSERVICECLIENT_12_001: [** IoTHubServiceClientAuth_CreateFromConnectionString shall verify the input parameter and if it is NULL then return NULL **]*/ if (connectionString == NULL) { LogError("Input parameter is NULL: connectionString"); result = NULL; } else { /*Codes_SRS_IOTHUBSERVICECLIENT_12_002: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory for a new service client instance. **] */ result = malloc(sizeof(IOTHUB_SERVICE_CLIENT_AUTH)); if (result == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_003: [** If the allocation failed, IoTHubServiceClientAuth_CreateFromConnectionString shall return NULL **] */ LogError("Malloc failed for IOTHUB_SERVICE_CLIENT_AUTH"); } else { /*Codes_SRS_IOTHUBSERVICECLIENT_12_009: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create a STRING_HANDLE from the given connection string by calling STRING_construct. **] */ STRING_HANDLE connection_string; if ((connection_string = STRING_construct(connectionString)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_010: [** If the STRING_construct fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("STRING_construct failed"); free(result); result = NULL; } else { /*Codes_SRS_IOTHUBSERVICECLIENT_12_004: [** IoTHubServiceClientAuth_CreateFromConnectionString shall populate hostName, iotHubName, iotHubSuffix, sharedAccessKeyName, sharedAccessKeyValue from the given connection string by calling connectionstringparser_parse **] */ MAP_HANDLE connection_string_values_map; if ((connection_string_values_map = connectionstringparser_parse(connection_string)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_005: [** If populating the IOTHUB_SERVICE_CLIENT_AUTH fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL **] */ LogError("Tokenizing failed on connectionString"); free(result); result = NULL; } else { STRING_TOKENIZER_HANDLE tokenizer = NULL; STRING_HANDLE token_key_string = NULL; STRING_HANDLE token_value_string = NULL; STRING_HANDLE host_name_string = NULL; const char* hostName; const char* keyName; const char* sharedAccessKey; const char* iothubName; const char* iothubSuffix; /*Codes_SRS_IOTHUBSERVICECLIENT_12_004: [** IoTHubServiceClientAuth_CreateFromConnectionString shall populate hostName, iotHubName, iotHubSuffix, sharedAccessKeyName, sharedAccessKeyValue from the given connection string by calling connectionstringparser_parse **] */ (void)memset(result, 0, sizeof(IOTHUB_SERVICE_CLIENT_AUTH)); if ((hostName = Map_GetValueFromKey(connection_string_values_map, IOTHUBHOSTNAME)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_011: [** If the populating HostName fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Couldn't find %s in connection string", IOTHUBHOSTNAME); free(result); result = NULL; } else if ((keyName = Map_GetValueFromKey(connection_string_values_map, IOTHUBSHAREDACESSKEYNAME)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_012: [** If the populating SharedAccessKeyName fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Couldn't find %s in connection string", IOTHUBSHAREDACESSKEYNAME); free(result); result = NULL; } else if ((sharedAccessKey = Map_GetValueFromKey(connection_string_values_map, IOTHUBSHAREDACESSKEY)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_013: [** If the populating SharedAccessKey fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Couldn't find %s in connection string", IOTHUBSHAREDACESSKEY); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_038: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create a STRING_handle from hostName by calling STRING_construct. **] */ else if ((host_name_string = STRING_construct(hostName)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_039: [** If the STRING_construct fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("STRING_construct failed"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_014: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create a STRING_TOKENIZER to parse HostName by calling STRING_TOKENIZER_create. **] */ else if ((tokenizer = STRING_TOKENIZER_create(host_name_string)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_015: [** If the STRING_TOKENIZER_create fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Error creating STRING tokenizer"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_016: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create a new STRING_HANDLE for token key string by calling STRING_new. **] */ else if ((token_key_string = STRING_new()) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_017: [** If the STRING_new fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Error creating key token STRING_HANDLE"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_018: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create a new STRING_HANDLE for token value string by calling STRING_new. **] */ else if ((token_value_string = STRING_new()) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_019: [** If the STRING_new fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Error creating value token STRING_HANDLE"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_020: [** IoTHubServiceClientAuth_CreateFromConnectionString shall call STRING_TOKENIZER_get_next_token to get token key string. **] */ else if (STRING_TOKENIZER_get_next_token(tokenizer, token_key_string, ".") != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_021: [** If the STRING_TOKENIZER_get_next_token fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Error reading key token STRING"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_022: [** IoTHubServiceClientAuth_CreateFromConnectionString shall call STRING_TOKENIZER_get_next_token to get token value string. **] */ else if (STRING_TOKENIZER_get_next_token(tokenizer, token_value_string, "0") != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_023: [** If the STRING_TOKENIZER_get_next_token fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("Error reading value token STRING"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_024: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory and copy hostName to result->hostName by calling mallocAndStrcpy_s. **] */ else if (mallocAndStrcpy_s(&result->hostname, hostName) != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_025: [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("mallocAndStrcpy_s failed for hostName"); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_026: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory and copy keyName to result->keyName by calling mallocAndStrcpy_s. **] */ else if (mallocAndStrcpy_s(&result->keyName, keyName) != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_027: [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("mallocAndStrcpy_s failed for keyName"); free(result->hostname); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_028: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory and copy sharedAccessKey to result->sharedAccessKey by calling mallocAndStrcpy_s. **] */ else if (mallocAndStrcpy_s(&result->sharedAccessKey, sharedAccessKey) != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_029: [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("mallocAndStrcpy_s failed for sharedAccessKey"); free(result->hostname); free(result->keyName); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_034: [** IoTHubServiceClientAuth_CreateFromConnectionString shall create C string from token key string handle by calling STRING_c_str. **] */ else if ((iothubName = STRING_c_str(token_key_string)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_035 : [** If the STRING_c_str fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("STRING_c_str failed for iothubName"); free(result->hostname); free(result->keyName); free(result->sharedAccessKey); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_036 : [** IoTHubServiceClientAuth_CreateFromConnectionString shall create C string from token value string handle by calling STRING_c_str. **] */ else if ((iothubSuffix = STRING_c_str(token_value_string)) == NULL) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_037 : [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("STRING_c_str failed for iothubSuffix"); free(result->hostname); free(result->keyName); free(result->sharedAccessKey); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_030: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory and copy iothubName to result->iothubName by calling mallocAndStrcpy_s. **] */ else if (mallocAndStrcpy_s(&result->iothubName, iothubName) != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_031 : [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("mallocAndStrcpy_s failed for sharedAccessKey"); free(result->hostname); free(result->keyName); free(result->sharedAccessKey); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_032: [** IoTHubServiceClientAuth_CreateFromConnectionString shall allocate memory and copy iothubSuffix to result->iothubSuffix by calling mallocAndStrcpy_s. **] */ else if (mallocAndStrcpy_s(&result->iothubSuffix, iothubSuffix) != 0) { /*Codes_SRS_IOTHUBSERVICECLIENT_12_033 : [** If the mallocAndStrcpy_s fails, IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return NULL. **] */ LogError("mallocAndStrcpy_s failed for sharedAccessKey"); free(result->hostname); free(result->keyName); free(result->sharedAccessKey); free(result->iothubName); free(result); result = NULL; } /*Codes_SRS_IOTHUBSERVICECLIENT_12_006: [** If the IOTHUB_SERVICE_CLIENT_AUTH has been populated IoTHubServiceClientAuth_CreateFromConnectionString shall do clean up and return with a IOTHUB_SERVICE_CLIENT_AUTH_HANDLE to it **] */ STRING_delete(token_key_string); STRING_delete(token_value_string); STRING_delete(host_name_string); STRING_TOKENIZER_destroy(tokenizer); Map_Destroy(connection_string_values_map); } STRING_delete(connection_string); } } } return result; }