From f5c7d80dd1b4e12df0fd7752f2eebe7ecbb13d77 Mon Sep 17 00:00:00 2001 From: jnashok Date: Wed, 3 Jun 2015 18:30:40 +0900 Subject: [PATCH] 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 Reviewed-on: https://gerrit.iotivity.org/gerrit/1181 Tested-by: jenkins-iotivity Reviewed-by: jihwan seo Reviewed-by: Erich Keane --- resource/csdk/connectivity/inc/caipadapter.h | 14 ++-- resource/csdk/connectivity/inc/caipinterface.h | 21 ++++++ .../csdk/connectivity/src/cainterfacecontroller.c | 2 +- .../csdk/connectivity/src/ip_adapter/caipadapter.c | 74 +++++++++++++++++++--- .../csdk/connectivity/src/ip_adapter/caipclient.c | 2 +- .../csdk/connectivity/src/ip_adapter/caipserver.c | 71 +++++++++++++-------- 6 files changed, 140 insertions(+), 44 deletions(-) diff --git a/resource/csdk/connectivity/inc/caipadapter.h b/resource/csdk/connectivity/inc/caipadapter.h index 22ab8ce..dce3cca 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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); -- 2.7.4