static void* construct_create_message(OUTPROCESS_HANDLE_DATA* handleData, int32_t * creationMessageSize) { void * result; uint32_t uri_length = STRING_length(handleData->message_uri); char * uri_string = (char*)STRING_c_str(handleData->message_uri); uint32_t args_length = STRING_length(handleData->module_args); char * args_string = (char*)STRING_c_str(handleData->module_args); if (uri_length == 0 || uri_string == NULL || args_length == 0 || args_string == NULL) { result = NULL; } else { /*Codes_SRS_OUTPROCESS_MODULE_17_012: [ This function shall construct a Create Message from configuration. ]*/ CONTROL_MESSAGE_MODULE_CREATE create_msg = { { CONTROL_MESSAGE_VERSION_CURRENT, /*version*/ CONTROL_MESSAGE_TYPE_MODULE_CREATE /*type*/ }, GATEWAY_MESSAGE_VERSION_CURRENT, /*gateway_message_version*/ { uri_length + 1, /*uri_size (+1 for null)*/ (uint8_t)NN_PAIR, /*uri_type*/ uri_string /*uri*/ }, args_length + 1, /*args_size;(+1 for null)*/ args_string /*args;*/ }; result = serialize_control_message((CONTROL_MESSAGE *)&create_msg, creationMessageSize); } return result; }
static void sendHttpRequestMethodExpectedCalls() { STRICT_EXPECTED_CALL(environment_get_variable(IGNORED_PTR_ARG)).CallCannotFail(); STRICT_EXPECTED_CALL(HTTPHeaders_Alloc()); STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)); STRICT_EXPECTED_CALL(UniqueId_Generate(IGNORED_PTR_ARG, IGNORED_NUM_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_AddHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(IoTHubClient_Auth_Get_SasToken(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_NUM_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_ReplaceHeaderNameValuePair(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPAPIEX_Create(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(IoTHubClient_Auth_Get_TrustBundle(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPAPIEX_SetOption(IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPAPIEX_ExecuteRequest(IGNORED_PTR_ARG, HTTPAPI_REQUEST_POST, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, IGNORED_PTR_ARG, NULL, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(HTTPHeaders_Free(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(HTTPAPIEX_Destroy(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG)); //cannot fail }
static int InitializeConnection(PMQTTTRANSPORT_HANDLE_DATA transportState, bool initialConnection) { int result = 0; if (!transportState->connected && !transportState->destroyCalled) { // Construct SAS token size_t secSinceEpoch = (size_t)(difftime(get_time(NULL), EPOCH_TIME_T_VALUE) + 0); size_t expiryTime = secSinceEpoch + SAS_TOKEN_DEFAULT_LIFETIME; // Not checking the success of this variable, if fail it will fail in the SASToken creation and return false; STRING_HANDLE emptyKeyName = STRING_new(); STRING_HANDLE sasToken = SASToken_Create(transportState->device_key, transportState->sasTokenSr, emptyKeyName, expiryTime); if (sasToken == NULL) { result = __LINE__; } else { MQTT_CLIENT_OPTIONS options = { 0 }; options.clientId = (char*)STRING_c_str(transportState->device_id); options.willMessage = NULL; options.username = (char*)STRING_c_str(transportState->configPassedThroughUsername); options.password = (char*)STRING_c_str(sasToken); options.keepAliveInterval = DEFAULT_MQTT_KEEPALIVE; options.useCleanSession = false; options.qualityOfServiceValue = DELIVER_AT_LEAST_ONCE; // construct address const char* hostAddress = STRING_c_str(transportState->hostAddress); const char* hostName = strstr(hostAddress, "//"); if (hostName == NULL) { hostName = hostAddress; } else { // Increment beyond the double backslash hostName += 2; } transportState->xioTransport = getIoTransportProvider(hostName, transportState->portNum); if (mqtt_client_connect(transportState->mqttClient, transportState->xioTransport, &options) != 0) { LogError("failure connecting to address %s:%d.\r\n", STRING_c_str(transportState->hostAddress), transportState->portNum); result = __LINE__; } else { transportState->connected = true; result = 0; } STRING_delete(emptyKeyName); STRING_delete(sasToken); } } return result; }
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; }
static int connection_setup(OUTPROCESS_HANDLE_DATA* handleData, OUTPROCESS_MODULE_CONFIG * config) { int result; handleData->control_socket = -1; /* * Start with messaging socket. */ /*Codes_SRS_OUTPROCESS_MODULE_17_008: [ This function shall create a pair socket for sending gateway messages to the module host. ]*/ handleData->message_socket = nn_socket(AF_SP, NN_PAIR); if (handleData->message_socket < 0) { result = handleData->message_socket; LogError("message socket failed to create, result = %d, errno = %d", result, nn_errno()); } else { /*Codes_SRS_OUTPROCESS_MODULE_17_009: [ This function shall bind and connect the pair socket to the message_uri. ]*/ int message_bind_id = nn_connect(handleData->message_socket, STRING_c_str(config->message_uri)); if (message_bind_id < 0) { result = message_bind_id; LogError("remote socket failed to bind to message URL, result = %d, errno = %d", result, nn_errno()); } else { /* * Now, the control socket. */ /*Codes_SRS_OUTPROCESS_MODULE_17_010: [ This function shall create a request/reply socket for sending control messages to the module host. ]*/ handleData->control_socket = nn_socket(AF_SP, NN_PAIR); if (handleData->control_socket < 0) { result = handleData->control_socket; LogError("remote socket failed to connect to control URL, result = %d, errno = %d", result, nn_errno()); } else { /*Codes_SRS_OUTPROCESS_MODULE_17_011: [ This function shall connect the request/reply socket to the control_id. ]*/ int control_connect_id = nn_connect(handleData->control_socket, STRING_c_str(config->control_uri)); if (control_connect_id < 0) { result = control_connect_id; LogError("remote socket failed to connect to control URL, result = %d, errno = %d", result, nn_errno()); } else { result = 0; } } } } return result; }
STRING_HANDLE URL_Encode(STRING_HANDLE input) { STRING_HANDLE result; if (input == NULL) { /*Codes_SRS_URL_ENCODE_06_001: [If input is NULL then URL_Encode will return NULL.]*/ result = NULL; LogError("URL_Encode:: NULL input\r\n"); } else { size_t lengthOfResult = 0; char* encodedURL; const char* currentInput; unsigned char currentUnsignedChar; currentInput = STRING_c_str(input); /*Codes_SRS_URL_ENCODE_06_003: [If input is a zero length string then URL_Encode will return a zero length string.]*/ do { currentUnsignedChar = (unsigned char)(*currentInput++); lengthOfResult += urlEncoding[currentUnsignedChar].numberOfChars; } while (currentUnsignedChar != 0); if ((encodedURL = malloc(lengthOfResult)) == NULL) { /*Codes_SRS_URL_ENCODE_06_002: [If an error occurs during the encoding of input then URL_Encode will return NULL.]*/ result = NULL; LogError("URL_Encode:: MALLOC failure on encode.\r\n"); } else { size_t currentEncodePosition = 0; currentInput = STRING_c_str(input); do { currentUnsignedChar = (unsigned char)(*currentInput++); if (urlEncoding[currentUnsignedChar].numberOfChars == 1) { encodedURL[currentEncodePosition++] = *(urlEncoding[currentUnsignedChar].encoding); } else { memcpy(encodedURL + currentEncodePosition, urlEncoding[currentUnsignedChar].encoding, urlEncoding[currentUnsignedChar].numberOfChars); currentEncodePosition += urlEncoding[currentUnsignedChar].numberOfChars; } } while (currentUnsignedChar != 0); result = STRING_new_with_memory(encodedURL); } } return result; }
static void on_write_complete(BLEIO_GATT_HANDLE bleio_gatt_handle, void* write_context, BLEIO_GATT_RESULT result) { // this MUST NOT be NULL WRITE_CONTEXT* context = (WRITE_CONTEXT*)write_context; if (context->handle_data->on_write_complete != NULL) { if (result != BLEIO_GATT_OK) { LogError("An error occurred while executing instruction of type %d for characteristic %s", context->instruction->instruction_type, STRING_c_str(context->instruction->characteristic_uuid) ); } /*Codes_SRS_BLEIO_SEQ_13_021: [ When the WRITE_AT_EXIT instruction completes execution this API shall invoke the on_write_complete callback passing in the status of the operation and the callback context that was passed in via the BLEIO_SEQ_INSTRUCTION structure. ]*/ /*Codes_SRS_BLEIO_SEQ_13_020: [ When the WRITE_AT_INIT instruction completes execution this API shall invoke the on_write_complete callback passing in the status of the operation and the callback context that was passed in via the BLEIO_SEQ_INSTRUCTION structure. ]*/ /*Codes_SRS_BLEIO_SEQ_13_034: [ When the WRITE_ONCE instruction completes execution this API shall invoke the on_write_complete callback passing in the status of the operation and the callback context that was passed in via the BLEIO_SEQ_INSTRUCTION structure. ]*/ /*Codes_SRS_BLEIO_SEQ_13_042: [ When a WRITE_ONCE or a WRITE_AT_INIT instruction completes execution this API shall invoke the on_write_complete callback passing in the status of the operation and the callback context that was passed in via the BLEIO_SEQ_INSTRUCTION structure. ]*/ context->handle_data->on_write_complete( (BLEIO_SEQ_HANDLE)context->handle_data, context->instruction->context, STRING_c_str(context->instruction->characteristic_uuid), context->instruction->instruction_type, result == BLEIO_GATT_OK ? BLEIO_SEQ_OK : BLEIO_SEQ_ERROR ); } /*Codes_SRS_BLEIO_SEQ_13_026: [ When the WRITE_AT_INIT instruction completes execution this API shall free the buffer that was passed in via the instruction. ]*/ /*Codes_SRS_BLEIO_SEQ_13_041: [ When a WRITE_AT_INIT or a WRITE_ONCE instruction completes execution this API shall free the buffer that was passed in via the instruction. ]*/ /*Codes_SRS_BLEIO_SEQ_13_027: [ When the WRITE_AT_EXIT instruction completes execution this API shall free the buffer that was passed in via the instruction. ]*/ /*Codes_SRS_BLEIO_SEQ_13_035: [ When the WRITE_ONCE instruction completes execution this API shall free the buffer that was passed in via the instruction. ]*/ // free the buffer that was written BUFFER_delete(context->instruction->data.buffer); context->instruction->data.buffer = NULL; // invoke the internal complete callback if we have one if (context->on_internal_read_complete != NULL) { context->on_internal_read_complete(context->handle_data, context->instruction); } // dec ref the handle data // NOTE: The call below MUST occur *after* the BUFFER_delete call above // because `dec_ref_handle` might end up destroying the sequence itself // at which point context->instruction no longer exists (because it is // simply a pointer to the instructions vector in the sequence). dec_ref_handle(context->handle_data); free(context); }
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(); }
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; }
static int prov_sc_get_record(PROVISIONING_SERVICE_CLIENT_HANDLE prov_client, const char* id, void** handle_ptr, HANDLE_FUNCTION_VECTOR vector, const char* path_format) { int result = 0; if (prov_client == NULL) { LogError("Invalid Provisioning Client Handle"); result = __FAILURE__; } else if (id == NULL) { LogError("Invalid id"); result = __FAILURE__; } else if (handle_ptr == NULL) { LogError("Invalid handle"); result = __FAILURE__; } else { STRING_HANDLE registration_path = create_registration_path(path_format, id); if (registration_path == NULL) { LogError("Failed to construct a registration path"); result = __FAILURE__; } else { HTTP_HEADERS_HANDLE request_headers; if ((request_headers = construct_http_headers(prov_client, NULL, HTTP_CLIENT_REQUEST_GET)) == NULL) { LogError("Failure constructing http headers"); result = __FAILURE__; } else { result = rest_call(prov_client, HTTP_CLIENT_REQUEST_GET, STRING_c_str(registration_path), request_headers, NULL); if (result == 0) { void* handle; if ((handle = vector.deserializeFromJson(prov_client->response)) == NULL) { LogError("Failure constructing new enrollment structure from json response"); result = __FAILURE__; } *handle_ptr = handle; } clear_response(prov_client); } HTTPHeaders_Free(request_headers); } STRING_delete(registration_path); } return result; }
static void show_platform_info() { STRING_HANDLE platform_info = platform_get_platform_info(); if (platform_info != NULL) { (void)printf("%s\r\n", STRING_c_str(platform_info)); STRING_delete(platform_info); } }
BLEIO_SEQ_RESULT schedule_write( BLEIO_SEQ_HANDLE_DATA* handle_data, BLEIO_SEQ_INSTRUCTION* instruction, ON_INTERNAL_IO_COMPLETE on_internal_read_complete ) { BLEIO_SEQ_RESULT result; WRITE_CONTEXT* context = (WRITE_CONTEXT*)malloc(sizeof(WRITE_CONTEXT)); /*Codes_SRS_BLEIO_SEQ_13_014: [ BLEIO_Seq_Run shall return BLEIO_SEQ_ERROR if an underlying platform call fails. ]*/ if (context == NULL) { LogError("malloc failed"); result = BLEIO_SEQ_ERROR; } else { context->handle_data = handle_data; context->instruction = instruction; context->on_internal_read_complete = on_internal_read_complete; const unsigned char* buffer = BUFFER_u_char(instruction->data.buffer); size_t buffer_size = BUFFER_length(instruction->data.buffer); // add ref to the handle data object since we now will have an // outstanding I/O operation; the reason why we increment the // reference here as opposed to when we know that BLEIO_gatt_read_char_by_uuid // was successful is because the operation could potentially complete // even before we hit the if check after this call and 'on_read_complete' // might have run by then in which case it would have done a DEC_REF and // the ref counts will be out of whack INC_REF(BLEIO_SEQ_HANDLE_DATA, handle_data); int write_result = BLEIO_gatt_write_char_by_uuid( handle_data->bleio_gatt_handle, STRING_c_str(instruction->characteristic_uuid), buffer, buffer_size, on_write_complete, context ); if (write_result != 0) { /*Codes_SRS_BLEIO_SEQ_13_014: [ BLEIO_Seq_Run shall return BLEIO_SEQ_ERROR if an underlying platform call fails. ]*/ result = BLEIO_SEQ_ERROR; free(context); DEC_REF(BLEIO_SEQ_HANDLE_DATA, handle_data); LogError("BLEIO_gatt_write_char_by_uuid failed with %d.", write_result); } else { result = BLEIO_SEQ_OK; } } return result; }
static STRING_HANDLE create_devices_path(STRING_HANDLE iothub_host_fqdn, const char* device_id) { STRING_HANDLE devices_path; if ((devices_path = STRING_construct_sprintf(IOTHUB_DEVICES_PATH_FMT, STRING_c_str(iothub_host_fqdn), device_id)) == NULL) { LogError("Failed creating devices_path (STRING_new failed)"); } return devices_path; }
/*returns 0 if success, otherwise __LINE__*/ static int stop_module(int publish_socket, BROKER_MODULEINFO* module_info) { int quit_result, close_result, thread_result, result; /*Codes_SRS_BROKER_17_021: [ This function shall send a quit signal to the worker thread by sending BROKER_MODULEINFO::quit_message_guid to the publish_socket. ]*/ /* send the unique quite id for this module */ if ((quit_result = nn_send(publish_socket, STRING_c_str(module_info->quit_message_guid), BROKER_GUID_SIZE, 0)) < 0) { /*Codes_SRS_BROKER_17_015: [ This function shall close the BROKER_MODULEINFO::receive_socket. ]*/ /* at the cost of a data race, we will close the socket to terminate the thread */ nn_close(module_info->receive_socket); LogError("unable to peacefully close thread for module [%p], nn_send error [%d], taking harsher methods", module_info, quit_result); } else { /*Codes_SRS_BROKER_02_001: [ Broker_RemoveModule shall lock BROKER_MODULEINFO::socket_lock. ]*/ if (Lock(module_info->socket_lock) != LOCK_OK) { /*Codes_SRS_BROKER_17_015: [ This function shall close the BROKER_MODULEINFO::receive_socket. ]*/ /* at the cost of a data race, we will close the socket to terminate the thread */ nn_close(module_info->receive_socket); LogError("unable to peacefully close thread for module [%p], Lock error, taking harsher methods", module_info ); } else { /*Codes_SRS_BROKER_17_015: [ This function shall close the BROKER_MODULEINFO::receive_socket. ]*/ close_result = nn_close(module_info->receive_socket); if (close_result < 0) { LogError("Receive socket close failed for module at item [%p] failed", module_info); } else { /*all is fine, thread will eventually stop and be joined*/ } /*Codes_SRS_BROKER_02_003: [ After closing the socket, Broker_RemoveModule shall unlock BROKER_MODULEINFO::info_lock. ]*/ if (Unlock(module_info->socket_lock) != LOCK_OK) { LogError("unable to unlock socket lock"); } } } /*Codes_SRS_BROKER_13_104: [The function shall wait for the module's thread to exit by joining BROKER_MODULEINFO::thread via ThreadAPI_Join. ]*/ if (ThreadAPI_Join(module_info->thread, &thread_result) != THREADAPI_OK) { result = __LINE__; LogError("ThreadAPI_Join() returned an error."); } else { result = 0; } return result; }
IOTHUB_DEVICE_HANDLE IoTHubTransportMqtt_Register(TRANSPORT_HANDLE handle, const char* deviceId, const char* deviceKey, IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, PDLIST_ENTRY waitingToSend) { IOTHUB_DEVICE_HANDLE result; // Codes_SRS_IOTHUB_MQTT_TRANSPORT_17_001: [ IoTHubTransportMqtt_Register shall return NULL if the TRANSPORT_HANDLE is NULL.] // Codes_SRS_IOTHUB_MQTT_TRANSPORT_17_002: [ IoTHubTransportMqtt_Register shall return NULL if deviceId, deviceKey or waitingToSend are NULL.] if ((handle == NULL) || (deviceId == NULL) || (deviceKey == NULL) || (waitingToSend == NULL)) { result = NULL; } else { MQTTTRANSPORT_HANDLE_DATA* transportState = (MQTTTRANSPORT_HANDLE_DATA*)handle; // Codes_SRS_IOTHUB_MQTT_TRANSPORT_17_003: [ IoTHubTransportMqtt_Register shall return NULL if deviceId or deviceKey do not match the deviceId and deviceKey passed in during IoTHubTransportMqtt_Create.] if (strcmp(STRING_c_str(transportState->device_id), deviceId) != 0) { result = NULL; } else if (strcmp(STRING_c_str(transportState->device_key), deviceKey) != 0) { result = NULL; } else { if (transportState->isRegistered == true) { LogError("Transport already has device registered by id: [%s]", deviceId); result = NULL; } else { transportState->isRegistered = true; // Codes_SRS_IOTHUB_MQTT_TRANSPORT_17_004: [ IoTHubTransportMqtt_Register shall return the TRANSPORT_HANDLE as the IOTHUB_DEVICE_HANDLE. ] result = (IOTHUB_DEVICE_HANDLE)handle; } } } return result; }
void IoTHubTransportMqtt_Unsubscribe(TRANSPORT_HANDLE handle) { PMQTTTRANSPORT_HANDLE_DATA transportState = (PMQTTTRANSPORT_HANDLE_DATA)handle; /* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_019: [If parameter handle is NULL then IoTHubTransportMqtt_Unsubscribe shall do nothing.] */ if (transportState != NULL && transportState->subscribed) { /* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_020: [IoTHubTransportMqtt_Unsubscribe shall call mqtt_client_unsubscribe to unsubscribe the mqtt message topic.] */ const char* unsubscribe[] = { STRING_c_str(transportState->mqttMessageTopic) }; (void)mqtt_client_unsubscribe(transportState->mqttClient, transportState->packetId++, unsubscribe, 1); transportState->subscribed = false; } }
static void PrintProperties(MAP_HANDLE map) { STRING_HANDLE jsonKVP = Map_ToJSON(map); if (jsonKVP != NULL) { (void)printf(" >>>Key Value Pairs Received:[%s]\r\n", STRING_c_str(jsonKVP)); STRING_delete(jsonKVP); } else { (void)printf(" >>>Key Value Pairs Received:[]\r\n"); } }
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 DYNAMIC_LIBRARY_HANDLE NodeModuleLoader_LoadBindingModule(const MODULE_LOADER* loader) { // find the binding path from the loader configuration; if there isn't one, use // a default path const char* binding_path = NODE_BINDING_MODULE_NAME; if (loader->configuration != NULL && loader->configuration->binding_path != NULL) { //Codes_SRS_NODE_MODULE_LOADER_13_032: [ NodeModuleLoader_Load shall use the the binding module path given in loader->configuration->binding_path if loader->configuration is not NULL. ] binding_path = STRING_c_str(loader->configuration->binding_path); } //Codes_SRS_NODE_MODULE_LOADER_13_004 : [NodeModuleLoader_Load shall load the binding module library into memory by calling DynamicLibrary_LoadLibrary.] return DynamicLibrary_LoadLibrary(binding_path); }
static void parseResponseJsonExpectedCalls() { STRICT_EXPECTED_CALL(BUFFER_u_char(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(BUFFER_length(IGNORED_PTR_ARG)).CallCannotFail(); //cannot fail (returns length 0) STRICT_EXPECTED_CALL(STRING_from_byte_array(IGNORED_PTR_ARG, IGNORED_NUM_ARG)); STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_parse_string(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_value_get_object(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_value(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_object_get_value(IGNORED_PTR_ARG, IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_serialize_to_string(IGNORED_PTR_ARG)); STRICT_EXPECTED_CALL(json_value_get_number(IGNORED_PTR_ARG)).CallCannotFail(); //cannot fail (returns -1, which isn't strictly failure) STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG)); //cannot fail STRICT_EXPECTED_CALL(json_value_free(IGNORED_PTR_ARG)); //cannot fail }
int connectionstringparser_splitHostName(STRING_HANDLE hostNameString, STRING_HANDLE nameString, STRING_HANDLE suffixString) { int result; if (hostNameString == NULL) { /* Codes_SRS_CONNECTIONSTRINGPARSER_21_034: [If the hostNameString is NULL, connectionstringparser_splitHostName shall return __FAILURE__.]*/ result = __FAILURE__; } else { /* Codes_SRS_CONNECTIONSTRINGPARSER_21_033: [connectionstringparser_splitHostName shall convert the hostNameString to a connection_string passed in as argument, and call connectionstringparser_splitHostName_from_char.]*/ result = connectionstringparser_splitHostName_from_char(STRING_c_str(hostNameString), nameString, suffixString); } return result; }
STRING_TOKENIZER_HANDLE STRING_TOKENIZER_create(STRING_HANDLE handle) { STRING_TOKENIZER_HANDLE result; /* 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."); result = NULL; } else { /* 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] */ result = STRING_TOKENIZER_create_from_char(STRING_c_str(handle)); } return result; }
/*this function "links" IoTHub to the serialization library*/ static IOTHUBMESSAGE_DISPOSITION_RESULT IoTHubMessage(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback) { const unsigned char* buffer; size_t size; if (IoTHubMessage_GetByteArray(message, &buffer, &size) != IOTHUB_MESSAGE_OK) { ASSERT_FAIL("unable to IoTHubMessage_GetByteArray"); } else { /*buffer is not zero terminated*/ STRING_HANDLE temp = STRING_construct_n((char*)buffer, size); ASSERT_IS_NOT_NULL(temp); EXECUTE_COMMAND(userContextCallback, STRING_c_str(temp)); STRING_delete(temp); } return IOTHUBMESSAGE_ACCEPTED; }
static int prov_sc_delete_record_by_param(PROVISIONING_SERVICE_CLIENT_HANDLE prov_client, const char* id, const char* etag, const char* path_format) { int result = 0; if (prov_client == NULL) { LogError("Invalid Provisioning Client Handle"); result = __FAILURE__; } else if (id == NULL) { LogError("Invalid Id"); result = __FAILURE__; } else { STRING_HANDLE registration_path = create_registration_path(path_format, id); if (registration_path == NULL) { LogError("Failed to construct a registration path"); result = __FAILURE__; } else { HTTP_HEADERS_HANDLE request_headers; if ((request_headers = construct_http_headers(prov_client, etag, HTTP_CLIENT_REQUEST_DELETE)) == NULL) { LogError("Failure constructing http headers"); result = __FAILURE__; } else { result = rest_call(prov_client, HTTP_CLIENT_REQUEST_DELETE, STRING_c_str(registration_path), request_headers, NULL); clear_response(prov_client); } HTTPHeaders_Free(request_headers); } STRING_delete(registration_path); } return result; }
static int put_SAS_token_to_cbs(AUTHENTICATION_INSTANCE* instance, STRING_HANDLE cbs_audience, char* sas_token) { int result; // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_043: [authentication_do_work() shall set `instance->is_cbs_put_token_in_progress` to TRUE] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_057: [authentication_do_work() shall set `instance->is_cbs_put_token_in_progress` to TRUE] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_075: [authentication_do_work() shall set `instance->is_cbs_put_token_in_progress` to TRUE] instance->is_cbs_put_token_in_progress = true; // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_046: [The SAS token provided shall be sent to CBS using cbs_put_token(), using `servicebus.windows.net:sastoken` as token type, `devices_path` as audience and passing on_cbs_put_token_complete_callback] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_058: [The SAS token shall be sent to CBS using cbs_put_token(), using `servicebus.windows.net:sastoken` as token type, `devices_path` as audience and passing on_cbs_put_token_complete_callback] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_076: [The SAS token shall be sent to CBS using cbs_put_token(), using `servicebus.windows.net:sastoken` as token type, `devices_path` as audience and passing on_cbs_put_token_complete_callback] const char* cbs_audience_c_str = STRING_c_str(cbs_audience); if (cbs_put_token_async(instance->cbs_handle, SAS_TOKEN_TYPE, cbs_audience_c_str, sas_token, on_cbs_put_token_complete_callback, instance) != RESULT_OK) { // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_048: [If cbs_put_token() failed, authentication_do_work() shall set `instance->is_cbs_put_token_in_progress` to FALSE, destroy `devices_path` and return] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_060: [If cbs_put_token() fails, `instance->is_cbs_put_token_in_progress` shall be set to FALSE] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_078: [If cbs_put_token() fails, `instance->is_cbs_put_token_in_progress` shall be set to FALSE] instance->is_cbs_put_token_in_progress = false; result = __FAILURE__; LogError("Failed putting SAS token to CBS for device '%s' (cbs_put_token failed)", instance->device_id); } else { // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_047: [If cbs_put_token() succeeds, authentication_do_work() shall set `instance->current_sas_token_put_time` with current time] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_059: [If cbs_put_token() succeeds, authentication_do_work() shall set `instance->current_sas_token_put_time` with current time] // Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_077: [If cbs_put_token() succeeds, authentication_do_work() shall set `instance->current_sas_token_put_time` with the current time] time_t current_time; if ((current_time = get_time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting current_sas_token_put_time for device '%s' (get_time() failed)", instance->device_id); } instance->current_sas_token_put_time = current_time; // If it failed, fear not. `current_sas_token_put_time` shall be checked for INDEFINITE_TIME wherever it is used. result = RESULT_OK; } 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 setup_dev_auth_emulator_create_mocks(bool use_persist_file) { STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)) .IgnoreArgument_size(); STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG)) .IgnoreArgument_handle(); if (use_persist_file) { setup_retrieve_persisted_key_mocks(true); } else { setup_retrieve_persisted_key_mocks(false); setup_generate_key_mocks(); setup_persisted_keys_info_mocks(); } STRICT_EXPECTED_CALL(json_value_free(IGNORED_PTR_ARG)) .IgnoreArgument_value(); }
static void connectionLost(void *context, char *cause) { PMQTTTAPI_HANDLE_DATA transportState = (PMQTTTAPI_HANDLE_DATA)context; LogError("Lost Connection, reseting Connection State. Cause: %s \r\n", cause); if (transportState != NULL) { transportState->connected = false; } LogInfo("Trying to connect again\r\n"); if (!checkAndTryToConnect(transportState)) { LogError("Could not connect again. \r\n"); } else { LogInfo("Connected.\r\n"); if (transportState->subscribed) { int rc; LogInfo("Trying to Subscribe after reconnect.\r\n"); if ((rc = MQTTClient_subscribe(transportState->client, STRING_c_str(transportState->subscribedTopicHandleData->topicName), SUBSCRIBEQOS)) != MQTTCLIENT_SUCCESS) { LogError("Could not subscribe again. Won't be able to receive messages. Error Code: %d.\r\n", rc); } else { LogInfo("Subscribed succesfully after reconnect..\r\n"); } } } if (cause != NULL) { MQTTClient_free(cause); } }
void MQTTAPI_Unsubscribe(MQTTAPI_TOPIC_HANDLE topicInstance) { /* Codes_SRS_MQTTAPI_04_034: [If topicInstance is NULL MQTTAPI_Unsubscribe shall do nothing.] */ if (topicInstance != NULL) { PMQTTAPI_TOPIC_HANDLE_DATA topicHandleData = topicInstance; PMQTTTAPI_HANDLE_DATA mqttApiInstance = topicHandleData->mqttApiInstance; /* Codes_SRS_MQTTAPI_04_035: [MQTTAPI_Unsubscribe shall call underlying library methods to unsubscribe to the topic Instance.] */ if (MQTTClient_unsubscribe(mqttApiInstance->client, STRING_c_str(topicHandleData->topicName)) != MQTTCLIENT_SUCCESS) { LogError("Problems on Unsubscribing to Commands.\r\n"); } else { mqttApiInstance->subscribed = false; /* Codes_SRS_MQTTAPI_04_060: [MQTTAPI_Unsubscribe shall release all previously allocated resources pointed by topicInstance.] */ STRING_delete(mqttApiInstance->subscribedTopicHandleData->topicName); free(mqttApiInstance->subscribedTopicHandleData); } } }
static int SubscribeToMqttProtocol(PMQTTTRANSPORT_HANDLE_DATA transportState) { int result; SUBSCRIBE_PAYLOAD subscribe[] = { { STRING_c_str(transportState->mqttMessageTopic), DELIVER_AT_LEAST_ONCE } }; /* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_016: [IoTHubTransportMqtt_Subscribe shall call mqtt_client_subscribe to subscribe to the Message Topic.] */ if (mqtt_client_subscribe(transportState->mqttClient, transportState->packetId++, subscribe, 1) != 0) { /* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_017: [Upon failure IoTHubTransportMqtt_Subscribe shall return a non-zero value.] */ result = __LINE__; } else { /* Codes_SRS_IOTHUB_MQTT_TRANSPORT_07_018: [On success IoTHubTransportMqtt_Subscribe shall return 0.] */ transportState->subscribed = true; transportState->currPacketState = SUBSCRIBE_TYPE; result = 0; } return result; }