#include "ocpayload.h"
#include "oic_malloc.h"
#include "oic_string.h"
+#include "octhread.h"
#include "occollection.h"
#include "logger.h"
#include "timer.h"
pointer = NULL; \
}
-// Mutex implementation macros
-#if defined(HAVE_PTHREAD_H)
-
- #include <pthread.h>
- pthread_mutex_t lock;
- #define MUTEX_LOCK(ARG_NAME) { pthread_mutex_lock(ARG_NAME); }
- #define MUTEX_UNLOCK(ARG_NAME) { pthread_mutex_unlock(ARG_NAME); }
-
-#elif defined(HAVE_WINDOWS_H)
-
- #include <windows.h>
- CRITICAL_SECTION lock;
- #define MUTEX_LOCK(ARG_NAME) { EnterCriticalSection(ARG_NAME); }
- #define MUTEX_UNLOCK(ARG_NAME) { LeaveCriticalSection(ARG_NAME); }
-
-#elif defined(WITH_ARDUINO)
-
- #define MUTEX_LOCK(ARG_NAME) { }
- #define MUTEX_UNLOCK(ARG_NAME) { }
-
-#else
-
- ERROR Need mutex implementation on this platform
-
-#endif
+oc_mutex g_scheduledResourceLock = NULL;
enum ACTION_TYPE
{
struct scheduledresourceinfo* next;
} ScheduledResourceInfo;
-ScheduledResourceInfo *scheduleResourceList = NULL;
+ScheduledResourceInfo *g_scheduleResourceList = NULL;
void AddScheduledResource(ScheduledResourceInfo **head,
ScheduledResourceInfo* add)
{
OIC_LOG(INFO, TAG, "AddScheduledResource Entering...");
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
ScheduledResourceInfo *tmp = NULL;
if (*head != NULL)
{
*head = add;
}
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
}
ScheduledResourceInfo* GetScheduledResource(ScheduledResourceInfo *head)
{
OIC_LOG(INFO, TAG, "GetScheduledResource Entering...");
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
time_t t_now;
exit:
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
if (tmp == NULL)
{
{
OIC_LOG(INFO, TAG, "GetScheduledResourceByActionSetName Entering...");
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
ScheduledResourceInfo *tmp = NULL;
tmp = head;
exit:
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
if (tmp == NULL)
{
ScheduledResourceInfo* del)
{
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
OIC_LOG(INFO, TAG, "RemoveScheduledResource Entering...");
ScheduledResourceInfo *tmp = NULL;
if (del == NULL)
{
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
return;
}
OCFREE(del)
- MUTEX_UNLOCK(&lock);
-
+ oc_mutex_unlock(g_scheduledResourceLock);
}
typedef struct aggregatehandleinfo
void DoScheduledGroupAction()
{
OIC_LOG(INFO, TAG, "DoScheduledGroupAction Entering...");
- ScheduledResourceInfo* info = GetScheduledResource(scheduleResourceList);
+ ScheduledResourceInfo* info = GetScheduledResource(g_scheduleResourceList);
if (info == NULL)
{
goto exit;
}
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
DoAction(info->resource, info->actionset, info->ehRequest);
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
if (info->actionset->type == RECURSIVE)
if (info->actionset->timesteps > 0)
{
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
schedule->resource = info->resource;
schedule->actionset = info->actionset;
schedule->ehRequest = info->ehRequest;
&schedule->timer_id,
&DoScheduledGroupAction);
- OIC_LOG(INFO, TAG, "Reregisteration.");
- MUTEX_UNLOCK(&lock);
- AddScheduledResource(&scheduleResourceList, schedule);
+ OIC_LOG(INFO, TAG, "Reregistration.");
+ oc_mutex_unlock(g_scheduledResourceLock);
+ AddScheduledResource(&g_scheduleResourceList, schedule);
}
else
{
}
}
- RemoveScheduledResource(&scheduleResourceList, info);
+ RemoveScheduledResource(&g_scheduleResourceList, info);
exit:
char *doWhat = NULL;
char *details = NULL;
-#if defined(_WIN32)
- static bool initializedCriticalSection = false;
-
- if(false == initializedCriticalSection) {
- /** @todo Find a way to DeleteCriticalSection somewhere. */
- InitializeCriticalSection(&lock);
- initializedCriticalSection = true;
- }
-#endif
+ assert(g_scheduledResourceLock != NULL);
stackRet = ExtractKeyValueFromRequest(ehRequest, &doWhat, &details);
OIC_LOG(INFO, TAG, "Building New Call Info.");
memset(schedule, 0,
sizeof(ScheduledResourceInfo));
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
schedule->resource = resource;
schedule->actionset = actionset;
schedule->ehRequest =
(OCServerRequest*) ehRequest->requestHandle;
- MUTEX_UNLOCK(&lock);
+ oc_mutex_unlock(g_scheduledResourceLock);
if (delay > 0)
{
OIC_LOG_V(INFO, TAG, "delay_time is %ld seconds.",
actionset->timesteps);
- MUTEX_LOCK(&lock);
+ oc_mutex_lock(g_scheduledResourceLock);
schedule->time = registerTimer(delay,
&schedule->timer_id,
&DoScheduledGroupAction);
- MUTEX_UNLOCK(&lock);
- AddScheduledResource(&scheduleResourceList,
+ oc_mutex_unlock(g_scheduledResourceLock);
+ AddScheduledResource(&g_scheduleResourceList,
schedule);
stackRet = OC_STACK_OK;
}
else if (strcmp(doWhat, "CancelAction") == 0)
{
ScheduledResourceInfo *info =
- GetScheduledResourceByActionSetName(scheduleResourceList, details);
+ GetScheduledResourceByActionSetName(g_scheduleResourceList, details);
if(info != NULL)
{
+ oc_mutex_lock(g_scheduledResourceLock);
unregisterTimer(info->timer_id);
+ oc_mutex_unlock(g_scheduledResourceLock);
- RemoveScheduledResource(&scheduleResourceList, info);
+ RemoveScheduledResource(&g_scheduleResourceList, info);
stackRet = OC_STACK_OK;
}
else
return stackRet;
}
+
+OCStackResult InitializeScheduleResourceList()
+{
+ assert(g_scheduledResourceLock == NULL);
+
+ g_scheduledResourceLock = oc_mutex_new();
+ if (g_scheduledResourceLock == NULL)
+ {
+ return OC_STACK_ERROR;
+ }
+
+ g_scheduleResourceList = NULL;
+ return OC_STACK_OK;
+}
+
+void TerminateScheduleResourceList()
+{
+ assert(g_scheduleResourceList == NULL);
+
+ if (g_scheduledResourceLock != NULL)
+ {
+ oc_mutex_free(g_scheduledResourceLock);
+ g_scheduledResourceLock = NULL;
+ }
+}
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "rd_storage.h"
-
-#ifdef HAVE_PTHREAD_H
-#include <pthread.h>
-#endif
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
#include <string.h>
#include "payload_logging.h"
#define TAG PCF("RDStorage")
-// Mutex implementation macros
-#if defined(HAVE_PTHREAD_H)
-
-#include <pthread.h>
-pthread_mutex_t storageMutex;
-#define MUTEX_LOCK(ARG_NAME) { pthread_mutex_lock(ARG_NAME); }
-#define MUTEX_UNLOCK(ARG_NAME) { pthread_mutex_unlock(ARG_NAME); }
-
-#elif defined(HAVE_WINDOWS_H)
-
-#include <windows.h>
-CRITICAL_SECTION storageMutex;
-#define MUTEX_LOCK(ARG_NAME) { EnterCriticalSection(ARG_NAME); }
-#define MUTEX_UNLOCK(ARG_NAME) { LeaveCriticalSection(ARG_NAME); }
-
-#else
-
-ERROR Need mutex implementation for this platform
-#define MUTEX_LOCK(ARG_NAME) { }
-#define MUTEX_UNLOCK(ARG_NAME) { }
-
-#endif
+oc_mutex g_storageMutex = NULL;
static OCRDStorePublishResources *g_rdStorage = NULL;
resources->publishedResource = storeResource;
resources->devAddr = *address;
- MUTEX_LOCK(&storageMutex);
+ oc_mutex_lock(g_storageMutex);
if (g_rdStorage)
{
OCRDStorePublishResources *temp = g_rdStorage;
{
g_rdStorage = resources;
}
- MUTEX_UNLOCK(&storageMutex);
+ oc_mutex_unlock(g_storageMutex);
printStoragedResources(g_rdStorage);
return OC_STACK_OK;
}
return OC_STACK_ERROR;
}
+
+/**
+ * Initializes the publish resources.
+ *
+ * @return ::OC_STACK_OK upon success, ::OC_STACK_ERROR in case of error.
+ */
+OCStackResult OCRDInitializeStorage()
+{
+ assert(g_storageMutex == NULL);
+
+ g_storageMutex = oc_mutex_new();
+ if (g_storageMutex == NULL)
+ {
+ return OC_STACK_ERROR;
+ }
+
+ g_rdStorage = NULL;
+ return OC_STACK_OK;
+}
+
+/**
+ * Cleans up the publish resources.
+ */
+void OCRDTerminateStorage()
+{
+ assert(g_rdStorage == NULL);
+
+ if (g_storageMutex != NULL)
+ {
+ oc_mutex_free(g_storageMutex);
+ g_storageMutex = NULL;
+ }
+}