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