IP adapter error handling

Ad dependencies got messed up, earlier patch set failed
Adding a fresh patch with right dependencies

Change-Id: Id55430b0d8ce502978e11e5102972fcb901e4472
Signed-off-by: jnashok <jn.ashok@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/1181
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: jihwan seo <jihwan.seo@samsung.com>
Reviewed-by: Erich Keane <erich.keane@intel.com>

diff --git a/resource/csdk/connectivity/inc/caipadapter.h b/resource/csdk/connectivity/inc/caipadapter.h
index 22ab8ce..dce3cca 100644 (file)
--- a/resource/csdk/connectivity/inc/caipadapter.h
+++ b/resource/csdk/connectivity/inc/caipadapter.h
@@ -39,16 +39,18 @@ extern "C"
  * @param registerCallback      [IN] Callback to register IP interfaces to Connectivity
  *                                   Abstraction Layer
  * @param networkPacketCallback [IN] Callback to notify request and response messages from server(s)
- *                                   started at Connectivity Abstraction Layer.
+ *                                   started at Connectivity Abstraction Layer
  * @param netCallback           [IN] Callback to notify the network additions to Connectivity
- *                                   Abstraction Layer.
+ *                                   Abstraction Layer
+ * @param errorCallback         [IN] Callback to notify the network errors to Connectivity
+ *                                   Abstraction Layer
  * @param handle                [IN] Threadpool Handle
  * @return  #CA_STATUS_OK or Appropriate error code
  */
-    CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
-                              CANetworkPacketReceivedCallback networkPacketCallback,
-                              CANetworkChangeCallback netCallback, ca_thread_pool_t handle);
-
+CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
+                          CANetworkPacketReceivedCallback networkPacketCallback,
+                          CANetworkChangeCallback netCallback,
+                          CAErrorHandleCallback errorCallback, ca_thread_pool_t handle);
 
 /**
  * @brief Start IP Interface adapter.

diff --git a/resource/csdk/connectivity/inc/caipinterface.h b/resource/csdk/connectivity/inc/caipinterface.h
index 4a403c2..d55284e 100644 (file)
--- a/resource/csdk/connectivity/inc/caipinterface.h
+++ b/resource/csdk/connectivity/inc/caipinterface.h
@@ -63,6 +63,19 @@ typedef void (*CAIPPacketReceivedCallback)(const CAEndpoint_t *endpoint,
                                            uint32_t dataLength);
 
 /**
+  * @brief Callback to notify error in the IP adapter
+  *
+  * @param  endpoint     [IN] [IN] network endpoint description
+  * @param  data         [IN] Data sent/received
+  * @param  dataLength   [IN] Length of data in bytes.
+  * @param  result       [IN] result of request from R.I
+  * @return NONE
+  * @pre  Callback must be registered using CAIPSetPacketReceiveCallback()
+ */
+typedef void (*CAIPErrorHandleCallback)(const CAEndpoint_t *endpoint, const void *data,
+                                        uint32_t dataLength, CAResult_t result);
+
+/**
  * @brief  Callback to be notified when exception occures on multicast/unicast server.
  * @param  type  [IN] Type of server(#CAAdapterServerType_t)
  * @return NONE
@@ -316,6 +329,14 @@ CAResult_t CAIPGetInterfaceSubnetMask(const char *ipAddress, char **subnetMask);
  */
 void CAIPSetConnectionStateChangeCallback(CAIPConnectionStateChangeCallback callback);
 
+/**
+ * @brief  Set callback for error handling
+ *
+ * @param  ipErrorCallback [IN] callback to notify error to the ipadapter
+ * @return NONE
+ */
+void CAIPSetErrorHandleCallback(CAIPErrorHandleCallback ipErrorCallback);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/resource/csdk/connectivity/src/cainterfacecontroller.c b/resource/csdk/connectivity/src/cainterfacecontroller.c
index 0497a38..a880fa4 100644 (file)
--- a/resource/csdk/connectivity/src/cainterfacecontroller.c
+++ b/resource/csdk/connectivity/src/cainterfacecontroller.c
@@ -148,7 +148,7 @@ void CAInitializeAdapters(ca_thread_pool_t handle)
     // Initialize adapters and register callback.
 #ifdef IP_ADAPTER
     CAInitializeIP(CARegisterCallback, CAReceivedPacketCallback, CANetworkChangedCallback,
-                   handle);
+                   CAAdapterErrorHandleCallback, handle);
 #endif /* IP_ADAPTER */
 
 #ifdef EDR_ADAPTER

diff --git a/resource/csdk/connectivity/src/ip_adapter/caipadapter.c b/resource/csdk/connectivity/src/ip_adapter/caipadapter.c
index 37b8f6b..c942302 100644 (file)
--- a/resource/csdk/connectivity/src/ip_adapter/caipadapter.c
+++ b/resource/csdk/connectivity/src/ip_adapter/caipadapter.c
@@ -91,6 +91,12 @@ static CANetworkPacketReceivedCallback g_networkPacketCallback = NULL;
 static CANetworkChangeCallback g_networkChangeCallback = NULL;
 
 /**
+ * @var g_errorCallback
+ * @brief error Callback to CA adapter
+ */
+static CAErrorHandleCallback g_errorCallback = NULL;
+
+/**
  * @var g_sendQueueHandle
  * @brief Queue handle for Send Data
  */
@@ -107,15 +113,17 @@ static CAResult_t CAIPInitializeQueueHandles();
 static void CAIPDeinitializeQueueHandles();
 
 static void CAIPNotifyNetworkChange(const char *address, uint16_t port,
-                                          CANetworkStatus_t status);
+                                    CANetworkStatus_t status);
 
 static void CAIPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status);
 
 static void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint,
-                                        const void *data, uint32_t dataLength);
+                                 const void *data, uint32_t dataLength);
+static void CAIPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
+                             uint32_t dataLength, CAResult_t result);
 #ifdef __WITH_DTLS__
 static uint32_t CAIPPacketSendCB(const CAEndpoint_t *endpoint,
-                                        const void *data, uint32_t dataLength);
+                                 const void *data, uint32_t dataLength);
 #endif
 
 static CAResult_t CAIPStopServers();
@@ -123,8 +131,7 @@ static CAResult_t CAIPStopServers();
 static void CAIPSendDataThread(void *threadData);
 
 static CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint,
-                                         const void *data, uint32_t dataLength,
-                                         bool isMulticast);
+                                const void *data, uint32_t dataLength, bool isMulticast);
 void CAFreeIPData(CAIPData *ipData);
 
 static void CADataDestroyer(void *data, uint32_t size);
@@ -267,6 +274,11 @@ uint32_t CAIPPacketSendCB(const CAEndpoint_t *endpoint, const void *data, uint32
 
     uint32_t sentLength = CAIPSendData(endpoint, data, dataLength, false);
 
+    if (sentLength == 0)
+    {
+        g_errorCallback(endpoint, data, dataLength, CA_SEND_FAILED);
+    }
+
     OIC_LOG_V(DEBUG, IP_ADAPTER_TAG, "Successfully sent %d of encrypted data!", sentLength);
 
     OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
@@ -305,9 +317,40 @@ void CAIPPacketReceivedCB(const CAEndpoint_t *endpoint, const void *data,
     OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
 }
 
+void CAIPErrorHandler (const CAEndpoint_t *endpoint, const void *data,
+                       uint32_t dataLength, CAResult_t result)
+{
+    OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
+
+    VERIFY_NON_NULL_VOID(endpoint, IP_ADAPTER_TAG, "endpoint is NULL");
+
+    VERIFY_NON_NULL_VOID(data, IP_ADAPTER_TAG, "data is NULL");
+
+    void *buf = (void*)OICMalloc(sizeof(char) * dataLength);
+    if (!buf)
+    {
+        OIC_LOG(ERROR, IP_ADAPTER_TAG, "Memory Allocation failed!");
+        return;
+    }
+    memcpy(buf, data, dataLength);
+    if (g_errorCallback)
+    {
+        g_errorCallback(endpoint, buf, dataLength, result);
+    }
+    else
+    {
+        OICFree(buf);
+    }
+
+    OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
+
+    return;
+}
+
 CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
                           CANetworkPacketReceivedCallback networkPacketCallback,
-                          CANetworkChangeCallback netCallback, ca_thread_pool_t handle)
+                          CANetworkChangeCallback netCallback,
+                          CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
 {
     OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
     VERIFY_NON_NULL(registerCallback, IP_ADAPTER_TAG, "registerCallback");
@@ -318,6 +361,7 @@ CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
     g_threadPool = handle;
     g_networkChangeCallback = netCallback;
     g_networkPacketCallback = networkPacketCallback;
+    g_errorCallback = errorCallback;
 
     CAResult_t ret = CAIPInitializeNetworkMonitor(g_threadPool);
     if (CA_STATUS_OK != ret)
@@ -336,6 +380,7 @@ CAResult_t CAInitializeIP(CARegisterConnectivityCallback registerCallback,
     }
 
     CAIPSetPacketReceiveCallback(CAIPPacketReceivedCB);
+    CAIPSetErrorHandleCallback(CAIPErrorHandler);
 #ifdef __WITH_DTLS__
     CAAdapterNetDtlsInit();
 
@@ -714,6 +759,8 @@ void CAIPSendDataThread(void *threadData)
     OIC_LOG(DEBUG, IP_ADAPTER_TAG, "IN");
 
     CAIPData *ipData = (CAIPData *) threadData;
+    uint32_t sentData = -1;
+
     if (!ipData)
     {
         OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Invalid ip data!");
@@ -726,7 +773,7 @@ void CAIPSendDataThread(void *threadData)
         OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Send Multicast Data is called");
         strncpy(ipData->remoteEndpoint->addr, CA_MULTICAST_IP, MAX_ADDR_STR_SIZE_CA);
         ipData->remoteEndpoint->port = CA_MCAST_PORT;
-        CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, true);
+        sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, true);
     }
     else
     {
@@ -740,6 +787,7 @@ void CAIPSendDataThread(void *threadData)
             if (CA_STATUS_OK != result)
             {
                 OIC_LOG(ERROR, IP_ADAPTER_TAG, "CAAdapterNetDtlsEncrypt failed!");
+                sentData = 0;
             }
             OIC_LOG_V(DEBUG, IP_ADAPTER_TAG,
                       "CAAdapterNetDtlsEncrypt returned with result[%d]", result);
@@ -747,18 +795,24 @@ void CAIPSendDataThread(void *threadData)
         else
         {
             OIC_LOG(DEBUG, IP_ADAPTER_TAG, "Send Unicast Data is called");
-            CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
+            sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
         }
 #else
-        CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
+        sentData = CAIPSendData(ipData->remoteEndpoint, ipData->data, ipData->dataLen, false);
 #endif
     }
 
+    if (0 == sentData)
+    {
+        g_errorCallback(ipData->remoteEndpoint, ipData->data, ipData->dataLen,
+                        CA_SEND_FAILED);
+    }
+
     OIC_LOG(DEBUG, IP_ADAPTER_TAG, "OUT");
 }
 
 CAIPData *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
-                                     uint32_t dataLength, bool isMulticast)
+                         uint32_t dataLength, bool isMulticast)
 {
     VERIFY_NON_NULL_RET(data, IP_ADAPTER_TAG, "IPData is NULL", NULL);
 

diff --git a/resource/csdk/connectivity/src/ip_adapter/caipclient.c b/resource/csdk/connectivity/src/ip_adapter/caipclient.c
index ac902db..4d57e70 100644 (file)
--- a/resource/csdk/connectivity/src/ip_adapter/caipclient.c
+++ b/resource/csdk/connectivity/src/ip_adapter/caipclient.c
@@ -131,7 +131,7 @@ uint32_t CAIPSendData(const CAEndpoint_t *endpoint, const void *data,
         {
             OIC_LOG(ERROR, IP_CLIENT_TAG, "Invalid Socket Fd");
             CAClearServerInfoList(tempServerInfoList);
-            return len;
+            return 0;
         }
 
         OIC_LOG_V(DEBUG, IP_CLIENT_TAG, "IP unicast SendData sockFd %d", sockFd);

diff --git a/resource/csdk/connectivity/src/ip_adapter/caipserver.c b/resource/csdk/connectivity/src/ip_adapter/caipserver.c
index c33953c..e78936b 100644 (file)
--- a/resource/csdk/connectivity/src/ip_adapter/caipserver.c
+++ b/resource/csdk/connectivity/src/ip_adapter/caipserver.c
@@ -77,6 +77,7 @@ typedef struct
     ca_thread_pool_t threadPool;
     CAIPPacketReceivedCallback packetReceivedCallback;
     CAIPExceptionCallback exceptionCallback;
+    CAIPErrorHandleCallback IPErrorCallback;
 } CAAdapterIPServerContext_t;
 
 /**
@@ -92,10 +93,10 @@ static u_arraylist_t *g_serverInfoList = NULL;
 static ca_mutex g_mutexServerInfoList = NULL;
 
 /**
- * @var g_adapterEthServerContext
+ * @var g_adapterIPServerContext
  * @brief Mutex to synchronize ethenet adapter context.
  */
-static CAAdapterIPServerContext_t *g_adapterEthServerContext = NULL;
+static CAAdapterIPServerContext_t *g_adapterIPServerContext = NULL;
 
 /**
  * @var g_mutexAdapterServerContext
@@ -224,10 +225,10 @@ static void CAReceiveHandler(void *data)
                     OIC_LOG_V(ERROR, IP_SERVER_TAG, "Server socket shutdown sock fd[%d]", sd);
                     ca_mutex_lock(g_mutexAdapterServerContext);
                     // Notify upper layer this exception
-                    if (g_adapterEthServerContext->exceptionCallback)
+                    if (g_adapterIPServerContext->exceptionCallback)
                     {
                         // need to make proper exception callback.
-                        //g_adapterEthServerContext->exceptionCallback(ctx->type);
+                        //g_adapterIPServerContext->exceptionCallback(ctx->type);
                     }
                     ca_mutex_unlock(g_mutexAdapterServerContext);
                 }
@@ -281,9 +282,9 @@ static void CAReceiveHandler(void *data)
                 {
                     ca_mutex_lock(g_mutexAdapterServerContext);
 
-                    if (g_adapterEthServerContext->packetReceivedCallback)
+                    if (g_adapterIPServerContext->packetReceivedCallback)
                     {
-                        g_adapterEthServerContext->packetReceivedCallback(&ep,
+                        g_adapterIPServerContext->packetReceivedCallback(&ep,
                                                           recvBuffer, recvLen);
                     }
 
@@ -429,9 +430,9 @@ static CAResult_t CAIPStartPacketReceiverHandler()
 
     ca_mutex_lock(g_mutexAdapterServerContext);
 
-    if (!g_adapterEthServerContext)
+    if (!g_adapterIPServerContext)
     {
-        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterEthServerContext NULL");
+        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterIPServerContext NULL");
         ca_mutex_unlock(g_mutexAdapterServerContext);
         return CA_STATUS_FAILED;
     }
@@ -439,7 +440,7 @@ static CAResult_t CAIPStartPacketReceiverHandler()
     if (1 == listLength) //Its first time.
     {
         g_packetHandlerStopFlag = false;
-        if (CA_STATUS_OK != ca_thread_pool_add_task(g_adapterEthServerContext->threadPool,
+        if (CA_STATUS_OK != ca_thread_pool_add_task(g_adapterIPServerContext->threadPool,
                                                    CAReceiveHandler, NULL ))
         {
             OIC_LOG(ERROR, IP_SERVER_TAG, "thread_pool_add_task failed!");
@@ -517,17 +518,17 @@ CAResult_t CAIPInitializeServer(const ca_thread_pool_t threadPool)
     }
 
     ca_mutex_lock(g_mutexAdapterServerContext);
-    g_adapterEthServerContext = (CAAdapterIPServerContext_t *) OICCalloc(1,
+    g_adapterIPServerContext = (CAAdapterIPServerContext_t *) OICCalloc(1,
                                  sizeof(CAAdapterIPServerContext_t));
 
-    if (!g_adapterEthServerContext)
+    if (!g_adapterIPServerContext)
     {
         OIC_LOG(ERROR, IP_SERVER_TAG, "Malloc failed");
         ca_mutex_unlock(g_mutexAdapterServerContext);
         return CA_MEMORY_ALLOC_FAILED;
     }
 
-    g_adapterEthServerContext->threadPool = threadPool;
+    g_adapterIPServerContext->threadPool = threadPool;
 
     ca_mutex_unlock(g_mutexAdapterServerContext);
 
@@ -549,15 +550,15 @@ void CAIPTerminateServer()
 {
     OIC_LOG(DEBUG, IP_SERVER_TAG, "IN");
     ca_mutex_lock(g_mutexAdapterServerContext);
-    if (!g_adapterEthServerContext)
+    if (!g_adapterIPServerContext)
     {
-        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterEthServerContext NULL");
+        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterIPServerContext NULL");
         ca_mutex_unlock(g_mutexAdapterServerContext);
         return;
     }
 
-    OICFree(g_adapterEthServerContext);
-    g_adapterEthServerContext = NULL;
+    OICFree(g_adapterIPServerContext);
+    g_adapterIPServerContext = NULL;
 
     ca_mutex_unlock(g_mutexAdapterServerContext);
 
@@ -936,13 +937,30 @@ void CAIPSetPacketReceiveCallback(CAIPPacketReceivedCallback callback)
 
     ca_mutex_lock(g_mutexAdapterServerContext);
 
-    if (!g_adapterEthServerContext)
+    if (g_adapterIPServerContext)
     {
-        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterEthServerContext NULL");
-        ca_mutex_unlock(g_mutexAdapterServerContext);
-        return;
+        g_adapterIPServerContext->packetReceivedCallback = callback;
+    }
+    else
+    {
+        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterIPServerContext NULL");
+    }
+
+    ca_mutex_unlock(g_mutexAdapterServerContext);
+
+    OIC_LOG(DEBUG, IP_SERVER_TAG, "OUT");
+}
+
+void CAIPSetErrorHandleCallback(CAIPErrorHandleCallback ipErrorCallback)
+{
+    OIC_LOG(DEBUG, IP_SERVER_TAG, "IN");
+
+    ca_mutex_lock(g_mutexAdapterServerContext);
+
+    if (g_adapterIPServerContext)
+    {
+        g_adapterIPServerContext->IPErrorCallback = ipErrorCallback;
     }
-    g_adapterEthServerContext->packetReceivedCallback = callback;
 
     ca_mutex_unlock(g_mutexAdapterServerContext);
 
@@ -954,13 +972,14 @@ void CAIPSetExceptionCallback(CAIPExceptionCallback callback)
     OIC_LOG(DEBUG, IP_SERVER_TAG, "IN");
     ca_mutex_lock(g_mutexAdapterServerContext);
 
-    if (!g_adapterEthServerContext)
+    if (g_adapterIPServerContext)
     {
-        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterEthServerContext NULL");
-        ca_mutex_unlock(g_mutexAdapterServerContext);
-        return;
+        g_adapterIPServerContext->exceptionCallback = callback;
+    }
+    else
+    {
+        OIC_LOG(ERROR, IP_SERVER_TAG, "g_adapterIPServerContext NULL");
     }
-    g_adapterEthServerContext->exceptionCallback = callback;
 
     ca_mutex_unlock(g_mutexAdapterServerContext);