replace : iotivity -> iotivity-sec

[platform/upstream/iotivity.git] / resource / src / InProcServerWrapper.cpp

diff --git a/resource/src/InProcServerWrapper.cpp b/resource/src/InProcServerWrapper.cpp
index fb26655..0659116 100644 (file)
--- a/resource/src/InProcServerWrapper.cpp
+++ b/resource/src/InProcServerWrapper.cpp
@@ -38,6 +38,9 @@
 #include <oic_malloc.h>
 #include <OCPlatform.h>
 #include <OCUtilities.h>
+#include "logger.h"
+
+#define TAG "OIC_SERVER_WRAPPER"
 
 using namespace std;
 using namespace OC;
@@ -254,19 +257,27 @@ namespace OC
 {
     InProcServerWrapper::InProcServerWrapper(
         std::weak_ptr<std::recursive_mutex> csdkLock, PlatformConfig cfg)
-     : m_csdkLock(csdkLock)
+     : m_threadRun(false),
+       m_csdkLock(csdkLock),
+       m_cfg { cfg }       
     {
-        OCMode initType;
+        start();
+    }
+
+    OCStackResult InProcServerWrapper::start()
+    {
+        OIC_LOG_V(INFO, TAG, "start ocplatform for server : %d", m_cfg.transportType);
 
-        if(cfg.mode == ModeType::Server)
+        OCMode initType;
+        if(m_cfg.mode == ModeType::Server)
         {
             initType = OC_SERVER;
         }
-        else if (cfg.mode == ModeType::Both)
+        else if (m_cfg.mode == ModeType::Both)
         {
             initType = OC_CLIENT_SERVER;
         }
-        else if (cfg.mode == ModeType::Gateway)
+        else if (m_cfg.mode == ModeType::Gateway)
         {
             initType = OC_GATEWAY;
         }
@@ -277,18 +288,43 @@ namespace OC
         }
 
         OCTransportFlags serverFlags =
-                            static_cast<OCTransportFlags>(cfg.serverConnectivity & CT_MASK_FLAGS);
+                            static_cast<OCTransportFlags>(m_cfg.serverConnectivity & CT_MASK_FLAGS);
         OCTransportFlags clientFlags =
-                            static_cast<OCTransportFlags>(cfg.clientConnectivity & CT_MASK_FLAGS);
-        OCStackResult result = OCInit1(initType, serverFlags, clientFlags);
+                            static_cast<OCTransportFlags>(m_cfg.clientConnectivity & CT_MASK_FLAGS);
+        OCStackResult result = OCInit2(initType, serverFlags, clientFlags,
+                                       m_cfg.transportType);
 
         if(OC_STACK_OK != result)
         {
             throw InitializeException(OC::InitException::STACK_INIT_ERROR, result);
         }
 
-        m_threadRun = true;
-        m_processThread = std::thread(&InProcServerWrapper::processFunc, this);
+        if (false == m_threadRun)
+        {
+            m_threadRun = true;
+            m_processThread = std::thread(&InProcServerWrapper::processFunc, this);
+        }
+        return OC_STACK_OK;
+    }
+
+    OCStackResult InProcServerWrapper::stop()
+    {
+        OIC_LOG(INFO, TAG, "stop");
+
+        if(m_processThread.joinable())
+        {
+            m_threadRun = false;
+            m_processThread.join();
+        }
+
+        OCStackResult res = OCStop();
+
+        if (OC_STACK_OK != res)
+        {
+           throw InitializeException(OC::InitException::STACK_TERMINATE_ERROR, res);
+        }
+
+        return OC_STACK_OK;
     }
 
     void InProcServerWrapper::processFunc()
@@ -612,7 +648,6 @@ namespace OC
             }
             else
             {
-                OICFree(response.payload);
                 result = OC_STACK_ERROR;
             }
 
@@ -620,18 +655,67 @@ namespace OC
             {
                 oclog() << "Error sending response\n";
             }
+
+            OCPayloadDestroy(response.payload);
             return result;
         }
     }
 
-    InProcServerWrapper::~InProcServerWrapper()
+    OCStackResult InProcServerWrapper::notifyAllObservers(OCResourceHandle resourceHandle,
+                                                          QualityOfService QoS)
     {
-        if(m_processThread.joinable())
+        auto cLock = m_csdkLock.lock();
+        OCStackResult result = OC_STACK_ERROR;
+        if (cLock)
         {
-            m_threadRun = false;
-            m_processThread.join();
+            std::lock_guard<std::recursive_mutex> lock(*cLock);
+            result = OCNotifyAllObservers(resourceHandle, static_cast<OCQualityOfService>(QoS));
         }
 
-        OCStop();
+        return result;
+    }
+
+    OCStackResult InProcServerWrapper::notifyListOfObservers(OCResourceHandle resourceHandle,
+                                               ObservationIds& observationIds,
+                                               const std::shared_ptr<OCResourceResponse> pResponse,
+                                               QualityOfService QoS)
+    {
+        if (!pResponse)
+        {
+            return OC_STACK_ERROR;
+        }
+
+        auto cLock = m_csdkLock.lock();
+        OCStackResult result = OC_STACK_ERROR;
+        if (cLock)
+        {
+            std::lock_guard<std::recursive_mutex> lock(*cLock);
+
+            OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload();
+            result = OCNotifyListOfObservers(resourceHandle,
+                                             &observationIds[0],
+                                             observationIds.size(),
+                                             pl,
+                                             static_cast<OCQualityOfService>(QoS));
+            OCRepPayloadDestroy(pl);
+        }
+
+        if (result != OC_STACK_OK)
+        {
+            throw OCException(OC::Exception::NOTIFY_LIST_OBSERVERS_FAILED, result);
+        }
+        return result;
+    }
+
+    InProcServerWrapper::~InProcServerWrapper()
+    {
+        try
+        {
+            stop();
+        }
+        catch (InitializeException &e)
+        {
+            oclog() << "Exception in stop"<< e.what() << std::flush;
+        }
     }
 }