├── src ├── iothub_transport_http.def ├── iothub_transport_mqtt.def ├── upload_to_blob.def ├── makefile ├── iothub_edge_modules.def ├── certs │ ├── certs.h │ ├── readme.md │ └── certs.c ├── version.c ├── iothubtransportmqtt.h ├── iothubtransporthttp.h ├── AzureIoTHub.h ├── iothub.c ├── internal │ ├── iothub_client_hsm_ll.h │ ├── uamqp_messaging.h │ ├── iothub_internal_consts.h │ ├── iothub_client_edge.h │ ├── iothub_client_diagnostic.h │ ├── iothubtransport.h │ ├── iothubtransportamqp_methods.h │ ├── iothubtransport_amqp_connection.h │ ├── iothub_client_retry_control.h │ ├── iothub_client_ll_uploadtoblob.h │ ├── iothubtransport_amqp_cbs_auth.h │ ├── iothub_client_authorization.h │ ├── iothub_client_private.h │ ├── iothubtransport_amqp_common.h │ ├── iothubtransport_mqtt_common.h │ ├── iothubtransport_amqp_twin_messenger.h │ ├── iothubtransport_amqp_telemetry_messenger.h │ ├── iothubtransport_amqp_messenger.h │ └── iothubtransport_amqp_device.h ├── iothub.h ├── schemaserializer.h ├── methodreturn.h ├── iothub_client_version.h ├── jsondecoder.h ├── iothub_transport_ll_private.c ├── iothub_transport_ll.h ├── dataserializer.h ├── jsonencoder.h ├── datamarshaller.h ├── azure_umqtt_c │ ├── mqtt_codec.h │ ├── mqtt_message.h │ ├── mqttconst.h │ └── mqtt_client.h ├── commanddecoder.h ├── multitree.h ├── dataserializer.c ├── datapublisher.h ├── schemalib.h ├── iotdevice.h ├── schemalib.c ├── methodreturn.c ├── iothub_client_options.h ├── iothub_client_core_ll.h ├── iothub_client_dll.def ├── iothub_client_core.h ├── iothub_client_diagnostic.c ├── iothub_device_client.c ├── iothub_client.c ├── codefirst.h ├── iothub_device_client_ll.c ├── iothub_module_client.c ├── iothub_client_ll.c └── serializer.def ├── azure-pipelines.yml ├── keywords.txt ├── examples ├── esp32 │ └── iothub_ll_telemetry_sample │ │ ├── sample_init.h │ │ └── iot_configs.h └── esp8266 │ └── iothub_ll_telemetry_sample │ ├── sample_init.h │ └── iot_configs.h ├── library.properties ├── LICENSE ├── README.md └── .travis.yml /src/iothub_transport_http.def: -------------------------------------------------------------------------------- 1 | LIBRARY iothub_client_dll 2 | EXPORTS 3 | HTTP_Protocol 4 | -------------------------------------------------------------------------------- /src/iothub_transport_mqtt.def: -------------------------------------------------------------------------------- 1 | LIBRARY iothub_client_dll 2 | EXPORTS 3 | MQTT_Protocol 4 | MQTT_WebSocket_Protocol 5 | -------------------------------------------------------------------------------- /src/upload_to_blob.def: -------------------------------------------------------------------------------- 1 | LIBRARY iothub_client_dll 2 | EXPORTS 3 | IoTHubClient_UploadToBlobAsync 4 | IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_RESULTStrings -------------------------------------------------------------------------------- /src/makefile: -------------------------------------------------------------------------------- 1 | !if 0 2 | Copyright (c) Microsoft. All rights reserved. 3 | Licensed under the MIT license. See LICENSE file in the project root for full license information. 4 | !endif 5 | 6 | !INCLUDE $(_MAKEENVROOT)\makefile.def 7 | -------------------------------------------------------------------------------- /src/iothub_edge_modules.def: -------------------------------------------------------------------------------- 1 | LIBRARY iothub_client_dll 2 | EXPORTS 3 | IoTHubModuleClient_LL_CreateFromEnvironment 4 | IoTHubModuleClient_CreateFromEnvironment 5 | IoTHubModuleClient_DeviceMethodInvokeAsync 6 | IoTHubModuleClient_LL_DeviceMethodInvoke 7 | IoTHubModuleClient_ModuleMethodInvokeAsync 8 | IoTHubModuleClient_LL_ModuleMethodInvoke 9 | -------------------------------------------------------------------------------- /src/certs/certs.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef CERTS_H 5 | #define CERTS_H 6 | 7 | #ifdef __cplusplus 8 | extern "C" 9 | { 10 | #endif 11 | 12 | extern const char certificates[]; 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | 18 | #endif /* CERTS_H */ 19 | -------------------------------------------------------------------------------- /src/version.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include "iothub_client_version.h" 5 | 6 | const char* IoTHubClient_GetVersionString(void) 7 | { 8 | /*Codes_SRS_IOTHUBCLIENT_05_001: [IoTHubClient_GetVersionString shall return a pointer to a constant string which indicates the version of IoTHubClient API.]*/ 9 | return IOTHUB_SDK_VERSION; 10 | } 11 | -------------------------------------------------------------------------------- /src/iothubtransportmqtt.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTMQTT_H 5 | #define IOTHUBTRANSPORTMQTT_H 6 | 7 | #include "iothub_transport_ll.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" 11 | { 12 | #endif 13 | extern const TRANSPORT_PROVIDER* MQTT_Protocol(void); 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | 19 | #endif /*IOTHUBTRANSPORTMQTT_H*/ 20 | -------------------------------------------------------------------------------- /src/iothubtransporthttp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTHTTP_H 5 | #define IOTHUBTRANSPORTHTTP_H 6 | 7 | #include "iothub_transport_ll.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" 11 | { 12 | #endif 13 | 14 | extern const TRANSPORT_PROVIDER* HTTP_Protocol(void); 15 | 16 | #ifdef __cplusplus 17 | } 18 | #endif 19 | 20 | #endif /*IOTHUBTRANSPORTHTTP_H*/ 21 | -------------------------------------------------------------------------------- /azure-pipelines.yml: -------------------------------------------------------------------------------- 1 | # Starter pipeline 2 | # Start with a minimal pipeline that you can customize to build and deploy your code. 3 | # Add steps that build, run tests, deploy, and more: 4 | # https://aka.ms/yaml 5 | 6 | trigger: 7 | - master 8 | 9 | pool: 10 | vmImage: ubuntu-latest 11 | 12 | steps: 13 | - script: echo Hello, world! 14 | displayName: 'Run a one-line script' 15 | 16 | - script: | 17 | echo Add other tasks to build, test, and deploy your project. 18 | echo See https://aka.ms/yaml 19 | displayName: 'Run a multi-line script' 20 | -------------------------------------------------------------------------------- /src/AzureIoTHub.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef AZUREIOTHUB_H 5 | #define AZUREIOTHUB_H 6 | 7 | #include "AzureIoTUtility.h" 8 | 9 | #include "serializer.h" 10 | 11 | #include "iothub.h" 12 | #include "iothub_client_ll.h" 13 | #include "iothub_device_client_ll.h" 14 | #include "iothub_client_options.h" 15 | #include "iothub_message.h" 16 | #include "certs/certs.h" 17 | 18 | #define AzureIoTHubVersion "1.6.0" 19 | #endif 20 | -------------------------------------------------------------------------------- /keywords.txt: -------------------------------------------------------------------------------- 1 | ####################################### 2 | # Syntax Coloring Map For AzureIoTHub 3 | ####################################### 4 | 5 | ####################################### 6 | # Datatypes (KEYWORD1) 7 | ####################################### 8 | 9 | AzureIoTHubClient KEYWORD1 10 | 11 | ####################################### 12 | # Methods and Functions (KEYWORD2) 13 | ####################################### 14 | 15 | begin KEYWORD2 16 | setEpochTime KEYWORD2 17 | 18 | ####################################### 19 | # Constants (LITERAL1) 20 | ####################################### 21 | -------------------------------------------------------------------------------- /examples/esp32/iothub_ll_telemetry_sample/sample_init.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef SAMPLE_INIT_H 5 | #define SAMPLE_INIT_H 6 | #if defined(ARDUINO_ARCH_ESP8266) 7 | #define sample_init esp8266_sample_init 8 | #define is_esp_board 9 | void esp8266_sample_init(const char* ssid, const char* password); 10 | #endif // ARDUINO_ARCH_ESP8266 11 | #if defined(ARDUINO_ARCH_ESP32) 12 | #define sample_init esp32_sample_init 13 | #define is_esp_board 14 | void esp32_sample_init(const char* ssid, const char* password); 15 | #endif // ARDUINO_ARCH_ESP32 16 | 17 | #endif // SAMPLE_INIT_H 18 | -------------------------------------------------------------------------------- /examples/esp8266/iothub_ll_telemetry_sample/sample_init.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef SAMPLE_INIT_H 5 | #define SAMPLE_INIT_H 6 | #if defined(ARDUINO_ARCH_ESP8266) 7 | #define sample_init esp8266_sample_init 8 | #define is_esp_board 9 | void esp8266_sample_init(const char* ssid, const char* password); 10 | #endif // ARDUINO_ARCH_ESP8266 11 | #if defined(ARDUINO_ARCH_ESP32) 12 | #define sample_init esp32_sample_init 13 | #define is_esp_board 14 | void esp32_sample_init(const char* ssid, const char* password); 15 | #endif // ARDUINO_ARCH_ESP32 16 | 17 | #endif // SAMPLE_INIT_H 18 | -------------------------------------------------------------------------------- /src/iothub.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | 6 | #include "azure_c_shared_utility/platform.h" 7 | #include "azure_c_shared_utility/xlogging.h" 8 | #include "azure_macro_utils/macro_utils.h" 9 | #include "iothub.h" 10 | 11 | int IoTHub_Init(void) 12 | { 13 | int result; 14 | if (platform_init() != 0) 15 | { 16 | LogError("Platform initialization failed"); 17 | result = MU_FAILURE; 18 | } 19 | else 20 | { 21 | result = 0; 22 | } 23 | return result; 24 | } 25 | 26 | void IoTHub_Deinit(void) 27 | { 28 | platform_deinit(); 29 | } 30 | -------------------------------------------------------------------------------- /src/internal/iothub_client_hsm_ll.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /** @file iothub_client_version.h 5 | * @brief Functions for managing the client SDK version. 6 | */ 7 | 8 | #ifndef IOTHUB_CLIENT_PROVISIONING_H 9 | #define IOTHUB_CLIENT_PROVISIONING_H 10 | 11 | #include "azure_macro_utils/macro_utils.h" 12 | #include "umock_c/umock_c_prod.h" 13 | 14 | #ifdef USE_PROV_MODULE 15 | #include "azure_prov_client/internal/iothub_auth_client.h" 16 | #endif 17 | 18 | #include "iothub_client_ll.h" 19 | 20 | /*This header is DEPREPCATED and mainatined only for backward compatibility*/ 21 | 22 | #endif // IOTHUB_CLIENT_PROVISIONING_H 23 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=AzureIoTHub 2 | version=1.6.1 3 | author=Microsoft 4 | maintainer=Microsoft 5 | sentence=[See deprecation warning!] Azure IoT library for Arduino. For the Arduino MKR1000 or Zero and WiFi Shield 101, Adafruit Huzzah and Feather M0, or SparkFun Thing. 6 | paragraph=[Warning: This library is being deprecated! Please use Azure SDK for C for new projects]. Arduino port of the Azure IoT C device SDK. It allows you to use your Arduino with the Azure IoT Hub. See readme.md for more details. Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information. 7 | category=Communication 8 | url=https://github.com/Azure/azure-iot-arduino 9 | architectures=esp8266,esp32 10 | -------------------------------------------------------------------------------- /src/iothub.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_H 5 | #define IOTHUB_H 6 | 7 | #include "umock_c/umock_c_prod.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" 11 | { 12 | #else 13 | #endif 14 | /** 15 | * @brief IoTHubClient_Init Initializes the IoTHub Client System. 16 | * 17 | * @return int zero upon success, any other value upon failure. 18 | */ 19 | MOCKABLE_FUNCTION(, int, IoTHub_Init); 20 | 21 | /** 22 | * @brief IoTHubClient_Deinit Frees resources initialized in the IoTHubClient_Init function call. 23 | * 24 | */ 25 | MOCKABLE_FUNCTION(, void, IoTHub_Deinit); 26 | 27 | #ifdef __cplusplus 28 | } 29 | #endif 30 | 31 | #endif /* IOTHUB_H */ 32 | -------------------------------------------------------------------------------- /src/internal/uamqp_messaging.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef UAMQP_MESSAGING_H 5 | #define UAMQP_MESSAGING_H 6 | 7 | #include "iothub_message.h" 8 | #include "azure_uamqp_c/message.h" 9 | #include "umock_c/umock_c_prod.h" 10 | 11 | #ifdef __cplusplus 12 | extern "C" 13 | { 14 | #endif 15 | 16 | MOCKABLE_FUNCTION(, int, message_create_IoTHubMessage_from_uamqp_message, MESSAGE_HANDLE, uamqp_message, IOTHUB_MESSAGE_HANDLE*, iothubclient_message); 17 | MOCKABLE_FUNCTION(, int, message_create_uamqp_encoding_from_iothub_message, MESSAGE_HANDLE, message_batch_container, IOTHUB_MESSAGE_HANDLE, message_handle, BINARY_DATA*, body_binary_data); 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | 23 | #endif /*UAMQP_MESSAGING_H*/ 24 | -------------------------------------------------------------------------------- /src/schemaserializer.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef SCHEMASERIALIZER_H 5 | #define SCHEMASERIALIZER_H 6 | 7 | #include "schema.h" 8 | #include "azure_c_shared_utility/strings.h" 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | #define SCHEMA_SERIALIZER_RESULT_VALUES \ 15 | SCHEMA_SERIALIZER_OK, \ 16 | SCHEMA_SERIALIZER_INVALID_ARG, \ 17 | SCHEMA_SERIALIZER_ERROR 18 | 19 | MU_DEFINE_ENUM_WITHOUT_INVALID(SCHEMA_SERIALIZER_RESULT, SCHEMA_SERIALIZER_RESULT_VALUES) 20 | 21 | extern SCHEMA_SERIALIZER_RESULT SchemaSerializer_SerializeCommandMetadata(SCHEMA_MODEL_TYPE_HANDLE modelHandle, STRING_HANDLE schemaText); 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | 27 | #endif /* SCHEMASERIALIZER_H */ 28 | -------------------------------------------------------------------------------- /src/methodreturn.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef METHODRETURN_H 5 | #define METHODRETURN_H 6 | 7 | typedef struct METHODRETURN_HANDLE_DATA_TAG* METHODRETURN_HANDLE; 8 | 9 | #include "azure_macro_utils/macro_utils.h" 10 | 11 | typedef struct METHODRETURN_DATA_TAG 12 | { 13 | int statusCode; 14 | char* jsonValue; 15 | }METHODRETURN_DATA; 16 | 17 | #include "umock_c/umock_c_prod.h" 18 | 19 | #ifdef __cplusplus 20 | extern "C" 21 | { 22 | #endif 23 | 24 | MOCKABLE_FUNCTION(, METHODRETURN_HANDLE, MethodReturn_Create, int, statusCode, const char*, jsonValue); 25 | MOCKABLE_FUNCTION(, void, MethodReturn_Destroy, METHODRETURN_HANDLE, handle); 26 | MOCKABLE_FUNCTION(, const METHODRETURN_DATA*, MethodReturn_GetReturn, METHODRETURN_HANDLE, handle); 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | 32 | 33 | #endif /*METHODRETURN_H*/ 34 | 35 | -------------------------------------------------------------------------------- /src/iothub_client_version.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /** @file iothub_client_version.h 5 | * @brief Functions for managing the client SDK version. 6 | */ 7 | 8 | #ifndef IOTHUB_CLIENT_VERSION_H 9 | #define IOTHUB_CLIENT_VERSION_H 10 | 11 | #define IOTHUB_SDK_VERSION "1.5.0" 12 | 13 | #include "umock_c/umock_c_prod.h" 14 | 15 | #ifdef __cplusplus 16 | extern "C" 17 | { 18 | #endif 19 | 20 | /** 21 | * @brief Returns a pointer to a null terminated string containing the 22 | * current IoT Hub Client SDK version. 23 | * 24 | * @return Pointer to a null terminated string containing the 25 | * current IoT Hub Client SDK version. 26 | */ 27 | MOCKABLE_FUNCTION(, const char*, IoTHubClient_GetVersionString); 28 | 29 | #ifdef __cplusplus 30 | } 31 | #endif 32 | 33 | #endif // IOTHUB_CLIENT_VERSION_H 34 | -------------------------------------------------------------------------------- /src/jsondecoder.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef JSONDECODER_H 5 | #define JSONDECODER_H 6 | 7 | #include "multitree.h" 8 | 9 | #ifdef __cplusplus 10 | #include 11 | extern "C" { 12 | #else 13 | #include 14 | #endif 15 | 16 | #include "umock_c/umock_c_prod.h" 17 | 18 | #define JSON_DECODER_RESULT_VALUES \ 19 | JSON_DECODER_OK, \ 20 | JSON_DECODER_INVALID_ARG, \ 21 | JSON_DECODER_PARSE_ERROR, \ 22 | JSON_DECODER_MULTITREE_FAILED, \ 23 | JSON_DECODER_ERROR \ 24 | 25 | MU_DEFINE_ENUM_WITHOUT_INVALID(JSON_DECODER_RESULT, JSON_DECODER_RESULT_VALUES); 26 | 27 | MOCKABLE_FUNCTION(, JSON_DECODER_RESULT, JSONDecoder_JSON_To_MultiTree, char*, json, MULTITREE_HANDLE*, multiTreeHandle); 28 | 29 | #ifdef __cplusplus 30 | } 31 | #endif 32 | 33 | #endif /* JSONDECODER_H */ 34 | -------------------------------------------------------------------------------- /src/internal/iothub_internal_consts.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_INTERNAL_CONSTS_H 5 | #define IOTHUB_INTERNAL_CONSTS_H 6 | 7 | #ifdef __cplusplus 8 | extern "C" 9 | { 10 | #endif 11 | 12 | static const char* IOTHUB_API_VERSION = "2020-09-30"; 13 | static const char* SECURITY_INTERFACE_INTERNAL_ID = "iothub-interface-internal-id"; 14 | static const char* SECURITY_INTERFACE_INTERNAL_ID_VALUE = "security*azureiot*com^SecurityAgent^1*0*0"; 15 | static const char* SECURITY_INTERFACE_ID = "iothub-interface-id"; 16 | static const char* SECURITY_INTERFACE_ID_MQTT = "ifid"; 17 | static const char* SECURITY_INTERFACE_ID_VALUE = "urn:azureiot:Security:SecurityAgent:1"; 18 | static const char* SECURITY_MESSAGE_SCHEMA = "iothub-message-schema"; 19 | static const char* SECURITY_MESSAGE_SCHEMA_VALUE = "sevent"; 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | 25 | #endif /* IOTHUB_INTERNAL_CONSTS_H */ 26 | -------------------------------------------------------------------------------- /examples/esp32/iothub_ll_telemetry_sample/iot_configs.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOT_CONFIGS_H 5 | #define IOT_CONFIGS_H 6 | 7 | /** 8 | * WiFi setup 9 | */ 10 | #define IOT_CONFIG_WIFI_SSID "your-wifi-name" 11 | #define IOT_CONFIG_WIFI_PASSWORD "your-wifi-pwd" 12 | 13 | /** 14 | * IoT Hub Device Connection String setup 15 | * Find your Device Connection String by going to your Azure portal, creating (or navigating to) an IoT Hub, 16 | * navigating to IoT Devices tab on the left, and creating (or selecting an existing) IoT Device. 17 | * Then click on the named Device ID, and you will have able to copy the Primary or Secondary Device Connection String to this sample. 18 | */ 19 | #define DEVICE_CONNECTION_STRING "your-iothub-DEVICE-connection-string" 20 | 21 | // The protocol you wish to use should be uncommented 22 | // 23 | #define SAMPLE_MQTT 24 | //#define SAMPLE_HTTP 25 | 26 | #endif /* IOT_CONFIGS_H */ 27 | -------------------------------------------------------------------------------- /examples/esp8266/iothub_ll_telemetry_sample/iot_configs.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOT_CONFIGS_H 5 | #define IOT_CONFIGS_H 6 | 7 | /** 8 | * WiFi setup 9 | */ 10 | #define IOT_CONFIG_WIFI_SSID "your-wifi-name" 11 | #define IOT_CONFIG_WIFI_PASSWORD "your-wifi-pwd" 12 | 13 | /** 14 | * IoT Hub Device Connection String setup 15 | * Find your Device Connection String by going to your Azure portal, creating (or navigating to) an IoT Hub, 16 | * navigating to IoT Devices tab on the left, and creating (or selecting an existing) IoT Device. 17 | * Then click on the named Device ID, and you will have able to copy the Primary or Secondary Device Connection String to this sample. 18 | */ 19 | #define DEVICE_CONNECTION_STRING "your-iothub-DEVICE-connection-string" 20 | 21 | // The protocol you wish to use should be uncommented 22 | // 23 | #define SAMPLE_MQTT 24 | //#define SAMPLE_HTTP 25 | 26 | #endif /* IOT_CONFIGS_H */ 27 | -------------------------------------------------------------------------------- /src/iothub_transport_ll_private.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | 6 | #include "azure_c_shared_utility/xlogging.h" 7 | #include "internal/iothub_transport_ll_private.h" 8 | 9 | int IoTHub_Transport_ValidateCallbacks(const TRANSPORT_CALLBACKS_INFO* transport_cb) 10 | { 11 | int result; 12 | if ( 13 | transport_cb == NULL || 14 | transport_cb->connection_status_cb == NULL || 15 | transport_cb->msg_input_cb == NULL || 16 | transport_cb->msg_cb == NULL || 17 | transport_cb->send_complete_cb == NULL || 18 | transport_cb->prod_info_cb == NULL || 19 | transport_cb->twin_rpt_state_complete_cb == NULL || 20 | transport_cb->twin_retrieve_prop_complete_cb == NULL || 21 | transport_cb->method_complete_cb == NULL 22 | ) 23 | { 24 | LogError("Failure callback function NULL"); 25 | result = MU_FAILURE; 26 | } 27 | else 28 | { 29 | result = 0; 30 | } 31 | return result; 32 | } 33 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Microsoft Azure IoT SDKs 2 | Copyright (c) Microsoft Corporation 3 | All rights reserved. 4 | MIT License 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the ""Software""), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # AzureIoTHub - Azure IoT Hub library for Arduino 2 | 3 | > ### Stop! Before you proceed: 4 | > 5 | > _This Arduino Library is deprecated._ 6 | > 7 | > _It is kept here for **reference only** and should not be used for any new development._ 8 | > 9 | > _If you’re looking for an Arduino Library you should use the new version: [aka.ms/arduino](https://aka.ms/arduino)_ 10 | > 11 | >_You can find more information about it in this [IoT Techcommunity blog post](https://techcommunity.microsoft.com/t5/internet-of-things-blog/arduino-library-for-azure-iot/ba-p/3034455)._ 12 | > 13 | ## License 14 | 15 | See [LICENSE](LICENSE) file. 16 | 17 | 18 | [azure-certifiedforiot]: http://azure.com/certifiedforiot 19 | 20 | [Microsoft-Azure-Certified-Badge]: images/Microsoft-Azure-Certified-150x150.png (Microsoft Azure Certified) 21 | 22 | Complete information for contributing to the Azure IoT Arduino libraries 23 | 24 | can be found [here](https://github.com/Azure/azure-iot-pal-arduino). 25 | 26 | 27 | This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. 28 | -------------------------------------------------------------------------------- /src/iothub_transport_ll.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_TRANSPORT_LL_H 5 | #define IOTHUB_TRANSPORT_LL_H 6 | 7 | #ifdef __cplusplus 8 | #include 9 | #include 10 | extern "C" 11 | { 12 | #else 13 | #include 14 | #include 15 | #endif 16 | 17 | #include "umock_c/umock_c_prod.h" 18 | 19 | typedef void* TRANSPORT_LL_HANDLE; 20 | typedef void* IOTHUB_DEVICE_HANDLE; 21 | 22 | struct TRANSPORT_HANDLE_DATA_TAG; 23 | typedef struct TRANSPORT_HANDLE_DATA_TAG* TRANSPORT_HANDLE; 24 | 25 | typedef void* METHOD_HANDLE; 26 | 27 | struct TRANSPORT_PROVIDER_TAG; 28 | typedef struct TRANSPORT_PROVIDER_TAG TRANSPORT_PROVIDER; 29 | 30 | typedef const TRANSPORT_PROVIDER*(*IOTHUB_CLIENT_TRANSPORT_PROVIDER)(void); 31 | 32 | MOCKABLE_FUNCTION(, TRANSPORT_HANDLE, IoTHubTransport_Create, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol, const char*, iotHubName, const char*, iotHubSuffix); 33 | MOCKABLE_FUNCTION(, void, IoTHubTransport_Destroy, TRANSPORT_HANDLE, transportHandle); 34 | MOCKABLE_FUNCTION(, TRANSPORT_LL_HANDLE, IoTHubTransport_GetLLTransport, TRANSPORT_HANDLE, transportHandle); 35 | 36 | #ifdef __cplusplus 37 | } 38 | #endif 39 | 40 | #endif /* IOTHUB_TRANSPORT_LL_H */ 41 | 42 | -------------------------------------------------------------------------------- /src/certs/readme.md: -------------------------------------------------------------------------------- 1 | ## Certificates - Important to know 2 | 3 | The Azure IoT Hub certificates presented during TLS negotiation must be always validated using the appropriate root CA certificate(s). 4 | 5 | The samples in this repository leverage the certificates in `certs.c` for the United States, Germany sovereign cloud and China sovereign cloud. 6 | 7 | For other regions (and private cloud environments), please use the appropriate root CA certificate of their IoT services endpoint. 8 | 9 | Always prefer using the local system's Trusted Root Certificate Authority store instead of hardcoding the certificates (i.e. using certs.c such as our samples require in certain combinations). 10 | 11 | A couple of examples: 12 | 13 | - Windows: Schannel will automatically pick up CA certificates from the store managed using `certmgr.msc`. 14 | - Debian Linux: OpenSSL will automatically pick up CA certificates from the store installed using `apt install ca-certificates`. Adding a certificate to the store is described here: http://manpages.ubuntu.com/manpages/precise/man8/update-ca-certificates.8.html 15 | 16 | 17 | ## Additional Information 18 | 19 | For additional guidance and important information about certificates, please refer to [this blog post](https://techcommunity.microsoft.com/t5/internet-of-things/azure-iot-tls-changes-are-coming-and-why-you-should-care/ba-p/1658456) from the security team. 20 | -------------------------------------------------------------------------------- /src/internal/iothub_client_edge.h: -------------------------------------------------------------------------------- 1 | #ifndef IOTHUB_CLIENT_EDGE_H 2 | #define IOTHUB_CLIENT_EDGE_H 3 | 4 | #include 5 | 6 | #include "azure_macro_utils/macro_utils.h" 7 | #include "umock_c/umock_c_prod.h" 8 | 9 | #include "iothub_client_authorization.h" 10 | #include "iothub_client_core_common.h" 11 | 12 | #ifdef __cplusplus 13 | extern "C" 14 | { 15 | #endif 16 | 17 | typedef struct IOTHUB_CLIENT_EDGE_HANDLE_DATA_TAG* IOTHUB_CLIENT_EDGE_HANDLE; 18 | 19 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_EDGE_HANDLE, IoTHubClient_EdgeHandle_Create, const IOTHUB_CLIENT_CONFIG*, config, IOTHUB_AUTHORIZATION_HANDLE, authorizationHandle, const char*, module_id); 20 | MOCKABLE_FUNCTION(, void, IoTHubClient_EdgeHandle_Destroy, IOTHUB_CLIENT_EDGE_HANDLE, methodHandle); 21 | 22 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClient_Edge_DeviceMethodInvoke, IOTHUB_CLIENT_EDGE_HANDLE, moduleMethodHandle, const char*, deviceId, const char*, methodName, const char*, methodPayload, unsigned int, timeout, int*, responseStatus, unsigned char**, responsePayload, size_t*, responsePayloadSize); 23 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClient_Edge_ModuleMethodInvoke, IOTHUB_CLIENT_EDGE_HANDLE, moduleMethodHandle, const char*, deviceId, const char*, moduleId, const char*, methodName, const char*, methodPayload, unsigned int, timeout, int*, responseStatus, unsigned char**, responsePayload, size_t*, responsePayloadSize); 24 | 25 | #ifdef __cplusplus 26 | } 27 | #endif 28 | 29 | #endif /* IOTHUB_CLIENT_EDGE_H */ -------------------------------------------------------------------------------- /src/internal/iothub_client_diagnostic.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /** @file iothub_client_diagnostic.h 5 | * @brief The @c diagnostic is a component that helps to add predefined diagnostic 6 | properties to message for end to end diagnostic purpose 7 | */ 8 | 9 | #ifndef IOTHUB_CLIENT_DIAGNOSTIC_H 10 | #define IOTHUB_CLIENT_DIAGNOSTIC_H 11 | 12 | #include "umock_c/umock_c_prod.h" 13 | 14 | #include "iothub_message.h" 15 | #include 16 | 17 | #ifdef __cplusplus 18 | #include 19 | extern "C" { 20 | #else 21 | #include 22 | #endif 23 | 24 | /** @brief diagnostic related setting */ 25 | typedef struct IOTHUB_DIAGNOSTIC_SETTING_DATA_TAG 26 | { 27 | uint32_t diagSamplingPercentage; 28 | uint32_t currentMessageNumber; 29 | } IOTHUB_DIAGNOSTIC_SETTING_DATA; 30 | 31 | /** 32 | * @brief Adds diagnostic information to message if: 33 | * a. diagSetting->diagSamplingPercentage > 0 and 34 | * b. the number of current message matches sample rule specified by diagSetting->diagSamplingPercentage 35 | * 36 | * @param diagSetting Pointer to an @c IOTHUB_DIAGNOSTIC_SETTING_DATA structure 37 | * 38 | * @param messageHandle message handle 39 | * 40 | * @return 0 upon success 41 | */ 42 | MOCKABLE_FUNCTION(, int, IoTHubClient_Diagnostic_AddIfNecessary, IOTHUB_DIAGNOSTIC_SETTING_DATA *, diagSetting, IOTHUB_MESSAGE_HANDLE, messageHandle); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif 47 | 48 | #endif /* IOTHUB_CLIENT_DIAGNOSTIC_H */ 49 | -------------------------------------------------------------------------------- /src/dataserializer.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef DATASERIALIZER_H 5 | #define DATASERIALIZER_H 6 | 7 | #include "azure_macro_utils/macro_utils.h" 8 | #include "multitree.h" 9 | #include "azure_c_shared_utility/buffer_.h" 10 | 11 | #ifdef __cplusplus 12 | #include 13 | extern "C" 14 | { 15 | #else 16 | #include 17 | #endif 18 | 19 | /*Codes_SRS_DATA_SERIALIZER_07_001: [DataSerializer will have the following interface]*/ 20 | #define DATA_SERIALIZER_RESULT_VALUES \ 21 | DATA_SERIALIZER_INVALID_ARG, \ 22 | DATA_SERIALIZER_ERROR \ 23 | 24 | MU_DEFINE_ENUM_WITHOUT_INVALID(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_RESULT_VALUES); 25 | 26 | #define DATA_SERIALIZER_MULTITREE_TYPE_VALUES \ 27 | DATA_SERIALIZER_TYPE_CHAR_PTR, \ 28 | DATA_SERIALIZER_TYPE_AGENT_DATA \ 29 | 30 | MU_DEFINE_ENUM_WITHOUT_INVALID(DATA_SERIALIZER_MULTITREE_TYPE, DATA_SERIALIZER_MULTITREE_TYPE_VALUES); 31 | 32 | typedef BUFFER_HANDLE (*DATA_SERIALIZER_ENCODE_FUNC)(MULTITREE_HANDLE multiTreeHandle, DATA_SERIALIZER_MULTITREE_TYPE dataType); 33 | typedef MULTITREE_HANDLE (*DATA_SERIALIZER_DECODE_FUNC)(BUFFER_HANDLE decodeData); 34 | 35 | extern BUFFER_HANDLE DataSerializer_Encode(MULTITREE_HANDLE multiTreeHandle, DATA_SERIALIZER_MULTITREE_TYPE dataType, DATA_SERIALIZER_ENCODE_FUNC encodeFunc); 36 | extern MULTITREE_HANDLE DataSerializer_Decode(BUFFER_HANDLE data, DATA_SERIALIZER_DECODE_FUNC decodeFunc); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | 42 | #endif // DATASERIALIZER_H 43 | -------------------------------------------------------------------------------- /src/jsonencoder.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef JSONENCODER_H 5 | #define JSONENCODER_H 6 | 7 | #include "azure_macro_utils/macro_utils.h" 8 | #include "azure_c_shared_utility/strings.h" 9 | 10 | #ifdef __cplusplus 11 | #include "cstddef" 12 | extern "C" { 13 | #else 14 | #include "stddef.h" 15 | #endif 16 | 17 | #include "multitree.h" 18 | 19 | #define JSON_ENCODER_RESULT_VALUES \ 20 | JSON_ENCODER_OK, \ 21 | JSON_ENCODER_INVALID_ARG, \ 22 | JSON_ENCODER_ALREADY_EXISTS, \ 23 | JSON_ENCODER_MULTITREE_ERROR, \ 24 | JSON_ENCODER_TOSTRING_FUNCTION_ERROR, \ 25 | JSON_ENCODER_ERROR 26 | 27 | MU_DEFINE_ENUM_WITHOUT_INVALID(JSON_ENCODER_RESULT, JSON_ENCODER_RESULT_VALUES); 28 | 29 | #define JSON_ENCODER_TOSTRING_RESULT_VALUES \ 30 | JSON_ENCODER_TOSTRING_OK, \ 31 | JSON_ENCODER_TOSTRING_INVALID_ARG, \ 32 | JSON_ENCODER_TOSTRING_ERROR 33 | 34 | MU_DEFINE_ENUM_WITHOUT_INVALID(JSON_ENCODER_TOSTRING_RESULT, JSON_ENCODER_TOSTRING_RESULT_VALUES); 35 | 36 | typedef JSON_ENCODER_TOSTRING_RESULT(*JSON_ENCODER_TOSTRING_FUNC)(STRING_HANDLE, const void* value); 37 | 38 | #include "umock_c/umock_c_prod.h" 39 | 40 | MOCKABLE_FUNCTION(, JSON_ENCODER_TOSTRING_RESULT, JSONEncoder_CharPtr_ToString, STRING_HANDLE, destination, const void*, value); 41 | MOCKABLE_FUNCTION(, JSON_ENCODER_RESULT, JSONEncoder_EncodeTree, MULTITREE_HANDLE, treeHandle, STRING_HANDLE, destination, JSON_ENCODER_TOSTRING_FUNC, toStringFunc); 42 | 43 | #ifdef __cplusplus 44 | } 45 | #endif 46 | 47 | 48 | #endif /* JSONENCODER_H */ 49 | -------------------------------------------------------------------------------- /src/internal/iothubtransport.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_TRANSPORT_H 5 | #define IOTHUB_TRANSPORT_H 6 | 7 | #include "azure_c_shared_utility/lock.h" 8 | #include "azure_c_shared_utility/crt_abstractions.h" 9 | #include "iothub_transport_ll.h" 10 | #include "iothub_client_core.h" 11 | #include "internal/iothub_client_private.h" 12 | #include "internal/iothub_transport_ll_private.h" 13 | #include "internal/iothub_client_authorization.h" 14 | 15 | #ifndef IOTHUB_CLIENT_CORE_INSTANCE_TYPE 16 | typedef struct IOTHUB_CLIENT_CORE_INSTANCE_TAG* IOTHUB_CLIENT_CORE_HANDLE; 17 | #define IOTHUB_CLIENT_CORE_INSTANCE_TYPE 18 | #endif // IOTHUB_CLIENT_CORE_INSTANCE 19 | 20 | #ifdef __cplusplus 21 | extern "C" 22 | { 23 | #else 24 | #include 25 | #endif 26 | 27 | #include "umock_c/umock_c_prod.h" 28 | 29 | /** @brief This struct captures IoTHub transport configuration. */ 30 | struct IOTHUBTRANSPORT_CONFIG_TAG 31 | { 32 | const IOTHUB_CLIENT_CONFIG* upperConfig; 33 | PDLIST_ENTRY waitingToSend; 34 | IOTHUB_AUTHORIZATION_HANDLE auth_module_handle; 35 | const char* moduleId; 36 | }; 37 | 38 | typedef void(*IOTHUB_CLIENT_MULTIPLEXED_DO_WORK)(void* iotHubClientInstance); 39 | 40 | MOCKABLE_FUNCTION(, LOCK_HANDLE, IoTHubTransport_GetLock, TRANSPORT_HANDLE, transportHandle); 41 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_StartWorkerThread, TRANSPORT_HANDLE, transportHandle, IOTHUB_CLIENT_CORE_HANDLE, clientHandle, IOTHUB_CLIENT_MULTIPLEXED_DO_WORK, muxDoWork); 42 | MOCKABLE_FUNCTION(, bool, IoTHubTransport_SignalEndWorkerThread, TRANSPORT_HANDLE, transportHandle, IOTHUB_CLIENT_CORE_HANDLE, clientHandle); 43 | MOCKABLE_FUNCTION(, void, IoTHubTransport_JoinWorkerThread, TRANSPORT_HANDLE, transportHandle, IOTHUB_CLIENT_CORE_HANDLE, clientHandle); 44 | 45 | #ifdef __cplusplus 46 | } 47 | #endif 48 | 49 | #endif /* IOTHUB_TRANSPORT_H */ 50 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | # Copyright (c) Microsoft. All rights reserved. 2 | # Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | language: generic 5 | env: 6 | global: 7 | - IDE_VERSION=1.8.10 8 | matrix: 9 | - BOARD="esp8266:esp8266:huzzah:FlashSize=4M3M,CpuFrequency=80" 10 | - BOARD="esp8266:esp8266:thing" 11 | - BOARD="esp32:esp32:huzzah" 12 | before_install: 13 | - /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16 14 | - sleep 3 15 | - export DISPLAY=:1.0 16 | - wget http://downloads.arduino.cc/arduino-$IDE_VERSION-linux64.tar.xz 17 | - tar xf arduino-$IDE_VERSION-linux64.tar.xz 18 | - mv arduino-$IDE_VERSION $HOME/arduino-ide 19 | - export PATH=$PATH:$HOME/arduino-ide 20 | - if [[ "$BOARD" =~ "esp8266:esp8266:" ]]; then 21 | arduino --pref "boardsmanager.additional.urls=http://arduino.esp8266.com/stable/package_esp8266com_index.json" --install-boards esp8266:esp8266; 22 | arduino --pref "boardsmanager.additional.urls=" --save-prefs; 23 | arduino --install-library NTPClient; 24 | fi 25 | - if [[ "$BOARD" =~ "esp32:esp32:" ]]; then 26 | arduino --pref "boardsmanager.additional.urls=https://dl.espressif.com/dl/package_esp32_index.json" --install-boards esp32:esp32; 27 | arduino --pref "boardsmanager.additional.urls=" --save-prefs; 28 | arduino --install-library NTPClient; 29 | fi 30 | 31 | - findAndReplace() { sed -i'' -e"s|$1|$2|g" "$3"; } 32 | - buildExampleSketch() { 33 | EXAMPLE_SKETCH=$PWD/examples/iothub_ll_telemetry_sample/iothub_ll_telemetry_sample.ino; 34 | 35 | arduino --verbose-build --verify --board $BOARD $EXAMPLE_SKETCH; 36 | } 37 | install: 38 | - arduino --install-library "AzureIoTUtility" 39 | - arduino --install-library "AzureIoTSocket_WiFi" 40 | - arduino --install-library "AzureIoTProtocol_MQTT" 41 | - arduino --install-library "AzureIoTProtocol_HTTP" 42 | - ln -s $PWD $HOME/Arduino/libraries/. 43 | script: 44 | - buildExampleSketch telemetry_sample.c 45 | -------------------------------------------------------------------------------- /src/internal/iothubtransportamqp_methods.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTAMQP_METHODS_H 5 | #define IOTHUBTRANSPORTAMQP_METHODS_H 6 | 7 | #include "azure_uamqp_c/session.h" 8 | #include "azure_c_shared_utility/buffer_.h" 9 | #include "umock_c/umock_c_prod.h" 10 | 11 | #ifdef __cplusplus 12 | #include 13 | 14 | extern "C" 15 | { 16 | #else 17 | #include 18 | #endif 19 | 20 | typedef struct IOTHUBTRANSPORT_AMQP_METHOD_TAG* IOTHUBTRANSPORT_AMQP_METHOD_HANDLE; 21 | typedef struct IOTHUBTRANSPORT_AMQP_METHODS_TAG* IOTHUBTRANSPORT_AMQP_METHODS_HANDLE; 22 | typedef void(*ON_METHODS_ERROR)(void* context); 23 | typedef int(*ON_METHOD_REQUEST_RECEIVED)(void* context, const char* method_name, const unsigned char* request, size_t request_size, IOTHUBTRANSPORT_AMQP_METHOD_HANDLE response); 24 | typedef void(*ON_METHODS_UNSUBSCRIBED)(void* context); 25 | 26 | MOCKABLE_FUNCTION(, IOTHUBTRANSPORT_AMQP_METHODS_HANDLE, iothubtransportamqp_methods_create, const char*, hostname, const char*, device_id, const char*, module_id); 27 | MOCKABLE_FUNCTION(, void, iothubtransportamqp_methods_destroy, IOTHUBTRANSPORT_AMQP_METHODS_HANDLE, iothubtransport_amqp_methods_handle); 28 | MOCKABLE_FUNCTION(, int, iothubtransportamqp_methods_subscribe, IOTHUBTRANSPORT_AMQP_METHODS_HANDLE, iothubtransport_amqp_methods_handle, 29 | SESSION_HANDLE, session_handle, ON_METHODS_ERROR, on_methods_error, void*, on_methods_error_context, 30 | ON_METHOD_REQUEST_RECEIVED, on_method_request_received, void*, on_method_request_received_context, 31 | ON_METHODS_UNSUBSCRIBED, on_methods_unsubscribed, void*, on_methods_unsubscribed_context); 32 | MOCKABLE_FUNCTION(, int, iothubtransportamqp_methods_respond, IOTHUBTRANSPORT_AMQP_METHOD_HANDLE, method_handle, 33 | const unsigned char*, response, size_t, response_size, int, status_code); 34 | MOCKABLE_FUNCTION(, void, iothubtransportamqp_methods_unsubscribe, IOTHUBTRANSPORT_AMQP_METHODS_HANDLE, iothubtransport_amqp_methods_handle); 35 | 36 | #ifdef __cplusplus 37 | } 38 | #endif 39 | 40 | #endif /* IOTHUBTRANSPORTAMQP_METHODS_H */ 41 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_connection.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTAMQP_AMQP_CONNECTION_H 5 | #define IOTHUBTRANSPORTAMQP_AMQP_CONNECTION_H 6 | 7 | #include "umock_c/umock_c_prod.h" 8 | #include "azure_macro_utils/macro_utils.h" 9 | #include "azure_c_shared_utility/xio.h" 10 | #include "azure_uamqp_c/session.h" 11 | #include "azure_uamqp_c/cbs.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" 15 | { 16 | #endif 17 | 18 | #define AMQP_CONNECTION_STATE_VALUES \ 19 | AMQP_CONNECTION_STATE_OPENED, \ 20 | AMQP_CONNECTION_STATE_CLOSED, \ 21 | AMQP_CONNECTION_STATE_ERROR 22 | 23 | MU_DEFINE_ENUM(AMQP_CONNECTION_STATE, AMQP_CONNECTION_STATE_VALUES); 24 | 25 | typedef void(*ON_AMQP_CONNECTION_STATE_CHANGED)(const void* context, AMQP_CONNECTION_STATE old_state, AMQP_CONNECTION_STATE new_state); 26 | 27 | typedef struct AMQP_CONNECTION_CONFIG_TAG 28 | { 29 | const char* iothub_host_fqdn; 30 | XIO_HANDLE underlying_io_transport; 31 | bool create_sasl_io; 32 | bool create_cbs_connection; 33 | bool is_trace_on; 34 | 35 | ON_AMQP_CONNECTION_STATE_CHANGED on_state_changed_callback; 36 | const void* on_state_changed_context; 37 | size_t svc2cl_keep_alive_timeout_secs; 38 | double cl2svc_keep_alive_send_ratio; 39 | } AMQP_CONNECTION_CONFIG; 40 | 41 | typedef struct AMQP_CONNECTION_INSTANCE* AMQP_CONNECTION_HANDLE; 42 | 43 | MOCKABLE_FUNCTION(, AMQP_CONNECTION_HANDLE, amqp_connection_create, AMQP_CONNECTION_CONFIG*, config); 44 | MOCKABLE_FUNCTION(, void, amqp_connection_destroy, AMQP_CONNECTION_HANDLE, conn_handle); 45 | MOCKABLE_FUNCTION(, void, amqp_connection_do_work, AMQP_CONNECTION_HANDLE, conn_handle); 46 | MOCKABLE_FUNCTION(, int, amqp_connection_get_session_handle, AMQP_CONNECTION_HANDLE, conn_handle, SESSION_HANDLE*, session_handle); 47 | MOCKABLE_FUNCTION(, int, amqp_connection_get_cbs_handle, AMQP_CONNECTION_HANDLE, conn_handle, CBS_HANDLE*, cbs_handle); 48 | MOCKABLE_FUNCTION(, int, amqp_connection_set_logging, AMQP_CONNECTION_HANDLE, conn_handle, bool, is_trace_on); 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif /*IOTHUBTRANSPORTAMQP_AMQP_CONNECTION_H*/ 55 | -------------------------------------------------------------------------------- /src/internal/iothub_client_retry_control.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_CLIENT_RETRY_CONTROL 5 | #define IOTHUB_CLIENT_RETRY_CONTROL 6 | 7 | #include 8 | #include 9 | #include "azure_c_shared_utility/optionhandler.h" 10 | #include "umock_c/umock_c_prod.h" 11 | #include "iothub_client_core_ll.h" 12 | #include "internal/iothubtransport.h" 13 | #include "azure_c_shared_utility/const_defines.h" 14 | 15 | #ifdef __cplusplus 16 | extern "C" 17 | { 18 | #endif 19 | 20 | static STATIC_VAR_UNUSED const char* RETRY_CONTROL_OPTION_INITIAL_WAIT_TIME_IN_SECS = "initial_wait_time_in_secs"; 21 | static STATIC_VAR_UNUSED const char* RETRY_CONTROL_OPTION_MAX_JITTER_PERCENT = "max_jitter_percent"; 22 | static STATIC_VAR_UNUSED const char* RETRY_CONTROL_OPTION_MAX_DELAY_IN_SECS = "max_delay_in_secs"; 23 | static STATIC_VAR_UNUSED const char* RETRY_CONTROL_OPTION_SAVED_OPTIONS = "retry_control_saved_options"; 24 | 25 | typedef enum RETRY_ACTION_TAG 26 | { 27 | RETRY_ACTION_RETRY_NOW, 28 | RETRY_ACTION_RETRY_LATER, 29 | RETRY_ACTION_STOP_RETRYING 30 | } RETRY_ACTION; 31 | 32 | struct RETRY_CONTROL_INSTANCE_TAG; 33 | typedef struct RETRY_CONTROL_INSTANCE_TAG* RETRY_CONTROL_HANDLE; 34 | 35 | MOCKABLE_FUNCTION(, RETRY_CONTROL_HANDLE, retry_control_create, IOTHUB_CLIENT_RETRY_POLICY, policy, unsigned int, max_retry_time_in_secs); 36 | MOCKABLE_FUNCTION(, int, retry_control_should_retry, RETRY_CONTROL_HANDLE, retry_control_handle, RETRY_ACTION*, retry_action); 37 | MOCKABLE_FUNCTION(, void, retry_control_reset, RETRY_CONTROL_HANDLE, retry_control_handle); 38 | MOCKABLE_FUNCTION(, int, retry_control_set_option, RETRY_CONTROL_HANDLE, retry_control_handle, const char*, name, const void*, value); 39 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, retry_control_retrieve_options, RETRY_CONTROL_HANDLE, retry_control_handle); 40 | MOCKABLE_FUNCTION(, void, retry_control_destroy, RETRY_CONTROL_HANDLE, retry_control_handle); 41 | 42 | MOCKABLE_FUNCTION(, int, is_timeout_reached, time_t, start_time, unsigned int, timeout_in_secs, bool*, is_timed_out); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif 47 | 48 | #endif // IOTHUB_CLIENT_RETRY_CONTROL 49 | -------------------------------------------------------------------------------- /src/datamarshaller.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef DATAMARSHALLER_H 5 | #define DATAMARSHALLER_H 6 | 7 | #include 8 | #include "agenttypesystem.h" 9 | #include "schema.h" 10 | #include "azure_macro_utils/macro_utils.h" 11 | #include "azure_c_shared_utility/vector.h" 12 | #ifdef __cplusplus 13 | extern "C" 14 | { 15 | #endif 16 | 17 | /*Codes_SRS_DATA_MARSHALLER_99_002:[ DataMarshaller shall have the following interface]*/ 18 | #define DATA_MARSHALLER_RESULT_VALUES \ 19 | DATA_MARSHALLER_OK, \ 20 | DATA_MARSHALLER_INVALID_ARG, \ 21 | DATA_MARSHALLER_NO_DEVICE_IDENTITY, \ 22 | DATA_MARSHALLER_SCHEMA_FAILED, \ 23 | DATA_MARSHALLER_INVALID_MODEL_PROPERTY, \ 24 | DATA_MARSHALLER_JSON_ENCODER_ERROR, \ 25 | DATA_MARSHALLER_ERROR, \ 26 | DATA_MARSHALLER_AGENT_DATA_TYPES_ERROR, \ 27 | DATA_MARSHALLER_MULTITREE_ERROR, \ 28 | DATA_MARSHALLER_ONLY_ONE_VALUE_ALLOWED \ 29 | 30 | MU_DEFINE_ENUM_WITHOUT_INVALID(DATA_MARSHALLER_RESULT, DATA_MARSHALLER_RESULT_VALUES); 31 | 32 | typedef struct DATA_MARSHALLER_VALUE_TAG 33 | { 34 | const char* PropertyPath; 35 | const AGENT_DATA_TYPE* Value; 36 | } DATA_MARSHALLER_VALUE; 37 | 38 | typedef struct DATA_MARSHALLER_HANDLE_DATA_TAG* DATA_MARSHALLER_HANDLE; 39 | #include "umock_c/umock_c_prod.h" 40 | 41 | MOCKABLE_FUNCTION(,DATA_MARSHALLER_HANDLE, DataMarshaller_Create, SCHEMA_MODEL_TYPE_HANDLE, modelHandle, bool, includePropertyPath); 42 | MOCKABLE_FUNCTION(,void, DataMarshaller_Destroy, DATA_MARSHALLER_HANDLE, dataMarshallerHandle); 43 | MOCKABLE_FUNCTION(,DATA_MARSHALLER_RESULT, DataMarshaller_SendData, DATA_MARSHALLER_HANDLE, dataMarshallerHandle, size_t, valueCount, const DATA_MARSHALLER_VALUE*, values, unsigned char**, destination, size_t*, destinationSize); 44 | 45 | MOCKABLE_FUNCTION(, DATA_MARSHALLER_RESULT, DataMarshaller_SendData_ReportedProperties, DATA_MARSHALLER_HANDLE, dataMarshallerHandle, VECTOR_HANDLE, values, unsigned char**, destination, size_t*, destinationSize); 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | 51 | #endif /* DATAMARSHALLER_H */ 52 | -------------------------------------------------------------------------------- /src/azure_umqtt_c/mqtt_codec.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef MQTT_CODEC_H 5 | #define MQTT_CODEC_H 6 | 7 | #include "azure_c_shared_utility/xio.h" 8 | #include "azure_c_shared_utility/buffer_.h" 9 | #include "umock_c/umock_c_prod.h" 10 | #include "azure_umqtt_c/mqttconst.h" 11 | #include "azure_c_shared_utility/strings.h" 12 | 13 | #ifdef __cplusplus 14 | #include 15 | #include 16 | extern "C" { 17 | #else 18 | #include 19 | #include 20 | #include 21 | #endif // __cplusplus 22 | 23 | typedef struct MQTTCODEC_INSTANCE_TAG* MQTTCODEC_HANDLE; 24 | 25 | typedef void(*ON_PACKET_COMPLETE_CALLBACK)(void* context, CONTROL_PACKET_TYPE packet, int flags, BUFFER_HANDLE headerData); 26 | 27 | MOCKABLE_FUNCTION(, MQTTCODEC_HANDLE, mqtt_codec_create, ON_PACKET_COMPLETE_CALLBACK, packetComplete, void*, callbackCtx); 28 | MOCKABLE_FUNCTION(, void, mqtt_codec_destroy, MQTTCODEC_HANDLE, handle); 29 | 30 | MOCKABLE_FUNCTION(, void, mqtt_codec_reset, MQTTCODEC_HANDLE, handle); 31 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_connect, const MQTT_CLIENT_OPTIONS*, mqttOptions, STRING_HANDLE, trace_log); 32 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_disconnect); 33 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_publish, QOS_VALUE, qosValue, bool, duplicateMsg, bool, serverRetain, uint16_t, packetId, const char*, topicName, const uint8_t*, msgBuffer, size_t, buffLen, STRING_HANDLE, trace_log); 34 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_publishAck, uint16_t, packetId); 35 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_publishReceived, uint16_t, packetId); 36 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_publishRelease, uint16_t, packetId); 37 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_publishComplete, uint16_t, packetId); 38 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_ping); 39 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_subscribe, uint16_t, packetId, SUBSCRIBE_PAYLOAD*, subscribeList, size_t, count, STRING_HANDLE, trace_log); 40 | MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_unsubscribe, uint16_t, packetId, const char**, unsubscribeList, size_t, count, STRING_HANDLE, trace_log); 41 | 42 | MOCKABLE_FUNCTION(, int, mqtt_codec_bytesReceived, MQTTCODEC_HANDLE, handle, const unsigned char*, buffer, size_t, size); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif // __cplusplus 47 | 48 | #endif // MQTT_CODEC_H 49 | -------------------------------------------------------------------------------- /src/azure_umqtt_c/mqtt_message.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef MQTT_MESSAGE_H 5 | #define MQTT_MESSAGE_H 6 | 7 | #include "azure_umqtt_c/mqttconst.h" 8 | #include "umock_c/umock_c_prod.h" 9 | 10 | #ifdef __cplusplus 11 | #include 12 | #include 13 | extern "C" { 14 | #else 15 | #include 16 | #include 17 | #include 18 | #endif // __cplusplus 19 | 20 | typedef struct MQTT_MESSAGE_TAG* MQTT_MESSAGE_HANDLE; 21 | 22 | MOCKABLE_FUNCTION(, MQTT_MESSAGE_HANDLE, mqttmessage_create_in_place, uint16_t, packetId, const char*, topicName, QOS_VALUE, qosValue, const uint8_t*, appMsg, size_t, appMsgLength); 23 | MOCKABLE_FUNCTION(, MQTT_MESSAGE_HANDLE, mqttmessage_create, uint16_t, packetId, const char*, topicName, QOS_VALUE, qosValue, const uint8_t*, appMsg, size_t, appMsgLength); 24 | MOCKABLE_FUNCTION(,void, mqttmessage_destroy, MQTT_MESSAGE_HANDLE, handle); 25 | MOCKABLE_FUNCTION(,MQTT_MESSAGE_HANDLE, mqttmessage_clone, MQTT_MESSAGE_HANDLE, handle); 26 | 27 | MOCKABLE_FUNCTION(, uint16_t, mqttmessage_getPacketId, MQTT_MESSAGE_HANDLE, handle); 28 | MOCKABLE_FUNCTION(, const char*, mqttmessage_getTopicName, MQTT_MESSAGE_HANDLE, handle); 29 | 30 | /* 31 | * @brief Gets the individual names of the MQTT topic levels, in the original order. 32 | * @param handle Handle to the MQTT message. 33 | * @param levels Pointer the variable where to store the level names. 34 | * @param count Number of levels in the topic name. 35 | * @return return Zero if no failures occur, or non-zero otherwise. 36 | */ 37 | MOCKABLE_FUNCTION(, int, mqttmessage_getTopicLevels, MQTT_MESSAGE_HANDLE, handle, char***, levels, size_t*, count); 38 | 39 | MOCKABLE_FUNCTION(, QOS_VALUE, mqttmessage_getQosType, MQTT_MESSAGE_HANDLE, handle); 40 | MOCKABLE_FUNCTION(, bool, mqttmessage_getIsDuplicateMsg, MQTT_MESSAGE_HANDLE, handle); 41 | MOCKABLE_FUNCTION(, bool, mqttmessage_getIsRetained, MQTT_MESSAGE_HANDLE, handle); 42 | MOCKABLE_FUNCTION(, int, mqttmessage_setIsDuplicateMsg, MQTT_MESSAGE_HANDLE, handle, bool, duplicateMsg); 43 | MOCKABLE_FUNCTION(, int, mqttmessage_setIsRetained, MQTT_MESSAGE_HANDLE, handle, bool, retainMsg); 44 | MOCKABLE_FUNCTION(, const APP_PAYLOAD*, mqttmessage_getApplicationMsg, MQTT_MESSAGE_HANDLE, handle); 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif // __cplusplus 49 | 50 | #endif // MQTT_MESSAGE_H 51 | -------------------------------------------------------------------------------- /src/commanddecoder.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef COMMAND_DECODER_H 5 | #define COMMAND_DECODER_H 6 | 7 | #include "multitree.h" 8 | #include "schema.h" 9 | #include "agenttypesystem.h" 10 | #include "azure_macro_utils/macro_utils.h" 11 | #include "methodreturn.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #else 16 | #include 17 | #endif 18 | 19 | #define COMMANDDECODER_RESULT_VALUES \ 20 | COMMANDDECODER_OK, \ 21 | COMMANDDECODER_ERROR, \ 22 | COMMANDDECODER_INVALID_ARG 23 | 24 | MU_DEFINE_ENUM_WITHOUT_INVALID(COMMANDDECODER_RESULT, COMMANDDECODER_RESULT_VALUES) 25 | 26 | #define EXECUTE_COMMAND_RESULT_VALUES \ 27 | EXECUTE_COMMAND_SUCCESS, /*when the final recipient of the command indicates a successful execution*/ \ 28 | EXECUTE_COMMAND_FAILED, /*when the final recipient of the command indicates a failure*/ \ 29 | EXECUTE_COMMAND_ERROR /*when a transient error either in the final recipient or until the final recipient*/ 30 | 31 | MU_DEFINE_ENUM_WITHOUT_INVALID(EXECUTE_COMMAND_RESULT, EXECUTE_COMMAND_RESULT_VALUES) 32 | 33 | 34 | 35 | 36 | /* Codes_SRS_COMMAND_DECODER_99_001:[ The CommandDecoder module shall expose the following API:] */ 37 | 38 | typedef struct COMMAND_DECODER_HANDLE_DATA_TAG* COMMAND_DECODER_HANDLE; 39 | typedef EXECUTE_COMMAND_RESULT(*ACTION_CALLBACK_FUNC)(void* actionCallbackContext, const char* relativeActionPath, const char* actionName, size_t argCount, const AGENT_DATA_TYPE* args); 40 | typedef METHODRETURN_HANDLE(*METHOD_CALLBACK_FUNC)(void* methodCallbackContext, const char* relativeMethodPath, const char* methodName, size_t argCount, const AGENT_DATA_TYPE* args); 41 | 42 | #include "umock_c/umock_c_prod.h" 43 | 44 | MOCKABLE_FUNCTION(,COMMAND_DECODER_HANDLE, CommandDecoder_Create, SCHEMA_MODEL_TYPE_HANDLE, modelHandle, ACTION_CALLBACK_FUNC, actionCallback, void*, actionCallbackContext, METHOD_CALLBACK_FUNC, methodCallback, void*, methodCallbackContext); 45 | MOCKABLE_FUNCTION(,EXECUTE_COMMAND_RESULT, CommandDecoder_ExecuteCommand, COMMAND_DECODER_HANDLE, handle, const char*, command); 46 | MOCKABLE_FUNCTION(,METHODRETURN_HANDLE, CommandDecoder_ExecuteMethod, COMMAND_DECODER_HANDLE, handle, const char*, fullMethodName, const char*, methodPayload); 47 | MOCKABLE_FUNCTION(,void, CommandDecoder_Destroy, COMMAND_DECODER_HANDLE, commandDecoderHandle); 48 | 49 | MOCKABLE_FUNCTION(, EXECUTE_COMMAND_RESULT, CommandDecoder_IngestDesiredProperties, void*, startAddress, COMMAND_DECODER_HANDLE, handle, const char*, jsonPayload, bool, parseDesiredNode); 50 | 51 | #ifdef __cplusplus 52 | } 53 | #endif 54 | 55 | #endif /* COMMAND_DECODER_H */ 56 | -------------------------------------------------------------------------------- /src/multitree.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef MULTITREE_H 5 | #define MULTITREE_H 6 | 7 | #include "azure_c_shared_utility/strings.h" 8 | #include "azure_macro_utils/macro_utils.h" 9 | 10 | #ifdef __cplusplus 11 | #include 12 | extern "C" 13 | { 14 | #else 15 | #include 16 | #include 17 | #endif 18 | 19 | typedef struct MULTITREE_HANDLE_DATA_TAG* MULTITREE_HANDLE; 20 | 21 | #define MULTITREE_RESULT_VALUES \ 22 | MULTITREE_OK, \ 23 | MULTITREE_INVALID_ARG, \ 24 | MULTITREE_ALREADY_HAS_A_VALUE, \ 25 | MULTITREE_EMPTY_CHILD_NAME, \ 26 | MULTITREE_EMPTY_VALUE, \ 27 | MULTITREE_OUT_OF_RANGE_INDEX, \ 28 | MULTITREE_ERROR, \ 29 | MULTITREE_CHILD_NOT_FOUND \ 30 | 31 | MU_DEFINE_ENUM_WITHOUT_INVALID(MULTITREE_RESULT, MULTITREE_RESULT_VALUES); 32 | 33 | typedef void (*MULTITREE_FREE_FUNCTION)(void* value); 34 | typedef int (*MULTITREE_CLONE_FUNCTION)(void** destination, const void* source); 35 | 36 | #include "umock_c/umock_c_prod.h" 37 | MOCKABLE_FUNCTION(, MULTITREE_HANDLE, MultiTree_Create, MULTITREE_CLONE_FUNCTION, cloneFunction, MULTITREE_FREE_FUNCTION, freeFunction); 38 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_AddLeaf, MULTITREE_HANDLE, treeHandle, const char*, destinationPath, const void*, value); 39 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_AddChild, MULTITREE_HANDLE, treeHandle, const char*, childName, MULTITREE_HANDLE*, childHandle); 40 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetChildCount, MULTITREE_HANDLE, treeHandle, size_t*, count); 41 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetChild, MULTITREE_HANDLE, treeHandle, size_t, index, MULTITREE_HANDLE*, childHandle); 42 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetChildByName, MULTITREE_HANDLE, treeHandle, const char*, childName, MULTITREE_HANDLE*, childHandle); 43 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetName, MULTITREE_HANDLE, treeHandle, STRING_HANDLE, destination); 44 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetValue, MULTITREE_HANDLE, treeHandle, const void**, destination); 45 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_GetLeafValue, MULTITREE_HANDLE, treeHandle, const char*, leafPath, const void**, destination); 46 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_SetValue, MULTITREE_HANDLE, treeHandle, void*, value); 47 | MOCKABLE_FUNCTION(, void, MultiTree_Destroy, MULTITREE_HANDLE, treeHandle); 48 | MOCKABLE_FUNCTION(, MULTITREE_RESULT, MultiTree_DeleteChild, MULTITREE_HANDLE, treeHandle, const char*, childName); 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /src/dataserializer.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include "azure_c_shared_utility/gballoc.h" 5 | 6 | #include "dataserializer.h" 7 | #include "azure_c_shared_utility/xlogging.h" 8 | 9 | MU_DEFINE_ENUM_STRINGS_WITHOUT_INVALID(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_RESULT_VALUES); 10 | 11 | BUFFER_HANDLE DataSerializer_Encode(MULTITREE_HANDLE multiTreeHandle, DATA_SERIALIZER_MULTITREE_TYPE dataType, DATA_SERIALIZER_ENCODE_FUNC encodeFunc) 12 | { 13 | BUFFER_HANDLE pBuffer; 14 | 15 | /* Codes_SRS_DATA_SERIALIZER_07_003: [NULL shall be returned when an invalid parameter is supplied.] */ 16 | if (multiTreeHandle == NULL || encodeFunc == NULL) 17 | { 18 | pBuffer = NULL; 19 | LogError("(Error code: %s)", MU_ENUM_TO_STRING(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_INVALID_ARG) ); 20 | } 21 | else 22 | { 23 | /* Codes_SRS_DATA_SERIALIZER_07_009: [DataSerializer_Encode function shall call into the given DATA_SERIALIZER_ENCODE_FUNC callback with a valid BUFFER object and valid MULTITREE_HANDLE object.] */ 24 | pBuffer = encodeFunc(multiTreeHandle, dataType); 25 | if (pBuffer == NULL) 26 | { 27 | /* Codes_SRS_DATA_SERIALIZER_07_010: [Upon a DATA_SERIALIZER_ENCODE_FUNC failure the DataSerializer_Encode function shall return NULL.] */ 28 | LogError("(Error code: %s)", MU_ENUM_TO_STRING(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_ERROR) ); 29 | } 30 | } 31 | /* Codes_SRS_DATA_SERIALIZER_07_002: [DataSerializer_Encode shall return a valid BUFFER_HANDLE when the function executes successfully.] */ 32 | return pBuffer; 33 | } 34 | 35 | MULTITREE_HANDLE DataSerializer_Decode(BUFFER_HANDLE data, DATA_SERIALIZER_DECODE_FUNC decodeFunc) 36 | { 37 | MULTITREE_HANDLE multiTreeHandle; 38 | 39 | /* Codes_SRS_DATA_SERIALIZER_07_007: [NULL shall be returned when an invalid parameter is supplied.] */ 40 | if (data == NULL || decodeFunc == NULL) 41 | { 42 | multiTreeHandle = NULL; 43 | LogError("(Error code: %s)", MU_ENUM_TO_STRING(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_INVALID_ARG) ); 44 | } 45 | else 46 | { 47 | /* Codes_SRS_DATA_SERIALIZER_07_012: [DataSerializer_Decode function shall call into the given DATA_SERIALIZER_DECODE_FUNC callback with a valid BUFFER object and valid MULTITREE_HANDLE object.] */ 48 | multiTreeHandle = decodeFunc(data); 49 | if (multiTreeHandle == NULL) 50 | { 51 | /* Codes_SRS_DATA_SERIALIZER_07_013: [Upon a DATA_SERIALIZER_DECODE_FUNC callback failure the DataSerializer_Encode function Shall return NULL.] */ 52 | LogError("(Error code: %s)", MU_ENUM_TO_STRING(DATA_SERIALIZER_RESULT, DATA_SERIALIZER_ERROR) ); 53 | } 54 | } 55 | 56 | /* Codes_SRS_DATA_SERIALIZER_07_006: [DataSerializer_Decode shall return a valid MULTITREE_HANDLE when the function executes successfully.] */ 57 | return multiTreeHandle; 58 | } 59 | -------------------------------------------------------------------------------- /src/internal/iothub_client_ll_uploadtoblob.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /** @file iothub_client_ll.h 5 | * @brief APIs that allow a user (usually a device) to communicate 6 | * with an Azure IoTHub. 7 | * 8 | * @details IoTHubClient_LL is a module that allows a user (usually a 9 | * device) to communicate with an Azure IoTHub. It can send events 10 | * and receive messages. At any given moment in time there can only 11 | * be at most 1 message callback function. 12 | * 13 | * This API surface contains a set of APIs that allows the user to 14 | * interact with the lower layer portion of the IoTHubClient. These APIs 15 | * contain @c _LL_ in their name, but retain the same functionality like the 16 | * @c IoTHubClient_... APIs, with one difference. If the @c _LL_ APIs are 17 | * used then the user is responsible for scheduling when the actual work done 18 | * by the IoTHubClient happens (when the data is sent/received on/from the wire). 19 | * This is useful for constrained devices where spinning a separate thread is 20 | * often not desired. 21 | */ 22 | 23 | #ifndef DONT_USE_UPLOADTOBLOB 24 | 25 | #ifndef IOTHUB_CLIENT_LL_UPLOADTOBLOB_H 26 | #define IOTHUB_CLIENT_LL_UPLOADTOBLOB_H 27 | 28 | #include "iothub_client_core_ll.h" 29 | #include "internal/iothub_client_authorization.h" 30 | 31 | #include "umock_c/umock_c_prod.h" 32 | #ifdef __cplusplus 33 | #include 34 | extern "C" 35 | { 36 | #else 37 | #include 38 | #endif 39 | 40 | #define BLOCK_SIZE (4*1024*1024) 41 | 42 | typedef struct IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE_DATA* IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE; 43 | 44 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE, IoTHubClient_LL_UploadToBlob_Create, const IOTHUB_CLIENT_CONFIG*, config, IOTHUB_AUTHORIZATION_HANDLE, auth_handle); 45 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClient_LL_UploadToBlob_Impl, IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE, handle, const char*, destinationFileName, const unsigned char*, source, size_t, size); 46 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClient_LL_UploadMultipleBlocksToBlob_Impl, IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE, handle, const char*, destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX, getDataCallbackEx, void*, context); 47 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClient_LL_UploadToBlob_SetOption, IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE, handle, const char*, optionName, const void*, value); 48 | MOCKABLE_FUNCTION(, void, IoTHubClient_LL_UploadToBlob_Destroy, IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE, handle); 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif /* IOTHUB_CLIENT_LL_UPLOADTOBLOB_H */ 55 | 56 | #else 57 | #error "trying to #include iothub_client_ll_uploadtoblob.h in the presence of #define DONT_USE_UPLOADTOBLOB" 58 | #endif /*DONT_USE_UPLOADTOBLOB*/ 59 | -------------------------------------------------------------------------------- /src/datapublisher.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef DATA_PUBLISHER_H 5 | #define DATA_PUBLISHER_H 6 | 7 | #include "agenttypesystem.h" 8 | #include "schema.h" 9 | /* Normally we could include for cpp, but some toolchains are not well behaved and simply don't have it - ARM CC for example */ 10 | #include 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | #define DATA_PUBLISHER_RESULT_VALUES \ 17 | DATA_PUBLISHER_OK, \ 18 | DATA_PUBLISHER_INVALID_ARG, \ 19 | DATA_PUBLISHER_MARSHALLER_ERROR, \ 20 | DATA_PUBLISHER_EMPTY_TRANSACTION, \ 21 | DATA_PUBLISHER_AGENT_DATA_TYPES_ERROR, \ 22 | DATA_PUBLISHER_SCHEMA_FAILED, \ 23 | DATA_PUBLISHER_BUFFER_STORAGE_ERROR, \ 24 | DATA_PUBLISHER_ERROR 25 | 26 | MU_DEFINE_ENUM_WITHOUT_INVALID(DATA_PUBLISHER_RESULT, DATA_PUBLISHER_RESULT_VALUES); 27 | 28 | #include "umock_c/umock_c_prod.h" 29 | 30 | typedef struct TRANSACTION_HANDLE_DATA_TAG* TRANSACTION_HANDLE; 31 | typedef struct REPORTED_PROPERTIES_TRANSACTION_HANDLE_DATA_TAG* REPORTED_PROPERTIES_TRANSACTION_HANDLE; 32 | typedef struct DATA_PUBLISHER_HANDLE_DATA_TAG* DATA_PUBLISHER_HANDLE; 33 | 34 | MOCKABLE_FUNCTION(,DATA_PUBLISHER_HANDLE, DataPublisher_Create, SCHEMA_MODEL_TYPE_HANDLE, modelHandle, bool, includePropertyPath); 35 | MOCKABLE_FUNCTION(,void, DataPublisher_Destroy, DATA_PUBLISHER_HANDLE, dataPublisherHandle); 36 | 37 | MOCKABLE_FUNCTION(,TRANSACTION_HANDLE, DataPublisher_StartTransaction, DATA_PUBLISHER_HANDLE, dataPublisherHandle); 38 | MOCKABLE_FUNCTION(,DATA_PUBLISHER_RESULT, DataPublisher_PublishTransacted, TRANSACTION_HANDLE, transactionHandle, const char*, propertyPath, const AGENT_DATA_TYPE*, data); 39 | MOCKABLE_FUNCTION(,DATA_PUBLISHER_RESULT, DataPublisher_EndTransaction, TRANSACTION_HANDLE, transactionHandle, unsigned char**, destination, size_t*, destinationSize); 40 | MOCKABLE_FUNCTION(,DATA_PUBLISHER_RESULT, DataPublisher_CancelTransaction, TRANSACTION_HANDLE, transactionHandle); 41 | MOCKABLE_FUNCTION(,void, DataPublisher_SetMaxBufferSize, size_t, value); 42 | MOCKABLE_FUNCTION(,size_t, DataPublisher_GetMaxBufferSize); 43 | 44 | MOCKABLE_FUNCTION(, REPORTED_PROPERTIES_TRANSACTION_HANDLE, DataPublisher_CreateTransaction_ReportedProperties, DATA_PUBLISHER_HANDLE, dataPublisherHandle); 45 | MOCKABLE_FUNCTION(, DATA_PUBLISHER_RESULT, DataPublisher_PublishTransacted_ReportedProperty, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle, const char*, reportedPropertyPath, const AGENT_DATA_TYPE*, data); 46 | MOCKABLE_FUNCTION(, DATA_PUBLISHER_RESULT, DataPublisher_CommitTransaction_ReportedProperties, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle, unsigned char**, destination, size_t*, destinationSize); 47 | MOCKABLE_FUNCTION(, void, DataPublisher_DestroyTransaction_ReportedProperties, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle); 48 | 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif /* DATA_PUBLISHER_H */ 55 | -------------------------------------------------------------------------------- /src/azure_umqtt_c/mqttconst.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef MQTTCONST_H 5 | #define MQTTCONST_H 6 | 7 | #include "azure_c_shared_utility/crt_abstractions.h" 8 | #include "azure_macro_utils/macro_utils.h" 9 | 10 | #ifdef __cplusplus 11 | #include 12 | #include 13 | extern "C" { 14 | #else 15 | #include 16 | #include 17 | #endif /* __cplusplus */ 18 | 19 | #define CONTROL_PACKET_TYPE_VALUES \ 20 | CONNECT_TYPE, 0x10, \ 21 | CONNACK_TYPE, 0x20, \ 22 | PUBLISH_TYPE, 0x30, \ 23 | PUBACK_TYPE, 0x40, \ 24 | PUBREC_TYPE, 0x50, \ 25 | PUBREL_TYPE, 0x60, \ 26 | PUBCOMP_TYPE, 0x70, \ 27 | SUBSCRIBE_TYPE, 0x80, \ 28 | SUBACK_TYPE, 0x90, \ 29 | UNSUBSCRIBE_TYPE, 0xA0, \ 30 | UNSUBACK_TYPE, 0xB0, \ 31 | PINGREQ_TYPE, 0xC0, \ 32 | PINGRESP_TYPE, 0xD0, \ 33 | DISCONNECT_TYPE, 0xE0, \ 34 | PACKET_TYPE_ERROR, 0xE1, /* 0xE1 was assigned because ENUM_2 needs it */ \ 35 | UNKNOWN_TYPE, 0xE2 /* 0xE2 was assigned because ENUM_2 needs it */ 36 | 37 | MU_DEFINE_ENUM_2(CONTROL_PACKET_TYPE, CONTROL_PACKET_TYPE_VALUES) 38 | 39 | #define QOS_VALUE_VALUES \ 40 | DELIVER_AT_MOST_ONCE, 0x00, \ 41 | DELIVER_AT_LEAST_ONCE, 0x01, \ 42 | DELIVER_EXACTLY_ONCE, 0x02, \ 43 | DELIVER_FAILURE, 0x80 44 | 45 | MU_DEFINE_ENUM_2(QOS_VALUE, QOS_VALUE_VALUES) 46 | 47 | typedef struct APP_PAYLOAD_TAG 48 | { 49 | uint8_t* message; 50 | size_t length; 51 | } APP_PAYLOAD; 52 | 53 | typedef struct MQTT_CLIENT_OPTIONS_TAG 54 | { 55 | char* clientId; 56 | char* willTopic; 57 | char* willMessage; 58 | char* username; 59 | char* password; 60 | uint16_t keepAliveInterval; 61 | bool messageRetain; 62 | bool useCleanSession; 63 | QOS_VALUE qualityOfServiceValue; 64 | bool log_trace; 65 | } MQTT_CLIENT_OPTIONS; 66 | 67 | typedef enum CONNECT_RETURN_CODE_TAG 68 | { 69 | CONNECTION_ACCEPTED = 0x00, 70 | CONN_REFUSED_UNACCEPTABLE_VERSION = 0x01, 71 | CONN_REFUSED_ID_REJECTED = 0x02, 72 | CONN_REFUSED_SERVER_UNAVAIL = 0x03, 73 | CONN_REFUSED_BAD_USERNAME_PASSWORD = 0x04, 74 | CONN_REFUSED_NOT_AUTHORIZED = 0x05, 75 | CONN_REFUSED_UNKNOWN 76 | } CONNECT_RETURN_CODE; 77 | 78 | typedef struct CONNECT_ACK_TAG 79 | { 80 | bool isSessionPresent; 81 | CONNECT_RETURN_CODE returnCode; 82 | } CONNECT_ACK; 83 | 84 | typedef struct SUBSCRIBE_PAYLOAD_TAG 85 | { 86 | const char* subscribeTopic; 87 | QOS_VALUE qosReturn; 88 | } SUBSCRIBE_PAYLOAD; 89 | 90 | typedef struct SUBSCRIBE_ACK_TAG 91 | { 92 | uint16_t packetId; 93 | QOS_VALUE* qosReturn; 94 | size_t qosCount; 95 | } SUBSCRIBE_ACK; 96 | 97 | typedef struct UNSUBSCRIBE_ACK_TAG 98 | { 99 | uint16_t packetId; 100 | } UNSUBSCRIBE_ACK; 101 | 102 | typedef struct PUBLISH_ACK_TAG 103 | { 104 | uint16_t packetId; 105 | } PUBLISH_ACK; 106 | 107 | #ifdef __cplusplus 108 | } 109 | #endif /* __cplusplus */ 110 | 111 | #endif // MQTTCONST_H 112 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_cbs_auth.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORT_AMQP_CBS_AUTH_H 5 | #define IOTHUBTRANSPORT_AMQP_CBS_AUTH_H 6 | 7 | #include 8 | #include "internal/iothub_transport_ll_private.h" 9 | #include "azure_uamqp_c/cbs.h" 10 | #include "umock_c/umock_c_prod.h" 11 | #include "azure_c_shared_utility/optionhandler.h" 12 | 13 | static const char* AUTHENTICATION_OPTION_SAVED_OPTIONS = "saved_authentication_options"; 14 | static const char* AUTHENTICATION_OPTION_CBS_REQUEST_TIMEOUT_SECS = "cbs_request_timeout_secs"; 15 | 16 | #ifdef __cplusplus 17 | extern "C" 18 | { 19 | #endif 20 | 21 | typedef enum AUTHENTICATION_STATE_TAG 22 | { 23 | AUTHENTICATION_STATE_STOPPED, 24 | AUTHENTICATION_STATE_STARTING, 25 | AUTHENTICATION_STATE_STARTED, 26 | AUTHENTICATION_STATE_ERROR 27 | } AUTHENTICATION_STATE; 28 | 29 | typedef enum AUTHENTICATION_ERROR_TAG 30 | { 31 | AUTHENTICATION_ERROR_AUTH_TIMEOUT, 32 | AUTHENTICATION_ERROR_AUTH_FAILED, 33 | AUTHENTICATION_ERROR_SAS_REFRESH_TIMEOUT, 34 | AUTHENTICATION_ERROR_SAS_REFRESH_FAILED 35 | } AUTHENTICATION_ERROR_CODE; 36 | 37 | typedef void(*ON_AUTHENTICATION_STATE_CHANGED_CALLBACK)(void* context, AUTHENTICATION_STATE previous_state, AUTHENTICATION_STATE new_state); 38 | typedef void(*ON_AUTHENTICATION_ERROR_CALLBACK)(void* context, AUTHENTICATION_ERROR_CODE error_code); 39 | 40 | typedef struct AUTHENTICATION_CONFIG_TAG 41 | { 42 | const char* device_id; 43 | const char* module_id; 44 | char* iothub_host_fqdn; 45 | 46 | ON_AUTHENTICATION_STATE_CHANGED_CALLBACK on_state_changed_callback; 47 | void* on_state_changed_callback_context; 48 | 49 | ON_AUTHENTICATION_ERROR_CALLBACK on_error_callback; 50 | void* on_error_callback_context; 51 | 52 | IOTHUB_AUTHORIZATION_HANDLE authorization_module; // with either SAS Token, x509 Certs, and Device SAS Token 53 | 54 | } AUTHENTICATION_CONFIG; 55 | 56 | typedef struct AUTHENTICATION_INSTANCE* AUTHENTICATION_HANDLE; 57 | 58 | MOCKABLE_FUNCTION(, AUTHENTICATION_HANDLE, authentication_create, const AUTHENTICATION_CONFIG*, config); 59 | MOCKABLE_FUNCTION(, int, authentication_start, AUTHENTICATION_HANDLE, authentication_handle, const CBS_HANDLE, cbs_handle); 60 | MOCKABLE_FUNCTION(, int, authentication_stop, AUTHENTICATION_HANDLE, authentication_handle); 61 | MOCKABLE_FUNCTION(, void, authentication_do_work, AUTHENTICATION_HANDLE, authentication_handle); 62 | MOCKABLE_FUNCTION(, void, authentication_destroy, AUTHENTICATION_HANDLE, authentication_handle); 63 | MOCKABLE_FUNCTION(, int, authentication_set_option, AUTHENTICATION_HANDLE, authentication_handle, const char*, name, void*, value); 64 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, authentication_retrieve_options, AUTHENTICATION_HANDLE, authentication_handle); 65 | 66 | #ifdef __cplusplus 67 | } 68 | #endif 69 | 70 | #endif /*IOTHUBTRANSPORT_AMQP_CBS_AUTH_H*/ 71 | -------------------------------------------------------------------------------- /src/schemalib.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /** @file schemalib.h 5 | * @brief The IoT Hub Serializer APIs allows developers to define models for 6 | * their devices 7 | */ 8 | 9 | #ifndef SCHEMALIB_H 10 | #define SCHEMALIB_H 11 | 12 | #include "azure_macro_utils/macro_utils.h" 13 | #include "azure_c_shared_utility/strings.h" 14 | #include "iotdevice.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | /* Codes_SRS_SCHEMALIB__99_001:[ IoTHubSchema_Client shall expose the following API: ... ] */ 21 | #define SERIALIZER_RESULT_VALUES \ 22 | SERIALIZER_OK, \ 23 | SERIALIZER_INVALID_ARG, \ 24 | SERIALIZER_CODEFIRST_INIT_FAILED, \ 25 | SERIALIZER_SCHEMA_FAILED, \ 26 | SERIALIZER_HTTP_API_INIT_FAILED, \ 27 | SERIALIZER_ALREADY_INIT, \ 28 | SERIALIZER_ERROR, \ 29 | SERIALIZER_NOT_INITIALIZED, \ 30 | SERIALIZER_ALREADY_STARTED, \ 31 | SERIALIZER_DEVICE_CREATE_FAILED, \ 32 | SERIALIZER_GET_MODEL_HANDLE_FAILED, \ 33 | SERIALIZER_SERVICEBUS_FAILED 34 | 35 | /** @brief Enumeration specifying the status of calls to various APIs in this 36 | * module. 37 | */ 38 | MU_DEFINE_ENUM_WITHOUT_INVALID(SERIALIZER_RESULT, SERIALIZER_RESULT_VALUES); 39 | 40 | #define SERIALIZER_CONFIG_VALUES \ 41 | CommandPollingInterval, \ 42 | SerializeDelayedBufferMaxSize 43 | 44 | /** @brief Enumeration specifying the option to set on the serializer when 45 | * calling ::serializer_setconfig. 46 | */ 47 | MU_DEFINE_ENUM_WITHOUT_INVALID(SERIALIZER_CONFIG, SERIALIZER_CONFIG_VALUES); 48 | 49 | /** 50 | * @brief Initializes the library. 51 | * 52 | * @param overrideSchemaNamespace An override schema namespace to use for all 53 | * models. Optional, can be @c NULL. 54 | * 55 | * If @p schemaNamespace is not @c NULL, its value shall be used 56 | * instead of the namespace defined for each model by using the 57 | * @c DECLARE_XXX macro. 58 | * 59 | * @return @c SERIALIZER_OK on success and any other error on failure. 60 | */ 61 | extern SERIALIZER_RESULT serializer_init(const char* overrideSchemaNamespace); 62 | 63 | /** @brief Shuts down the IOT library. 64 | * 65 | * The library will track all created devices and upon a call to 66 | * ::serializer_deinit it will de-initialize all devices. 67 | */ 68 | extern void serializer_deinit(void); 69 | 70 | /** 71 | * @brief Set serializer options. 72 | * 73 | * @param which The option to be set. 74 | * @param value The value to set for the given option. 75 | * 76 | * @return @c SERIALIZER_OK on success and any other error on failure. 77 | */ 78 | extern SERIALIZER_RESULT serializer_setconfig(SERIALIZER_CONFIG which, void* value); 79 | 80 | #ifdef __cplusplus 81 | } 82 | #endif 83 | 84 | #endif /* SCHEMALIB_H */ 85 | -------------------------------------------------------------------------------- /src/azure_umqtt_c/mqtt_client.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef MQTT_CLIENT_H 5 | #define MQTT_CLIENT_H 6 | 7 | #include "azure_c_shared_utility/xio.h" 8 | #include "azure_macro_utils/macro_utils.h" 9 | #include "azure_umqtt_c/mqttconst.h" 10 | #include "azure_umqtt_c/mqtt_message.h" 11 | #include "umock_c/umock_c_prod.h" 12 | 13 | #ifdef __cplusplus 14 | #include 15 | extern "C" { 16 | #else 17 | #include 18 | #endif // __cplusplus 19 | 20 | 21 | typedef struct MQTT_CLIENT_TAG* MQTT_CLIENT_HANDLE; 22 | 23 | #define MQTT_CLIENT_EVENT_VALUES \ 24 | MQTT_CLIENT_ON_CONNACK, \ 25 | MQTT_CLIENT_ON_PUBLISH_ACK, \ 26 | MQTT_CLIENT_ON_PUBLISH_RECV, \ 27 | MQTT_CLIENT_ON_PUBLISH_REL, \ 28 | MQTT_CLIENT_ON_PUBLISH_COMP, \ 29 | MQTT_CLIENT_ON_SUBSCRIBE_ACK, \ 30 | MQTT_CLIENT_ON_UNSUBSCRIBE_ACK, \ 31 | MQTT_CLIENT_ON_PING_RESPONSE, \ 32 | MQTT_CLIENT_ON_DISCONNECT 33 | 34 | MU_DEFINE_ENUM(MQTT_CLIENT_EVENT_RESULT, MQTT_CLIENT_EVENT_VALUES); 35 | 36 | #define MQTT_CLIENT_EVENT_ERROR_VALUES \ 37 | MQTT_CLIENT_CONNECTION_ERROR, \ 38 | MQTT_CLIENT_PARSE_ERROR, \ 39 | MQTT_CLIENT_MEMORY_ERROR, \ 40 | MQTT_CLIENT_COMMUNICATION_ERROR, \ 41 | MQTT_CLIENT_NO_PING_RESPONSE, \ 42 | MQTT_CLIENT_UNKNOWN_ERROR 43 | 44 | MU_DEFINE_ENUM(MQTT_CLIENT_EVENT_ERROR, MQTT_CLIENT_EVENT_ERROR_VALUES); 45 | 46 | typedef void(*ON_MQTT_OPERATION_CALLBACK)(MQTT_CLIENT_HANDLE handle, MQTT_CLIENT_EVENT_RESULT actionResult, const void* msgInfo, void* callbackCtx); 47 | typedef void(*ON_MQTT_ERROR_CALLBACK)(MQTT_CLIENT_HANDLE handle, MQTT_CLIENT_EVENT_ERROR error, void* callbackCtx); 48 | typedef void(*ON_MQTT_MESSAGE_RECV_CALLBACK)(MQTT_MESSAGE_HANDLE msgHandle, void* callbackCtx); 49 | typedef void(*ON_MQTT_DISCONNECTED_CALLBACK)(void* callbackCtx); 50 | 51 | MOCKABLE_FUNCTION(, void, mqtt_client_clear_xio, MQTT_CLIENT_HANDLE, handle); 52 | MOCKABLE_FUNCTION(, MQTT_CLIENT_HANDLE, mqtt_client_init, ON_MQTT_MESSAGE_RECV_CALLBACK, msgRecv, ON_MQTT_OPERATION_CALLBACK, opCallback, void*, opCallbackCtx, ON_MQTT_ERROR_CALLBACK, onErrorCallBack, void*, errorCBCtx); 53 | MOCKABLE_FUNCTION(, void, mqtt_client_deinit, MQTT_CLIENT_HANDLE, handle); 54 | 55 | MOCKABLE_FUNCTION(, int, mqtt_client_connect, MQTT_CLIENT_HANDLE, handle, XIO_HANDLE, xioHandle, MQTT_CLIENT_OPTIONS*, mqttOptions); 56 | MOCKABLE_FUNCTION(, int, mqtt_client_disconnect, MQTT_CLIENT_HANDLE, handle, ON_MQTT_DISCONNECTED_CALLBACK, callback, void*, ctx); 57 | 58 | MOCKABLE_FUNCTION(, int, mqtt_client_subscribe, MQTT_CLIENT_HANDLE, handle, uint16_t, packetId, SUBSCRIBE_PAYLOAD*, subscribeList, size_t, count); 59 | MOCKABLE_FUNCTION(, int, mqtt_client_unsubscribe, MQTT_CLIENT_HANDLE, handle, uint16_t, packetId, const char**, unsubscribeList, size_t, count); 60 | 61 | MOCKABLE_FUNCTION(, int, mqtt_client_publish, MQTT_CLIENT_HANDLE, handle, MQTT_MESSAGE_HANDLE, msgHandle); 62 | 63 | MOCKABLE_FUNCTION(, void, mqtt_client_dowork, MQTT_CLIENT_HANDLE, handle); 64 | 65 | MOCKABLE_FUNCTION(, void, mqtt_client_set_trace, MQTT_CLIENT_HANDLE, handle, bool, traceOn, bool, rawBytesOn); 66 | 67 | #ifdef __cplusplus 68 | } 69 | #endif // __cplusplus 70 | 71 | #endif // MQTTCLIENT_H 72 | -------------------------------------------------------------------------------- /src/internal/iothub_client_authorization.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_CLIENT_AUTHORIZATION_H 5 | #define IOTHUB_CLIENT_AUTHORIZATION_H 6 | 7 | #include "azure_macro_utils/macro_utils.h" 8 | #include "umock_c/umock_c_prod.h" 9 | #include "azure_c_shared_utility/xio.h" 10 | 11 | #ifdef __cplusplus 12 | extern "C" { 13 | #include 14 | #else 15 | #include 16 | #include 17 | #endif /* __cplusplus */ 18 | 19 | typedef struct IOTHUB_AUTHORIZATION_DATA_TAG* IOTHUB_AUTHORIZATION_HANDLE; 20 | 21 | #define IOTHUB_CREDENTIAL_TYPE_VALUES \ 22 | IOTHUB_CREDENTIAL_TYPE_UNKNOWN, \ 23 | IOTHUB_CREDENTIAL_TYPE_DEVICE_KEY, \ 24 | IOTHUB_CREDENTIAL_TYPE_X509, \ 25 | IOTHUB_CREDENTIAL_TYPE_X509_ECC, \ 26 | IOTHUB_CREDENTIAL_TYPE_SAS_TOKEN, \ 27 | IOTHUB_CREDENTIAL_TYPE_DEVICE_AUTH 28 | 29 | 30 | MU_DEFINE_ENUM_WITHOUT_INVALID(IOTHUB_CREDENTIAL_TYPE, IOTHUB_CREDENTIAL_TYPE_VALUES); 31 | 32 | #define SAS_TOKEN_STATUS_VALUES \ 33 | SAS_TOKEN_STATUS_FAILED, \ 34 | SAS_TOKEN_STATUS_VALID, \ 35 | SAS_TOKEN_STATUS_INVALID 36 | 37 | MU_DEFINE_ENUM_WITHOUT_INVALID(SAS_TOKEN_STATUS, SAS_TOKEN_STATUS_VALUES); 38 | 39 | MOCKABLE_FUNCTION(, IOTHUB_AUTHORIZATION_HANDLE, IoTHubClient_Auth_Create, const char*, device_key, const char*, device_id, const char*, device_sas_token, const char *, module_id); 40 | MOCKABLE_FUNCTION(, IOTHUB_AUTHORIZATION_HANDLE, IoTHubClient_Auth_CreateFromDeviceAuth, const char*, device_id, const char*, module_id); 41 | MOCKABLE_FUNCTION(, void, IoTHubClient_Auth_Destroy, IOTHUB_AUTHORIZATION_HANDLE, handle); 42 | MOCKABLE_FUNCTION(, IOTHUB_CREDENTIAL_TYPE, IoTHubClient_Auth_Set_x509_Type, IOTHUB_AUTHORIZATION_HANDLE, handle, bool, enable_x509); 43 | MOCKABLE_FUNCTION(, IOTHUB_CREDENTIAL_TYPE, IoTHubClient_Auth_Get_Credential_Type, IOTHUB_AUTHORIZATION_HANDLE, handle); 44 | MOCKABLE_FUNCTION(, char*, IoTHubClient_Auth_Get_SasToken, IOTHUB_AUTHORIZATION_HANDLE, handle, const char*, scope, size_t, expiry_time_relative_seconds, const char*, key_name); 45 | MOCKABLE_FUNCTION(, int, IoTHubClient_Auth_Set_xio_Certificate, IOTHUB_AUTHORIZATION_HANDLE, handle, XIO_HANDLE, xio); 46 | MOCKABLE_FUNCTION(, const char*, IoTHubClient_Auth_Get_DeviceId, IOTHUB_AUTHORIZATION_HANDLE, handle); 47 | MOCKABLE_FUNCTION(, const char*, IoTHubClient_Auth_Get_ModuleId, IOTHUB_AUTHORIZATION_HANDLE, handle); 48 | MOCKABLE_FUNCTION(, const char*, IoTHubClient_Auth_Get_DeviceKey, IOTHUB_AUTHORIZATION_HANDLE, handle); 49 | MOCKABLE_FUNCTION(, SAS_TOKEN_STATUS, IoTHubClient_Auth_Is_SasToken_Valid, IOTHUB_AUTHORIZATION_HANDLE, handle); 50 | MOCKABLE_FUNCTION(, int, IoTHubClient_Auth_Get_x509_info, IOTHUB_AUTHORIZATION_HANDLE, handle, char**, x509_cert, char**, x509_key); 51 | MOCKABLE_FUNCTION(, int, IoTHubClient_Auth_Set_SasToken_Expiry, IOTHUB_AUTHORIZATION_HANDLE, handle, size_t, expiry_time_seconds); 52 | MOCKABLE_FUNCTION(, size_t, IoTHubClient_Auth_Get_SasToken_Expiry, IOTHUB_AUTHORIZATION_HANDLE, handle); 53 | 54 | 55 | #ifdef USE_EDGE_MODULES 56 | MOCKABLE_FUNCTION(, char*, IoTHubClient_Auth_Get_TrustBundle, IOTHUB_AUTHORIZATION_HANDLE, handle, const char*, certificate_file_name); 57 | #endif 58 | 59 | 60 | #ifdef __cplusplus 61 | } 62 | #endif 63 | 64 | #endif /* IOTHUB_CLIENT_AUTHORIZATION_H */ 65 | -------------------------------------------------------------------------------- /src/iotdevice.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTDEVICE_H 5 | #define IOTDEVICE_H 6 | 7 | #include 8 | #include "azure_macro_utils/macro_utils.h" 9 | #include "schema.h" 10 | #include "datapublisher.h" 11 | #include "commanddecoder.h" 12 | #include "methodreturn.h" 13 | 14 | #ifdef __cplusplus 15 | #include 16 | extern "C" { 17 | #else 18 | #include 19 | #endif 20 | 21 | #define DEVICE_RESULT_VALUES \ 22 | DEVICE_OK, \ 23 | DEVICE_INVALID_ARG, \ 24 | DEVICE_DATA_PUBLISHER_FAILED, \ 25 | DEVICE_COMMAND_DECODER_FAILED, \ 26 | DEVICE_ERROR 27 | 28 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_RESULT, DEVICE_RESULT_VALUES) 29 | 30 | #include "umock_c/umock_c_prod.h" 31 | 32 | typedef struct DEVICE_HANDLE_DATA_TAG* DEVICE_HANDLE; 33 | typedef EXECUTE_COMMAND_RESULT (*pfDeviceActionCallback)(DEVICE_HANDLE deviceHandle, void* callbackUserContext, const char* relativeActionPath, const char* actionName, size_t argCount, const AGENT_DATA_TYPE* args); 34 | typedef METHODRETURN_HANDLE (*pfDeviceMethodCallback)(DEVICE_HANDLE deviceHandle, void* callbackUserContext, const char* relativeMethodPath, const char* methodName, size_t argCount, const AGENT_DATA_TYPE* args); 35 | 36 | MOCKABLE_FUNCTION(,DEVICE_RESULT, Device_Create, SCHEMA_MODEL_TYPE_HANDLE, modelHandle, pfDeviceActionCallback, deviceActionCallback, void*, callbackUserContext, pfDeviceMethodCallback, methodCallback, void*, methodCallbackContext, bool, includePropertyPath, DEVICE_HANDLE*, deviceHandle); 37 | MOCKABLE_FUNCTION(, void, Device_Destroy, DEVICE_HANDLE, deviceHandle); 38 | 39 | MOCKABLE_FUNCTION(,TRANSACTION_HANDLE, Device_StartTransaction, DEVICE_HANDLE, deviceHandle); 40 | MOCKABLE_FUNCTION(,DEVICE_RESULT, Device_PublishTransacted, TRANSACTION_HANDLE, transactionHandle, const char*, propertyPath, const AGENT_DATA_TYPE*, data); 41 | MOCKABLE_FUNCTION(,DEVICE_RESULT, Device_EndTransaction, TRANSACTION_HANDLE, transactionHandle, unsigned char**, destination, size_t*, destinationSize); 42 | MOCKABLE_FUNCTION(,DEVICE_RESULT, Device_CancelTransaction, TRANSACTION_HANDLE, transactionHandle); 43 | 44 | MOCKABLE_FUNCTION(, REPORTED_PROPERTIES_TRANSACTION_HANDLE, Device_CreateTransaction_ReportedProperties, DEVICE_HANDLE, deviceHandle); 45 | MOCKABLE_FUNCTION(, DEVICE_RESULT, Device_PublishTransacted_ReportedProperty, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle, const char*, reportedPropertyPath, const AGENT_DATA_TYPE*, data); 46 | MOCKABLE_FUNCTION(, DEVICE_RESULT, Device_CommitTransaction_ReportedProperties, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle, unsigned char**, destination, size_t*, destinationSize); 47 | MOCKABLE_FUNCTION(, void, Device_DestroyTransaction_ReportedProperties, REPORTED_PROPERTIES_TRANSACTION_HANDLE, transactionHandle); 48 | 49 | MOCKABLE_FUNCTION(, EXECUTE_COMMAND_RESULT, Device_ExecuteCommand, DEVICE_HANDLE, deviceHandle, const char*, command); 50 | MOCKABLE_FUNCTION(, METHODRETURN_HANDLE, Device_ExecuteMethod, DEVICE_HANDLE, deviceHandle, const char*, methodName, const char*, methodPayload); 51 | 52 | MOCKABLE_FUNCTION(, DEVICE_RESULT, Device_IngestDesiredProperties, void*, startAddress, DEVICE_HANDLE, deviceHandle, const char*, jsonPayload, bool, parseDesiredNode); 53 | #ifdef __cplusplus 54 | } 55 | #endif 56 | 57 | #endif /* IOTDEVICE_H */ 58 | 59 | -------------------------------------------------------------------------------- /src/internal/iothub_client_private.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_CLIENT_PRIVATE_H 5 | #define IOTHUB_CLIENT_PRIVATE_H 6 | 7 | #include 8 | 9 | #include "azure_c_shared_utility/constbuffer.h" 10 | #include "azure_c_shared_utility/doublylinkedlist.h" 11 | #include "azure_c_shared_utility/tickcounter.h" 12 | #include "umock_c/umock_c_prod.h" 13 | 14 | #include "iothub_message.h" 15 | #include "internal/iothub_transport_ll_private.h" 16 | #include "iothub_client_core_common.h" 17 | #include "iothub_client_core_ll.h" 18 | 19 | #ifdef USE_EDGE_MODULES 20 | #include "internal/iothub_client_edge.h" 21 | #endif 22 | 23 | #ifdef __cplusplus 24 | extern "C" 25 | { 26 | #endif 27 | 28 | #define CLIENT_DEVICE_TYPE_PREFIX "iothubclient" 29 | #define CLIENT_DEVICE_BACKSLASH "/" 30 | 31 | typedef bool(*IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC_EX)(MESSAGE_CALLBACK_INFO* messageData, void* userContextCallback); 32 | 33 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetMessageCallback_Ex, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC_EX, messageCallback, void*, userContextCallback); 34 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SendMessageDisposition, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, MESSAGE_CALLBACK_INFO*, messageData, IOTHUBMESSAGE_DISPOSITION_RESULT, disposition); 35 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetInputMessageCallbackEx, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, inputName, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC_EX, eventHandlerCallbackEx, void *, userContextCallback, size_t, userContextCallbackLength); 36 | MOCKABLE_FUNCTION(, int, IoTHubClientCore_LL_GetTransportCallbacks, TRANSPORT_CALLBACKS_INFO*, transport_cb); 37 | 38 | #ifdef USE_EDGE_MODULES 39 | /* (Should be replaced after iothub_client refactor)*/ 40 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_EDGE_HANDLE, IoTHubClientCore_LL_GetEdgeHandle, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle); 41 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_GenericMethodInvoke, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, deviceId, const char*, moduleId, const char*, methodName, const char*, methodPayload, unsigned int, timeout, int*, responseStatus, unsigned char**, responsePayload, size_t*, responsePayloadSize); 42 | #endif 43 | 44 | typedef struct IOTHUB_MESSAGE_LIST_TAG 45 | { 46 | IOTHUB_MESSAGE_HANDLE messageHandle; 47 | IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK callback; 48 | void* context; 49 | DLIST_ENTRY entry; 50 | tickcounter_ms_t ms_timesOutAfter; /* a value of "0" means "no timeout", if the IOTHUBCLIENT_LL's handle tickcounter > msTimesOutAfer then the message shall timeout*/ 51 | tickcounter_ms_t message_timeout_value; 52 | }IOTHUB_MESSAGE_LIST; 53 | 54 | typedef struct IOTHUB_DEVICE_TWIN_TAG 55 | { 56 | uint32_t item_id; 57 | tickcounter_ms_t ms_timesOutAfter; /* a value of "0" means "no timeout", if the IOTHUBCLIENT_LL's handle tickcounter > msTimesOutAfer then the message shall timeout*/ 58 | IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reported_state_callback; 59 | CONSTBUFFER_HANDLE report_data_handle; 60 | void* context; 61 | DLIST_ENTRY entry; 62 | IOTHUB_CLIENT_CORE_LL_HANDLE client_handle; 63 | IOTHUB_DEVICE_HANDLE device_handle; 64 | } IOTHUB_DEVICE_TWIN; 65 | 66 | union IOTHUB_IDENTITY_INFO_TAG 67 | { 68 | IOTHUB_DEVICE_TWIN* device_twin; 69 | IOTHUB_MESSAGE_LIST* iothub_message; 70 | }; 71 | 72 | #ifdef __cplusplus 73 | } 74 | #endif 75 | 76 | #endif /* IOTHUB_CLIENT_PRIVATE_H */ 77 | -------------------------------------------------------------------------------- /src/schemalib.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include "azure_c_shared_utility/gballoc.h" 5 | 6 | #include "schemalib.h" 7 | #include "codefirst.h" 8 | #include "schema.h" 9 | #include "datamarshaller.h" 10 | #include "datapublisher.h" 11 | #include 12 | #include "azure_c_shared_utility/xlogging.h" 13 | #include "iotdevice.h" 14 | 15 | #define DEFAULT_CONTAINER_NAME "Container" 16 | 17 | MU_DEFINE_ENUM_STRINGS_WITHOUT_INVALID(SERIALIZER_RESULT, SERIALIZER_RESULT_VALUES); 18 | 19 | typedef enum AGENT_STATE_TAG 20 | { 21 | AGENT_NOT_INITIALIZED, 22 | AGENT_INITIALIZED 23 | } AGENT_STATE; 24 | 25 | static AGENT_STATE g_AgentState = AGENT_NOT_INITIALIZED; 26 | 27 | SERIALIZER_RESULT serializer_init(const char* overrideSchemaNamespace) 28 | { 29 | SERIALIZER_RESULT result; 30 | 31 | /* Codes_SRS_SCHEMALIB_99_074:[serializer_init when already initialized shall return SERIALIZER_ALREADY_INIT.] */ 32 | if (g_AgentState != AGENT_NOT_INITIALIZED) 33 | { 34 | result = SERIALIZER_ALREADY_INIT; 35 | LogError("(result = %s)", MU_ENUM_TO_STRING(SERIALIZER_RESULT, result)); 36 | } 37 | else 38 | { 39 | /* Codes_SRS_SCHEMALIB_99_006:[ Initialize CodeFirst by a call to CodeFirst_Init.] */ 40 | /* Codes_SRS_SCHEMALIB_99_076:[serializer_init shall pass the value of overrideSchemaNamespace argument to CodeFirst_Init.] */ 41 | if (CodeFirst_Init(overrideSchemaNamespace) != CODEFIRST_OK) 42 | { 43 | /* Codes_SRS_SCHEMALIB_99_007:[ On error SERIALIZER_CODEFIRST_INIT_FAILED shall be returned.] */ 44 | result = SERIALIZER_CODEFIRST_INIT_FAILED; 45 | LogError("(result = %s)", MU_ENUM_TO_STRING(SERIALIZER_RESULT, result)); 46 | } 47 | else 48 | { 49 | /* Codes_SRS_SCHEMALIB_99_075:[When an serializer_init call fails for any reason the previous initialization state shall be preserved. The initialized state shall only be changed on a succesfull Init.] */ 50 | g_AgentState = AGENT_INITIALIZED; 51 | 52 | /* Codes_SRS_SCHEMALIB_99_073:[On success serializer_init shall return SERIALIZER_OK.] */ 53 | result = SERIALIZER_OK; 54 | } 55 | } 56 | 57 | return result; 58 | } 59 | 60 | void serializer_deinit(void) 61 | { 62 | /* Codes_SRS_SCHEMALIB_99_025:[ serializer_deinit shall de-initialize all modules initialized by serializer_init.] */ 63 | if (g_AgentState == AGENT_INITIALIZED) 64 | { 65 | CodeFirst_Deinit(); 66 | } 67 | 68 | /* Codes_SRS_SCHEMALIB_99_026:[ A subsequent call to serializer_start shall succeed.] */ 69 | g_AgentState = AGENT_NOT_INITIALIZED; 70 | } 71 | 72 | SERIALIZER_RESULT serializer_setconfig(SERIALIZER_CONFIG which, void* value) 73 | { 74 | SERIALIZER_RESULT result; 75 | 76 | /* Codes_SRS_SCHEMALIB_99_137:[ If the value argument is NULL, serializer_setconfig shall return SERIALIZER_INVALID_ARG.] */ 77 | if (value == NULL) 78 | { 79 | result = SERIALIZER_INVALID_ARG; 80 | } 81 | /* Codes_SRS_SCHEMALIB_99_142:[ When the which argument is SerializeDelayedBufferMaxSize, serializer_setconfig shall invoke DataPublisher_SetMaxBufferSize with the dereferenced value argument, and shall return SERIALIZER_OK.] */ 82 | else if (which == SerializeDelayedBufferMaxSize) 83 | { 84 | DataPublisher_SetMaxBufferSize(*(size_t*)value); 85 | result = SERIALIZER_OK; 86 | } 87 | /* Codes_SRS_SCHEMALIB_99_138:[ If the which argument is not one of the declared members of the SERIALIZER_CONFIG enum, serializer_setconfig shall return SERIALIZER_INVALID_ARG.] */ 88 | else 89 | { 90 | result = SERIALIZER_INVALID_ARG; 91 | } 92 | 93 | return result; 94 | } 95 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_common.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTAMQP_COMMON_H 5 | #define IOTHUBTRANSPORTAMQP_COMMON_H 6 | 7 | #include "azure_c_shared_utility/strings.h" 8 | #include "umock_c/umock_c_prod.h" 9 | #include "internal/iothub_transport_ll_private.h" 10 | 11 | #ifdef __cplusplus 12 | extern "C" 13 | { 14 | #endif 15 | 16 | typedef struct AMQP_TRANSPORT_PROXY_OPTIONS_TAG 17 | { 18 | const char* host_address; 19 | int port; 20 | const char* username; 21 | const char* password; 22 | } AMQP_TRANSPORT_PROXY_OPTIONS; 23 | 24 | typedef XIO_HANDLE(*AMQP_GET_IO_TRANSPORT)(const char* target_fqdn, const AMQP_TRANSPORT_PROXY_OPTIONS* amqp_transport_proxy_options); 25 | 26 | MOCKABLE_FUNCTION(, TRANSPORT_LL_HANDLE, IoTHubTransport_AMQP_Common_Create, const IOTHUBTRANSPORT_CONFIG*, config, AMQP_GET_IO_TRANSPORT, get_io_transport, TRANSPORT_CALLBACKS_INFO*, cb_info, void*, ctx); 27 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_Destroy, TRANSPORT_LL_HANDLE, handle); 28 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_Subscribe, IOTHUB_DEVICE_HANDLE, handle); 29 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_Unsubscribe, IOTHUB_DEVICE_HANDLE, handle); 30 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_Subscribe_DeviceTwin, IOTHUB_DEVICE_HANDLE, handle); 31 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_Unsubscribe_DeviceTwin, IOTHUB_DEVICE_HANDLE, handle); 32 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_AMQP_Common_GetTwinAsync, IOTHUB_DEVICE_HANDLE, handle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, completionCallback, void*, callbackContext); 33 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_Subscribe_DeviceMethod, IOTHUB_DEVICE_HANDLE, handle); 34 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_Unsubscribe_DeviceMethod, IOTHUB_DEVICE_HANDLE, handle); 35 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_DeviceMethod_Response, IOTHUB_DEVICE_HANDLE, handle, METHOD_HANDLE, methodId, const unsigned char*, response, size_t, response_size, int, status_response); 36 | MOCKABLE_FUNCTION(, IOTHUB_PROCESS_ITEM_RESULT, IoTHubTransport_AMQP_Common_ProcessItem, TRANSPORT_LL_HANDLE, handle, IOTHUB_IDENTITY_TYPE, item_type, IOTHUB_IDENTITY_INFO*, iothub_item); 37 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_DoWork, TRANSPORT_LL_HANDLE, handle); 38 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_SetRetryPolicy, TRANSPORT_LL_HANDLE, handle, IOTHUB_CLIENT_RETRY_POLICY, retryPolicy, size_t, retryTimeoutLimitInSeconds); 39 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_AMQP_Common_GetSendStatus, IOTHUB_DEVICE_HANDLE, handle, IOTHUB_CLIENT_STATUS*, iotHubClientStatus); 40 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_AMQP_Common_SetOption, TRANSPORT_LL_HANDLE, handle, const char*, option, const void*, value); 41 | MOCKABLE_FUNCTION(, IOTHUB_DEVICE_HANDLE, IoTHubTransport_AMQP_Common_Register, TRANSPORT_LL_HANDLE, handle, const IOTHUB_DEVICE_CONFIG*, device, PDLIST_ENTRY, waitingToSend); 42 | MOCKABLE_FUNCTION(, void, IoTHubTransport_AMQP_Common_Unregister, IOTHUB_DEVICE_HANDLE, deviceHandle); 43 | MOCKABLE_FUNCTION(, STRING_HANDLE, IoTHubTransport_AMQP_Common_GetHostname, TRANSPORT_LL_HANDLE, handle); 44 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_AMQP_Common_SendMessageDisposition, MESSAGE_CALLBACK_INFO*, message_data, IOTHUBMESSAGE_DISPOSITION_RESULT, disposition); 45 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_SetCallbackContext, TRANSPORT_LL_HANDLE, handle, void*, ctx); 46 | MOCKABLE_FUNCTION(, int, IoTHubTransport_AMQP_Common_GetSupportedPlatformInfo, TRANSPORT_LL_HANDLE, handle, PLATFORM_INFO_OPTION*, info); 47 | 48 | #ifdef __cplusplus 49 | } 50 | #endif 51 | 52 | #endif /* IOTHUBTRANSPORTAMQP_COMMON_H */ 53 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_mqtt_common.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORT_MQTT_COMMON_H 5 | #define IOTHUBTRANSPORT_MQTT_COMMON_H 6 | 7 | #include "internal/iothub_transport_ll_private.h" 8 | #include "umock_c/umock_c_prod.h" 9 | 10 | #ifdef __cplusplus 11 | extern "C" 12 | { 13 | #include 14 | #else 15 | #include 16 | #endif 17 | 18 | typedef struct MQTT_TRANSPORT_PROXY_OPTIONS_TAG 19 | { 20 | const char* host_address; 21 | int port; 22 | const char* username; 23 | const char* password; 24 | } MQTT_TRANSPORT_PROXY_OPTIONS; 25 | 26 | typedef XIO_HANDLE(*MQTT_GET_IO_TRANSPORT)(const char* fully_qualified_name, const MQTT_TRANSPORT_PROXY_OPTIONS* mqtt_transport_proxy_options); 27 | 28 | MOCKABLE_FUNCTION(, TRANSPORT_LL_HANDLE, IoTHubTransport_MQTT_Common_Create, const IOTHUBTRANSPORT_CONFIG*, config, MQTT_GET_IO_TRANSPORT, get_io_transport, TRANSPORT_CALLBACKS_INFO*, cb_info, void*, ctx); 29 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Destroy, TRANSPORT_LL_HANDLE, handle); 30 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_Subscribe, TRANSPORT_LL_HANDLE, handle); 31 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Unsubscribe, TRANSPORT_LL_HANDLE, handle); 32 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_Subscribe_DeviceTwin, TRANSPORT_LL_HANDLE, handle); 33 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_MQTT_Common_GetTwinAsync, IOTHUB_DEVICE_HANDLE, handle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, completionCallback, void*, callbackContext); 34 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Unsubscribe_DeviceTwin, TRANSPORT_LL_HANDLE, handle); 35 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_Subscribe_DeviceMethod, TRANSPORT_LL_HANDLE, handle); 36 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Unsubscribe_DeviceMethod, TRANSPORT_LL_HANDLE, handle); 37 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_DeviceMethod_Response, TRANSPORT_LL_HANDLE, handle, METHOD_HANDLE, methodId, const unsigned char*, response, size_t, response_size, int, status_response); 38 | MOCKABLE_FUNCTION(, IOTHUB_PROCESS_ITEM_RESULT, IoTHubTransport_MQTT_Common_ProcessItem, TRANSPORT_LL_HANDLE, handle, IOTHUB_IDENTITY_TYPE, item_type, IOTHUB_IDENTITY_INFO*, iothub_item); 39 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_DoWork, TRANSPORT_LL_HANDLE, handle); 40 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_MQTT_Common_GetSendStatus, TRANSPORT_LL_HANDLE, handle, IOTHUB_CLIENT_STATUS*, iotHubClientStatus); 41 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_MQTT_Common_SetOption, TRANSPORT_LL_HANDLE, handle, const char*, option, const void*, value); 42 | MOCKABLE_FUNCTION(, TRANSPORT_LL_HANDLE, IoTHubTransport_MQTT_Common_Register, TRANSPORT_LL_HANDLE, handle, const IOTHUB_DEVICE_CONFIG*, device, PDLIST_ENTRY, waitingToSend); 43 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Unregister, TRANSPORT_LL_HANDLE, deviceHandle); 44 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_SetRetryPolicy, TRANSPORT_LL_HANDLE, handle, IOTHUB_CLIENT_RETRY_POLICY, retryPolicy, size_t, retryTimeoutLimitInSeconds); 45 | MOCKABLE_FUNCTION(, STRING_HANDLE, IoTHubTransport_MQTT_Common_GetHostname, TRANSPORT_LL_HANDLE, handle); 46 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubTransport_MQTT_Common_SendMessageDisposition, MESSAGE_CALLBACK_INFO*, message_data, IOTHUBMESSAGE_DISPOSITION_RESULT, disposition); 47 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_Common_Subscribe_InputQueue, TRANSPORT_LL_HANDLE, handle); 48 | MOCKABLE_FUNCTION(, void, IoTHubTransport_MQTT_Common_Unsubscribe_InputQueue, TRANSPORT_LL_HANDLE, handle); 49 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_SetCallbackContext, TRANSPORT_LL_HANDLE, handle, void*, ctx); 50 | MOCKABLE_FUNCTION(, int, IoTHubTransport_MQTT_GetSupportedPlatformInfo, TRANSPORT_LL_HANDLE, handle, PLATFORM_INFO_OPTION*, info); 51 | 52 | #ifdef __cplusplus 53 | } 54 | #endif 55 | 56 | #endif /* IOTHUBTRANSPORT_MQTT_COMMON_H */ 57 | -------------------------------------------------------------------------------- /src/methodreturn.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include 6 | 7 | #include "azure_c_shared_utility/gballoc.h" 8 | #include "azure_c_shared_utility/xlogging.h" 9 | #include "azure_c_shared_utility/crt_abstractions.h" 10 | #include "azure_c_shared_utility/strings.h" 11 | #include "parson.h" 12 | 13 | #include "methodreturn.h" 14 | 15 | typedef struct METHODRETURN_HANDLE_DATA_TAG 16 | { 17 | METHODRETURN_DATA data; 18 | }METHODRETURN_HANDLE_DATA; 19 | 20 | bool is_json_present_and_unparsable(const char* jsonValue) 21 | { 22 | bool is_present_and_unparsable; 23 | if (jsonValue == NULL) 24 | { 25 | // Null json is not considered invalid here 26 | is_present_and_unparsable = false; 27 | } 28 | else 29 | { 30 | JSON_Value* temp = json_parse_string(jsonValue); 31 | if (temp == NULL) 32 | { 33 | is_present_and_unparsable = true; 34 | } 35 | else 36 | { 37 | json_value_free(temp); 38 | is_present_and_unparsable = false; 39 | } 40 | } 41 | return is_present_and_unparsable; 42 | } 43 | 44 | METHODRETURN_HANDLE MethodReturn_Create(int statusCode, const char* jsonValue) 45 | { 46 | METHODRETURN_HANDLE result; 47 | /*Codes_SRS_METHODRETURN_02_009: [ If jsonValue is not a JSON value then MethodReturn_Create shall fail and return NULL. ]*/ 48 | if (is_json_present_and_unparsable(jsonValue)) 49 | { 50 | LogError("%s is not JSON", jsonValue); 51 | result = NULL; 52 | } 53 | else 54 | { 55 | result = (METHODRETURN_HANDLE_DATA*)calloc(1, sizeof(METHODRETURN_HANDLE_DATA)); 56 | if (result == NULL) 57 | { 58 | /*Codes_SRS_METHODRETURN_02_002: [ If any failure is encountered then MethodReturn_Create shall return NULL ]*/ 59 | LogError("unable to malloc"); 60 | /*return as is*/ 61 | } 62 | else 63 | { 64 | if (jsonValue == NULL) 65 | { 66 | /*Codes_SRS_METHODRETURN_02_001: [ MethodReturn_Create shall create a non-NULL handle containing statusCode and a clone of jsonValue. ]*/ 67 | result->data.jsonValue = NULL; 68 | result->data.statusCode = statusCode; 69 | } 70 | else 71 | { 72 | if (mallocAndStrcpy_s(&(result->data.jsonValue), jsonValue) != 0) 73 | { 74 | LogError("failure in mallocAndStrcpy_s"); 75 | free(result); 76 | result = NULL; 77 | } 78 | else 79 | { 80 | /*Codes_SRS_METHODRETURN_02_001: [ MethodReturn_Create shall create a non-NULL handle containing statusCode and a clone of jsonValue. ]*/ 81 | result->data.statusCode = statusCode; 82 | } 83 | } 84 | } 85 | } 86 | 87 | return result; 88 | } 89 | 90 | void MethodReturn_Destroy(METHODRETURN_HANDLE handle) 91 | { 92 | if (handle == NULL) 93 | { 94 | /*Codes_SRS_METHODRETURN_02_003: [ If handle is NULL then MethodReturn_Destroy shall return. ]*/ 95 | LogError("invalid argument METHODRETURN_HANDLE handle=%p", handle); 96 | } 97 | else 98 | { 99 | /*Codes_SRS_METHODRETURN_02_004: [ Otherwise, MethodReturn_Destroy shall free all used resources by handle. ]*/ 100 | if (handle->data.jsonValue != NULL) 101 | { 102 | free(handle->data.jsonValue); 103 | } 104 | free(handle); 105 | } 106 | } 107 | 108 | 109 | const METHODRETURN_DATA* MethodReturn_GetReturn(METHODRETURN_HANDLE handle) 110 | { 111 | const METHODRETURN_DATA* result; 112 | if (handle == NULL) 113 | { 114 | /*Codes_SRS_METHODRETURN_02_010: [ If handle is NULL then MethodReturn_GetReturn shall fail and return NULL. ]*/ 115 | result = NULL; 116 | } 117 | else 118 | { 119 | /*Codes_SRS_METHODRETURN_02_011: [ Otherwise, MethodReturn_GetReturn shall return a non-NULL const pointer to a METHODRETURN_DATA. ]*/ 120 | result = &(handle->data); 121 | } 122 | return result; 123 | } 124 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_twin_messenger.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORT_AMQP_TWIN_MESSENGER 5 | #define IOTHUBTRANSPORT_AMQP_TWIN_MESSENGER 6 | 7 | #include "azure_macro_utils/macro_utils.h" 8 | #include "umock_c/umock_c_prod.h" 9 | #include "azure_c_shared_utility/optionhandler.h" 10 | #include "azure_uamqp_c/session.h" 11 | #include "iothub_client_private.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" 15 | { 16 | #endif 17 | 18 | typedef struct TWIN_MESSENGER_INSTANCE* TWIN_MESSENGER_HANDLE; 19 | 20 | #define TWIN_MESSENGER_SEND_STATUS_VALUES \ 21 | TWIN_MESSENGER_SEND_STATUS_IDLE, \ 22 | TWIN_MESSENGER_SEND_STATUS_BUSY 23 | 24 | MU_DEFINE_ENUM_WITHOUT_INVALID(TWIN_MESSENGER_SEND_STATUS, TWIN_MESSENGER_SEND_STATUS_VALUES); 25 | 26 | #define TWIN_REPORT_STATE_RESULT_VALUES \ 27 | TWIN_REPORT_STATE_RESULT_SUCCESS, \ 28 | TWIN_REPORT_STATE_RESULT_ERROR, \ 29 | TWIN_REPORT_STATE_RESULT_CANCELLED 30 | 31 | MU_DEFINE_ENUM_WITHOUT_INVALID(TWIN_REPORT_STATE_RESULT, TWIN_REPORT_STATE_RESULT_VALUES); 32 | 33 | #define TWIN_REPORT_STATE_REASON_VALUES \ 34 | TWIN_REPORT_STATE_REASON_NONE, \ 35 | TWIN_REPORT_STATE_REASON_INTERNAL_ERROR, \ 36 | TWIN_REPORT_STATE_REASON_FAIL_SENDING, \ 37 | TWIN_REPORT_STATE_REASON_TIMEOUT, \ 38 | TWIN_REPORT_STATE_REASON_INVALID_RESPONSE, \ 39 | TWIN_REPORT_STATE_REASON_MESSENGER_DESTROYED 40 | 41 | MU_DEFINE_ENUM_WITHOUT_INVALID(TWIN_REPORT_STATE_REASON, TWIN_REPORT_STATE_REASON_VALUES); 42 | 43 | #define TWIN_MESSENGER_STATE_VALUES \ 44 | TWIN_MESSENGER_STATE_STARTING, \ 45 | TWIN_MESSENGER_STATE_STARTED, \ 46 | TWIN_MESSENGER_STATE_STOPPING, \ 47 | TWIN_MESSENGER_STATE_STOPPED, \ 48 | TWIN_MESSENGER_STATE_ERROR 49 | 50 | MU_DEFINE_ENUM_WITHOUT_INVALID(TWIN_MESSENGER_STATE, TWIN_MESSENGER_STATE_VALUES); 51 | 52 | #define TWIN_UPDATE_TYPE_VALUES \ 53 | TWIN_UPDATE_TYPE_PARTIAL, \ 54 | TWIN_UPDATE_TYPE_COMPLETE 55 | 56 | MU_DEFINE_ENUM_WITHOUT_INVALID(TWIN_UPDATE_TYPE, TWIN_UPDATE_TYPE_VALUES); 57 | 58 | typedef void(*TWIN_MESSENGER_STATE_CHANGED_CALLBACK)(void* context, TWIN_MESSENGER_STATE previous_state, TWIN_MESSENGER_STATE new_state); 59 | typedef void(*TWIN_MESSENGER_REPORT_STATE_COMPLETE_CALLBACK)(TWIN_REPORT_STATE_RESULT result, TWIN_REPORT_STATE_REASON reason, int status_code, const void* context); 60 | typedef void(*TWIN_STATE_UPDATE_CALLBACK)(TWIN_UPDATE_TYPE update_type, const char* payload, size_t size, const void* context); 61 | 62 | typedef struct TWIN_MESSENGER_CONFIG_TAG 63 | { 64 | pfTransport_GetOption_Product_Info_Callback prod_info_cb; 65 | void* prod_info_ctx; 66 | const char* device_id; 67 | const char* module_id; 68 | char* iothub_host_fqdn; 69 | TWIN_MESSENGER_STATE_CHANGED_CALLBACK on_state_changed_callback; 70 | void* on_state_changed_context; 71 | } TWIN_MESSENGER_CONFIG; 72 | 73 | MOCKABLE_FUNCTION(, TWIN_MESSENGER_HANDLE, twin_messenger_create, const TWIN_MESSENGER_CONFIG*, messenger_config); 74 | MOCKABLE_FUNCTION(, int, twin_messenger_report_state_async, TWIN_MESSENGER_HANDLE, twin_msgr_handle, CONSTBUFFER_HANDLE, data, TWIN_MESSENGER_REPORT_STATE_COMPLETE_CALLBACK, on_report_state_complete_callback, const void*, context); 75 | MOCKABLE_FUNCTION(, int, twin_messenger_subscribe, TWIN_MESSENGER_HANDLE, twin_msgr_handle, TWIN_STATE_UPDATE_CALLBACK, on_twin_state_update_callback, void*, context); 76 | MOCKABLE_FUNCTION(, int, twin_messenger_unsubscribe, TWIN_MESSENGER_HANDLE, twin_msgr_handle); 77 | MOCKABLE_FUNCTION(, int, twin_messenger_get_twin_async, TWIN_MESSENGER_HANDLE, twin_msgr_handle, TWIN_STATE_UPDATE_CALLBACK, on_get_twin_completed_callback, void*, context); 78 | MOCKABLE_FUNCTION(, int, twin_messenger_get_send_status, TWIN_MESSENGER_HANDLE, twin_msgr_handle, TWIN_MESSENGER_SEND_STATUS*, send_status); 79 | MOCKABLE_FUNCTION(, int, twin_messenger_start, TWIN_MESSENGER_HANDLE, twin_msgr_handle, SESSION_HANDLE, session_handle); 80 | MOCKABLE_FUNCTION(, int, twin_messenger_stop, TWIN_MESSENGER_HANDLE, twin_msgr_handle); 81 | MOCKABLE_FUNCTION(, void, twin_messenger_do_work, TWIN_MESSENGER_HANDLE, twin_msgr_handle); 82 | MOCKABLE_FUNCTION(, void, twin_messenger_destroy, TWIN_MESSENGER_HANDLE, twin_msgr_handle); 83 | MOCKABLE_FUNCTION(, int, twin_messenger_set_option, TWIN_MESSENGER_HANDLE, twin_msgr_handle, const char*, name, void*, value); 84 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, twin_messenger_retrieve_options, TWIN_MESSENGER_HANDLE, twin_msgr_handle); 85 | 86 | #ifdef __cplusplus 87 | } 88 | #endif 89 | 90 | #endif /*IOTHUBTRANSPORT_AMQP_TWIN_MESSENGER*/ 91 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_telemetry_messenger.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORT_AMQP_TELEMETRY_MESSENGER 5 | #define IOTHUBTRANSPORT_AMQP_TELEMETRY_MESSENGER 6 | 7 | #include "umock_c/umock_c_prod.h" 8 | #include "azure_c_shared_utility/optionhandler.h" 9 | #include "azure_uamqp_c/session.h" 10 | 11 | #include "azure_uamqp_c/amqp_definitions_sequence_no.h" 12 | #include "azure_uamqp_c/amqp_definitions_delivery_number.h" 13 | 14 | #include "iothub_client_private.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" 18 | { 19 | #endif 20 | 21 | 22 | static const char* TELEMETRY_MESSENGER_OPTION_EVENT_SEND_TIMEOUT_SECS = "telemetry_event_send_timeout_secs"; 23 | static const char* TELEMETRY_MESSENGER_OPTION_SAVED_OPTIONS = "saved_telemetry_messenger_options"; 24 | 25 | typedef struct TELEMETRY_MESSENGER_INSTANCE* TELEMETRY_MESSENGER_HANDLE; 26 | 27 | typedef enum TELEMETRY_MESSENGER_SEND_STATUS_TAG 28 | { 29 | TELEMETRY_MESSENGER_SEND_STATUS_IDLE, 30 | TELEMETRY_MESSENGER_SEND_STATUS_BUSY 31 | } TELEMETRY_MESSENGER_SEND_STATUS; 32 | 33 | typedef enum TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_TAG 34 | { 35 | TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_OK, 36 | TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_ERROR_CANNOT_PARSE, 37 | TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_ERROR_FAIL_SENDING, 38 | TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_ERROR_TIMEOUT, 39 | TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT_MESSENGER_DESTROYED 40 | } TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT; 41 | 42 | typedef enum TELEMETRY_MESSENGER_DISPOSITION_RESULT_TAG 43 | { 44 | TELEMETRY_MESSENGER_DISPOSITION_RESULT_NONE, 45 | TELEMETRY_MESSENGER_DISPOSITION_RESULT_ACCEPTED, 46 | TELEMETRY_MESSENGER_DISPOSITION_RESULT_REJECTED, 47 | TELEMETRY_MESSENGER_DISPOSITION_RESULT_RELEASED 48 | } TELEMETRY_MESSENGER_DISPOSITION_RESULT; 49 | 50 | typedef enum TELEMETRY_MESSENGER_STATE_TAG 51 | { 52 | TELEMETRY_MESSENGER_STATE_STARTING, 53 | TELEMETRY_MESSENGER_STATE_STARTED, 54 | TELEMETRY_MESSENGER_STATE_STOPPING, 55 | TELEMETRY_MESSENGER_STATE_STOPPED, 56 | TELEMETRY_MESSENGER_STATE_ERROR 57 | } TELEMETRY_MESSENGER_STATE; 58 | 59 | typedef struct TELEMETRY_MESSENGER_MESSAGE_DISPOSITION_INFO_TAG 60 | { 61 | delivery_number message_id; 62 | char* source; 63 | } TELEMETRY_MESSENGER_MESSAGE_DISPOSITION_INFO; 64 | 65 | typedef void(*ON_TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE)(IOTHUB_MESSAGE_LIST* iothub_message_list, TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE_RESULT messenger_event_send_complete_result, void* context); 66 | typedef void(*ON_TELEMETRY_MESSENGER_STATE_CHANGED_CALLBACK)(void* context, TELEMETRY_MESSENGER_STATE previous_state, TELEMETRY_MESSENGER_STATE new_state); 67 | typedef TELEMETRY_MESSENGER_DISPOSITION_RESULT(*ON_TELEMETRY_MESSENGER_MESSAGE_RECEIVED)(IOTHUB_MESSAGE_HANDLE message, TELEMETRY_MESSENGER_MESSAGE_DISPOSITION_INFO* disposition_info, void* context); 68 | 69 | typedef struct TELEMETRY_MESSENGER_CONFIG_TAG 70 | { 71 | const char* device_id; 72 | const char* module_id; 73 | char* iothub_host_fqdn; 74 | ON_TELEMETRY_MESSENGER_STATE_CHANGED_CALLBACK on_state_changed_callback; 75 | void* on_state_changed_context; 76 | } TELEMETRY_MESSENGER_CONFIG; 77 | 78 | #define AMQP_BATCHING_RESERVE_SIZE (1024) 79 | 80 | MOCKABLE_FUNCTION(, TELEMETRY_MESSENGER_HANDLE, telemetry_messenger_create, const TELEMETRY_MESSENGER_CONFIG*, messenger_config, pfTransport_GetOption_Product_Info_Callback, prod_info_cb, void*, prod_info_ctx); 81 | MOCKABLE_FUNCTION(, int, telemetry_messenger_send_async, TELEMETRY_MESSENGER_HANDLE, messenger_handle, IOTHUB_MESSAGE_LIST*, message, ON_TELEMETRY_MESSENGER_EVENT_SEND_COMPLETE, on_messenger_event_send_complete_callback, void*, context); 82 | MOCKABLE_FUNCTION(, int, telemetry_messenger_subscribe_for_messages, TELEMETRY_MESSENGER_HANDLE, messenger_handle, ON_TELEMETRY_MESSENGER_MESSAGE_RECEIVED, on_message_received_callback, void*, context); 83 | MOCKABLE_FUNCTION(, int, telemetry_messenger_unsubscribe_for_messages, TELEMETRY_MESSENGER_HANDLE, messenger_handle); 84 | MOCKABLE_FUNCTION(, int, telemetry_messenger_send_message_disposition, TELEMETRY_MESSENGER_HANDLE, messenger_handle, TELEMETRY_MESSENGER_MESSAGE_DISPOSITION_INFO*, disposition_info, TELEMETRY_MESSENGER_DISPOSITION_RESULT, disposition_result); 85 | MOCKABLE_FUNCTION(, int, telemetry_messenger_get_send_status, TELEMETRY_MESSENGER_HANDLE, messenger_handle, TELEMETRY_MESSENGER_SEND_STATUS*, send_status); 86 | MOCKABLE_FUNCTION(, int, telemetry_messenger_start, TELEMETRY_MESSENGER_HANDLE, messenger_handle, SESSION_HANDLE, session_handle); 87 | MOCKABLE_FUNCTION(, int, telemetry_messenger_stop, TELEMETRY_MESSENGER_HANDLE, messenger_handle); 88 | MOCKABLE_FUNCTION(, void, telemetry_messenger_do_work, TELEMETRY_MESSENGER_HANDLE, messenger_handle); 89 | MOCKABLE_FUNCTION(, void, telemetry_messenger_destroy, TELEMETRY_MESSENGER_HANDLE, messenger_handle); 90 | MOCKABLE_FUNCTION(, int, telemetry_messenger_set_option, TELEMETRY_MESSENGER_HANDLE, messenger_handle, const char*, name, void*, value); 91 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, telemetry_messenger_retrieve_options, TELEMETRY_MESSENGER_HANDLE, messenger_handle); 92 | 93 | 94 | #ifdef __cplusplus 95 | } 96 | #endif 97 | 98 | #endif /*IOTHUBTRANSPORT_AMQP_TELEMETRY_MESSENGER*/ 99 | -------------------------------------------------------------------------------- /src/iothub_client_options.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUB_CLIENT_OPTIONS_H 5 | #define IOTHUB_CLIENT_OPTIONS_H 6 | 7 | #include "azure_c_shared_utility/const_defines.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" 11 | { 12 | #endif 13 | 14 | typedef struct IOTHUB_PROXY_OPTIONS_TAG 15 | { 16 | const char* host_address; 17 | const char* username; 18 | const char* password; 19 | } IOTHUB_PROXY_OPTIONS; 20 | 21 | static STATIC_VAR_UNUSED const char* OPTION_RETRY_INTERVAL_SEC = "retry_interval_sec"; 22 | static STATIC_VAR_UNUSED const char* OPTION_RETRY_MAX_DELAY_SECS = "retry_max_delay_secs"; 23 | 24 | static STATIC_VAR_UNUSED const char* OPTION_LOG_TRACE = "logtrace"; 25 | static STATIC_VAR_UNUSED const char* OPTION_X509_CERT = "x509certificate"; 26 | static STATIC_VAR_UNUSED const char* OPTION_X509_PRIVATE_KEY = "x509privatekey"; 27 | static STATIC_VAR_UNUSED const char* OPTION_KEEP_ALIVE = "keepalive"; 28 | static STATIC_VAR_UNUSED const char* OPTION_CONNECTION_TIMEOUT = "connect_timeout"; 29 | 30 | /* None of the OPTION_PROXY_* options below are implemented. Use OPTION_HTTP_PROXY 31 | from shared_util_options.h in https://github.com/Azure/azure-c-shared-utility/ repo instead */ 32 | static STATIC_VAR_UNUSED const char* OPTION_PROXY_HOST = "proxy_address"; 33 | static STATIC_VAR_UNUSED const char* OPTION_PROXY_USERNAME = "proxy_username"; 34 | static STATIC_VAR_UNUSED const char* OPTION_PROXY_PASSWORD = "proxy_password"; 35 | 36 | static STATIC_VAR_UNUSED const char* OPTION_SAS_TOKEN_LIFETIME = "sas_token_lifetime"; 37 | static STATIC_VAR_UNUSED const char* OPTION_SAS_TOKEN_REFRESH_TIME = "sas_token_refresh_time"; 38 | static STATIC_VAR_UNUSED const char* OPTION_CBS_REQUEST_TIMEOUT = "cbs_request_timeout"; 39 | 40 | static STATIC_VAR_UNUSED const char* OPTION_MIN_POLLING_TIME = "MinimumPollingTime"; 41 | static STATIC_VAR_UNUSED const char* OPTION_BATCHING = "Batching"; 42 | 43 | /* DEPRECATED:: OPTION_MESSAGE_TIMEOUT is DEPRECATED! Use OPTION_SERVICE_SIDE_KEEP_ALIVE_FREQ_SECS for AMQP; MQTT has no option available. OPTION_MESSAGE_TIMEOUT legacy variable will be kept for back-compat. */ 44 | static STATIC_VAR_UNUSED const char* OPTION_MESSAGE_TIMEOUT = "messageTimeout"; 45 | static STATIC_VAR_UNUSED const char* OPTION_BLOB_UPLOAD_TIMEOUT_SECS = "blob_upload_timeout_secs"; 46 | static STATIC_VAR_UNUSED const char* OPTION_PRODUCT_INFO = "product_info"; 47 | 48 | /* 49 | * @brief Specifies the Digital Twin Model Id of the connection. Only valid for use with MQTT Transport 50 | */ 51 | static STATIC_VAR_UNUSED const char* OPTION_MODEL_ID = "model_id"; 52 | 53 | /* 54 | * @brief Turns on automatic URL encoding of message properties + system properties. Only valid for use with MQTT Transport 55 | */ 56 | static STATIC_VAR_UNUSED const char* OPTION_AUTO_URL_ENCODE_DECODE = "auto_url_encode_decode"; 57 | 58 | /* 59 | * @brief Informs the service of what is the maximum period the client will wait for a keep-alive message from the service. 60 | * The service must send keep-alives before this timeout is reached, otherwise the client will trigger its re-connection logic. 61 | * Setting this option to a low value results in more aggressive/responsive re-connection by the client. 62 | * The default value for this option is 240 seconds, and the minimum allowed is usually 5 seconds. 63 | * To virtually disable the keep-alives from the service (and consequently the keep-alive timeout control on the client-side), set this option to a high value (e.g., UINT_MAX). 64 | */ 65 | static STATIC_VAR_UNUSED const char* OPTION_SERVICE_SIDE_KEEP_ALIVE_FREQ_SECS = "svc2cl_keep_alive_timeout_secs"; 66 | 67 | /* DEPRECATED:: OPTION_C2D_KEEP_ALIVE_FREQ_SECS is DEPRECATED! Use OPTION_SERVICE_SIDE_KEEP_ALIVE_FREQ_SECS, but OPTION_C2D_KEEP_ALIVE_FREQ_SECS legacy variable kept for back-compat. */ 68 | static STATIC_VAR_UNUSED const char* OPTION_C2D_KEEP_ALIVE_FREQ_SECS = "c2d_keep_alive_freq_secs"; 69 | 70 | /* 71 | * @brief Ratio to be used for client side pings in AMQP protocol. 72 | * The client must use this ratio to send keep-alives before service side remote idle timeout is reached, otherwise the service will disconnect the client. 73 | * The default value for this option is 1/2 of the remote idle value sent by the service. 74 | * For AMQP remote idle set to 4 minutes, default client ping will be 2 minutes. For AMQP remote idle set to 25 minutes configured via per Hub basis, the default ping will be 12.5 minutes. 75 | */ 76 | static STATIC_VAR_UNUSED const char* OPTION_REMOTE_IDLE_TIMEOUT_RATIO = "cl2svc_keep_alive_send_ratio"; 77 | 78 | /* 79 | * @brief This option should be used instead of OPTION_MESSAGE_TIMEOUT if using AMQP protocol. 80 | * It defines the maximum ammount of time, in seconds, the client will wait for a telemetry message to complete sending before returning it with a IOTHUB_CLIENT_CONFIRMATION_MESSAGE_TIMEOUT error. 81 | * The default value 5 (five) minutes. 82 | * This option is applicable only to AMQP protocol. 83 | */ 84 | static STATIC_VAR_UNUSED const char* OPTION_EVENT_SEND_TIMEOUT_SECS = "event_send_timeout_secs"; 85 | 86 | //diagnostic sampling percentage value, [0-100] 87 | static STATIC_VAR_UNUSED const char* OPTION_DIAGNOSTIC_SAMPLING_PERCENTAGE = "diag_sampling_percentage"; 88 | 89 | static STATIC_VAR_UNUSED const char* OPTION_DO_WORK_FREQUENCY_IN_MS = "do_work_freq_ms"; 90 | 91 | #ifdef __cplusplus 92 | } 93 | #endif 94 | 95 | #endif /* IOTHUB_CLIENT_OPTIONS_H */ 96 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_messenger.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORT_AMQP_MESSENGER 5 | #define IOTHUBTRANSPORT_AMQP_MESSENGER 6 | 7 | #include "umock_c/umock_c_prod.h" 8 | #include "azure_c_shared_utility/optionhandler.h" 9 | #include "azure_c_shared_utility/map.h" 10 | #include "azure_uamqp_c/message.h" 11 | #include "azure_uamqp_c/session.h" 12 | #include "azure_uamqp_c/link.h" 13 | #include "azure_uamqp_c/amqp_definitions_sequence_no.h" 14 | #include "azure_uamqp_c/amqp_definitions_delivery_number.h" 15 | #include "internal/iothub_transport_ll_private.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" 19 | { 20 | #endif 21 | 22 | 23 | static const char* AMQP_MESSENGER_OPTION_EVENT_SEND_TIMEOUT_SECS = "amqp_event_send_timeout_secs"; 24 | static const char *CLIENT_VERSION_PROPERTY_NAME = "com.microsoft:client-version"; 25 | 26 | typedef struct AMQP_MESSENGER_INSTANCE* AMQP_MESSENGER_HANDLE; 27 | 28 | #define AMQP_MESSENGER_SEND_STATUS_VALUES \ 29 | AMQP_MESSENGER_SEND_STATUS_IDLE, \ 30 | AMQP_MESSENGER_SEND_STATUS_BUSY 31 | 32 | MU_DEFINE_ENUM_WITHOUT_INVALID(AMQP_MESSENGER_SEND_STATUS, AMQP_MESSENGER_SEND_STATUS_VALUES); 33 | 34 | #define AMQP_MESSENGER_SEND_RESULT_VALUES \ 35 | AMQP_MESSENGER_SEND_RESULT_SUCCESS, \ 36 | AMQP_MESSENGER_SEND_RESULT_ERROR, \ 37 | AMQP_MESSENGER_SEND_RESULT_CANCELLED 38 | 39 | MU_DEFINE_ENUM_WITHOUT_INVALID(AMQP_MESSENGER_SEND_RESULT, AMQP_MESSENGER_SEND_RESULT_VALUES); 40 | 41 | #define AMQP_MESSENGER_REASON_VALUES \ 42 | AMQP_MESSENGER_REASON_NONE, \ 43 | AMQP_MESSENGER_REASON_CANNOT_PARSE, \ 44 | AMQP_MESSENGER_REASON_FAIL_SENDING, \ 45 | AMQP_MESSENGER_REASON_TIMEOUT, \ 46 | AMQP_MESSENGER_REASON_MESSENGER_DESTROYED 47 | 48 | MU_DEFINE_ENUM_WITHOUT_INVALID(AMQP_MESSENGER_REASON, AMQP_MESSENGER_REASON_VALUES); 49 | 50 | #define AMQP_MESSENGER_DISPOSITION_RESULT_VALUES \ 51 | AMQP_MESSENGER_DISPOSITION_RESULT_NONE, \ 52 | AMQP_MESSENGER_DISPOSITION_RESULT_ACCEPTED, \ 53 | AMQP_MESSENGER_DISPOSITION_RESULT_REJECTED, \ 54 | AMQP_MESSENGER_DISPOSITION_RESULT_RELEASED 55 | 56 | MU_DEFINE_ENUM_WITHOUT_INVALID(AMQP_MESSENGER_DISPOSITION_RESULT, AMQP_MESSENGER_DISPOSITION_RESULT_VALUES); 57 | 58 | #define AMQP_MESSENGER_STATE_VALUES \ 59 | AMQP_MESSENGER_STATE_STARTING, \ 60 | AMQP_MESSENGER_STATE_STARTED, \ 61 | AMQP_MESSENGER_STATE_STOPPING, \ 62 | AMQP_MESSENGER_STATE_STOPPED, \ 63 | AMQP_MESSENGER_STATE_ERROR 64 | 65 | MU_DEFINE_ENUM_WITHOUT_INVALID(AMQP_MESSENGER_STATE, AMQP_MESSENGER_STATE_VALUES); 66 | 67 | typedef struct AMQP_MESSENGER_MESSAGE_DISPOSITION_INFO_TAG 68 | { 69 | delivery_number message_id; 70 | char* source; 71 | } AMQP_MESSENGER_MESSAGE_DISPOSITION_INFO; 72 | 73 | typedef void(*AMQP_MESSENGER_SEND_COMPLETE_CALLBACK)(AMQP_MESSENGER_SEND_RESULT result, AMQP_MESSENGER_REASON reason, void* context); 74 | typedef void(*AMQP_MESSENGER_STATE_CHANGED_CALLBACK)(void* context, AMQP_MESSENGER_STATE previous_state, AMQP_MESSENGER_STATE new_state); 75 | typedef void(*AMQP_MESSENGER_SUBSCRIPTION_CALLBACK)(void* context, bool is_subscribed); 76 | typedef AMQP_MESSENGER_DISPOSITION_RESULT(*ON_AMQP_MESSENGER_MESSAGE_RECEIVED)(MESSAGE_HANDLE message, AMQP_MESSENGER_MESSAGE_DISPOSITION_INFO* disposition_info, void* context); 77 | 78 | typedef struct AMQP_MESSENGER_LINK_CONFIG_TAG 79 | { 80 | /** 81 | * @brief Sample format: "/messages/devicebound" 82 | */ 83 | char* source_suffix; 84 | 85 | /** 86 | * @brief Sample format: "/messages/events" 87 | */ 88 | char* target_suffix; 89 | 90 | receiver_settle_mode rcv_settle_mode; 91 | sender_settle_mode snd_settle_mode; 92 | 93 | MAP_HANDLE attach_properties; 94 | } AMQP_MESSENGER_LINK_CONFIG; 95 | 96 | typedef struct AMQP_MESSENGER_CONFIG_TAG 97 | { 98 | char* device_id; 99 | char* module_id; 100 | char* iothub_host_fqdn; 101 | 102 | AMQP_MESSENGER_LINK_CONFIG send_link; 103 | AMQP_MESSENGER_LINK_CONFIG receive_link; 104 | 105 | AMQP_MESSENGER_STATE_CHANGED_CALLBACK on_state_changed_callback; 106 | void* on_state_changed_context; 107 | 108 | AMQP_MESSENGER_SUBSCRIPTION_CALLBACK on_subscription_changed_callback; 109 | void* on_subscription_changed_context; 110 | 111 | pfTransport_GetOption_Product_Info_Callback prod_info_cb; 112 | void* prod_info_ctx; 113 | } AMQP_MESSENGER_CONFIG; 114 | 115 | MOCKABLE_FUNCTION(, AMQP_MESSENGER_HANDLE, amqp_messenger_create, const AMQP_MESSENGER_CONFIG*, messenger_config); 116 | MOCKABLE_FUNCTION(, int, amqp_messenger_send_async, AMQP_MESSENGER_HANDLE, messenger_handle, MESSAGE_HANDLE, message, AMQP_MESSENGER_SEND_COMPLETE_CALLBACK, on_messenger_event_send_complete_callback, void*, context); 117 | MOCKABLE_FUNCTION(, int, amqp_messenger_subscribe_for_messages, AMQP_MESSENGER_HANDLE, messenger_handle, ON_AMQP_MESSENGER_MESSAGE_RECEIVED, on_message_received_callback, void*, context); 118 | MOCKABLE_FUNCTION(, int, amqp_messenger_unsubscribe_for_messages, AMQP_MESSENGER_HANDLE, messenger_handle); 119 | MOCKABLE_FUNCTION(, int, amqp_messenger_send_message_disposition, AMQP_MESSENGER_HANDLE, messenger_handle, AMQP_MESSENGER_MESSAGE_DISPOSITION_INFO*, disposition_info, AMQP_MESSENGER_DISPOSITION_RESULT, disposition_result); 120 | MOCKABLE_FUNCTION(, int, amqp_messenger_get_send_status, AMQP_MESSENGER_HANDLE, messenger_handle, AMQP_MESSENGER_SEND_STATUS*, send_status); 121 | MOCKABLE_FUNCTION(, int, amqp_messenger_start, AMQP_MESSENGER_HANDLE, messenger_handle, SESSION_HANDLE, session_handle); 122 | MOCKABLE_FUNCTION(, int, amqp_messenger_stop, AMQP_MESSENGER_HANDLE, messenger_handle); 123 | MOCKABLE_FUNCTION(, void, amqp_messenger_do_work, AMQP_MESSENGER_HANDLE, messenger_handle); 124 | MOCKABLE_FUNCTION(, void, amqp_messenger_destroy, AMQP_MESSENGER_HANDLE, messenger_handle); 125 | MOCKABLE_FUNCTION(, int, amqp_messenger_set_option, AMQP_MESSENGER_HANDLE, messenger_handle, const char*, name, void*, value); 126 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, amqp_messenger_retrieve_options, AMQP_MESSENGER_HANDLE, messenger_handle); 127 | MOCKABLE_FUNCTION(, void, amqp_messenger_destroy_disposition_info, AMQP_MESSENGER_MESSAGE_DISPOSITION_INFO*, disposition_info); 128 | 129 | 130 | #ifdef __cplusplus 131 | } 132 | #endif 133 | 134 | #endif /*IOTHUBTRANSPORT_AMQP_AMQP_MESSENGER*/ 135 | -------------------------------------------------------------------------------- /src/certs/certs.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | /* This file contains certs needed to communicate with Azure (IoT) */ 5 | 6 | #include "certs.h" 7 | /* Note: for devices with limited resources, only one cert should be loaded. 8 | #defines are used to reduce memory footprint of certificates. 9 | For DE and CN regions, please build with -DUSE_MICROSOFTAZURE_DE_CERT or -DUSE_PORTAL_AZURE_CN_CERT, respectively, 10 | if you wish to load ONLY those certs. 11 | */ 12 | #if !defined(USE_BALTIMORE_CERT) && !defined(USE_MICROSOFTAZURE_DE_CERT) && !defined(USE_PORTAL_AZURE_CN_CERT) 13 | // For legacy, if no certificates were explicitly selected then include all of them 14 | #define USE_BALTIMORE_CERT 15 | #define USE_MICROSOFTAZURE_DE_CERT 16 | #define USE_PORTAL_AZURE_CN_CERT 17 | #endif 18 | 19 | const char certificates[] = 20 | #if defined(USE_BALTIMORE_CERT) 21 | /* DigiCert Baltimore Root --Used Globally--*/ 22 | // This cert should be used when connecting to Azure IoT on the Azure Cloud available globally. When in doubt, use this cert. 23 | "-----BEGIN CERTIFICATE-----\r\n" 24 | "MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ\r\n" 25 | "RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD\r\n" 26 | "VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX\r\n" 27 | "DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y\r\n" 28 | "ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy\r\n" 29 | "VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr\r\n" 30 | "mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr\r\n" 31 | "IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK\r\n" 32 | "mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu\r\n" 33 | "XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy\r\n" 34 | "dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye\r\n" 35 | "jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1\r\n" 36 | "BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3\r\n" 37 | "DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92\r\n" 38 | "9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx\r\n" 39 | "jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0\r\n" 40 | "Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz\r\n" 41 | "ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS\r\n" 42 | "R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp\r\n" 43 | "-----END CERTIFICATE-----\r\n" 44 | #endif /* BALTIMORE_CERT */ 45 | 46 | #if defined(USE_PORTAL_AZURE_CN_CERT) 47 | /* DigiCert Global Root CA */ 48 | // This cert should be used when connecting to Azure IoT on the https://portal.azure.cn Cloud address. 49 | "-----BEGIN CERTIFICATE-----\r\n" 50 | "MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh\r\n" 51 | "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\r\n" 52 | "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD\r\n" 53 | "QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT\r\n" 54 | "MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\r\n" 55 | "b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG\r\n" 56 | "9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB\r\n" 57 | "CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97\r\n" 58 | "nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt\r\n" 59 | "43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P\r\n" 60 | "T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4\r\n" 61 | "gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO\r\n" 62 | "BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR\r\n" 63 | "TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw\r\n" 64 | "DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr\r\n" 65 | "hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg\r\n" 66 | "06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF\r\n" 67 | "PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls\r\n" 68 | "YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk\r\n" 69 | "CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=\r\n" 70 | "-----END CERTIFICATE-----\r\n" 71 | #endif /* PORTAL_AZURE_CN_CERT */ 72 | 73 | #if defined(USE_MICROSOFTAZURE_DE_CERT) 74 | /* D-TRUST Root Class 3 CA 2 2009 */ 75 | // This cert should be used when connecting to Azure IoT on the https://portal.microsoftazure.de Cloud address. 76 | "-----BEGIN CERTIFICATE-----\r\n" 77 | "MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF\r\n" 78 | "MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD\r\n" 79 | "bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha\r\n" 80 | "ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM\r\n" 81 | "HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB\r\n" 82 | "BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03\r\n" 83 | "UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42\r\n" 84 | "tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R\r\n" 85 | "ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM\r\n" 86 | "lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp\r\n" 87 | "/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G\r\n" 88 | "A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G\r\n" 89 | "A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj\r\n" 90 | "dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy\r\n" 91 | "MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl\r\n" 92 | "cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js\r\n" 93 | "L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL\r\n" 94 | "BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni\r\n" 95 | "acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0\r\n" 96 | "o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K\r\n" 97 | "zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8\r\n" 98 | "PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y\r\n" 99 | "Johw1+qRzT65ysCQblrGXnRl11z+o+I=\r\n" 100 | "-----END CERTIFICATE-----\r\n" 101 | #endif /* MICROSOFTAZURE_DE_CERT */ 102 | 103 | ; 104 | -------------------------------------------------------------------------------- /src/iothub_client_core_ll.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | //********************************************************************** 5 | // NOTE: THIS HEADER IS FOR INTERNAL USE ONLY 6 | // 7 | // Applications should use iothub_device_client_ll.h or iothub_module_client_ll.h 8 | // instead for the official API. 9 | // 10 | //********************************************************************** 11 | 12 | #ifndef IOTHUB_CLIENT_CORE_LL_H 13 | #define IOTHUB_CLIENT_CORE_LL_H 14 | 15 | typedef struct IOTHUB_CLIENT_CORE_LL_HANDLE_DATA_TAG* IOTHUB_CLIENT_CORE_LL_HANDLE; 16 | 17 | #include 18 | #include "umock_c/umock_c_prod.h" 19 | #include "iothub_transport_ll.h" 20 | #include "iothub_client_core_common.h" 21 | 22 | #ifdef __cplusplus 23 | extern "C" 24 | { 25 | #endif 26 | 27 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_LL_HANDLE, IoTHubClientCore_LL_CreateFromConnectionString, const char*, connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 28 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_LL_HANDLE, IoTHubClientCore_LL_Create, const IOTHUB_CLIENT_CONFIG*, config); 29 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_LL_HANDLE, IoTHubClientCore_LL_CreateWithTransport, const IOTHUB_CLIENT_DEVICE_CONFIG*, config); 30 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_LL_HANDLE, IoTHubClientCore_LL_CreateFromDeviceAuth, const char*, iothub_uri, const char*, device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 31 | MOCKABLE_FUNCTION(, void, IoTHubClientCore_LL_Destroy, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle); 32 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SendEventAsync, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_MESSAGE_HANDLE, eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK, eventConfirmationCallback, void*, userContextCallback); 33 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_GetSendStatus, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_STATUS*, iotHubClientStatus); 34 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetMessageCallback, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC, messageCallback, void*, userContextCallback); 35 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetConnectionStatusCallback, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK, connectionStatusCallback, void*, userContextCallback); 36 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetRetryPolicy, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY, retryPolicy, size_t, retryTimeoutLimitInSeconds); 37 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_GetRetryPolicy, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY*, retryPolicy, size_t*, retryTimeoutLimitInSeconds); 38 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_GetLastMessageReceiveTime, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, time_t*, lastMessageReceiveTime); 39 | MOCKABLE_FUNCTION(, void, IoTHubClientCore_LL_DoWork, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle); 40 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetOption, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, optionName, const void*, value); 41 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetDeviceTwinCallback, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, deviceTwinCallback, void*, userContextCallback); 42 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SendReportedState, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const unsigned char*, reportedState, size_t, size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK, reportedStateCallback, void*, userContextCallback); 43 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_GetTwinAsync, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, deviceTwinCallback, void*, userContextCallback); 44 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetDeviceMethodCallback, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC, deviceMethodCallback, void*, userContextCallback); 45 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetDeviceMethodCallback_Ex, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_INBOUND_DEVICE_METHOD_CALLBACK, inboundDeviceMethodCallback, void*, userContextCallback); 46 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_DeviceMethodResponse, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, METHOD_HANDLE, methodId, const unsigned char*, response, size_t, respSize, int, statusCode); 47 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SendEventToOutputAsync, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, IOTHUB_MESSAGE_HANDLE, eventMessageHandle, const char*, outputName, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK, eventConfirmationCallback, void*, userContextCallback); 48 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_SetInputMessageCallback, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, inputName, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC, eventHandlerCallback, void*, userContextCallback); 49 | 50 | #ifndef DONT_USE_UPLOADTOBLOB 51 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_UploadToBlob, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, destinationFileName, const unsigned char*, source, size_t, size); 52 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_UploadMultipleBlocksToBlob, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK, getDataCallback, void*, context); 53 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_LL_UploadMultipleBlocksToBlobEx, IOTHUB_CLIENT_CORE_LL_HANDLE, iotHubClientHandle, const char*, destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX, getDataCallbackEx, void*, context); 54 | #endif /*DONT_USE_UPLOADTOBLOB*/ 55 | 56 | #ifdef USE_EDGE_MODULES 57 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_LL_HANDLE, IoTHubClientCore_LL_CreateFromEnvironment, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 58 | #endif 59 | #ifdef __cplusplus 60 | } 61 | #endif 62 | 63 | #endif /* IOTHUB_CLIENT_CORE_LL_H */ 64 | -------------------------------------------------------------------------------- /src/iothub_client_dll.def: -------------------------------------------------------------------------------- 1 | LIBRARY iothub_client_dll 2 | EXPORTS 3 | IoTHub_Init 4 | IoTHub_Deinit 5 | 6 | IoTHubTransport_Create 7 | IoTHubTransport_Destroy 8 | IoTHubTransport_GetLock 9 | IoTHubTransport_GetLLTransport 10 | IoTHubTransport_StartWorkerThread 11 | IoTHubTransport_SignalEndWorkerThread 12 | IoTHubTransport_JoinWorkerThread 13 | 14 | IoTHubClient_GetVersionString 15 | 16 | IoTHubClient_CreateFromConnectionString 17 | IoTHubClient_Create 18 | IoTHubClient_CreateWithTransport 19 | IoTHubClient_CreateFromDeviceAuth 20 | IoTHubClient_Destroy 21 | IoTHubClient_SendEventAsync 22 | IoTHubClient_GetSendStatus 23 | IoTHubClient_SetMessageCallback 24 | IoTHubClient_SetConnectionStatusCallback 25 | IoTHubClient_SetRetryPolicy 26 | IoTHubClient_GetRetryPolicy 27 | IoTHubClient_GetLastMessageReceiveTime 28 | IoTHubClient_SetOption 29 | IoTHubClient_SetDeviceTwinCallback 30 | IoTHubClient_SendReportedState 31 | IoTHubClient_SetDeviceMethodCallback 32 | 33 | IoTHubDeviceClient_CreateFromConnectionString 34 | IoTHubDeviceClient_Create 35 | IoTHubDeviceClient_CreateWithTransport 36 | IoTHubDeviceClient_CreateFromDeviceAuth 37 | IoTHubDeviceClient_Destroy 38 | IoTHubDeviceClient_SendEventAsync 39 | IoTHubDeviceClient_GetSendStatus 40 | IoTHubDeviceClient_SetMessageCallback 41 | IoTHubDeviceClient_SetConnectionStatusCallback 42 | IoTHubDeviceClient_SetRetryPolicy 43 | IoTHubDeviceClient_GetRetryPolicy 44 | IoTHubDeviceClient_GetLastMessageReceiveTime 45 | IoTHubDeviceClient_SetOption 46 | IoTHubDeviceClient_SetDeviceTwinCallback 47 | IoTHubDeviceClient_SendReportedState 48 | IoTHubDeviceClient_SetDeviceMethodCallback 49 | IoTHubDeviceClient_DeviceMethodResponse 50 | IoTHubDeviceClient_UploadToBlobAsync 51 | IoTHubDeviceClient_UploadMultipleBlocksToBlobAsync 52 | 53 | IoTHubModuleClient_CreateFromConnectionString 54 | IoTHubModuleClient_Destroy 55 | IoTHubModuleClient_SendEventAsync 56 | IoTHubModuleClient_GetSendStatus 57 | IoTHubModuleClient_SetMessageCallback 58 | IoTHubModuleClient_SetConnectionStatusCallback 59 | IoTHubModuleClient_SetRetryPolicy 60 | IoTHubModuleClient_GetRetryPolicy 61 | IoTHubModuleClient_GetLastMessageReceiveTime 62 | IoTHubModuleClient_SetOption 63 | IoTHubModuleClient_SetModuleTwinCallback 64 | IoTHubModuleClient_SendReportedState 65 | IoTHubModuleClient_SetModuleMethodCallback 66 | IoTHubModuleClient_SendEventToOutputAsync 67 | IoTHubModuleClient_SetInputMessageCallback 68 | 69 | IoTHubClient_LL_CreateFromConnectionString 70 | IoTHubClient_LL_Destroy 71 | IoTHubClient_LL_DoWork 72 | IoTHubClient_LL_SendEventAsync 73 | IoTHubClient_LL_SetMessageCallback 74 | IoTHubClient_LL_SetOption 75 | 76 | IoTHubDeviceClient_LL_CreateFromConnectionString 77 | IoTHubDeviceClient_LL_Create 78 | IoTHubDeviceClient_LL_CreateWithTransport 79 | IoTHubDeviceClient_LL_CreateFromDeviceAuth 80 | IoTHubDeviceClient_LL_Destroy 81 | IoTHubDeviceClient_LL_SendEventAsync 82 | IoTHubDeviceClient_LL_GetSendStatus 83 | IoTHubDeviceClient_LL_SetMessageCallback 84 | IoTHubDeviceClient_LL_SetConnectionStatusCallback 85 | IoTHubDeviceClient_LL_SetRetryPolicy 86 | IoTHubDeviceClient_LL_GetRetryPolicy 87 | IoTHubDeviceClient_LL_GetLastMessageReceiveTime 88 | IoTHubDeviceClient_LL_DoWork 89 | IoTHubDeviceClient_LL_SetOption 90 | IoTHubDeviceClient_LL_SetDeviceTwinCallback 91 | IoTHubDeviceClient_LL_SendReportedState 92 | IoTHubDeviceClient_LL_SetDeviceMethodCallback 93 | IoTHubDeviceClient_LL_DeviceMethodResponse 94 | IoTHubDeviceClient_LL_UploadToBlob 95 | IoTHubDeviceClient_LL_UploadMultipleBlocksToBlob 96 | 97 | IoTHubModuleClient_LL_CreateFromConnectionString 98 | IoTHubModuleClient_LL_Destroy 99 | IoTHubModuleClient_LL_SendEventAsync 100 | IoTHubModuleClient_LL_GetSendStatus 101 | IoTHubModuleClient_LL_SetMessageCallback 102 | IoTHubModuleClient_LL_SetConnectionStatusCallback 103 | IoTHubModuleClient_LL_SetRetryPolicy 104 | IoTHubModuleClient_LL_GetRetryPolicy 105 | IoTHubModuleClient_LL_GetLastMessageReceiveTime 106 | IoTHubModuleClient_LL_DoWork 107 | IoTHubModuleClient_LL_SetOption 108 | IoTHubModuleClient_LL_SetModuleTwinCallback 109 | IoTHubModuleClient_LL_SendReportedState 110 | IoTHubModuleClient_LL_SetModuleMethodCallback 111 | IoTHubModuleClient_LL_SendEventToOutputAsync 112 | IoTHubModuleClient_LL_SetInputMessageCallback 113 | 114 | IoTHubMessage_CreateFromString 115 | IoTHubMessage_CreateFromByteArray 116 | IoTHubMessage_Clone 117 | IoTHubMessage_Destroy 118 | IoTHubMessage_GetByteArray 119 | IoTHubMessage_GetString 120 | IoTHubMessage_GetContentType 121 | IoTHubMessage_GetContentTypeSystemProperty 122 | IoTHubMessage_GetContentEncodingSystemProperty 123 | IoTHubMessage_GetMessageCreationTimeUtcSystemProperty 124 | IoTHubMessage_GetMessageUserIdSystemProperty 125 | IoTHubMessage_GetCorrelationId 126 | IoTHubMessage_GetDiagnosticPropertyData 127 | IoTHubMessage_GetMessageId 128 | IoTHubMessage_GetOutputName 129 | IoTHubMessage_GetProperty 130 | IoTHubMessage_Properties 131 | IoTHubMessage_SetConnectionDeviceId 132 | IoTHubMessage_SetConnectionModuleId 133 | IoTHubMessage_SetContentTypeSystemProperty 134 | IoTHubMessage_SetContentEncodingSystemProperty 135 | IoTHubMessage_SetMessageCreationTimeUtcSystemProperty 136 | IoTHubMessage_SetMessageUserIdSystemProperty 137 | IoTHubMessage_SetCorrelationId 138 | IoTHubMessage_SetInputName 139 | IoTHubMessage_SetMessageId 140 | IoTHubMessage_SetProperty 141 | IoTHubMessage_SetAsSecurityMessage 142 | IoTHubMessage_IsSecurityMessage 143 | 144 | IOTHUB_CLIENT_CONFIRMATION_RESULTStrings 145 | IOTHUB_CLIENT_FILE_UPLOAD_RESULTStrings 146 | IOTHUB_CLIENT_RESULTStrings 147 | IOTHUB_CLIENT_RETRY_POLICYStrings 148 | IOTHUB_CLIENT_STATUSStrings 149 | IOTHUB_IDENTITY_TYPEStrings 150 | IOTHUB_PROCESS_ITEM_RESULTStrings 151 | IOTHUB_CLIENT_IOTHUB_METHOD_STATUSStrings 152 | IOTHUB_CLIENT_CONFIRMATION_RESULTStrings 153 | IOTHUB_CLIENT_CONNECTION_STATUSStrings 154 | IOTHUB_CLIENT_CONNECTION_STATUS_REASONStrings 155 | TRANSPORT_TYPEStrings 156 | DEVICE_TWIN_UPDATE_STATEStrings 157 | -------------------------------------------------------------------------------- /src/iothub_client_core.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | //********************************************************************** 5 | // NOTE: THIS HEADER IS FOR INTERNAL USE ONLY 6 | // 7 | // Applications should use iothub_device_client.h or iothub_module_client.h 8 | // instead for the official API. 9 | // 10 | //********************************************************************** 11 | 12 | #ifndef IOTHUB_CLIENT_CORE_H 13 | #define IOTHUB_CLIENT_CORE_H 14 | 15 | #include 16 | #include 17 | #include "umock_c/umock_c_prod.h" 18 | 19 | #include "iothub_client_core_ll.h" 20 | 21 | #ifndef IOTHUB_CLIENT_CORE_INSTANCE_TYPE 22 | typedef struct IOTHUB_CLIENT_CORE_INSTANCE_TAG* IOTHUB_CLIENT_CORE_HANDLE; 23 | #define IOTHUB_CLIENT_CORE_INSTANCE_TYPE 24 | #endif // IOTHUB_CLIENT_CORE_INSTANCE 25 | 26 | #ifdef __cplusplus 27 | extern "C" 28 | { 29 | #endif 30 | 31 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_HANDLE, IoTHubClientCore_CreateFromConnectionString, const char*, connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 32 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_HANDLE, IoTHubClientCore_Create, const IOTHUB_CLIENT_CONFIG*, config); 33 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_HANDLE, IoTHubClientCore_CreateWithTransport, TRANSPORT_HANDLE, transportHandle, const IOTHUB_CLIENT_CONFIG*, config); 34 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_HANDLE, IoTHubClientCore_CreateFromDeviceAuth, const char*, iothub_uri, const char*, device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 35 | MOCKABLE_FUNCTION(, void, IoTHubClientCore_Destroy, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle); 36 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SendEventAsync, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_MESSAGE_HANDLE, eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK, eventConfirmationCallback, void*, userContextCallback); 37 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_GetSendStatus, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_STATUS*, iotHubClientStatus); 38 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetMessageCallback, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC, messageCallback, void*, userContextCallback); 39 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetConnectionStatusCallback, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK, connectionStatusCallback, void*, userContextCallback); 40 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetRetryPolicy, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY, retryPolicy, size_t, retryTimeoutLimitInSeconds); 41 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_GetRetryPolicy, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY*, retryPolicy, size_t*, retryTimeoutLimitInSeconds); 42 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_GetLastMessageReceiveTime, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, time_t*, lastMessageReceiveTime); 43 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetOption, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const char*, optionName, const void*, value); 44 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetDeviceTwinCallback, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, deviceTwinCallback, void*, userContextCallback); 45 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SendReportedState, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const unsigned char*, reportedState, size_t, size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK, reportedStateCallback, void*, userContextCallback); 46 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_GetTwinAsync, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK, deviceTwinCallback, void*, userContextCallback); 47 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetDeviceMethodCallback, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC, deviceMethodCallback, void*, userContextCallback); 48 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetDeviceMethodCallback_Ex, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_CLIENT_INBOUND_DEVICE_METHOD_CALLBACK, inboundDeviceMethodCallback, void*, userContextCallback); 49 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_DeviceMethodResponse, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, METHOD_HANDLE, methodId, const unsigned char*, response, size_t, response_size, int, statusCode); 50 | 51 | #ifndef DONT_USE_UPLOADTOBLOB 52 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_UploadToBlobAsync, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const char*, destinationFileName, const unsigned char*, source, size_t, size, IOTHUB_CLIENT_FILE_UPLOAD_CALLBACK, iotHubClientFileUploadCallback, void*, context); 53 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_UploadMultipleBlocksToBlobAsync, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const char*, destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK, getDataCallback, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX, getDataCallbackEx, void*, context); 54 | #endif /* DONT_USE_UPLOADTOBLOB */ 55 | 56 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SendEventToOutputAsync, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, IOTHUB_MESSAGE_HANDLE, eventMessageHandle, const char*, outputName, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK, eventConfirmationCallback, void*, userContextCallback); 57 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_SetInputMessageCallback, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const char*, inputName, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC, eventHandlerCallback, void*, userContextCallback); 58 | 59 | #ifdef USE_EDGE_MODULES 60 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_CORE_HANDLE, IoTHubClientCore_CreateFromEnvironment, IOTHUB_CLIENT_TRANSPORT_PROVIDER, protocol); 61 | MOCKABLE_FUNCTION(, IOTHUB_CLIENT_RESULT, IoTHubClientCore_GenericMethodInvoke, IOTHUB_CLIENT_CORE_HANDLE, iotHubClientHandle, const char*, deviceId, const char*, moduleId, const char*, methodName, const char*, methodPayload, unsigned int, timeout, IOTHUB_METHOD_INVOKE_CALLBACK, methodInvokeCallback, void*, context); 62 | #endif /* USE_EDGE_MODULES */ 63 | 64 | #ifdef __cplusplus 65 | } 66 | #endif 67 | 68 | #endif /* IOTHUB_CLIENT_CORE_H */ 69 | -------------------------------------------------------------------------------- /src/iothub_client_diagnostic.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include 6 | #include 7 | #include "azure_c_shared_utility/optimize_size.h" 8 | #include "azure_c_shared_utility/gballoc.h" 9 | #include "azure_c_shared_utility/xlogging.h" 10 | #include "azure_c_shared_utility/agenttime.h" 11 | #include "azure_c_shared_utility/buffer_.h" 12 | 13 | #include "internal/iothub_client_diagnostic.h" 14 | 15 | #define TIME_STRING_BUFFER_LEN 30 16 | 17 | static const int BASE_36 = 36; 18 | 19 | #define INDEFINITE_TIME ((time_t)-1) 20 | 21 | static char* get_epoch_time(char* timeBuffer) 22 | { 23 | char* result; 24 | time_t epochTime; 25 | int timeLen = sizeof(time_t); 26 | 27 | if ((epochTime = get_time(NULL)) == INDEFINITE_TIME) 28 | { 29 | LogError("Failed getting current time"); 30 | result = NULL; 31 | } 32 | else if (timeLen == sizeof(int64_t)) 33 | { 34 | if (sprintf(timeBuffer, "%"PRIu64, (int64_t)epochTime) < 0) 35 | { 36 | LogError("Failed sprintf to timeBuffer with 8 bytes of time_t"); 37 | result = NULL; 38 | } 39 | else 40 | { 41 | result = timeBuffer; 42 | } 43 | } 44 | else if (timeLen == sizeof(int32_t)) 45 | { 46 | if (sprintf(timeBuffer, "%"PRIu32, (int32_t)epochTime) < 0) 47 | { 48 | LogError("Failed sprintf to timeBuffer with 4 bytes of time_t"); 49 | result = NULL; 50 | } 51 | else 52 | { 53 | result = timeBuffer; 54 | } 55 | } 56 | else 57 | { 58 | LogError("Unknown size of time_t"); 59 | result = NULL; 60 | } 61 | 62 | return result; 63 | } 64 | 65 | static char get_base36_char(unsigned char value) 66 | { 67 | return value <= 9 ? '0' + value : 'a' + value - 10; 68 | } 69 | 70 | static char* generate_eight_random_characters(char *randomString) 71 | { 72 | int i; 73 | char* randomStringPos = randomString; 74 | for (i = 0; i < 4; ++i) 75 | { 76 | int rawRandom = rand(); 77 | int first = rawRandom % BASE_36; 78 | int second = rawRandom / BASE_36 % BASE_36; 79 | *randomStringPos++ = get_base36_char((unsigned char)first); 80 | *randomStringPos++ = get_base36_char((unsigned char)second); 81 | } 82 | *randomStringPos = 0; 83 | 84 | return randomString; 85 | } 86 | 87 | static bool should_add_diagnostic_info(IOTHUB_DIAGNOSTIC_SETTING_DATA* diagSetting) 88 | { 89 | bool result = false; 90 | if (diagSetting->diagSamplingPercentage > 0) 91 | { 92 | double number; 93 | double percentage; 94 | 95 | if (diagSetting->currentMessageNumber == UINT32_MAX) 96 | { 97 | diagSetting->currentMessageNumber %= diagSetting->diagSamplingPercentage * 100; 98 | } 99 | ++diagSetting->currentMessageNumber; 100 | 101 | number = diagSetting->currentMessageNumber; 102 | percentage = diagSetting->diagSamplingPercentage; 103 | result = (floor((number - 2) * percentage / 100.0) < floor((number - 1) * percentage / 100.0)); 104 | } 105 | return result; 106 | } 107 | 108 | static IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA* prepare_message_diagnostic_data() 109 | { 110 | IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA* result = (IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA*)malloc(sizeof(IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA)); 111 | if (result == NULL) 112 | { 113 | LogError("malloc for DiagnosticData failed"); 114 | } 115 | else 116 | { 117 | char* diagId = (char*)malloc(9); 118 | if (diagId == NULL) 119 | { 120 | LogError("malloc for diagId failed"); 121 | free(result); 122 | result = NULL; 123 | } 124 | else 125 | { 126 | char* timeBuffer; 127 | 128 | (void)generate_eight_random_characters(diagId); 129 | result->diagnosticId = diagId; 130 | 131 | timeBuffer = (char*)malloc(TIME_STRING_BUFFER_LEN); 132 | if (timeBuffer == NULL) 133 | { 134 | LogError("malloc for timeBuffer failed"); 135 | free(result->diagnosticId); 136 | free(result); 137 | result = NULL; 138 | } 139 | else if (get_epoch_time(timeBuffer) == NULL) 140 | { 141 | LogError("Failed getting current time"); 142 | free(result->diagnosticId); 143 | free(result); 144 | free(timeBuffer); 145 | result = NULL; 146 | } 147 | else 148 | { 149 | result->diagnosticCreationTimeUtc = timeBuffer; 150 | } 151 | } 152 | } 153 | return result; 154 | } 155 | 156 | int IoTHubClient_Diagnostic_AddIfNecessary(IOTHUB_DIAGNOSTIC_SETTING_DATA* diagSetting, IOTHUB_MESSAGE_HANDLE messageHandle) 157 | { 158 | int result; 159 | /* Codes_SRS_IOTHUB_DIAGNOSTIC_13_001: [ IoTHubClient_Diagnostic_AddIfNecessary should return nonezero if diagSetting or messageHandle is NULL. ]*/ 160 | if (diagSetting == NULL || messageHandle == NULL) 161 | { 162 | result = MU_FAILURE; 163 | } 164 | /* Codes_SRS_IOTHUB_DIAGNOSTIC_13_003: [ If diagSamplingPercentage is equal to 0, message number should not be increased and no diagnostic properties added ]*/ 165 | else if (should_add_diagnostic_info(diagSetting)) 166 | { 167 | /* Codes_SRS_IOTHUB_DIAGNOSTIC_13_004: [ If diagSamplingPercentage is equal to 100, diagnostic properties should be added to all messages]*/ 168 | /* Codes_SRS_IOTHUB_DIAGNOSTIC_13_005: [ If diagSamplingPercentage is between(0, 100), diagnostic properties should be added based on percentage]*/ 169 | 170 | IOTHUB_MESSAGE_DIAGNOSTIC_PROPERTY_DATA* diagnosticData; 171 | if ((diagnosticData = prepare_message_diagnostic_data()) == NULL) 172 | { 173 | result = MU_FAILURE; 174 | } 175 | else 176 | { 177 | if (IoTHubMessage_SetDiagnosticPropertyData(messageHandle, diagnosticData) != IOTHUB_MESSAGE_OK) 178 | { 179 | /* Codes_SRS_IOTHUB_DIAGNOSTIC_13_002: [ IoTHubClient_Diagnostic_AddIfNecessary should return nonezero if failing to add diagnostic property. ]*/ 180 | result = MU_FAILURE; 181 | } 182 | else 183 | { 184 | result = 0; 185 | } 186 | 187 | free(diagnosticData->diagnosticCreationTimeUtc); 188 | free(diagnosticData->diagnosticId); 189 | free(diagnosticData); 190 | diagnosticData = NULL; 191 | } 192 | } 193 | else 194 | { 195 | result = 0; 196 | } 197 | 198 | return result; 199 | } 200 | -------------------------------------------------------------------------------- /src/iothub_device_client.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include "umock_c/umock_c_prod.h" 6 | #include "azure_c_shared_utility/gballoc.h" 7 | 8 | #include "iothub_client_core.h" 9 | #include "iothub_device_client.h" 10 | 11 | IOTHUB_DEVICE_CLIENT_HANDLE IoTHubDeviceClient_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 12 | { 13 | return (IOTHUB_DEVICE_CLIENT_HANDLE)IoTHubClientCore_CreateFromConnectionString(connectionString, protocol); 14 | } 15 | 16 | IOTHUB_DEVICE_CLIENT_HANDLE IoTHubDeviceClient_Create(const IOTHUB_CLIENT_CONFIG* config) 17 | { 18 | return (IOTHUB_DEVICE_CLIENT_HANDLE)IoTHubClientCore_Create(config); 19 | } 20 | 21 | IOTHUB_DEVICE_CLIENT_HANDLE IoTHubDeviceClient_CreateWithTransport(TRANSPORT_HANDLE transportHandle, const IOTHUB_CLIENT_CONFIG* config) 22 | { 23 | return (IOTHUB_DEVICE_CLIENT_HANDLE)IoTHubClientCore_CreateWithTransport(transportHandle, config); 24 | } 25 | 26 | IOTHUB_DEVICE_CLIENT_HANDLE IoTHubDeviceClient_CreateFromDeviceAuth(const char* iothub_uri, const char* device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 27 | { 28 | return (IOTHUB_DEVICE_CLIENT_HANDLE)IoTHubClientCore_CreateFromDeviceAuth(iothub_uri, device_id, protocol); 29 | } 30 | 31 | void IoTHubDeviceClient_Destroy(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle) 32 | { 33 | IoTHubClientCore_Destroy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle); 34 | } 35 | 36 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SendEventAsync(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 37 | { 38 | return IoTHubClientCore_SendEventAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback); 39 | } 40 | 41 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_GetSendStatus(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus) 42 | { 43 | return IoTHubClientCore_GetSendStatus((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, iotHubClientStatus); 44 | } 45 | 46 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetMessageCallback(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback) 47 | { 48 | return IoTHubClientCore_SetMessageCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, messageCallback, userContextCallback); 49 | } 50 | 51 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetConnectionStatusCallback(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK connectionStatusCallback, void * userContextCallback) 52 | { 53 | return IoTHubClientCore_SetConnectionStatusCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, connectionStatusCallback, userContextCallback); 54 | } 55 | 56 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetRetryPolicy(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY retryPolicy, size_t retryTimeoutLimitInSeconds) 57 | { 58 | return IoTHubClientCore_SetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 59 | } 60 | 61 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_GetRetryPolicy(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY* retryPolicy, size_t* retryTimeoutLimitInSeconds) 62 | { 63 | return IoTHubClientCore_GetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 64 | } 65 | 66 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_GetLastMessageReceiveTime(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime) 67 | { 68 | return IoTHubClientCore_GetLastMessageReceiveTime((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, lastMessageReceiveTime); 69 | } 70 | 71 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetOption(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, const char* optionName, const void* value) 72 | { 73 | return IoTHubClientCore_SetOption((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, optionName, value); 74 | } 75 | 76 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetDeviceTwinCallback(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 77 | { 78 | return IoTHubClientCore_SetDeviceTwinCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 79 | } 80 | 81 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_GetTwinAsync(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 82 | { 83 | return IoTHubClientCore_GetTwinAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 84 | } 85 | 86 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SendReportedState(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, const unsigned char* reportedState, size_t size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reportedStateCallback, void* userContextCallback) 87 | { 88 | return IoTHubClientCore_SendReportedState((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, reportedState, size, reportedStateCallback, userContextCallback); 89 | } 90 | 91 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_SetDeviceMethodCallback(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC deviceMethodCallback, void* userContextCallback) 92 | { 93 | return IoTHubClientCore_SetDeviceMethodCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, deviceMethodCallback, userContextCallback); 94 | } 95 | 96 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_DeviceMethodResponse(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, METHOD_HANDLE methodId, const unsigned char* response, size_t respSize, int statusCode) 97 | { 98 | return IoTHubClientCore_DeviceMethodResponse((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, methodId, response, respSize, statusCode); 99 | } 100 | 101 | #ifndef DONT_USE_UPLOADTOBLOB 102 | 103 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_UploadToBlobAsync(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, const char* destinationFileName, const unsigned char* source, size_t size, IOTHUB_CLIENT_FILE_UPLOAD_CALLBACK iotHubClientFileUploadCallback, void* context) 104 | { 105 | return IoTHubClientCore_UploadToBlobAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, destinationFileName, source, size, iotHubClientFileUploadCallback, context); 106 | } 107 | 108 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_UploadMultipleBlocksToBlobAsync(IOTHUB_DEVICE_CLIENT_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX getDataCallbackEx, void* context) 109 | { 110 | return IoTHubClientCore_UploadMultipleBlocksToBlobAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, destinationFileName, NULL, getDataCallbackEx, context); 111 | } 112 | 113 | #endif /*DONT_USE_UPLOADTOBLOB*/ 114 | -------------------------------------------------------------------------------- /src/iothub_client.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include "umock_c/umock_c_prod.h" 6 | #include "azure_c_shared_utility/gballoc.h" 7 | 8 | #include "iothub_client_core.h" 9 | #include "iothub_client.h" 10 | 11 | IOTHUB_CLIENT_HANDLE IoTHubClient_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 12 | { 13 | return (IOTHUB_CLIENT_HANDLE)IoTHubClientCore_CreateFromConnectionString(connectionString, protocol); 14 | } 15 | 16 | IOTHUB_CLIENT_HANDLE IoTHubClient_Create(const IOTHUB_CLIENT_CONFIG* config) 17 | { 18 | return (IOTHUB_CLIENT_HANDLE)IoTHubClientCore_Create(config); 19 | } 20 | 21 | IOTHUB_CLIENT_HANDLE IoTHubClient_CreateWithTransport(TRANSPORT_HANDLE transportHandle, const IOTHUB_CLIENT_CONFIG* config) 22 | { 23 | return (IOTHUB_CLIENT_HANDLE)IoTHubClientCore_CreateWithTransport(transportHandle, config); 24 | } 25 | 26 | IOTHUB_CLIENT_HANDLE IoTHubClient_CreateFromDeviceAuth(const char* iothub_uri, const char* device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 27 | { 28 | return (IOTHUB_CLIENT_HANDLE)IoTHubClientCore_CreateFromDeviceAuth(iothub_uri, device_id, protocol); 29 | } 30 | 31 | void IoTHubClient_Destroy(IOTHUB_CLIENT_HANDLE iotHubClientHandle) 32 | { 33 | IoTHubClientCore_Destroy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle); 34 | } 35 | 36 | IOTHUB_CLIENT_RESULT IoTHubClient_SendEventAsync(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 37 | { 38 | return IoTHubClientCore_SendEventAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback); 39 | } 40 | 41 | IOTHUB_CLIENT_RESULT IoTHubClient_GetSendStatus(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus) 42 | { 43 | return IoTHubClientCore_GetSendStatus((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, iotHubClientStatus); 44 | } 45 | 46 | IOTHUB_CLIENT_RESULT IoTHubClient_SetMessageCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback) 47 | { 48 | return IoTHubClientCore_SetMessageCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, messageCallback, userContextCallback); 49 | } 50 | 51 | IOTHUB_CLIENT_RESULT IoTHubClient_SetConnectionStatusCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK connectionStatusCallback, void * userContextCallback) 52 | { 53 | return IoTHubClientCore_SetConnectionStatusCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, connectionStatusCallback, userContextCallback); 54 | } 55 | 56 | IOTHUB_CLIENT_RESULT IoTHubClient_SetRetryPolicy(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY retryPolicy, size_t retryTimeoutLimitInSeconds) 57 | { 58 | return IoTHubClientCore_SetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 59 | } 60 | 61 | IOTHUB_CLIENT_RESULT IoTHubClient_GetRetryPolicy(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY* retryPolicy, size_t* retryTimeoutLimitInSeconds) 62 | { 63 | return IoTHubClientCore_GetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 64 | } 65 | 66 | IOTHUB_CLIENT_RESULT IoTHubClient_GetLastMessageReceiveTime(IOTHUB_CLIENT_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime) 67 | { 68 | return IoTHubClientCore_GetLastMessageReceiveTime((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, lastMessageReceiveTime); 69 | } 70 | 71 | IOTHUB_CLIENT_RESULT IoTHubClient_SetOption(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const char* optionName, const void* value) 72 | { 73 | return IoTHubClientCore_SetOption((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, optionName, value); 74 | } 75 | 76 | IOTHUB_CLIENT_RESULT IoTHubClient_SetDeviceTwinCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 77 | { 78 | return IoTHubClientCore_SetDeviceTwinCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 79 | } 80 | 81 | IOTHUB_CLIENT_RESULT IoTHubClient_SendReportedState(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* reportedState, size_t size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reportedStateCallback, void* userContextCallback) 82 | { 83 | return IoTHubClientCore_SendReportedState((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, reportedState, size, reportedStateCallback, userContextCallback); 84 | } 85 | 86 | IOTHUB_CLIENT_RESULT IoTHubClient_SetDeviceMethodCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC deviceMethodCallback, void* userContextCallback) 87 | { 88 | return IoTHubClientCore_SetDeviceMethodCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, deviceMethodCallback, userContextCallback); 89 | } 90 | 91 | IOTHUB_CLIENT_RESULT IoTHubClient_SetDeviceMethodCallback_Ex(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_INBOUND_DEVICE_METHOD_CALLBACK inboundDeviceMethodCallback, void* userContextCallback) 92 | { 93 | return IoTHubClientCore_SetDeviceMethodCallback_Ex((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, inboundDeviceMethodCallback, userContextCallback); 94 | } 95 | 96 | IOTHUB_CLIENT_RESULT IoTHubClient_DeviceMethodResponse(IOTHUB_CLIENT_HANDLE iotHubClientHandle, METHOD_HANDLE methodId, const unsigned char* response, size_t respSize, int statusCode) 97 | { 98 | return IoTHubClientCore_DeviceMethodResponse((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, methodId, response, respSize, statusCode); 99 | } 100 | 101 | #ifndef DONT_USE_UPLOADTOBLOB 102 | 103 | IOTHUB_CLIENT_RESULT IoTHubClient_UploadToBlobAsync(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const char* destinationFileName, const unsigned char* source, size_t size, IOTHUB_CLIENT_FILE_UPLOAD_CALLBACK iotHubClientFileUploadCallback, void* context) 104 | { 105 | return IoTHubClientCore_UploadToBlobAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, destinationFileName, source, size, iotHubClientFileUploadCallback, context); 106 | } 107 | 108 | IOTHUB_CLIENT_RESULT IoTHubClient_UploadMultipleBlocksToBlobAsync(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK getDataCallback, void* context) 109 | { 110 | return IoTHubClientCore_UploadMultipleBlocksToBlobAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, destinationFileName, getDataCallback, NULL, context); 111 | } 112 | 113 | IOTHUB_CLIENT_RESULT IoTHubClient_UploadMultipleBlocksToBlobAsyncEx(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX getDataCallbackEx, void* context) 114 | { 115 | return IoTHubClientCore_UploadMultipleBlocksToBlobAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, destinationFileName, NULL, getDataCallbackEx, context); 116 | } 117 | 118 | #endif /*DONT_USE_UPLOADTOBLOB*/ 119 | 120 | -------------------------------------------------------------------------------- /src/internal/iothubtransport_amqp_device.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef IOTHUBTRANSPORTAMQP_AMQP_DEVICE_H 5 | #define IOTHUBTRANSPORTAMQP_AMQP_DEVICE_H 6 | 7 | #include "umock_c/umock_c_prod.h" 8 | #include "azure_c_shared_utility/optionhandler.h" 9 | #include "azure_uamqp_c/session.h" 10 | #include "azure_uamqp_c/cbs.h" 11 | #include "iothub_message.h" 12 | #include "iothub_client_private.h" 13 | #include "iothubtransport_amqp_device.h" 14 | 15 | #ifdef __cplusplus 16 | extern "C" 17 | { 18 | #endif 19 | 20 | // @brief name of option to apply the instance obtained using amqp_device_retrieve_options 21 | static const char* DEVICE_OPTION_SAVED_OPTIONS = "saved_device_options"; 22 | static const char* DEVICE_OPTION_EVENT_SEND_TIMEOUT_SECS = "event_send_timeout_secs"; 23 | static const char* DEVICE_OPTION_CBS_REQUEST_TIMEOUT_SECS = "cbs_request_timeout_secs"; 24 | static const char* DEVICE_OPTION_SAS_TOKEN_REFRESH_TIME_SECS = "sas_token_refresh_time_secs"; 25 | static const char* DEVICE_OPTION_SAS_TOKEN_LIFETIME_SECS = "sas_token_lifetime_secs"; 26 | 27 | #define DEVICE_STATE_VALUES \ 28 | DEVICE_STATE_STOPPED, \ 29 | DEVICE_STATE_STOPPING, \ 30 | DEVICE_STATE_STARTING, \ 31 | DEVICE_STATE_STARTED, \ 32 | DEVICE_STATE_ERROR_AUTH, \ 33 | DEVICE_STATE_ERROR_AUTH_TIMEOUT, \ 34 | DEVICE_STATE_ERROR_MSG 35 | 36 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_STATE, DEVICE_STATE_VALUES); 37 | 38 | #define DEVICE_AUTH_MODE_VALUES \ 39 | DEVICE_AUTH_MODE_CBS, \ 40 | DEVICE_AUTH_MODE_X509 41 | 42 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_AUTH_MODE, DEVICE_AUTH_MODE_VALUES); 43 | 44 | #define DEVICE_SEND_STATUS_VALUES \ 45 | DEVICE_SEND_STATUS_IDLE, \ 46 | DEVICE_SEND_STATUS_BUSY 47 | 48 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_SEND_STATUS, DEVICE_SEND_STATUS_VALUES); 49 | 50 | #define D2C_EVENT_SEND_RESULT_VALUES \ 51 | D2C_EVENT_SEND_COMPLETE_RESULT_OK, \ 52 | D2C_EVENT_SEND_COMPLETE_RESULT_ERROR_CANNOT_PARSE, \ 53 | D2C_EVENT_SEND_COMPLETE_RESULT_ERROR_FAIL_SENDING, \ 54 | D2C_EVENT_SEND_COMPLETE_RESULT_ERROR_TIMEOUT, \ 55 | D2C_EVENT_SEND_COMPLETE_RESULT_DEVICE_DESTROYED, \ 56 | D2C_EVENT_SEND_COMPLETE_RESULT_ERROR_UNKNOWN 57 | 58 | MU_DEFINE_ENUM_WITHOUT_INVALID(D2C_EVENT_SEND_RESULT, D2C_EVENT_SEND_RESULT_VALUES); 59 | 60 | #define DEVICE_MESSAGE_DISPOSITION_RESULT_VALUES \ 61 | DEVICE_MESSAGE_DISPOSITION_RESULT_NONE, \ 62 | DEVICE_MESSAGE_DISPOSITION_RESULT_ACCEPTED, \ 63 | DEVICE_MESSAGE_DISPOSITION_RESULT_REJECTED, \ 64 | DEVICE_MESSAGE_DISPOSITION_RESULT_RELEASED 65 | 66 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_MESSAGE_DISPOSITION_RESULT, DEVICE_MESSAGE_DISPOSITION_RESULT_VALUES); 67 | 68 | #define DEVICE_TWIN_UPDATE_RESULT_STRINGS \ 69 | DEVICE_TWIN_UPDATE_RESULT_OK, \ 70 | DEVICE_TWIN_UPDATE_RESULT_ERROR 71 | 72 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_TWIN_UPDATE_RESULT, DEVICE_TWIN_UPDATE_RESULT_STRINGS); 73 | 74 | #define DEVICE_TWIN_UPDATE_TYPE_STRINGS \ 75 | DEVICE_TWIN_UPDATE_TYPE_PARTIAL, \ 76 | DEVICE_TWIN_UPDATE_TYPE_COMPLETE 77 | 78 | MU_DEFINE_ENUM_WITHOUT_INVALID(DEVICE_TWIN_UPDATE_TYPE, DEVICE_TWIN_UPDATE_TYPE_STRINGS) 79 | 80 | typedef struct DEVICE_MESSAGE_DISPOSITION_INFO_TAG 81 | { 82 | unsigned long message_id; 83 | char* source; 84 | } DEVICE_MESSAGE_DISPOSITION_INFO; 85 | 86 | typedef void(*ON_DEVICE_STATE_CHANGED)(void* context, DEVICE_STATE previous_state, DEVICE_STATE new_state); 87 | typedef DEVICE_MESSAGE_DISPOSITION_RESULT(*ON_DEVICE_C2D_MESSAGE_RECEIVED)(IOTHUB_MESSAGE_HANDLE message, DEVICE_MESSAGE_DISPOSITION_INFO* disposition_info, void* context); 88 | typedef void(*ON_DEVICE_D2C_EVENT_SEND_COMPLETE)(IOTHUB_MESSAGE_LIST* message, D2C_EVENT_SEND_RESULT result, void* context); 89 | typedef void(*DEVICE_SEND_TWIN_UPDATE_COMPLETE_CALLBACK)(DEVICE_TWIN_UPDATE_RESULT result, int status_code, void* context); 90 | typedef void(*DEVICE_TWIN_UPDATE_RECEIVED_CALLBACK)(DEVICE_TWIN_UPDATE_TYPE update_type, const unsigned char* message, size_t length, void* context); 91 | 92 | typedef struct DEVICE_CONFIG_TAG 93 | { 94 | const char* device_id; 95 | const char* module_id; 96 | pfTransport_GetOption_Product_Info_Callback prod_info_cb; 97 | void* prod_info_ctx; 98 | char* iothub_host_fqdn; 99 | DEVICE_AUTH_MODE authentication_mode; 100 | ON_DEVICE_STATE_CHANGED on_state_changed_callback; 101 | void* on_state_changed_context; 102 | 103 | // Auth module used to generating handle authorization 104 | // with either SAS Token, x509 Certs, and Device SAS Token 105 | IOTHUB_AUTHORIZATION_HANDLE authorization_module; 106 | } AMQP_DEVICE_CONFIG; 107 | 108 | typedef struct AMQP_DEVICE_INSTANCE* AMQP_DEVICE_HANDLE; 109 | 110 | MOCKABLE_FUNCTION(, AMQP_DEVICE_HANDLE, amqp_device_create, AMQP_DEVICE_CONFIG*, config); 111 | MOCKABLE_FUNCTION(, void, amqp_device_destroy, AMQP_DEVICE_HANDLE, handle); 112 | MOCKABLE_FUNCTION(, int, amqp_device_start_async, AMQP_DEVICE_HANDLE, handle, SESSION_HANDLE, session_handle, CBS_HANDLE, cbs_handle); 113 | MOCKABLE_FUNCTION(, int, amqp_device_stop, AMQP_DEVICE_HANDLE, handle); 114 | MOCKABLE_FUNCTION(, void, amqp_device_do_work, AMQP_DEVICE_HANDLE, handle); 115 | MOCKABLE_FUNCTION(, int, amqp_device_send_event_async, AMQP_DEVICE_HANDLE, handle, IOTHUB_MESSAGE_LIST*, message, ON_DEVICE_D2C_EVENT_SEND_COMPLETE, on_device_d2c_event_send_complete_callback, void*, context); 116 | MOCKABLE_FUNCTION(, int, amqp_device_send_twin_update_async, AMQP_DEVICE_HANDLE, handle, CONSTBUFFER_HANDLE, data, DEVICE_SEND_TWIN_UPDATE_COMPLETE_CALLBACK, on_send_twin_update_complete_callback, void*, context); 117 | MOCKABLE_FUNCTION(, int, amqp_device_subscribe_for_twin_updates, AMQP_DEVICE_HANDLE, handle, DEVICE_TWIN_UPDATE_RECEIVED_CALLBACK, on_device_twin_update_received_callback, void*, context); 118 | MOCKABLE_FUNCTION(, int, amqp_device_unsubscribe_for_twin_updates, AMQP_DEVICE_HANDLE, handle); 119 | MOCKABLE_FUNCTION(, int, amqp_device_get_twin_async, AMQP_DEVICE_HANDLE, handle, DEVICE_TWIN_UPDATE_RECEIVED_CALLBACK, on_device_get_twin_completed_callback, void*, context); 120 | MOCKABLE_FUNCTION(, int, amqp_device_get_send_status, AMQP_DEVICE_HANDLE, handle, DEVICE_SEND_STATUS*, send_status); 121 | MOCKABLE_FUNCTION(, int, amqp_device_subscribe_message, AMQP_DEVICE_HANDLE, handle, ON_DEVICE_C2D_MESSAGE_RECEIVED, on_message_received_callback, void*, context); 122 | MOCKABLE_FUNCTION(, int, amqp_device_unsubscribe_message, AMQP_DEVICE_HANDLE, handle); 123 | MOCKABLE_FUNCTION(, int, amqp_device_send_message_disposition, AMQP_DEVICE_HANDLE, AMQP_DEVICE_HANDLE, DEVICE_MESSAGE_DISPOSITION_INFO*, disposition_info, DEVICE_MESSAGE_DISPOSITION_RESULT, disposition_result); 124 | MOCKABLE_FUNCTION(, int, amqp_device_set_retry_policy, AMQP_DEVICE_HANDLE, handle, IOTHUB_CLIENT_RETRY_POLICY, policy, size_t, retry_timeout_limit_in_seconds); 125 | MOCKABLE_FUNCTION(, int, amqp_device_set_option, AMQP_DEVICE_HANDLE, handle, const char*, name, void*, value); 126 | MOCKABLE_FUNCTION(, OPTIONHANDLER_HANDLE, amqp_device_retrieve_options, AMQP_DEVICE_HANDLE, handle); 127 | 128 | 129 | #ifdef __cplusplus 130 | } 131 | #endif 132 | 133 | #endif // IOTHUBTRANSPORTAMQP_AMQP_DEVICE_H 134 | -------------------------------------------------------------------------------- /src/codefirst.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #ifndef CODEFIRST_H 5 | #define CODEFIRST_H 6 | 7 | #include "methodreturn.h" 8 | #include "agenttypesystem.h" 9 | #include "schema.h" 10 | #include "azure_macro_utils/macro_utils.h" 11 | #include "azure_c_shared_utility/strings.h" 12 | #include "iotdevice.h" 13 | 14 | #ifdef __cplusplus 15 | #include 16 | #include 17 | extern "C" { 18 | #else 19 | #include 20 | #include 21 | #include 22 | #endif 23 | 24 | typedef char* ascii_char_ptr; 25 | typedef char* ascii_char_ptr_no_quotes; 26 | 27 | typedef enum REFLECTION_TYPE_TAG 28 | { 29 | REFLECTION_METHOD_TYPE, 30 | REFLECTION_DESIRED_PROPERTY_TYPE, 31 | REFLECTION_REPORTED_PROPERTY_TYPE, 32 | REFLECTION_STRUCT_TYPE, 33 | REFLECTION_FIELD_TYPE, 34 | REFLECTION_PROPERTY_TYPE, 35 | REFLECTION_ACTION_TYPE, 36 | REFLECTION_MODEL_TYPE, 37 | REFLECTION_NOTHING 38 | }REFLECTION_TYPE; 39 | 40 | typedef EXECUTE_COMMAND_RESULT (*actionWrapper)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values); 41 | 42 | typedef METHODRETURN_HANDLE (*methodWrapper)(void* device, size_t ParameterCount, const AGENT_DATA_TYPE* values); 43 | 44 | typedef struct REFLECTION_STRUCT_TAG 45 | { 46 | const char* name; 47 | }REFLECTION_STRUCT; 48 | 49 | typedef struct WRAPPER_ARGUMENT_TAG 50 | { 51 | const char* type; 52 | const char* name; 53 | }WRAPPER_ARGUMENT; 54 | 55 | typedef struct REFLECTION_ACTION_TAG 56 | { 57 | const char* name; 58 | size_t nArguments; 59 | const WRAPPER_ARGUMENT* arguments; 60 | actionWrapper wrapper; 61 | const char* modelName; 62 | }REFLECTION_ACTION; 63 | 64 | typedef struct REFLECTION_METHOD_TAG 65 | { 66 | const char* name; 67 | size_t nArguments; 68 | const WRAPPER_ARGUMENT* arguments; 69 | methodWrapper wrapper; 70 | const char* modelName; 71 | }REFLECTION_METHOD; 72 | 73 | typedef struct REFLECTION_FIELD_TAG 74 | { 75 | const char* fieldName; 76 | const char* fieldType; 77 | const char* structName; 78 | }REFLECTION_FIELD; 79 | 80 | typedef struct REFLECTION_PROPERTY_TAG 81 | { 82 | const char* name; 83 | const char* type; 84 | int(*Create_AGENT_DATA_TYPE_from_Ptr)(void* param, AGENT_DATA_TYPE* dest); 85 | size_t offset; 86 | size_t size; 87 | const char* modelName; 88 | } REFLECTION_PROPERTY; 89 | 90 | 91 | typedef struct REFLECTION_REPORTED_PROPERTY_TAG 92 | { 93 | const char* name; 94 | const char* type; 95 | int(*Create_AGENT_DATA_TYPE_from_Ptr)(void* param, AGENT_DATA_TYPE* dest); 96 | size_t offset; 97 | size_t size; 98 | const char* modelName; 99 | } REFLECTION_REPORTED_PROPERTY; 100 | 101 | typedef struct REFLECTION_DESIRED_PROPERTY_TAG 102 | { 103 | pfOnDesiredProperty onDesiredProperty; 104 | void(*desiredPropertInitialize)(void* destination); 105 | void(*desiredPropertDeinitialize)(void* destination); 106 | const char* name; 107 | const char* type; 108 | int(*FromAGENT_DATA_TYPE)(const AGENT_DATA_TYPE* source, void* dest); /*destination is "something" everytime. When the DESIRED_PROPERTY is a MODEL, the function is empty*/ 109 | size_t offset; 110 | size_t size; 111 | const char* modelName; 112 | } REFLECTION_DESIRED_PROPERTY; 113 | 114 | typedef struct REFLECTION_MODEL_TAG 115 | { 116 | const char* name; 117 | } REFLECTION_MODEL; 118 | 119 | typedef struct REFLECTED_SOMETHING_TAG 120 | { 121 | REFLECTION_TYPE type; 122 | const struct REFLECTED_SOMETHING_TAG* next; 123 | struct what 124 | { 125 | REFLECTION_METHOD method; 126 | REFLECTION_DESIRED_PROPERTY desiredProperty; 127 | REFLECTION_REPORTED_PROPERTY reportedProperty; 128 | REFLECTION_STRUCT structure; 129 | REFLECTION_FIELD field; 130 | REFLECTION_PROPERTY property; 131 | REFLECTION_ACTION action; 132 | REFLECTION_MODEL model; 133 | } what; 134 | } REFLECTED_SOMETHING; 135 | 136 | typedef struct REFLECTED_DATA_FROM_DATAPROVIDER_TAG 137 | { 138 | const REFLECTED_SOMETHING* reflectedData; 139 | }REFLECTED_DATA_FROM_DATAPROVIDER; 140 | 141 | #define ALL_SOMETHING_REFLECTED(schemaNamespace) MU_C2(schemaNamespace, _allSomethingReflected) 142 | #define ALL_REFLECTED(schemaNamespace) MU_C2(schemaNamespace, _allReflected) 143 | #define ADDRESS_OF_ALL_REFLECTED(schemaNamespace) & MU_C2(schemaNamespace, _allReflected), 144 | #define DECLARE_EXTERN_CONST_DATAPROVIDER_DATA(x) extern const REFLECTED_DATA_FROM_DATAPROVIDER ALL_REFLECTED(x); 145 | 146 | #define CODEFIRST_RESULT_VALUES \ 147 | CODEFIRST_OK, \ 148 | CODEFIRST_INVALID_ARG, \ 149 | CODEFIRST_ALREADY_INIT, \ 150 | CODEFIRST_NOT_INIT, \ 151 | CODEFIRST_ERROR, \ 152 | CODEFIRST_NOT_ENOUGH_MEMORY, \ 153 | CODEFIRST_ACTION_NOT_FOUND, \ 154 | CODEFIRST_ACTION_EXECUTION_ERROR, \ 155 | CODEFIRST_SCHEMA_ERROR, \ 156 | CODEFIRST_AGENT_DATA_TYPE_ERROR, \ 157 | CODEFIRST_VALUES_FROM_DIFFERENT_DEVICES_ERROR, \ 158 | CODEFIRST_DEVICE_FAILED, \ 159 | CODEFIRST_DEVICE_PUBLISH_FAILED, \ 160 | CODEFIRST_NOT_A_PROPERTY 161 | 162 | MU_DEFINE_ENUM_WITHOUT_INVALID(CODEFIRST_RESULT, CODEFIRST_RESULT_VALUES) 163 | 164 | #include "umock_c/umock_c_prod.h" 165 | MOCKABLE_FUNCTION(, CODEFIRST_RESULT, CodeFirst_Init, const char*, overrideSchemaNamespace); 166 | MOCKABLE_FUNCTION(, void, CodeFirst_Deinit); 167 | MOCKABLE_FUNCTION(, SCHEMA_HANDLE, CodeFirst_RegisterSchema, const char*, schemaNamespace, const REFLECTED_DATA_FROM_DATAPROVIDER*, metadata); 168 | 169 | MOCKABLE_FUNCTION(, EXECUTE_COMMAND_RESULT, CodeFirst_InvokeAction, DEVICE_HANDLE, deviceHandle, void*, callbackUserContext, const char*, relativeActionPath, const char*, actionName, size_t, parameterCount, const AGENT_DATA_TYPE*, parameterValues); 170 | 171 | MOCKABLE_FUNCTION(, METHODRETURN_HANDLE, CodeFirst_InvokeMethod, DEVICE_HANDLE, deviceHandle, void*, callbackUserContext, const char*, relativeMethodPath, const char*, methodName, size_t, parameterCount, const AGENT_DATA_TYPE*, parameterValues); 172 | 173 | MOCKABLE_FUNCTION(, EXECUTE_COMMAND_RESULT, CodeFirst_ExecuteCommand, void*, device, const char*, command); 174 | 175 | MOCKABLE_FUNCTION(, METHODRETURN_HANDLE, CodeFirst_ExecuteMethod, void*, device, const char*, methodName, const char*, methodPayload); 176 | 177 | MOCKABLE_FUNCTION(, void*, CodeFirst_CreateDevice, SCHEMA_MODEL_TYPE_HANDLE, model, const REFLECTED_DATA_FROM_DATAPROVIDER*, metadata, size_t, dataSize, bool, includePropertyPath); 178 | MOCKABLE_FUNCTION(, void, CodeFirst_DestroyDevice, void*, device); 179 | 180 | extern CODEFIRST_RESULT CodeFirst_SendAsync(unsigned char** destination, size_t* destinationSize, size_t numProperties, ...); 181 | extern CODEFIRST_RESULT CodeFirst_SendAsyncReported(unsigned char** destination, size_t* destinationSize, size_t numReportedProperties, ...); 182 | 183 | MOCKABLE_FUNCTION(, CODEFIRST_RESULT, CodeFirst_IngestDesiredProperties, void*, device, const char*, jsonPayload, bool, parseDesiredNode); 184 | 185 | MOCKABLE_FUNCTION(, AGENT_DATA_TYPE_TYPE, CodeFirst_GetPrimitiveType, const char*, typeName); 186 | 187 | #ifdef __cplusplus 188 | } 189 | #endif 190 | 191 | #endif /* CODEFIRST_H */ 192 | -------------------------------------------------------------------------------- /src/iothub_device_client_ll.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include 6 | #include "azure_c_shared_utility/optimize_size.h" 7 | #include "azure_c_shared_utility/gballoc.h" 8 | #include "azure_c_shared_utility/string_tokenizer.h" 9 | #include "azure_c_shared_utility/doublylinkedlist.h" 10 | #include "azure_c_shared_utility/xlogging.h" 11 | #include "azure_c_shared_utility/tickcounter.h" 12 | #include "azure_c_shared_utility/constbuffer.h" 13 | #include "azure_c_shared_utility/platform.h" 14 | 15 | #include "iothub_client_core_ll.h" 16 | #include "internal/iothub_client_authorization.h" 17 | #include "iothub_device_client_ll.h" 18 | #include "iothub_transport_ll.h" 19 | #include "internal/iothub_client_private.h" 20 | #include "iothub_client_options.h" 21 | #include "iothub_client_version.h" 22 | #include "internal/iothub_client_diagnostic.h" 23 | #include 24 | 25 | #ifndef DONT_USE_UPLOADTOBLOB 26 | #include "internal/iothub_client_ll_uploadtoblob.h" 27 | #endif 28 | 29 | IOTHUB_DEVICE_CLIENT_LL_HANDLE IoTHubDeviceClient_LL_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 30 | { 31 | return (IOTHUB_DEVICE_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateFromConnectionString(connectionString, protocol); 32 | } 33 | 34 | IOTHUB_DEVICE_CLIENT_LL_HANDLE IoTHubDeviceClient_LL_Create(const IOTHUB_CLIENT_CONFIG* config) 35 | { 36 | return (IOTHUB_DEVICE_CLIENT_LL_HANDLE)IoTHubClientCore_LL_Create(config); 37 | } 38 | 39 | IOTHUB_DEVICE_CLIENT_LL_HANDLE IoTHubDeviceClient_LL_CreateWithTransport(const IOTHUB_CLIENT_DEVICE_CONFIG * config) 40 | { 41 | return (IOTHUB_DEVICE_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateWithTransport(config); 42 | } 43 | 44 | IOTHUB_DEVICE_CLIENT_LL_HANDLE IoTHubDeviceClient_LL_CreateFromDeviceAuth(const char* iothub_uri, const char* device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 45 | { 46 | return (IOTHUB_DEVICE_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateFromDeviceAuth(iothub_uri, device_id, protocol); 47 | } 48 | 49 | void IoTHubDeviceClient_LL_Destroy(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle) 50 | { 51 | IoTHubClientCore_LL_Destroy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle); 52 | } 53 | 54 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SendEventAsync(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 55 | { 56 | return IoTHubClientCore_LL_SendEventAsync((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback); 57 | } 58 | 59 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_GetSendStatus(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus) 60 | { 61 | return IoTHubClientCore_LL_GetSendStatus((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, iotHubClientStatus); 62 | } 63 | 64 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetMessageCallback(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback) 65 | { 66 | return IoTHubClientCore_LL_SetMessageCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, messageCallback, userContextCallback); 67 | } 68 | 69 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetConnectionStatusCallback(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK connectionStatusCallback, void * userContextCallback) 70 | { 71 | return IoTHubClientCore_LL_SetConnectionStatusCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, connectionStatusCallback, userContextCallback); 72 | } 73 | 74 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetRetryPolicy(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY retryPolicy, size_t retryTimeoutLimitInSeconds) 75 | { 76 | return IoTHubClientCore_LL_SetRetryPolicy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 77 | } 78 | 79 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_GetRetryPolicy(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY* retryPolicy, size_t* retryTimeoutLimitInSeconds) 80 | { 81 | return IoTHubClientCore_LL_GetRetryPolicy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 82 | } 83 | 84 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_GetLastMessageReceiveTime(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime) 85 | { 86 | return IoTHubClientCore_LL_GetLastMessageReceiveTime((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, lastMessageReceiveTime); 87 | } 88 | 89 | void IoTHubDeviceClient_LL_DoWork(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle) 90 | { 91 | IoTHubClientCore_LL_DoWork((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle); 92 | } 93 | 94 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetOption(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, const char* optionName, const void* value) 95 | { 96 | return IoTHubClientCore_LL_SetOption((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, optionName, value); 97 | } 98 | 99 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetDeviceTwinCallback(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 100 | { 101 | return IoTHubClientCore_LL_SetDeviceTwinCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 102 | } 103 | 104 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_GetTwinAsync(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 105 | { 106 | return IoTHubClientCore_LL_GetTwinAsync((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 107 | } 108 | 109 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SendReportedState(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, const unsigned char* reportedState, size_t size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reportedStateCallback, void* userContextCallback) 110 | { 111 | return IoTHubClientCore_LL_SendReportedState((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, reportedState, size, reportedStateCallback, userContextCallback); 112 | } 113 | 114 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_SetDeviceMethodCallback(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC deviceMethodCallback, void* userContextCallback) 115 | { 116 | return IoTHubClientCore_LL_SetDeviceMethodCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, deviceMethodCallback, userContextCallback); 117 | } 118 | 119 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_DeviceMethodResponse(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, METHOD_HANDLE methodId, const unsigned char* response, size_t response_size, int status_response) 120 | { 121 | return IoTHubClientCore_LL_DeviceMethodResponse((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, methodId, response, response_size, status_response); 122 | } 123 | 124 | #ifndef DONT_USE_UPLOADTOBLOB 125 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_UploadToBlob(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, const char* destinationFileName, const unsigned char* source, size_t size) 126 | { 127 | return IoTHubClientCore_LL_UploadToBlob((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, destinationFileName, source, size); 128 | } 129 | 130 | IOTHUB_CLIENT_RESULT IoTHubDeviceClient_LL_UploadMultipleBlocksToBlob(IOTHUB_DEVICE_CLIENT_LL_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX getDataCallbackEx, void* context) 131 | { 132 | return IoTHubClientCore_LL_UploadMultipleBlocksToBlobEx((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, destinationFileName, getDataCallbackEx, context); 133 | } 134 | 135 | #endif 136 | -------------------------------------------------------------------------------- /src/iothub_module_client.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include "umock_c/umock_c_prod.h" 6 | #include "azure_c_shared_utility/gballoc.h" 7 | #include "azure_c_shared_utility/xlogging.h" 8 | 9 | #include "iothub_client_core.h" 10 | #include "iothub_module_client.h" 11 | 12 | IOTHUB_MODULE_CLIENT_HANDLE IoTHubModuleClient_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 13 | { 14 | return (IOTHUB_MODULE_CLIENT_HANDLE)IoTHubClientCore_CreateFromConnectionString(connectionString, protocol); 15 | } 16 | 17 | void IoTHubModuleClient_Destroy(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle) 18 | { 19 | IoTHubClientCore_Destroy((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle); 20 | } 21 | 22 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SendEventAsync(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 23 | { 24 | return IoTHubClientCore_SendEventAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback); 25 | } 26 | 27 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_GetSendStatus(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus) 28 | { 29 | return IoTHubClientCore_GetSendStatus((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, iotHubClientStatus); 30 | } 31 | 32 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetMessageCallback(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback) 33 | { 34 | return IoTHubClientCore_SetInputMessageCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, NULL, messageCallback, userContextCallback);} 35 | 36 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetConnectionStatusCallback(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK connectionStatusCallback, void * userContextCallback) 37 | { 38 | return IoTHubClientCore_SetConnectionStatusCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, connectionStatusCallback, userContextCallback); 39 | } 40 | 41 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetRetryPolicy(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_RETRY_POLICY retryPolicy, size_t retryTimeoutLimitInSeconds) 42 | { 43 | return IoTHubClientCore_SetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 44 | } 45 | 46 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_GetRetryPolicy(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_RETRY_POLICY* retryPolicy, size_t* retryTimeoutLimitInSeconds) 47 | { 48 | return IoTHubClientCore_GetRetryPolicy((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 49 | } 50 | 51 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_GetLastMessageReceiveTime(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, time_t* lastMessageReceiveTime) 52 | { 53 | return IoTHubClientCore_GetLastMessageReceiveTime((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, lastMessageReceiveTime); 54 | } 55 | 56 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetOption(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, const char* optionName, const void* value) 57 | { 58 | return IoTHubClientCore_SetOption((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, optionName, value); 59 | } 60 | 61 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetModuleTwinCallback(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK moduleTwinCallback, void* userContextCallback) 62 | { 63 | return IoTHubClientCore_SetDeviceTwinCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, moduleTwinCallback, userContextCallback); 64 | } 65 | 66 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SendReportedState(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, const unsigned char* reportedState, size_t size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reportedStateCallback, void* userContextCallback) 67 | { 68 | return IoTHubClientCore_SendReportedState((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, reportedState, size, reportedStateCallback, userContextCallback); 69 | } 70 | 71 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_GetTwinAsync(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK moduleTwinCallback, void* userContextCallback) 72 | { 73 | return IoTHubClientCore_GetTwinAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, moduleTwinCallback, userContextCallback); 74 | } 75 | 76 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetModuleMethodCallback(IOTHUB_MODULE_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC methodCallback, void* userContextCallback) 77 | { 78 | return IoTHubClientCore_SetDeviceMethodCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubClientHandle, (IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC)methodCallback, userContextCallback); 79 | } 80 | 81 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SendEventToOutputAsync(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, const char* outputName, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 82 | { 83 | return IoTHubClientCore_SendEventToOutputAsync((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, eventMessageHandle, outputName, eventConfirmationCallback, userContextCallback); 84 | } 85 | 86 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_SetInputMessageCallback(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, const char* inputName, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC eventHandlerCallback, void* userContextCallback) 87 | { 88 | return IoTHubClientCore_SetInputMessageCallback((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, inputName, eventHandlerCallback, userContextCallback); 89 | } 90 | 91 | #ifdef USE_EDGE_MODULES 92 | 93 | IOTHUB_MODULE_CLIENT_HANDLE IoTHubModuleClient_CreateFromEnvironment(IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 94 | { 95 | return IoTHubClientCore_CreateFromEnvironment(protocol); 96 | } 97 | 98 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_DeviceMethodInvokeAsync(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, const char* deviceId, const char* methodName, const char* methodPayload, unsigned int timeout, IOTHUB_METHOD_INVOKE_CALLBACK methodInvokeCallback, void* context) 99 | { 100 | IOTHUB_CLIENT_RESULT result; 101 | 102 | if ((iotHubModuleClientHandle == NULL) || (deviceId == NULL) || (methodName == NULL) || (methodPayload == NULL)) 103 | { 104 | LogError("Argument cannot be NULL"); 105 | result = IOTHUB_CLIENT_INVALID_ARG; 106 | } 107 | else 108 | { 109 | result = IoTHubClientCore_GenericMethodInvoke((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, deviceId, NULL, methodName, methodPayload, timeout, methodInvokeCallback, context); 110 | } 111 | return result; 112 | } 113 | 114 | IOTHUB_CLIENT_RESULT IoTHubModuleClient_ModuleMethodInvokeAsync(IOTHUB_MODULE_CLIENT_HANDLE iotHubModuleClientHandle, const char* deviceId, const char* moduleId, const char* methodName, const char* methodPayload, unsigned int timeout, IOTHUB_METHOD_INVOKE_CALLBACK methodInvokeCallback, void* context) 115 | { 116 | IOTHUB_CLIENT_RESULT result; 117 | 118 | if ((iotHubModuleClientHandle == NULL) || (deviceId == NULL) || (moduleId == NULL) || (methodName == NULL) || (methodPayload == NULL)) 119 | { 120 | LogError("Argument cannot be NULL"); 121 | result = IOTHUB_CLIENT_INVALID_ARG; 122 | } 123 | else 124 | { 125 | result = IoTHubClientCore_GenericMethodInvoke((IOTHUB_CLIENT_CORE_HANDLE)iotHubModuleClientHandle, deviceId, moduleId, methodName, methodPayload, timeout, methodInvokeCallback, context); 126 | } 127 | return result; 128 | } 129 | 130 | #endif /*USE_EDGE_MODULES*/ 131 | 132 | -------------------------------------------------------------------------------- /src/iothub_client_ll.c: -------------------------------------------------------------------------------- 1 | // Copyright (c) Microsoft. All rights reserved. 2 | // Licensed under the MIT license. See LICENSE file in the project root for full license information. 3 | 4 | #include 5 | #include 6 | #include "azure_c_shared_utility/optimize_size.h" 7 | #include "azure_c_shared_utility/gballoc.h" 8 | #include "azure_c_shared_utility/string_tokenizer.h" 9 | #include "azure_c_shared_utility/doublylinkedlist.h" 10 | #include "azure_c_shared_utility/xlogging.h" 11 | #include "azure_c_shared_utility/tickcounter.h" 12 | #include "azure_c_shared_utility/constbuffer.h" 13 | #include "azure_c_shared_utility/platform.h" 14 | 15 | #include "iothub_client_core_ll.h" 16 | #include "internal/iothub_client_authorization.h" 17 | #include "iothub_client_ll.h" 18 | #include "iothub_transport_ll.h" 19 | #include "iothub_device_client_ll.h" 20 | #include "internal/iothub_client_private.h" 21 | #include "iothub_client_options.h" 22 | #include "iothub_client_version.h" 23 | #include 24 | 25 | #ifndef DONT_USE_UPLOADTOBLOB 26 | #include "internal/iothub_client_ll_uploadtoblob.h" 27 | #endif 28 | 29 | IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 30 | { 31 | return (IOTHUB_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateFromConnectionString(connectionString, protocol); 32 | } 33 | 34 | IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_Create(const IOTHUB_CLIENT_CONFIG* config) 35 | { 36 | return (IOTHUB_CLIENT_LL_HANDLE)IoTHubClientCore_LL_Create(config); 37 | } 38 | 39 | IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_CreateWithTransport(const IOTHUB_CLIENT_DEVICE_CONFIG * config) 40 | { 41 | return (IOTHUB_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateWithTransport(config); 42 | } 43 | 44 | IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_CreateFromDeviceAuth(const char* iothub_uri, const char* device_id, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol) 45 | { 46 | return (IOTHUB_CLIENT_LL_HANDLE)IoTHubClientCore_LL_CreateFromDeviceAuth(iothub_uri, device_id, protocol); 47 | } 48 | 49 | void IoTHubClient_LL_Destroy(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle) 50 | { 51 | IoTHubClientCore_LL_Destroy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle); 52 | } 53 | 54 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SendEventAsync(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback) 55 | { 56 | return IoTHubClientCore_LL_SendEventAsync((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback); 57 | } 58 | 59 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_GetSendStatus(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus) 60 | { 61 | return IoTHubClientCore_LL_GetSendStatus((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, iotHubClientStatus); 62 | } 63 | 64 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetMessageCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback) 65 | { 66 | return IoTHubClientCore_LL_SetMessageCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, messageCallback, userContextCallback); 67 | } 68 | 69 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetConnectionStatusCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_CONNECTION_STATUS_CALLBACK connectionStatusCallback, void * userContextCallback) 70 | { 71 | return IoTHubClientCore_LL_SetConnectionStatusCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, connectionStatusCallback, userContextCallback); 72 | } 73 | 74 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetRetryPolicy(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY retryPolicy, size_t retryTimeoutLimitInSeconds) 75 | { 76 | return IoTHubClientCore_LL_SetRetryPolicy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 77 | } 78 | 79 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_GetRetryPolicy(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_RETRY_POLICY* retryPolicy, size_t* retryTimeoutLimitInSeconds) 80 | { 81 | return IoTHubClientCore_LL_GetRetryPolicy((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, retryPolicy, retryTimeoutLimitInSeconds); 82 | } 83 | 84 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_GetLastMessageReceiveTime(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime) 85 | { 86 | return IoTHubClientCore_LL_GetLastMessageReceiveTime((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, lastMessageReceiveTime); 87 | } 88 | 89 | void IoTHubClient_LL_DoWork(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle) 90 | { 91 | IoTHubClientCore_LL_DoWork((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle); 92 | } 93 | 94 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetDeviceTwinCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_TWIN_CALLBACK deviceTwinCallback, void* userContextCallback) 95 | { 96 | return IoTHubClientCore_LL_SetDeviceTwinCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, deviceTwinCallback, userContextCallback); 97 | } 98 | 99 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetOption(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, const char* optionName, const void* value) 100 | { 101 | return IoTHubClientCore_LL_SetOption((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, optionName, value); 102 | } 103 | 104 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SendReportedState(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, const unsigned char* reportedState, size_t size, IOTHUB_CLIENT_REPORTED_STATE_CALLBACK reportedStateCallback, void* userContextCallback) 105 | { 106 | return IoTHubClientCore_LL_SendReportedState((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, reportedState, size, reportedStateCallback, userContextCallback); 107 | } 108 | 109 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetDeviceMethodCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_DEVICE_METHOD_CALLBACK_ASYNC deviceMethodCallback, void* userContextCallback) 110 | { 111 | return IoTHubClientCore_LL_SetDeviceMethodCallback((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, deviceMethodCallback, userContextCallback); 112 | } 113 | 114 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetDeviceMethodCallback_Ex(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_INBOUND_DEVICE_METHOD_CALLBACK inboundDeviceMethodCallback, void* userContextCallback) 115 | { 116 | return IoTHubClientCore_LL_SetDeviceMethodCallback_Ex((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, inboundDeviceMethodCallback, userContextCallback); 117 | } 118 | 119 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_DeviceMethodResponse(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, METHOD_HANDLE methodId, const unsigned char* response, size_t response_size, int status_response) 120 | { 121 | return IoTHubClientCore_LL_DeviceMethodResponse((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, methodId, response, response_size, status_response); 122 | } 123 | 124 | #ifndef DONT_USE_UPLOADTOBLOB 125 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_UploadToBlob(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, const char* destinationFileName, const unsigned char* source, size_t size) 126 | { 127 | return IoTHubClientCore_LL_UploadToBlob((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, destinationFileName, source, size); 128 | } 129 | 130 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_UploadMultipleBlocksToBlob(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK getDataCallback, void* context) 131 | { 132 | return IoTHubClientCore_LL_UploadMultipleBlocksToBlob((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, destinationFileName, getDataCallback, context); 133 | } 134 | 135 | IOTHUB_CLIENT_RESULT IoTHubClient_LL_UploadMultipleBlocksToBlobEx(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, const char* destinationFileName, IOTHUB_CLIENT_FILE_UPLOAD_GET_DATA_CALLBACK_EX getDataCallbackEx, void* context) 136 | { 137 | return IoTHubClientCore_LL_UploadMultipleBlocksToBlobEx((IOTHUB_CLIENT_CORE_LL_HANDLE)iotHubClientHandle, destinationFileName, getDataCallbackEx, context); 138 | } 139 | #endif 140 | 141 | 142 | -------------------------------------------------------------------------------- /src/serializer.def: -------------------------------------------------------------------------------- 1 | LIBRARY serializer 2 | EXPORTS 3 | MethodReturn_Create 4 | MethodReturn_Destroy 5 | MethodReturn_GetReturn 6 | SCHEMA_SERIALIZER_RESULTStringStorage 7 | SCHEMA_SERIALIZER_RESULTStrings 8 | SCHEMA_SERIALIZER_RESULT_FromString 9 | SchemaSerializer_SerializeCommandMetadata 10 | SERIALIZER_RESULTStringStorage 11 | SERIALIZER_RESULTStrings 12 | SERIALIZER_RESULT_FromString 13 | serializer_init 14 | serializer_deinit 15 | serializer_setconfig 16 | SCHEMA_RESULTStringStorage 17 | SCHEMA_RESULTStrings 18 | SCHEMA_RESULT_FromString 19 | Schema_Create 20 | Schema_GetMetadata 21 | Schema_GetSchemaCount 22 | Schema_GetSchemaByNamespace 23 | Schema_GetSchemaForModel 24 | Schema_GetSchemaNamespace 25 | Schema_AddDeviceRef 26 | Schema_ReleaseDeviceRef 27 | Schema_CreateModelType 28 | Schema_GetSchemaForModelType 29 | Schema_GetModelName 30 | Schema_CreateStructType 31 | Schema_GetStructTypeName 32 | Schema_AddStructTypeProperty 33 | Schema_AddModelProperty 34 | Schema_AddModelReportedProperty 35 | Schema_AddModelDesiredProperty 36 | Schema_AddModelModel 37 | Schema_CreateModelAction 38 | Schema_CreateModelMethod 39 | Schema_AddModelActionArgument 40 | Schema_AddModelMethodArgument 41 | Schema_GetModelDesiredProperty_pfDesiredPropertyFromAGENT_DATA_TYPE 42 | Schema_GetModelDesiredProperty_pfOnDesiredProperty 43 | Schema_GetModelModelByName_Offset 44 | Schema_GetModelModelByName_OnDesiredProperty 45 | Schema_GetModelModelByIndex_Offset 46 | Schema_GetModelDesiredProperty_offset 47 | Schema_GetModelDesiredPropertyType 48 | Schema_GetModelDesiredProperty_pfDesiredPropertyDeinitialize 49 | Schema_GetModelDesiredProperty_pfDesiredPropertyInitialize 50 | Schema_GetModelElementByName 51 | Schema_GetModelCount 52 | Schema_GetModelByName 53 | Schema_GetModelByIndex 54 | Schema_GetModelPropertyCount 55 | Schema_GetModelPropertyByName 56 | Schema_GetModelPropertyByIndex 57 | Schema_GetModelReportedPropertyCount 58 | Schema_GetModelReportedPropertyByName 59 | Schema_GetModelReportedPropertyByIndex 60 | Schema_GetModelDesiredPropertyCount 61 | Schema_GetModelDesiredPropertyByName 62 | Schema_GetModelDesiredPropertyByIndex 63 | Schema_GetModelModelCount 64 | Schema_GetModelModelByName 65 | Schema_GetModelModelyByIndex 66 | Schema_GetModelModelPropertyNameByIndex 67 | Schema_ModelPropertyByPathExists 68 | Schema_ModelReportedPropertyByPathExists 69 | Schema_ModelDesiredPropertyByPathExists 70 | Schema_GetModelActionCount 71 | Schema_GetModelActionByName 72 | Schema_GetModelMethodByName 73 | Schema_GetModelActionByIndex 74 | Schema_GetModelActionArgumentCount 75 | Schema_GetModelMethodArgumentCount 76 | Schema_GetModelActionName 77 | Schema_GetModelActionArgumentByName 78 | Schema_GetModelActionArgumentByIndex 79 | Schema_GetModelMethodArgumentByIndex 80 | Schema_GetActionArgumentName 81 | Schema_GetMethodArgumentName 82 | Schema_GetActionArgumentType 83 | Schema_GetMethodArgumentType 84 | Schema_GetStructTypeCount 85 | Schema_GetStructTypeByName 86 | Schema_GetStructTypeByIndex 87 | Schema_GetStructTypePropertyCount 88 | Schema_GetStructTypePropertyByName 89 | Schema_GetStructTypePropertyByIndex 90 | Schema_GetPropertyName 91 | Schema_GetPropertyType 92 | Schema_Destroy 93 | Schema_DestroyIfUnused 94 | MULTITREE_RESULTStringStorage 95 | MULTITREE_RESULTStrings 96 | MULTITREE_RESULT_FromString 97 | MultiTree_Create 98 | MultiTree_AddLeaf 99 | MultiTree_AddChild 100 | MultiTree_GetChildCount 101 | MultiTree_GetChild 102 | MultiTree_GetChildByName 103 | MultiTree_GetName 104 | MultiTree_GetValue 105 | MultiTree_GetLeafValue 106 | MultiTree_SetValue 107 | MultiTree_Destroy 108 | JSON_ENCODER_TOSTRING_RESULTStringStorage 109 | JSON_ENCODER_RESULTStringStorage 110 | JSON_ENCODER_RESULTStrings 111 | JSON_ENCODER_RESULT_FromString 112 | JSON_ENCODER_TOSTRING_RESULTStrings 113 | JSON_ENCODER_TOSTRING_RESULT_FromString 114 | JSONEncoder_CharPtr_ToString 115 | JSONEncoder_EncodeTree 116 | JSONDecoder_JSON_To_MultiTree 117 | SkipWhiteSpaces 118 | DEVICE_RESULTStringStorage 119 | DEVICE_RESULTStrings 120 | DEVICE_RESULT_FromString 121 | Device_Create 122 | Device_Destroy 123 | Device_StartTransaction 124 | Device_PublishTransacted 125 | Device_EndTransaction 126 | Device_CancelTransaction 127 | Device_CreateTransaction_ReportedProperties 128 | Device_PublishTransacted_ReportedProperty 129 | Device_CommitTransaction_ReportedProperties 130 | Device_DestroyTransaction_ReportedProperties 131 | Device_ExecuteCommand 132 | Device_ExecuteMethod 133 | Device_IngestDesiredProperties 134 | DATA_SERIALIZER_RESULTStringStorage 135 | DATA_SERIALIZER_RESULTStrings 136 | DATA_SERIALIZER_RESULT_FromString 137 | DataSerializer_Encode 138 | DataSerializer_Decode 139 | DATA_PUBLISHER_RESULTStringStorage 140 | DATA_PUBLISHER_RESULTStrings 141 | DATA_PUBLISHER_RESULT_FromString 142 | DataPublisher_Create 143 | DataPublisher_Destroy 144 | DataPublisher_StartTransaction 145 | DataPublisher_PublishTransacted 146 | DataPublisher_EndTransaction 147 | DataPublisher_CancelTransaction 148 | DataPublisher_SetMaxBufferSize 149 | DataPublisher_GetMaxBufferSize 150 | DataPublisher_CreateTransaction_ReportedProperties 151 | DataPublisher_PublishTransacted_ReportedProperty 152 | DataPublisher_CommitTransaction_ReportedProperties 153 | DataPublisher_DestroyTransaction_ReportedProperties 154 | DATA_MARSHALLER_RESULTStringStorage 155 | DATA_MARSHALLER_RESULTStrings 156 | DATA_MARSHALLER_RESULT_FromString 157 | DataMarshaller_Create 158 | DataMarshaller_Destroy 159 | DataMarshaller_SendData 160 | DataMarshaller_SendData_ReportedProperties 161 | COMMANDDECODER_RESULTStringStorage 162 | AGENT_DATA_TYPE_TYPEStringStorage 163 | AGENT_DATA_TYPE_TYPEStrings 164 | AGENT_DATA_TYPE_TYPE_FromString 165 | COMMANDDECODER_RESULTStrings 166 | COMMANDDECODER_RESULT_FromString 167 | CommandDecoder_Create 168 | CommandDecoder_ExecuteCommand 169 | CommandDecoder_ExecuteMethod 170 | CommandDecoder_Destroy 171 | CommandDecoder_IngestDesiredProperties 172 | CODEFIRST_RESULTStringStorage 173 | EXECUTE_COMMAND_RESULTStringStorage 174 | EXECUTE_COMMAND_RESULTStrings 175 | EXECUTE_COMMAND_RESULT_FromString 176 | CODEFIRST_RESULTStrings 177 | CODEFIRST_RESULT_FromString 178 | CodeFirst_Init 179 | CodeFirst_Deinit 180 | CodeFirst_RegisterSchema 181 | CodeFirst_InvokeAction 182 | CodeFirst_InvokeMethod 183 | CodeFirst_ExecuteCommand 184 | CodeFirst_ExecuteMethod 185 | CodeFirst_CreateDevice 186 | CodeFirst_DestroyDevice 187 | CodeFirst_SendAsync 188 | CodeFirst_SendAsyncReported 189 | CodeFirst_IngestDesiredProperties 190 | CodeFirst_GetPrimitiveType 191 | hexToASCII 192 | AGENT_DATA_TYPES_RESULTStringStorage 193 | AGENT_DATA_TYPES_RESULTStrings 194 | AGENT_DATA_TYPES_RESULT_FromString 195 | AgentDataTypes_ToString 196 | Create_EDM_BOOLEAN_from_int 197 | Create_AGENT_DATA_TYPE_from_UINT8 198 | Create_AGENT_DATA_TYPE_from_date 199 | Create_EDM_DECIMAL_from_charz 200 | Create_AGENT_DATA_TYPE_from_DOUBLE 201 | Create_AGENT_DATA_TYPE_from_SINT16 202 | Create_AGENT_DATA_TYPE_from_SINT32 203 | Create_AGENT_DATA_TYPE_from_SINT64 204 | Create_AGENT_DATA_TYPE_from_SINT8 205 | Create_AGENT_DATA_TYPE_from_EDM_DATE_TIME_OFFSET 206 | Create_AGENT_DATA_TYPE_from_EDM_GUID 207 | Create_AGENT_DATA_TYPE_from_EDM_BINARY 208 | Create_AGENT_DATA_TYPE_from_FLOAT 209 | Create_AGENT_DATA_TYPE_from_charz 210 | Create_AGENT_DATA_TYPE_from_charz_no_quotes 211 | Create_NULL_AGENT_DATA_TYPE 212 | Create_AGENT_DATA_TYPE_from_Members 213 | Create_AGENT_DATA_TYPE_from_MemberPointers 214 | Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE 215 | Destroy_AGENT_DATA_TYPE 216 | CreateAgentDataType_From_String 217 | AgentDataType_GetComplexTypeField 218 | 219 | --------------------------------------------------------------------------------