#define _POSIX_C_SOURCE 200809L
#endif
+#ifdef __TIZENRT__
+#include <tinyara/config.h>
+#endif
+
+#include "iotivity_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#ifdef TB_LOG
+#include <inttypes.h>
+#endif
#ifndef SINGLE_THREAD
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#include <time.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
+#ifdef HAVE_SYS_TIMEB_H
+#include <sys/timeb.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#endif
#if defined(__ANDROID__)
#include <linux/time.h>
#include "caremotehandler.h"
#include "caprotocolmessage.h"
#include "oic_malloc.h"
+#include "oic_time.h"
+#include "ocrandom.h"
#include "logger.h"
#define TAG "OIC_CA_RETRANS"
#endif
uint8_t triedCount; /**< retransmission count */
uint16_t messageId; /**< coap PDU message id */
+ CADataType_t dataType; /**< data Type (Request/Response) */
CAEndpoint_t *endpoint; /**< remote endpoint */
void *pdu; /**< coap PDU */
uint32_t size; /**< coap PDU size */
} CARetransmissionData_t;
static const uint64_t USECS_PER_SEC = 1000000;
-
-/**
- * @brief getCurrent monotonic time
- * @return current time in microseconds
- */
-uint64_t getCurrentTimeInMicroSeconds();
+static const uint64_t MSECS_PER_SEC = 1000;
#ifndef SINGLE_THREAD
/**
*/
static uint64_t CAGetTimeoutValue()
{
- return ((DEFAULT_ACK_TIMEOUT_SEC * 1000) + ((1000 * (random() & 0xFF)) >> 8)) *
- (uint64_t) 1000;
+ return ((DEFAULT_ACK_TIMEOUT_SEC * MSECS_PER_SEC)
+ + ((MSECS_PER_SEC * OCGetRandomByte()) >> 8)) * MSECS_PER_SEC;
}
CAResult_t CARetransmissionStart(CARetransmission_t *context)
OIC_LOG(ERROR, TAG, "thread pool handle is empty..");
return CA_STATUS_INVALID_PARAM;
}
-
+#ifndef __TIZENRT__
CAResult_t res = ca_thread_pool_add_task(context->threadPool, CARetransmissionBaseRoutine,
- context);
-
+ context, NULL);
+#else
+ CAResult_t res = ca_thread_pool_add_task(context->threadPool, CARetransmissionBaseRoutine,
+ context, NULL, "IoT_Retransmit",
+ CONFIG_IOTIVITY_RETRANSMIT_PTHREAD_STACKSIZE);
+#endif
if (CA_STATUS_OK != res)
{
OIC_LOG(ERROR, TAG, "thread pool add task error(send thread).");
#ifndef SINGLE_THREAD
// #1. calculate timeout
uint32_t milliTimeoutValue = retData->timeout * 0.001;
- uint64_t timeout = (milliTimeoutValue << retData->triedCount) * (uint64_t) 1000;
+ uint64_t timeout = ((uint64_t) milliTimeoutValue << retData->triedCount) * MSECS_PER_SEC;
if (currentTime >= retData->timeStamp + timeout)
{
- OIC_LOG_V(DEBUG, TAG, "%llu microseconds time out!!, tried count(%d)",
+#ifndef __TIZENRT__
+ OIC_LOG_V(DEBUG, TAG, "%" PRIu64 " microseconds time out!!, tried count(%d)",
timeout, retData->triedCount);
+#endif
return true;
}
#else
// #1. calculate timeout
- uint64_t timeOut = (2 << retData->triedCount) * 1000000;
+ uint64_t timeOut = (2 << retData->triedCount) * USECS_PER_SEC;
if (currentTime >= retData->timeStamp + timeOut)
{
}
// mutex lock
- ca_mutex_lock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
uint32_t i = 0;
uint32_t len = u_arraylist_length(context->dataList);
continue;
}
- uint64_t currentTime = getCurrentTimeInMicroSeconds();
+ uint64_t currentTime = OICGetCurrentTime(TIME_IN_US);
if (CACheckTimeout(currentTime, retData))
{
{
OIC_LOG_V(DEBUG, TAG, "retransmission CON data!!, msgid=%d",
retData->messageId);
- context->dataSendMethod(retData->endpoint, retData->pdu, retData->size);
+ context->dataSendMethod(retData->endpoint, retData->pdu,
+ retData->size, retData->dataType);
}
// #3. increase the retransmission count and update timestamp.
{
OIC_LOG(ERROR, TAG, "Removed data is NULL");
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
return;
}
OIC_LOG_V(DEBUG, TAG, "max trying count, remove RTCON data,"
}
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
}
void CARetransmissionBaseRoutine(void *threadValue)
while (!context->isStop)
{
// mutex lock
- ca_mutex_lock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
if (!context->isStop && u_arraylist_length(context->dataList) <= 0)
{
OIC_LOG(DEBUG, TAG, "wait..there is no retransmission data.");
// wait
- ca_cond_wait(context->threadCond, context->threadMutex);
+ oc_cond_wait(context->threadCond, context->threadMutex);
OIC_LOG(DEBUG, TAG, "wake up..");
}
else if (!context->isStop)
{
// check each RETRANSMISSION_CHECK_PERIOD_SEC time.
- OIC_LOG_V(DEBUG, TAG, "wait..(%lld)microseconds",
+#ifndef __TIZENRT__
+ OIC_LOG_V(DEBUG, TAG, "wait..(%" PRIu64 ")microseconds",
RETRANSMISSION_CHECK_PERIOD_SEC * (uint64_t) USECS_PER_SEC);
+#endif
// wait
uint64_t absTime = RETRANSMISSION_CHECK_PERIOD_SEC * (uint64_t) USECS_PER_SEC;
- ca_cond_wait_for(context->threadCond, context->threadMutex, absTime );
+ oc_cond_wait_for(context->threadCond, context->threadMutex, absTime );
}
else
{
}
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
// check stop flag
if (context->isStop)
CACheckRetransmissionList(context);
}
- ca_mutex_lock(context->threadMutex);
- ca_cond_signal(context->threadCond);
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
+ oc_cond_signal(context->threadCond);
+ oc_mutex_unlock(context->threadMutex);
#endif
OIC_LOG(DEBUG, TAG, "retransmission main thread end");
// set send thread data
context->threadPool = handle;
- context->threadMutex = ca_mutex_new();
- context->threadCond = ca_cond_new();
+ context->threadMutex = oc_mutex_new();
+ context->threadCond = oc_cond_new();
context->dataSendMethod = retransmissionSendMethod;
context->timeoutCallback = timeoutCallback;
context->config = cfg;
CAResult_t CARetransmissionSentData(CARetransmission_t *context,
const CAEndpoint_t *endpoint,
+ CADataType_t dataType,
const void *pdu, uint32_t size)
{
if (NULL == context || NULL == endpoint || NULL == pdu)
}
// #2. add additional information. (time stamp, retransmission count...)
- retData->timeStamp = getCurrentTimeInMicroSeconds();
+ retData->timeStamp = OICGetCurrentTime(TIME_IN_US);
#ifndef SINGLE_THREAD
retData->timeout = CAGetTimeoutValue();
#endif
retData->endpoint = remoteEndpoint;
retData->pdu = pduData;
retData->size = size;
+ retData->dataType = dataType;
#ifndef SINGLE_THREAD
// mutex lock
- ca_mutex_lock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
uint32_t i = 0;
uint32_t len = u_arraylist_length(context->dataList);
OIC_LOG(ERROR, TAG, "Duplicate message ID");
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
OICFree(retData);
OICFree(pduData);
}
}
- u_arraylist_add(context->dataList, (void *) retData);
+ bool res = u_arraylist_add(context->dataList, (void *) retData);
+ if (!res)
+ {
+ OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
+
+ oc_mutex_unlock(context->threadMutex);
+
+ OICFree(retData);
+ OICFree(pduData);
+ OICFree(remoteEndpoint);
+ return CA_MEMORY_ALLOC_FAILED;
+ }
// notify the thread
- ca_cond_signal(context->threadCond);
+ oc_cond_signal(context->threadCond);
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
#else
- u_arraylist_add(context->dataList, (void *) retData);
+ bool res = u_arraylist_add(context->dataList, (void *) retData);
+ if (!res)
+ {
+ OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
+
+ oc_mutex_unlock(context->threadMutex);
+
+ OICFree(retData);
+ OICFree(pduData);
+ OICFree(remoteEndpoint);
+ return CA_MEMORY_ALLOC_FAILED;
+ }
CACheckRetransmissionList(context);
#endif
}
// mutex lock
- ca_mutex_lock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
uint32_t len = u_arraylist_length(context->dataList);
// find index
OIC_LOG(ERROR, TAG, "retData->pdu is null");
OICFree(retData);
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
return CA_STATUS_FAILED;
}
OIC_LOG(ERROR, TAG, "memory error");
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
return CA_MEMORY_ALLOC_FAILED;
}
OIC_LOG(ERROR, TAG, "Removed data is NULL");
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
return CA_STATUS_FAILED;
}
}
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
+CAResult_t CARetransmissionClearAdapterData(CARetransmission_t *context, CATransportAdapter_t type)
+{
+ if (NULL == context)
+ {
+ OIC_LOG(ERROR, TAG, "thread instance is empty..");
+ return CA_STATUS_INVALID_PARAM;
+ }
+
+ OIC_LOG_V(DEBUG, TAG, "clear queue data for Adapter : %d ", type);
+
+ // mutex lock
+ oc_mutex_lock(context->threadMutex);
+
+ uint32_t len = u_arraylist_length(context->dataList);
+
+ // find index
+ uint32_t i;
+ for (i = 0; i < len; i++)
+ {
+ // get data
+ CARetransmissionData_t *removedData = (CARetransmissionData_t *) u_arraylist_get(
+ context->dataList, i);
+
+ // free
+ if (NULL != removedData && NULL != removedData->endpoint &&
+ removedData->endpoint->adapter == type)
+ {
+ CAFreeEndpoint(removedData->endpoint);
+ OICFree(removedData->pdu);
+ OICFree(removedData);
+ }
+ }
+
+ // mutex unlock
+ oc_mutex_unlock(context->threadMutex);
+
+ return CA_STATUS_OK;
+}
+
CAResult_t CARetransmissionStop(CARetransmission_t *context)
{
if (NULL == context)
OIC_LOG(DEBUG, TAG, "retransmission stop request!!");
// mutex lock
- ca_mutex_lock(context->threadMutex);
+ oc_mutex_lock(context->threadMutex);
// set stop flag
context->isStop = true;
// notify the thread
- ca_cond_signal(context->threadCond);
+ oc_cond_signal(context->threadCond);
- ca_cond_wait(context->threadCond, context->threadMutex);
+ oc_cond_wait(context->threadCond, context->threadMutex);
// mutex unlock
- ca_mutex_unlock(context->threadMutex);
+ oc_mutex_unlock(context->threadMutex);
return CA_STATUS_OK;
}
OIC_LOG(DEBUG, TAG, "retransmission context destroy..");
- ca_mutex_free(context->threadMutex);
+ oc_mutex_free(context->threadMutex);
context->threadMutex = NULL;
- ca_cond_free(context->threadCond);
+ oc_cond_free(context->threadCond);
u_arraylist_free(&context->dataList);
return CA_STATUS_OK;
}
-
-uint64_t getCurrentTimeInMicroSeconds()
-{
- OIC_LOG(DEBUG, TAG, "IN");
- uint64_t currentTime = 0;
-
-#ifdef __ANDROID__
- struct timespec getTs;
-
- clock_gettime(CLOCK_MONOTONIC, &getTs);
-
- currentTime = (getTs.tv_sec * (uint64_t)1000000000 + getTs.tv_nsec)/1000;
- OIC_LOG_V(DEBUG, TAG, "current time = %lld", currentTime);
-#elif defined __ARDUINO__
- currentTime = millis() * 1000;
- OIC_LOG_V(DEBUG, TAG, "currtime=%lu", currentTime);
-#else
-#if _POSIX_TIMERS > 0
- struct timespec ts;
- clock_gettime(CLOCK_MONOTONIC, &ts);
- currentTime = ts.tv_sec * USECS_PER_SEC + ts.tv_nsec / 1000;
-#else
- struct timeval tv;
- gettimeofday(&tv, NULL);
- currentTime = tv.tv_sec * USECS_PER_SEC + tv.tv_usec;
-#endif
-#endif
-
- OIC_LOG(DEBUG, TAG, "OUT");
- return currentTime;
-}
projects / platform / upstream / iotivity.git / blobdiff