Diff: iothub_client_ll.c

Revision:

9:3ec7e2695f98

Parent:

1:bec6dd049b54

Child:

10:38383e246675

--- a/iothub_client_ll.c	Wed Sep 16 06:38:05 2015 +0000
+++ b/iothub_client_ll.c	Tue Sep 22 20:36:48 2015 -0700
@@ -26,16 +26,15 @@
     DLIST_ENTRY waitingToSend;
     TRANSPORT_HANDLE transportHandle;
     TRANSPORT_PROVIDER_FIELDS;
-    IOTHUB_CLIENT_NOTIFICATION_CALLBACK_ASYNC notificationCallback;
-    void* notificationUserContextCallback;
-    time_t lastNotificationReceiveTime;
+    IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback;
+    void* messageUserContextCallback;
+    time_t lastMessageReceiveTime;
 }IOTHUB_CLIENT_LL_HANDLE_DATA;
 
 static const char HOSTNAME_TOKEN[] = "HostName";
-static const char CREDSCOPE_TOKEN[] = "CredentialScope";
 static const char DEVICEID_TOKEN[] = "DeviceId";
 static const char DEVICEKEY_TOKEN[] = "SharedAccessKey";
-static const char CREDSCOPE_VALUE[] = "Device";
+static const char PROTOCOL_GATEWAY_HOST[] = "GatewayHostName";
 
 IOTHUB_CLIENT_LL_HANDLE IoTHubClient_LL_CreateFromConnectionString(const char* connectionString, IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol)
 {
@@ -74,6 +73,7 @@
             STRING_HANDLE hostSuffixString = NULL;
             STRING_HANDLE deviceIdString = NULL;
             STRING_HANDLE deviceKeyString = NULL;
+            STRING_HANDLE protocolGateway = NULL;
 
             config->protocol = protocol;
 
@@ -81,7 +81,6 @@
             config->iotHubSuffix = NULL;
             config->deviceId = NULL;
             config->deviceKey = NULL;
-            bool credential_scope_ok = false;
 
             if ((connString = STRING_construct(connectionString)) == NULL)
             {
@@ -108,7 +107,7 @@
                 LogError("Error creating HostSuffix String\r\n");
             }
             /* SRS_IOTHUBCLIENT_LL_12_005: [IoTHubClient_LL_CreateFromConnectionString shall try to parse the connectionString input parameter for the following structure: "Key1=value1;key2=value2;key3=value3..."] */
-            /* SRS_IOTHUBCLIENT_LL_12_006: [IoTHubClient_LL_CreateFromConnectionString shall verify the existence of the following Key/Value pairs in the connection string: HostName, CredentialScope , DeviceId, SharedAccessKey.]  */
+            /* SRS_IOTHUBCLIENT_LL_12_006: [IoTHubClient_LL_CreateFromConnectionString shall verify the existence of the following Key/Value pairs in the connection string: HostName, DeviceId, SharedAccessKey.]  */
             else
             {
                 while ((STRING_TOKENIZER_get_next_token(tokenizer1, tokenString, "=") == 0))
@@ -125,19 +124,7 @@
                             /* SRS_IOTHUBCLIENT_LL_12_010: [IoTHubClient_LL_CreateFromConnectionString shall fill up the IOTHUB_CLIENT_CONFIG structure using the following mapping: iotHubName = Name, iotHubSuffix = Suffix, deviceId = DeviceId, deviceKey = SharedAccessKey] */
                             const char* s_token = STRING_c_str(tokenString);
                             const char* s_value = STRING_c_str(valueString);
-                            if (strcmp(s_token, CREDSCOPE_TOKEN) == 0)
-                            {
-                                if (strcmp(s_value, CREDSCOPE_VALUE) == 0)
-                                {
-                                    credential_scope_ok = true;
-                                }
-                                else
-                                {
-                                    LogError("Unexpected credential scope\r\n");
-                                    break;
-                                }
-                            }
-                            else if (strcmp(s_token, HOSTNAME_TOKEN) == 0)
+							if (strcmp(s_token, HOSTNAME_TOKEN) == 0)
                             {
                                 /* SRS_IOTHUBCLIENT_LL_12_009: [IoTHubClient_LL_CreateFromConnectionString shall split the value of HostName to Name and Suffix using the first "." as a separator] */
                                 STRING_TOKENIZER_HANDLE tokenizer2 = NULL;
@@ -188,15 +175,19 @@
                                     config->deviceKey = STRING_c_str(deviceKeyString);
                                 }
                             }
+                            else if (strcmp(s_token, PROTOCOL_GATEWAY_HOST) == 0)
+                            {
+                                protocolGateway = STRING_clone(valueString);
+                                if (protocolGateway != NULL)
+                                {
+                                    config->protocolGatewayHostName = STRING_c_str(protocolGateway);
+                                }
+                            }
                         }
                     }
                 }
                 /* parsing is done - check the result */
-                if (!credential_scope_ok)
-                {
-                    LogError("Credential scope is not specified\r\n");
-                }
-                else if (config->iotHubName == NULL)
+                if (config->iotHubName == NULL)
                 {
                     LogError("iotHubName is not found\r\n");
                 }
@@ -236,6 +227,8 @@
                 STRING_delete(tokenString);
             if (connString != NULL)
                 STRING_delete(connString);
+            if (protocolGateway != NULL)
+                STRING_delete(protocolGateway);
 
             if (tokenizer1 != NULL)
                 STRING_TOKENIZER_destroy(tokenizer1);
@@ -279,9 +272,9 @@
             handleData->IoTHubTransport_Unsubscribe = ((TRANSPORT_PROVIDER*)config->protocol())->IoTHubTransport_Unsubscribe;
             handleData->IoTHubTransport_DoWork = ((TRANSPORT_PROVIDER*)config->protocol())->IoTHubTransport_DoWork;
             handleData->IoTHubTransport_GetSendStatus = ((TRANSPORT_PROVIDER*)config->protocol())->IoTHubTransport_GetSendStatus;
-            handleData->notificationCallback = NULL;
-            handleData->notificationUserContextCallback = NULL;
-            handleData->lastNotificationReceiveTime = INDEFINITE_TIME;
+            handleData->messageCallback = NULL;
+            handleData->messageUserContextCallback = NULL;
+            handleData->lastMessageReceiveTime = INDEFINITE_TIME;
             /*Codes_SRS_IOTHUBCLIENT_LL_02_006: [IoTHubClient_LL_Create shall populate a structure of type IOTHUBTRANSPORT_CONFIG with the information from config parameter and the previous DLIST and shall pass that to the underlying layer _Create function.]*/
             lowerLayerConfig.upperConfig = config;
             lowerLayerConfig.waitingToSend = &(handleData->waitingToSend);
@@ -316,7 +309,7 @@
         while ((unsend = DList_RemoveHeadList(&(handleData->waitingToSend))) != &(handleData->waitingToSend))
         {
             IOTHUB_MESSAGE_LIST* temp = containingRecord(unsend, IOTHUB_MESSAGE_LIST, entry);
-            /*Codes_SRS_IOTHUBCLIENT_LL_02_033: [Otherwise, IoTHubClient_LL_Destroy shall complete all the event notification callbacks that are in the waitingToSend list with the result IOTHUB_CLIENT_CONFIRMATION_BECAUSE_DESTROY.] */
+            /*Codes_SRS_IOTHUBCLIENT_LL_02_033: [Otherwise, IoTHubClient_LL_Destroy shall complete all the event message callbacks that are in the waitingToSend list with the result IOTHUB_CLIENT_CONFIRMATION_BECAUSE_DESTROY.] */
             if (temp->callback != NULL)
             {
                 temp->callback(IOTHUB_CLIENT_CONFIRMATION_BECAUSE_DESTROY, temp->context);
@@ -375,10 +368,10 @@
     return result; 
 }
 
-IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetNotificationCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_NOTIFICATION_CALLBACK_ASYNC notificationCallback, void* userContextCallback)
+IOTHUB_CLIENT_RESULT IoTHubClient_LL_SetMessageCallback(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, IOTHUB_CLIENT_MESSAGE_CALLBACK_ASYNC messageCallback, void* userContextCallback)
 {
     IOTHUB_CLIENT_RESULT result;
-    /*Codes_SRS_IOTHUBCLIENT_LL_02_016: [IoTHubClient_LL_SetNotificationCallback shall fail and return IOTHUB_CLIENT_INVALID_ARG if parameter iotHubClientHandle is NULL.] */
+    /*Codes_SRS_IOTHUBCLIENT_LL_02_016: [IoTHubClient_LL_SetMessageCallback shall fail and return IOTHUB_CLIENT_INVALID_ARG if parameter iotHubClientHandle is NULL.] */
     if (iotHubClientHandle == NULL)
     {
         result = IOTHUB_CLIENT_INVALID_ARG;
@@ -387,28 +380,28 @@
     else
     {
         IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)iotHubClientHandle;
-        if (notificationCallback == NULL)
+        if (messageCallback == NULL)
         {
-            /*Codes_SRS_IOTHUBCLIENT_LL_02_019: [If parameter notificationCallback is NULL then IoTHubClient_LL_SetNotificationCallback shall call the underlying layer's _Unsubscribe function and return IOTHUB_CLIENT_OK.] */
+            /*Codes_SRS_IOTHUBCLIENT_LL_02_019: [If parameter messageCallback is NULL then IoTHubClient_LL_SetMessageCallback shall call the underlying layer's _Unsubscribe function and return IOTHUB_CLIENT_OK.] */
             handleData->IoTHubTransport_Unsubscribe(handleData->transportHandle);
-            handleData->notificationCallback = NULL;
-            handleData->notificationUserContextCallback = NULL;
+            handleData->messageCallback = NULL;
+            handleData->messageUserContextCallback = NULL;
             result = IOTHUB_CLIENT_OK;
         }
         else
         {
-            /*Codes_SRS_IOTHUBCLIENT_LL_02_017: [If parameter notificationCallback is non-NULL then IoTHubClient_LL_SetNotificationCallback shall call the underlying layer's _Subscribe function.]*/
+            /*Codes_SRS_IOTHUBCLIENT_LL_02_017: [If parameter messageCallback is non-NULL then IoTHubClient_LL_SetMessageCallback shall call the underlying layer's _Subscribe function.]*/
             if (handleData->IoTHubTransport_Subscribe(handleData->transportHandle) == 0)
             {
-                handleData->notificationCallback = notificationCallback;
-                handleData->notificationUserContextCallback = userContextCallback;
+                handleData->messageCallback = messageCallback;
+                handleData->messageUserContextCallback = userContextCallback;
                 result = IOTHUB_CLIENT_OK;
             }
             else
             {
-                handleData->notificationCallback = NULL;
-                handleData->notificationUserContextCallback = NULL;
-                /*Codes_SRS_IOTHUBCLIENT_LL_02_018: [If the underlying layer's _Subscribe function fails, then IoTHubClient_LL_SetNotificationCallback shall fail and return IOTHUB_CLIENT_ERROR. Otherwise IoTHubClient_LL_SetNotificationCallback shall succeed and return IOTHUB_CLIENT_OK.]*/
+                handleData->messageCallback = NULL;
+                handleData->messageUserContextCallback = NULL;
+                /*Codes_SRS_IOTHUBCLIENT_LL_02_018: [If the underlying layer's _Subscribe function fails, then IoTHubClient_LL_SetMessageCallback shall fail and return IOTHUB_CLIENT_ERROR. Otherwise IoTHubClient_LL_SetMessageCallback shall succeed and return IOTHUB_CLIENT_OK.]*/
                 result = IOTHUB_CLIENT_ERROR;
             }
         }
@@ -479,10 +472,10 @@
     }
 }
 
-IOTHUBMESSAGE_DISPOSITION_RESULT IoTHubClient_LL_NotificationCallback(IOTHUB_CLIENT_LL_HANDLE handle, IOTHUB_MESSAGE_HANDLE notificationMessage)
+IOTHUBMESSAGE_DISPOSITION_RESULT IoTHubClient_LL_MessageCallback(IOTHUB_CLIENT_LL_HANDLE handle, IOTHUB_MESSAGE_HANDLE message)
 {
     int result;
-    /*Codes_SRS_IOTHUBCLIENT_LL_02_029: [If parameter handle is NULL then IoTHubClient_LL_NotificationCallback shall return IOTHUBMESSAGE_ABANDONED.] */
+    /*Codes_SRS_IOTHUBCLIENT_LL_02_029: [If parameter handle is NULL then IoTHubClient_LL_MessageCallback shall return IOTHUBMESSAGE_ABANDONED.] */
     if (handle == NULL)
     {
         LogError("invalid argument\r\n");
@@ -492,49 +485,49 @@
     {
         IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)handle;
 
-        /* Codes_SRS_IOTHUBCLIENT_LL_09_004: [IoTHubClient_LL_GetLastNotificationReceiveTime shall return lastNotificationReceiveTime in localtime] */
-        handleData->lastNotificationReceiveTime = get_time(NULL);
+        /* Codes_SRS_IOTHUBCLIENT_LL_09_004: [IoTHubClient_LL_GetLastMessageReceiveTime shall return lastMessageReceiveTime in localtime] */
+        handleData->lastMessageReceiveTime = get_time(NULL);
 
-        /*Codes_SRS_IOTHUBCLIENT_LL_02_030: [IoTHubClient_LL_NotificationCallback shall invoke the last callback function (the parameter notificationCallback to IoTHubClient_LL_SetNotificationCallback) passing the notificationMessage and the passed userContextCallback.]*/
-        if (handleData->notificationCallback != NULL)
+        /*Codes_SRS_IOTHUBCLIENT_LL_02_030: [IoTHubClient_LL_MessageCallback shall invoke the last callback function (the parameter messageCallback to IoTHubClient_LL_SetMessageCallback) passing the message and the passed userContextCallback.]*/
+        if (handleData->messageCallback != NULL)
         {
-            result = handleData->notificationCallback(notificationMessage, handleData->notificationUserContextCallback);
+            result = handleData->messageCallback(message, handleData->messageUserContextCallback);
         }
         else
         {
-            /*Codes_SRS_IOTHUBCLIENT_LL_02_032: [If the last callback function was NULL, then IoTHubClient_LL_NotificationCallback  shall return IOTHUBMESSAGE_ABANDONED.] */
+            /*Codes_SRS_IOTHUBCLIENT_LL_02_032: [If the last callback function was NULL, then IoTHubClient_LL_MessageCallback  shall return IOTHUBMESSAGE_ABANDONED.] */
             LogError("user callback was NULL\r\n");
             result = IOTHUBMESSAGE_ABANDONED;
         }
     }
-    /*Codes_SRS_IOTHUBCLIENT_LL_02_031: [Then IoTHubClient_LL_NotificationCallback shall return what the user function returns.]*/
+    /*Codes_SRS_IOTHUBCLIENT_LL_02_031: [Then IoTHubClient_LL_MessageCallback shall return what the user function returns.]*/
     return result;
 }
 
-IOTHUB_CLIENT_RESULT IoTHubClient_LL_GetLastNotificationReceiveTime(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, time_t* lastNotificationReceiveTime)
+IOTHUB_CLIENT_RESULT IoTHubClient_LL_GetLastMessageReceiveTime(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle, time_t* lastMessageReceiveTime)
 {
     IOTHUB_CLIENT_RESULT result;
     IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)iotHubClientHandle;
 
-    /* Codes_SRS_IOTHUBCLIENT_LL_09_001: [IoTHubClient_LL_GetLastNotificationReceiveTime shall return IOTHUB_CLIENT_INVALID_ARG if any of the arguments is NULL] */
-    if (handleData == NULL || lastNotificationReceiveTime == NULL)
+    /* Codes_SRS_IOTHUBCLIENT_LL_09_001: [IoTHubClient_LL_GetLastMessageReceiveTime shall return IOTHUB_CLIENT_INVALID_ARG if any of the arguments is NULL] */
+    if (handleData == NULL || lastMessageReceiveTime == NULL)
     {
         result = IOTHUB_CLIENT_INVALID_ARG;
         LOG_ERROR;
     }
     else
     {
-        /* Codes_SRS_IOTHUBCLIENT_LL_09_002: [IoTHubClient_LL_GetLastNotificationReceiveTime shall return IOTHUB_CLIENT_INDEFINITE_TIME - and not set 'lastNotificationReceiveTime' - if it is unable to provide the time for the last commands] */
-        if (handleData->lastNotificationReceiveTime == INDEFINITE_TIME)
+        /* Codes_SRS_IOTHUBCLIENT_LL_09_002: [IoTHubClient_LL_GetLastMessageReceiveTime shall return IOTHUB_CLIENT_INDEFINITE_TIME - and not set 'lastMessageReceiveTime' - if it is unable to provide the time for the last commands] */
+        if (handleData->lastMessageReceiveTime == INDEFINITE_TIME)
         {
             result = IOTHUB_CLIENT_INDEFINITE_TIME;
             LOG_ERROR;
         }
         else
         {
-            /* Codes_SRS_IOTHUBCLIENT_LL_09_003: [IoTHubClient_LL_GetLastNotificationReceiveTime shall return IOTHUB_CLIENT_OK if it wrote in the lastNotificationReceiveTime the time when the last command was received] */
-            /* Codes_SRS_IOTHUBCLIENT_LL_09_004: [IoTHubClient_LL_GetLastNotificationReceiveTime shall return lastNotificationReceiveTime in localtime] */
-            *lastNotificationReceiveTime = handleData->lastNotificationReceiveTime;
+            /* Codes_SRS_IOTHUBCLIENT_LL_09_003: [IoTHubClient_LL_GetLastMessageReceiveTime shall return IOTHUB_CLIENT_OK if it wrote in the lastMessageReceiveTime the time when the last command was received] */
+            /* Codes_SRS_IOTHUBCLIENT_LL_09_004: [IoTHubClient_LL_GetLastMessageReceiveTime shall return lastMessageReceiveTime in localtime] */
+            *lastMessageReceiveTime = handleData->lastMessageReceiveTime;
             result = IOTHUB_CLIENT_OK;
         }
     }