int Map_Init()
{
if (SDL_VideoInit(NULL) < 0)
{
fprintf(stdout, "%s\n", SDL_GetError());
return FAILURE;
}
if ((pMap = malloc(sizeof(*pMap))) == NULL)
{
fprintf(stdout, "%s\n", strerror(errno));
Map_Destroy();
return FAILURE;
}
pMap->width = WINDOW_W;
pMap->height = WINDOW_H;
pMap->offsetx = 0;
pMap->offsety = 0;
pMap->zoom = 0;
pWindow = SDL_CreateWindow("MAP",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
pMap->width,
pMap->height,
SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if (pWindow == NULL)
{
fprintf(stdout, "%s\n", SDL_GetError());
Map_Destroy();
return FAILURE;
}
pRenderer = SDL_CreateRenderer(
pWindow,
DEFAULT_INDEX,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (pRenderer == NULL)
{
fprintf(stdout, "%s\n", SDL_GetError());
Map_Destroy();
return FAILURE;
}
SDL_SetRenderDrawColor(pRenderer, 221, 221, 221, 255);
SDL_RenderClear(pRenderer);
SDL_RenderPresent(pRenderer);
SDL_SetRenderDrawColor(pRenderer, 0, 0, 0, 255);
SDL_RenderPresent(pRenderer);
return SUCCESS;
}
/*
* @brief Republish message with new data from our matching identities.
*/
static void IdentityMap_RepublishC2D(
IDENTITY_MAP_DATA * idModule,
MESSAGE_HANDLE messageHandle,
IDENTITY_MAP_CONFIG * match)
{
CONSTMAP_HANDLE properties = Message_GetProperties(messageHandle);
if (properties == NULL)
{
LogError("Could not extract message properties");
}
else
{
/*Codes_SRS_IDMAP_17_049: [ On a C2D message received, IdentityMap_Receive shall call ConstMap_CloneWriteable on the message properties. ]*/
MAP_HANDLE newProperties = ConstMap_CloneWriteable(properties);
if (newProperties == NULL)
{
/*Codes_SRS_IDMAP_17_050: [ If ConstMap_CloneWriteable fails, IdentityMap_Receive shall deallocate any resources and return. ]*/
LogError("Could not make writeable new properties map");
}
else
{
/*Codes_SRS_IDMAP_17_051: [ IdentityMap_Receive shall call Map_AddOrUpdate with key of "macAddress" and value of found macAddress. ]*/
if (Map_AddOrUpdate(newProperties, GW_MAC_ADDRESS_PROPERTY, match->macAddress) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_052: [ If adding macAddress fails, IdentityMap_Receive shall deallocate all resources and return. ]*/
LogError("Could not attach %s property to message", GW_MAC_ADDRESS_PROPERTY);
}
/*Codes_SRS_IDMAP_17_032: [IdentityMap_Receive shall call Map_AddOrUpdate with key of "source" and value of "mapping".]*/
else if (Map_AddOrUpdate(newProperties, GW_SOURCE_PROPERTY, GW_IDMAP_MODULE) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_033: [If adding source fails, IdentityMap_Receive shall deallocate all resources and return.]*/
LogError("Could not attach %s property to message", GW_SOURCE_PROPERTY);
}
/*Codes_SRS_IDMAP_17_055: [ IdentityMap_Receive shall call Map_Delete to remove the "deviceName" property. ]*/
else if (Map_Delete(newProperties, GW_DEVICENAME_PROPERTY) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_056: [ If deleting the device name fails, IdentityMap_Receive shall deallocate all resources and return. ]*/
LogError("Could not remove %s property from message", GW_DEVICENAME_PROPERTY);
}
/*Codes_SRS_IDMAP_17_057: [ IdentityMap_Receive shall call Map_Delete to remove the "deviceKey" property. ]*/
else if (Map_Delete(newProperties, GW_DEVICEKEY_PROPERTY) == MAP_INVALIDARG)
{
/*Codes_SRS_IDMAP_17_058: [ If deleting the device key does not return MAP_OK or MAP_KEYNOTFOUND, IdentityMap_Receive shall deallocate all resources and return. ]*/
LogError("Could not remove %s property from message", GW_DEVICEKEY_PROPERTY);
}
else
{
publish_with_new_properties(newProperties, messageHandle, idModule);
}
Map_Destroy(newProperties);
}
ConstMap_Destroy(properties);
}
}
/*
* @brief Republish message with new data from our matching identities.
*/
static void IdentityMap_RepublishD2C(
IDENTITY_MAP_DATA * idModule,
MESSAGE_HANDLE messageHandle,
IDENTITY_MAP_CONFIG * match)
{
CONSTMAP_HANDLE properties = Message_GetProperties(messageHandle);
if (properties == NULL)
{
LogError("Could not extract message properties");
}
else
{
/*Codes_SRS_IDMAP_17_026: [On a message which passes all checks, IdentityMap_Receive shall call ConstMap_CloneWriteable on the message properties.]*/
MAP_HANDLE newProperties = ConstMap_CloneWriteable(properties);
if (newProperties == NULL)
{
/*Codes_SRS_IDMAP_17_027: [If ConstMap_CloneWriteable fails, IdentityMap_Receive shall deallocate any resources and return.] */
LogError("Could not make writeable new properties map");
}
else
{
/*Codes_SRS_IDMAP_17_028: [IdentityMap_Receive shall call Map_AddOrUpdate with key of "deviceName" and value of found deviceId.]*/
if (Map_AddOrUpdate(newProperties, GW_DEVICENAME_PROPERTY, match->deviceId) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_029: [If adding deviceName fails,IdentityMap_Receive shall deallocate all resources and return.]*/
LogError("Could not attach %s property to message", GW_DEVICENAME_PROPERTY);
}
/*Codes_SRS_IDMAP_17_030: [IdentityMap_Receive shall call Map_AddOrUpdate with key of "deviceKey" and value of found deviceKey.]*/
else if (Map_AddOrUpdate(newProperties, GW_DEVICEKEY_PROPERTY, match->deviceKey) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_031: [If adding deviceKey fails, IdentityMap_Receive shall deallocate all resources and return.]*/
LogError("Could not attach %s property to message", GW_DEVICEKEY_PROPERTY);
}
/*Codes_SRS_IDMAP_17_032: [IdentityMap_Receive shall call Map_AddOrUpdate with key of "source" and value of "mapping".]*/
else if (Map_AddOrUpdate(newProperties, GW_SOURCE_PROPERTY, GW_IDMAP_MODULE) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_033: [If adding source fails, IdentityMap_Receive shall deallocate all resources and return.]*/
LogError("Could not attach %s property to message", GW_SOURCE_PROPERTY);
}
/*Codes_SRS_IDMAP_17_053: [ IdentityMap_Receive shall call Map_Delete to remove the "macAddress" property. ]*/
else if (Map_Delete(newProperties, GW_MAC_ADDRESS_PROPERTY) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_054: [ If deleting the MAC Address fails, IdentityMap_Receive shall deallocate all resources and return. ]*/
LogError("Could not remove %s property from message", GW_MAC_ADDRESS_PROPERTY);
}
else
{
publish_with_new_properties(newProperties, messageHandle, idModule);
}
Map_Destroy(newProperties);
}
ConstMap_Destroy(properties);
}
}
/*Codes_SRS_HTTP_HEADERS_99_005:[ Calling this API shall de-allocate the data structures allocated by previous API calls to the same handle.]*/
void HTTPHeaders_Free(HTTP_HEADERS_HANDLE handle)
{
/*Codes_SRS_HTTP_HEADERS_02_001: [If httpHeadersHandle is NULL then HTTPHeaders_Free shall perform no action.] */
if (handle == NULL)
{
/*do nothing*/
}
else
{
/*Codes_SRS_HTTP_HEADERS_99_005:[ Calling this API shall de-allocate the data structures allocated by previous API calls to the same handle.]*/
HTTP_HEADERS_HANDLE_DATA* handleData = (HTTP_HEADERS_HANDLE_DATA*)handle;
Map_Destroy(handleData->headers);
free(handleData);
}
}
int main(int argc, char** argv)
{
char file[LENGTH_PATH];
int i;
if(argc < 1 || argc > 2)
{
//fprintf(stdout, "%s\n", ARGC_FAILURE);
return EXIT_FAILURE;
}
memset(file, 0, LENGTH_PATH);
if(argc == 1)
strcpy(file, DEFAULT_OSM);
else
strcpy(file, argv[1]);
if(parse(file) == FAILURE)
{
Objs_Free();
return EXIT_FAILURE;
}
tri_rapide_node(pRoot->arrayNodes, pRoot->size_nodes);
tri_rapide_way(pRoot->arrayWays, pRoot->size_ways);
tri_rapide_relation(pRoot->arrayRelations, pRoot->size_relations);
if(Map_Init() == FAILURE)
{
Objs_Free();
return EXIT_FAILURE;
}
Map_Draw();
Map_Loop();
Map_Destroy();
Objs_Free();
return EXIT_SUCCESS;
}
void ConstMap_Destroy(CONSTMAP_HANDLE handle)
{
/*Codes_SRS_CONSTMAP_17_005: [If parameter handle is NULL then ConstMap_Destroy shall take no action.]*/
if (handle == NULL)
{
LOG_CONSTMAP_ERROR(CONSTMAP_INVALIDARG);
}
else
{
/*Codes_SRS_CONSTMAP_17_049: [ConstMap_Destroy shall decrement the internal reference count of the immutable map.]*/
if (DEC_REF(CONSTMAP_HANDLE_DATA, handle) == DEC_RETURN_ZERO)
{
/*Codes_SRS_CONSTMAP_17_004: [If the reference count is zero, ConstMap_Destroy shall release all resources associated with the immutable map.]*/
Map_Destroy(((CONSTMAP_HANDLE_DATA *)handle)->map);
free(handle);
}
}
}
/*
* @brief Republish message with new data from our matching identities.
*/
static void IdentityMap_RepublishC2D(
IDENTITY_MAP_DATA * idModule,
MESSAGE_HANDLE messageHandle,
IDENTITY_MAP_CONFIG * match)
{
CONSTMAP_HANDLE properties = Message_GetProperties(messageHandle);
if (properties == NULL)
{
LogError("Could not extract message properties");
}
else
{
/*Codes_SRS_IDMAP_17_049: [ On a C2D message received, IdentityMap_Receive shall call ConstMap_CloneWriteable on the message properties. ]*/
MAP_HANDLE newProperties = ConstMap_CloneWriteable(properties);
if (newProperties == NULL)
{
/*Codes_SRS_IDMAP_17_050: [ If ConstMap_CloneWriteable fails, IdentityMap_Receive shall deallocate any resources and return. ]*/
LogError("Could not make writeable new properties map");
}
else
{
/*Codes_SRS_IDMAP_17_051: [ IdentityMap_Receive shall call Map_AddOrUpdate with key of "macAddress" and value of found macAddress. ]*/
if (Map_AddOrUpdate(newProperties, GW_MAC_ADDRESS_PROPERTY, match->macAddress) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_052: [ If adding macAddress fails, IdentityMap_Receive shall deallocate all resources and return. ]*/
LogError("Could not attach MAC address property to message");
}
/*Codes_SRS_IDMAP_17_032: [IdentityMap_Receive shall call Map_AddOrUpdate with key of "source" and value of "mapping".]*/
else if (Map_AddOrUpdate(newProperties, GW_SOURCE_PROPERTY, GW_IDMAP_MODULE) != MAP_OK)
{
/*Codes_SRS_IDMAP_17_033: [If adding source fails, IdentityMap_Receive shall deallocate all resources and return.]*/
LogError("Could not attach source property to message");
}
else
{
publish_with_new_properties(newProperties, messageHandle, idModule);
}
Map_Destroy(newProperties);
}
ConstMap_Destroy(properties);
}
}
void IoTHubMessage_Destroy(IOTHUB_MESSAGE_HANDLE iotHubMessageHandle)
{
/*Codes_SRS_IOTHUBMESSAGE_01_004: [If iotHubMessageHandle is NULL, IoTHubMessage_Destroy shall do nothing.] */
if (iotHubMessageHandle != NULL)
{
/*Codes_SRS_IOTHUBMESSAGE_01_003: [IoTHubMessage_Destroy shall free all resources associated with iotHubMessageHandle.] */
IOTHUB_MESSAGE_HANDLE_DATA* handleData = iotHubMessageHandle;
if (handleData->contentType == IOTHUBMESSAGE_BYTEARRAY)
{
BUFFER_delete(handleData->value.byteArray);
}
else
{
/*can only be STRING*/
STRING_delete(handleData->value.string);
}
Map_Destroy(handleData->properties);
free(handleData);
}
}
static void DestroyMessageData(IOTHUB_MESSAGE_HANDLE_DATA* handleData)
{
if (handleData->contentType == IOTHUBMESSAGE_BYTEARRAY)
{
BUFFER_delete(handleData->value.byteArray);
}
else if (handleData->contentType == IOTHUBMESSAGE_STRING)
{
STRING_delete(handleData->value.string);
}
Map_Destroy(handleData->properties);
free(handleData->messageId);
handleData->messageId = NULL;
free(handleData->correlationId);
handleData->correlationId = NULL;
free(handleData->userDefinedContentType);
free(handleData->contentEncoding);
DestroyDiagnosticPropertyData(handleData->diagnosticData);
free(handleData);
}
PROVISIONING_SERVICE_CLIENT_HANDLE prov_sc_create_from_connection_string(const char* conn_string)
{
PROV_SERVICE_CLIENT* result;
if (conn_string == NULL)
{
LogError("Input parameter is NULL: conn_string");
result = NULL;
}
else
{
STRING_HANDLE cs_string;
if ((cs_string = STRING_construct(conn_string)) == NULL)
{
LogError("STRING_construct failed");
result = NULL;
}
else
{
MAP_HANDLE connection_string_values_map;
if ((connection_string_values_map = connectionstringparser_parse(cs_string)) == NULL)
{
LogError("Tokenizing conn_string failed");
result = NULL;
}
else
{
const char* hostname = NULL;
const char* key_name = NULL;
const char* key = NULL;
if ((hostname = Map_GetValueFromKey(connection_string_values_map, IOTHUBHOSTNAME)) == NULL)
{
LogError("Couldn't find %s in conn_string", IOTHUBHOSTNAME);
result = NULL;
}
else if ((key_name = Map_GetValueFromKey(connection_string_values_map, IOTHUBSHAREDACESSKEYNAME)) == NULL)
{
LogError("Couldn't find %s in conn_string", IOTHUBSHAREDACESSKEYNAME);
result = NULL;
}
else if ((key = Map_GetValueFromKey(connection_string_values_map, IOTHUBSHAREDACESSKEY)) == NULL)
{
LogError("Couldn't find %s in conn_string", IOTHUBSHAREDACESSKEY);
result = NULL;
}
if (hostname == NULL || key_name == NULL || key == NULL)
{
LogError("invalid parameter hostname: %p, key_name: %p, key: %p", hostname, key_name, key);
result = NULL;
}
else if ((result = malloc(sizeof(PROV_SERVICE_CLIENT))) == NULL)
{
LogError("Allocation of provisioning service client failed");
result = NULL;
}
else
{
memset(result, 0, sizeof(PROV_SERVICE_CLIENT));
if (mallocAndStrcpy_s(&result->provisioning_service_uri, hostname) != 0)
{
LogError("Failure allocating of provisioning service uri");
prov_sc_destroy(result);
result = NULL;
}
else if (mallocAndStrcpy_s(&result->key_name, key_name) != 0)
{
LogError("Failure allocating of keyname");
prov_sc_destroy(result);
result = NULL;
}
else if (mallocAndStrcpy_s(&result->access_key, key) != 0)
{
LogError("Failure allocating of access key");
prov_sc_destroy(result);
result = NULL;
}
else
{
result->tracing = TRACING_STATUS_OFF;
}
}
Map_Destroy(connection_string_values_map);
}
}
STRING_delete(cs_string);
}
return result;
}
static int SimulatorModule_thread(void * context)
{
int thread_result;
SIMULATOR_MODULE_HANDLE * module = (SIMULATOR_MODULE_HANDLE *)context;
MESSAGE_CONFIG message_to_send;
thread_result = SimulatorModule_create_message(module, &message_to_send);
if (thread_result != 0)
{
LogError("unable to continue with simulation");
if (message_to_send.sourceProperties != NULL)
{
Map_Destroy(message_to_send.sourceProperties);
}
if (message_to_send.source != NULL)
{
free( (void*)message_to_send.source);
}
}
else
{
using HrClock = std::chrono::high_resolution_clock;
using MicroSeconds = std::chrono::microseconds;
long long time_to_wait = module->message_delay * 1000;
size_t messages_produced = 0;
thread_result = 0;
while (module->thread_flag)
{
std::chrono::time_point<HrClock, MicroSeconds> t1 = std::chrono::time_point_cast<MicroSeconds>(HrClock::now());
auto t1_as_int = t1.time_since_epoch().count();
std::string t1_as_string = std::to_string(t1_as_int);
messages_produced++;
std::string messages_produced_as_string = std::to_string(messages_produced);
if (Map_AddOrUpdate(message_to_send.sourceProperties, "timestamp", t1_as_string.c_str()) != MAP_OK)
{
LogError("Unable to update timestamp in message");
module->thread_flag = false;
thread_result = -__LINE__;
break;
}
else if (Map_AddOrUpdate(message_to_send.sourceProperties, "sequence number", messages_produced_as_string.c_str()) != MAP_OK)
{
LogError("Unable to update sequence number in message");
module->thread_flag = false;
thread_result = -__LINE__;
break;
}
else
{
MESSAGE_HANDLE next_message = Message_Create(&message_to_send);
if (next_message == NULL)
{
LogError("Unable to create next message");
module->thread_flag = false;
thread_result = -__LINE__;
break;
}
else
{
if (Broker_Publish(module->broker, module, next_message) != BROKER_OK)
{
LogError("Unable to publish message");
module->thread_flag = false;
thread_result = -__LINE__;
break;
}
else
{
Message_Destroy(next_message);
std::chrono::time_point<HrClock, MicroSeconds> t2 = std::chrono::time_point_cast<MicroSeconds>(HrClock::now());
auto time_to_publish = t2.time_since_epoch().count() - t1_as_int;
if (time_to_publish < time_to_wait)
{
unsigned int remaining_time = static_cast<unsigned int>((time_to_wait - time_to_publish)/1000);
ThreadAPI_Sleep(remaining_time);
}
}
}
}
}
if (message_to_send.sourceProperties != NULL)
{
Map_Destroy(message_to_send.sourceProperties);
}
if (message_to_send.source != NULL)
{
free((void*)message_to_send.source);
}
}
return thread_result;
}
static int SimulatorModule_create_message(SIMULATOR_MODULE_HANDLE * module, MESSAGE_CONFIG* message)
{
int thread_result;
MAP_HANDLE property_map = Map_Create(NULL);
if (property_map == NULL)
{
LogError("Allocation of properties map failed.");
thread_result = -__LINE__;
}
else
{
std::string property_string(module->psuedo_random_buffer, module->properties_size);
std::string property_count_string = std::to_string(module->properties_count);
if (property_string.empty() || property_count_string.empty())
{
LogError("Allocation of properties string failed.");
Map_Destroy(property_map);
thread_result = -__LINE__;
}
else
{
if (Map_Add(property_map, "deviceId", module->device_id) != MAP_OK)
{
Map_Destroy(property_map);
thread_result = -__LINE__;
}
else if (Map_Add(property_map, "property count", property_count_string.c_str()) != MAP_OK)
{
Map_Destroy(property_map);
thread_result = -__LINE__;
}
else
{
thread_result = 0;
for (size_t p = 0; p < module->properties_count; p++)
{
std::ostringstream property_n;
property_n << "property" << p;
if (Map_Add(property_map, property_n.str().c_str(), property_string.c_str()))
{
thread_result = -__LINE__;
break;
}
}
if (thread_result != 0)
{
Map_Destroy(property_map);
thread_result = -__LINE__;
}
else
{
message->source = (const unsigned char*)malloc(module->message_size);
if (message->source == NULL)
{
LogError("unable to allocate message buffer");
Map_Destroy(property_map);
thread_result = -__LINE__;
}
else
{
message->sourceProperties = property_map;
message->size = module->message_size;
if (module->message_size == 0)
{
message->source = NULL;
}
else
{
memcpy((void*)message->source, module->psuedo_random_buffer, message->size - 1);
((char*)(message->source))[message->size - 1] = '\0';
}
thread_result = 0;
}
}
}
}
}
return thread_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;
}
