iothub_mod_client.c

00001 // Copyright (c) Microsoft. All rights reserved.
00002 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
00003 
00004 // iothub_mod_client.c : modified version of iothub_client.c
00005 
00006 #include <stdlib.h> 
00007 #ifdef _CRTDBG_MAP_ALLOC
00008 #include <crtdbg.h>
00009 #endif
00010 #include "gballoc.h"
00011 
00012 #include <stdlib.h>
00013 #include <signal.h>
00014 #include "crt_abstractions.h"
00015 #include "iothub_mod_client.h"
00016 #include "iothub_client_ll.h"
00017 #include "threadapi.h"
00018 #include "lock.h"
00019 #include "iot_logging.h"
00020 
00021 typedef struct IOTHUB_CLIENT_INSTANCE_TAG
00022 {
00023     IOTHUB_CLIENT_LL_HANDLE IoTHubClientLLHandle;
00024     THREAD_HANDLE ThreadHandle;
00025     LOCK_HANDLE LockHandle;
00026     sig_atomic_t StopThread;
00027     IOTHUB_CLIENT_SEND_CALLBACK SendCallback;
00028     void* SendContext;
00029 } IOTHUB_CLIENT_INSTANCE;
00030 
00031 static int ScheduleWork_Mod_Thread(void* threadArgument)
00032 {
00033     IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)threadArgument;
00034     
00035     /* Codes_SRS_IOTHUBCLIENT_01_038: [The thread shall exit when IoTHubClient_Destroy is called.] */
00036     while (!iotHubClientInstance->StopThread)
00037     {
00038         /* Codes_SRS_IOTHUBCLIENT_01_039: [All calls to IoTHubClient_LL_DoWork shall be protected by the lock created in IotHubClient_Create.] */
00039         /* Codes_SRS_IOTHUBCLIENT_01_040: [If acquiring the lock fails, IoTHubClient_LL_DoWork shall not be called.] */
00040         if (Lock(iotHubClientInstance->LockHandle) == LOCK_OK)
00041         {
00042             /* Codes_SRS_IOTHUBCLIENT_01_037: [The thread created by IoTHubClient_SendEvent or IoTHubClient_SetMessageCallback shall call IoTHubClient_LL_DoWork every 1 ms.] */
00043             IoTHubClient_LL_DoWork(iotHubClientInstance->IoTHubClientLLHandle);
00044             /* Codes_SRS_IOTHUBCLIENT_01_039: [All calls to IoTHubClient_LL_DoWork shall be protected by the lock created in IotHubClient_Create.] */
00045             Unlock(iotHubClientInstance->LockHandle);
00046         }
00047         if (iotHubClientInstance->SendCallback != NULL)
00048         {
00049             iotHubClientInstance->SendCallback(iotHubClientInstance, iotHubClientInstance->SendContext);
00050         }
00051         ThreadAPI_Sleep(1);
00052     }
00053 
00054     return 0;
00055 }
00056 
00057 static void StartWorkerThreadIfNeeded_Mod(IOTHUB_CLIENT_INSTANCE* iotHubClientInstance)
00058 {
00059     if (iotHubClientInstance->ThreadHandle == NULL)
00060     {
00061         iotHubClientInstance->StopThread = 0;
00062         if (ThreadAPI_Create(&iotHubClientInstance->ThreadHandle, ScheduleWork_Mod_Thread, iotHubClientInstance) != THREADAPI_OK)
00063         {
00064             iotHubClientInstance->ThreadHandle = NULL;
00065         }
00066     }
00067 }
00068 
00069 IOTHUB_CLIENT_HANDLE IoTHubClient_Mod_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol)
00070 {
00071     IOTHUB_CLIENT_INSTANCE* result = NULL;
00072 
00073     /* Codes_SRS_IOTHUBCLIENT_12_003: [IoTHubClient_CreateFromConnectionString shall verify the input parameter and if it is NULL then return NULL] */
00074     if (connectionString == NULL)
00075     {
00076         LogError("Input parameter is NULL: connectionString\r\n");
00077     }
00078     else if (protocol == NULL)
00079     {
00080         LogError("Input parameter is NULL: protocol\r\n");
00081     }
00082     else
00083     {
00084         /* Codes_SRS_IOTHUBCLIENT_12_004: [IoTHubClient_CreateFromConnectionString shall allocate a new IoTHubClient instance.] */
00085         result = malloc(sizeof(IOTHUB_CLIENT_INSTANCE));
00086 
00087         /* Codes_SRS_IOTHUBCLIENT_12_011: [If the allocation failed, IoTHubClient_CreateFromConnectionString returns NULL] */
00088         if (result == NULL)
00089         {
00090             LogError("Malloc failed\r\n");
00091         }
00092         else
00093         {
00094             /* Codes_SRS_IOTHUBCLIENT_12_005: [IoTHubClient_CreateFromConnectionString shall create a lock object to be used later for serializing IoTHubClient calls] */
00095             result->LockHandle = Lock_Init();
00096             if (result->LockHandle == NULL)
00097             {
00098                 /* Codes_SRS_IOTHUBCLIENT_12_009: [If lock creation failed, IoTHubClient_CreateFromConnectionString shall do clean up and return NULL] */
00099                 free(result);
00100                 result = NULL;
00101                 LogError("Lock_Init failed\r\n");
00102             }
00103             else
00104             {
00105                 /* Codes_SRS_IOTHUBCLIENT_12_006: [IoTHubClient_CreateFromConnectionString shall instantiate a new IoTHubClient_LL instance by calling IoTHubClient_LL_CreateFromConnectionString and passing the connectionString] */
00106                 result->IoTHubClientLLHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, protocol);
00107                 if (result->IoTHubClientLLHandle == NULL)
00108                 {
00109                     /* Codes_SRS_IOTHUBCLIENT_12_010: [If IoTHubClient_LL_CreateFromConnectionString fails then IoTHubClient_CreateFromConnectionString shall do clean - up and return NULL] */
00110                     Lock_Deinit(result->LockHandle);
00111                     free(result);
00112                     result = NULL;
00113                     LogError("IoTHubClient_LL_CreateFromConnectionString failed\r\n");
00114                 }
00115                 else
00116                 { 
00117                     result->ThreadHandle = NULL;
00118                     result->SendCallback = NULL;
00119                 }
00120             }
00121         }
00122     }
00123     return result;
00124 }
00125 
00126 
00127 IOTHUB_CLIENT_HANDLE IoTHubClient_Mod_Create(const IOTHUB_CLIENT_CONFIG* config)
00128 {
00129     /* Codes_SRS_IOTHUBCLIENT_01_001: [IoTHubClient_Create shall allocate a new IoTHubClient instance and return a non-NULL handle to it.] */
00130     IOTHUB_CLIENT_INSTANCE* result = (IOTHUB_CLIENT_INSTANCE*)malloc(sizeof(IOTHUB_CLIENT_INSTANCE));
00131 
00132     /* Codes_SRS_IOTHUBCLIENT_01_004: [If allocating memory for the new IoTHubClient instance fails, then IoTHubClient_Create shall return NULL.] */
00133     if (result != NULL)
00134     {
00135         result->ThreadHandle = NULL;
00136         result->SendCallback = NULL;
00137 
00138         /* Codes_SRS_IOTHUBCLIENT_01_029: [IoTHubClient_Create shall create a lock object to be used later for serializing IoTHubClient calls.] */
00139         result->LockHandle = Lock_Init();
00140         if (result->LockHandle == NULL)
00141         {
00142             /* Codes_SRS_IOTHUBCLIENT_01_030: [If creating the lock fails, then IoTHubClient_Create shall return NULL.] */
00143             /* Codes_SRS_IOTHUBCLIENT_01_031: [If IoTHubClient_Create fails, all resources allocated by it shall be freed.] */
00144             free(result);
00145             result = NULL;
00146         }
00147         else
00148         {
00149             /* Codes_SRS_IOTHUBCLIENT_01_002: [IoTHubClient_Create shall instantiate a new IoTHubClient_LL instance by calling IoTHubClient_LL_Create and passing the config argument.] */
00150             result->IoTHubClientLLHandle = IoTHubClient_LL_Create(config);
00151             if (result->IoTHubClientLLHandle == NULL)
00152             {
00153                 /* Codes_SRS_IOTHUBCLIENT_01_003: [If IoTHubClient_LL_Create fails, then IoTHubClient_Create shall return NULL.] */
00154                 /* Codes_SRS_IOTHUBCLIENT_01_031: [If IoTHubClient_Create fails, all resources allocated by it shall be freed.] */
00155                 Lock_Deinit(result->LockHandle);
00156                 free(result);
00157                 result = NULL;
00158             }
00159         }
00160     }
00161 
00162     return result;
00163 }
00164 
00165 /* Codes_SRS_IOTHUBCLIENT_01_005: [IoTHubClient_Destroy shall free all resources associated with the iotHubClientHandle instance.] */
00166 void IoTHubClient_Mod_Destroy(IOTHUB_CLIENT_HANDLE iotHubClientHandle)
00167 {
00168     /* Codes_SRS_IOTHUBCLIENT_01_008: [IoTHubClient_Destroy shall do nothing if parameter iotHubClientHandle is NULL.] */
00169     if (iotHubClientHandle != NULL)
00170     {
00171         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00172 
00173         /* Codes_SRS_IOTHUBCLIENT_01_007: [The thread created as part of executing IoTHubClient_SendEventAsync or IoTHubClient_SetMessageCallback shall be joined.] */
00174         if (iotHubClientInstance->ThreadHandle != NULL)
00175         {
00176             int res;
00177             iotHubClientInstance->StopThread = 1;
00178             if (ThreadAPI_Join(iotHubClientInstance->ThreadHandle, &res) != THREADAPI_OK)
00179             {
00180                 LogError("ThreadAPI_Join failed\r\n");
00181             }
00182         }
00183 
00184         /* Codes_SRS_IOTHUBCLIENT_01_006: [That includes destroying the IoTHubClient_LL instance by calling IoTHubClient_LL_Destroy.] */
00185         IoTHubClient_LL_Destroy(iotHubClientInstance->IoTHubClientLLHandle);
00186 
00187         /* Codes_SRS_IOTHUBCLIENT_01_032: [The lock allocated in IoTHubClient_Create shall be also freed.] */
00188         Lock_Deinit(iotHubClientInstance->LockHandle);
00189         free(iotHubClientInstance);
00190     }
00191 }
00192 
00193 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_SendEventAsync(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_MESSAGE_HANDLE eventMessageHandle, IOTHUB_CLIENT_EVENT_CONFIRMATION_CALLBACK eventConfirmationCallback, void* userContextCallback)
00194 {
00195     IOTHUB_CLIENT_RESULT result;
00196 
00197     if (iotHubClientHandle == NULL)
00198     {
00199         /* Codes_SRS_IOTHUBCLIENT_01_011: [If iotHubClientHandle is NULL, IoTHubClient_SendEventAsync shall return IOTHUB_CLIENT_INVALID_ARG.] */
00200         result = IOTHUB_CLIENT_INVALID_ARG;
00201         LogError("NULL iothubClientHandle\r\n");
00202     }
00203     else
00204     {
00205         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00206 
00207         /* Codes_SRS_IOTHUBCLIENT_01_025: [IoTHubClient_SendEventAsync shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00208         if (Lock(iotHubClientInstance->LockHandle) != LOCK_OK)
00209         {
00210             /* Codes_SRS_IOTHUBCLIENT_01_026: [If acquiring the lock fails, IoTHubClient_SendEventAsync shall return IOTHUB_CLIENT_ERROR.] */
00211             result = IOTHUB_CLIENT_ERROR;
00212             LogError("Could not acquire lock\r\n");
00213         }
00214         else
00215         {
00216             /* Codes_SRS_IOTHUBCLIENT_01_009: [IoTHubClient_SendEventAsync shall start the worker thread if it was not previously started.] */
00217             StartWorkerThreadIfNeeded_Mod(iotHubClientInstance);
00218 
00219             if (iotHubClientInstance->ThreadHandle == NULL)
00220             {
00221                 /* Codes_SRS_IOTHUBCLIENT_01_010: [If starting the thread fails, IoTHubClient_SendEventAsync shall return IOTHUB_CLIENT_ERROR.] */
00222                 result = IOTHUB_CLIENT_ERROR;
00223                 LogError("Could not start worker thread\r\n");
00224             }
00225             else
00226             {
00227                 /* Codes_SRS_IOTHUBCLIENT_01_012: [IoTHubClient_SendEventAsync shall call IoTHubClient_LL_SendEventAsync, while passing the IoTHubClient_LL handle created by IoTHubClient_Create and the parameters eventMessageHandle, eventConfirmationCallback and userContextCallback.] */
00228                 /* Codes_SRS_IOTHUBCLIENT_01_013: [When IoTHubClient_LL_SendEventAsync is called, IoTHubClient_SendEventAsync shall return the result of IoTHubClient_LL_SendEventAsync.] */
00229                 result = IoTHubClient_LL_SendEventAsync(iotHubClientInstance->IoTHubClientLLHandle, eventMessageHandle, eventConfirmationCallback, userContextCallback);
00230             }
00231 
00232             /* Codes_SRS_IOTHUBCLIENT_01_025: [IoTHubClient_SendEventAsync shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00233             (void)Unlock(iotHubClientInstance->LockHandle);
00234         }
00235     }
00236 
00237     return result;
00238 }
00239 
00240 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_GetSendStatus(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_STATUS *iotHubClientStatus)
00241 {
00242     IOTHUB_CLIENT_RESULT result;
00243 
00244     if (iotHubClientHandle == NULL)
00245     {
00246         /* Codes_SRS_IOTHUBCLIENT_01_023: [If iotHubClientHandle is NULL, IoTHubClient_ GetSendStatus shall return IOTHUB_CLIENT_INVALID_ARG.] */
00247         result = IOTHUB_CLIENT_INVALID_ARG;
00248         LogError("NULL iothubClientHandle\r\n");
00249     }
00250     else
00251     {
00252         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00253 
00254         /* Codes_SRS_IOTHUBCLIENT_01_033: [IoTHubClient_GetSendStatus shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00255         if (Lock(iotHubClientInstance->LockHandle) != LOCK_OK)
00256         {
00257             /* Codes_SRS_IOTHUBCLIENT_01_034: [If acquiring the lock fails, IoTHubClient_GetSendStatus shall return IOTHUB_CLIENT_ERROR.] */
00258             result = IOTHUB_CLIENT_ERROR;
00259             LogError("Could not acquire lock\r\n");
00260         }
00261         else
00262         {
00263             /* Codes_SRS_IOTHUBCLIENT_01_022: [IoTHubClient_GetSendStatus shall call IoTHubClient_LL_GetSendStatus, while passing the IoTHubClient_LL handle created by IoTHubClient_Create and the parameter iotHubClientStatus.] */
00264             /* Codes_SRS_IOTHUBCLIENT_01_024: [Otherwise, IoTHubClient_GetSendStatus shall return the result of IoTHubClient_LL_GetSendStatus.] */
00265             result = IoTHubClient_LL_GetSendStatus(iotHubClientInstance->IoTHubClientLLHandle, iotHubClientStatus);
00266 
00267             /* Codes_SRS_IOTHUBCLIENT_01_033: [IoTHubClient_GetSendStatus shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00268             (void)Unlock(iotHubClientInstance->LockHandle);
00269         }
00270     }
00271 
00272     return result;
00273 }
00274 
00275 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_SetMessageCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback)
00276 {
00277     IOTHUB_CLIENT_RESULT result;
00278 
00279     if (iotHubClientHandle == NULL)
00280     {
00281         /* Codes_SRS_IOTHUBCLIENT_01_016: [If iotHubClientHandle is NULL, IoTHubClient_SetMessageCallback shall return IOTHUB_CLIENT_INVALID_ARG.] */
00282         result = IOTHUB_CLIENT_INVALID_ARG;
00283         LogError("NULL iothubClientHandle\r\n");
00284     }
00285     else
00286     {
00287         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00288 
00289         /* Codes_SRS_IOTHUBCLIENT_01_027: [IoTHubClient_SetMessageCallback shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00290         if (Lock(iotHubClientInstance->LockHandle) != LOCK_OK)
00291         {
00292             /* Codes_SRS_IOTHUBCLIENT_01_028: [If acquiring the lock fails, IoTHubClient_SetMessageCallback shall return IOTHUB_CLIENT_ERROR.] */
00293             result = IOTHUB_CLIENT_ERROR;
00294             LogError("Could not acquire lock\r\n");
00295         }
00296         else
00297         {
00298             /* Codes_SRS_IOTHUBCLIENT_01_014: [IoTHubClient_SetMessageCallback shall start the worker thread if it was not previously started.] */
00299             StartWorkerThreadIfNeeded_Mod(iotHubClientInstance);
00300 
00301             if (iotHubClientInstance->ThreadHandle == NULL)
00302             {
00303                 /* Codes_SRS_IOTHUBCLIENT_01_015: [If starting the thread fails, IoTHubClient_SetMessageCallback shall return IOTHUB_CLIENT_ERROR.] */
00304                 result = IOTHUB_CLIENT_ERROR;
00305                 LogError("Could not start worker thread\r\n");
00306             }
00307             else
00308             {
00309                 /* Codes_SRS_IOTHUBCLIENT_01_017: [IoTHubClient_SetMessageCallback shall call IoTHubClient_LL_SetMessageCallback, while passing the IoTHubClient_LL handle created by IoTHubClient_Create and the parameters messageCallback and userContextCallback.] */
00310                 result = IoTHubClient_LL_SetMessageCallback(iotHubClientInstance->IoTHubClientLLHandle, messageCallback, userContextCallback);
00311             }
00312 
00313             /* Codes_SRS_IOTHUBCLIENT_01_027: [IoTHubClient_SetMessageCallback shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00314             Unlock(iotHubClientInstance->LockHandle);
00315         }
00316     }
00317 
00318     return result;
00319 }
00320 
00321 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_SetSendCallback(IOTHUB_CLIENT_HANDLE iotHubClientHandle, IOTHUB_CLIENT_SEND_CALLBACK sendCallback, void* userContextCallback)
00322 {
00323     IOTHUB_CLIENT_RESULT result;
00324 
00325     if (iotHubClientHandle == NULL)
00326     {
00327         /* Codes_SRS_IOTHUBCLIENT_01_016: [If iotHubClientHandle is NULL, IoTHubClient_SetMessageCallback shall return IOTHUB_CLIENT_INVALID_ARG.] */
00328         result = IOTHUB_CLIENT_INVALID_ARG;
00329         LogError("NULL iothubClientHandle\r\n");
00330     }
00331     else
00332     {
00333         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00334 
00335         /* Codes_SRS_IOTHUBCLIENT_01_027: [IoTHubClient_SetMessageCallback shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00336         if (Lock(iotHubClientInstance->LockHandle) != LOCK_OK)
00337         {
00338             /* Codes_SRS_IOTHUBCLIENT_01_028: [If acquiring the lock fails, IoTHubClient_SetMessageCallback shall return IOTHUB_CLIENT_ERROR.] */
00339             result = IOTHUB_CLIENT_ERROR;
00340             LogError("Could not acquire lock\r\n");
00341         }
00342         else
00343         {
00344             iotHubClientInstance->SendCallback = sendCallback;
00345             iotHubClientInstance->SendContext = userContextCallback;
00346 
00347             /* Codes_SRS_IOTHUBCLIENT_01_027: [IoTHubClient_SetMessageCallback shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00348             Unlock(iotHubClientInstance->LockHandle);
00349         }
00350     }
00351 
00352     return result;
00353 }
00354 
00355 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_GetLastMessageReceiveTime(IOTHUB_CLIENT_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime)
00356 {
00357     IOTHUB_CLIENT_RESULT result;
00358 
00359     if (iotHubClientHandle == NULL)
00360     {
00361         /* Codes_SRS_IOTHUBCLIENT_01_020: [If iotHubClientHandle is NULL, IoTHubClient_GetLastMessageReceiveTime shall return IOTHUB_CLIENT_INVALID_ARG.] */
00362         result = IOTHUB_CLIENT_INVALID_ARG;
00363         LogError("NULL iothubClientHandle\r\n");
00364     }
00365     else
00366     {
00367         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00368 
00369         /* Codes_SRS_IOTHUBCLIENT_01_035: [IoTHubClient_GetLastMessageReceiveTime shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00370         if (Lock(iotHubClientInstance->LockHandle) != LOCK_OK)
00371         {
00372             /* Codes_SRS_IOTHUBCLIENT_01_036: [If acquiring the lock fails, IoTHubClient_GetLastMessageReceiveTime shall return IOTHUB_CLIENT_ERROR.] */
00373             result = IOTHUB_CLIENT_ERROR;
00374             LogError("Could not acquire lock\r\n");
00375         }
00376         else
00377         {
00378             /* Codes_SRS_IOTHUBCLIENT_01_019: [IoTHubClient_GetLastMessageReceiveTime shall call IoTHubClient_LL_GetLastMessageReceiveTime, while passing the IoTHubClient_LL handle created by IoTHubClient_Create and the parameter lastMessageReceiveTime.] */
00379             /* Codes_SRS_IOTHUBCLIENT_01_021: [Otherwise, IoTHubClient_GetLastMessageReceiveTime shall return the result of IoTHubClient_LL_GetLastMessageReceiveTime.] */
00380             result = IoTHubClient_LL_GetLastMessageReceiveTime(iotHubClientInstance->IoTHubClientLLHandle, lastMessageReceiveTime);
00381 
00382             /* Codes_SRS_IOTHUBCLIENT_01_035: [IoTHubClient_GetLastMessageReceiveTime shall be made thread-safe by using the lock created in IoTHubClient_Create.] */
00383             Unlock(iotHubClientInstance->LockHandle);
00384         }
00385     }
00386 
00387     return result;
00388 }
00389 
00390 IOTHUB_CLIENT_RESULT IoTHubClient_Mod_SetOption(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const char* optionName, const void* value)
00391 {
00392     IOTHUB_CLIENT_RESULT result;
00393     /*Codes_SRS_IOTHUBCLIENT_02_034: [If parameter iotHubClientHandle is NULL then IoTHubClient_SetOption shall return IOTHUB_CLIENT_INVALID_ARG.] */
00394     if (
00395         (iotHubClientHandle == NULL) ||
00396         (optionName == NULL) ||
00397         (value == NULL)
00398         )
00399     {
00400         result = IOTHUB_CLIENT_INVALID_ARG;
00401         LogError("invalid arg (NULL)r\n");
00402     }
00403     else
00404     {
00405         IOTHUB_CLIENT_INSTANCE* iotHubClientInstance = (IOTHUB_CLIENT_INSTANCE*)iotHubClientHandle;
00406         /*Codes_SRS_IOTHUBCLIENT_02_038: [If optionName doesn't match one of the options handled by this module then IoTHubClient_SetOption shall call IoTHubClient_LL_SetOption passing the same parameters and return what IoTHubClient_LL_SetOption returns.] */
00407         result = IoTHubClient_LL_SetOption(iotHubClientInstance->IoTHubClientLLHandle, optionName, value);
00408 
00409         if (result != IOTHUB_CLIENT_OK)
00410         {
00411             LogError("IoTHubClient_LL_SetOption failed\r\n");
00412         }
00413     }
00414     return result;
00415 }