replace : iotivity -> iotivity-sec

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

diff --git a/resource/src/OCPlatform_impl.cpp b/resource/src/OCPlatform_impl.cpp
old mode 100644 (file)
new mode 100755 (executable)
index a8e8fd3..d782d6b
--- a/resource/src/OCPlatform_impl.cpp
+++ b/resource/src/OCPlatform_impl.cpp
@@ -44,8 +44,11 @@
 #include "OCUtilities.h"
 #include "ocpayload.h"
 
+#include "logger.h"
 #include "oc_logger.hpp"
 
+#define TAG "OIC_PLATFORM"
+
 namespace OC
 {
 
@@ -55,10 +58,24 @@ namespace OC
         return s_config;
     }
 
-    void OCPlatform_impl::Configure(const PlatformConfig& config)
+    OCStackResult OCPlatform_impl::Configure(const PlatformConfig& config)
     {
-        OCRegisterPersistentStorageHandler(config.ps);
+        OIC_LOG_V(INFO, TAG, "Configure : %d %p", config.transportType, config.ps);
+        OCStackResult res = OC_STACK_OK;
+
+        res = OCSetSecurePSI(config.key, config.ps, config.psEnc, config.psRescue);
+        if (OC_STACK_OK == res && config.psEnc)
+        {
+            OIC_LOG(INFO, TAG, "It uses psEnc for svr db.");
+            res = OCRegisterPersistentStorageHandler(config.psEnc);
+        } else
+        {
+            OIC_LOG(INFO, TAG, "It uses ps for svr db.");
+            res = OCRegisterPersistentStorageHandler(config.ps);
+        }
+
         globalConfig() = config;
+        return res;
     }
 
     OCPlatform_impl& OCPlatform_impl::Instance()
@@ -67,22 +84,105 @@ namespace OC
         return platform;
     }
 
+    OCStackResult OCPlatform_impl::start()
+    {
+        OIC_LOG(INFO, TAG, "start");
+
+        OCStackResult res = OC_STACK_OK;
+        if (OC_CLIENT == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::start))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else if (OC_SERVER == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::start))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else if (OC_CLIENT_SERVER == m_modeType || OC_GATEWAY == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::start))
+            {
+                res = OC_STACK_ERROR;
+            }
+
+            if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::start))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else
+        {
+            res = OC_STACK_ERROR;
+        }
+
+        return res;
+    }
+
+    OCStackResult OCPlatform_impl::stop()
+    {
+        OIC_LOG(INFO, TAG, "stop");
+
+        OCStackResult res = OC_STACK_OK;
+        if (OC_CLIENT == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::stop))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else if (OC_SERVER == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::stop))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else if (OC_CLIENT_SERVER == m_modeType)
+        {
+            if (OC_STACK_OK != checked_guard(m_client, &IClientWrapper::stop))
+            {
+                res = OC_STACK_ERROR;
+            }
+
+            if (OC_STACK_OK != checked_guard(m_server, &IServerWrapper::stop))
+            {
+                res = OC_STACK_ERROR;
+            }
+        }
+        else
+        {
+            res = OC_STACK_ERROR;
+        }
+
+        return res;
+    }
+
     void OCPlatform_impl::init(const PlatformConfig& config)
     {
+        OIC_LOG(INFO, TAG, "init");
+
         switch(config.mode)
         {
             case ModeType::Server:
                 m_server = m_WrapperInstance->CreateServerWrapper(m_csdkLock, config);
+                m_modeType = OC_SERVER;
                 break;
 
             case ModeType::Client:
                 m_client = m_WrapperInstance->CreateClientWrapper(m_csdkLock, config);
+                m_modeType = OC_CLIENT;
                 break;
 
             case ModeType::Both:
             case ModeType::Gateway:
                 m_server = m_WrapperInstance->CreateServerWrapper(m_csdkLock, config);
                 m_client = m_WrapperInstance->CreateClientWrapper(m_csdkLock, config);
+                m_modeType = OC_CLIENT_SERVER;
                 break;
          }
     }
@@ -108,8 +208,7 @@ namespace OC
     OCStackResult OCPlatform_impl::notifyAllObservers(OCResourceHandle resourceHandle,
                                                 QualityOfService QoS)
     {
-        return result_guard(OCNotifyAllObservers(resourceHandle,
-                    static_cast<OCQualityOfService>(QoS)));
+        return checked_guard(m_server, &IServerWrapper::notifyAllObservers, resourceHandle, QoS);
     }
 
     OCStackResult OCPlatform_impl::notifyAllObservers(OCResourceHandle resourceHandle)
@@ -129,19 +228,8 @@ namespace OC
                                        const std::shared_ptr<OCResourceResponse> pResponse,
                                        QualityOfService QoS)
     {
-        if(!pResponse)
-        {
-         return result_guard(OC_STACK_ERROR);
-        }
-
-        OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload();
-        OCStackResult result =
-                   OCNotifyListOfObservers(resourceHandle,
-                            &observationIds[0], observationIds.size(),
-                            pl,
-                            static_cast<OCQualityOfService>(QoS));
-        OCRepPayloadDestroy(pl);
-        return result_guard(result);
+        return checked_guard(m_server, &IServerWrapper::notifyListOfObservers, resourceHandle,
+                             observationIds, pResponse, QoS);
     }
 
     OCResource::Ptr OCPlatform_impl::constructResourceObject(const std::string& host,
@@ -166,7 +254,7 @@ namespace OC
                                             uri, "", connectivityType,
                                             resourceProperty,
                                             resourceTypes,
-                                            interfaces));
+                                            interfaces, ""));
     }
 
     OCStackResult OCPlatform_impl::findResource(const std::string& host,
@@ -215,10 +303,22 @@ namespace OC
                                             FindResListCallback resourceHandler,
                                             QualityOfService QoS)
     {
-        return checked_guard(m_client, &IClientWrapper::ListenForResource2,
+        return checked_guard(m_client, &IClientWrapper::ListenForResourceList,
                              host, resourceName, connectivityType, resourceHandler, QoS);
     }
 
+    OCStackResult OCPlatform_impl::findResourceList(const std::string& host,
+                                            const std::string& resourceName,
+                                            OCConnectivityType connectivityType,
+                                            FindResListCallback resourceHandler,
+                                            FindErrorCallback errorHandler,
+                                            QualityOfService Qos)
+    {
+        return checked_guard(m_client, &IClientWrapper::ListenForResourceListWithError,
+                             host, resourceName, connectivityType, resourceHandler,
+                             errorHandler, Qos);
+    }
+
     OCStackResult OCPlatform_impl::getDeviceInfo(const std::string& host,
                                             const std::string& deviceURI,
                                             OCConnectivityType connectivityType,
@@ -478,7 +578,19 @@ namespace OC
                                                                       connectivityType));
     }
 #endif // WITH_CLOUD
+#ifdef TCP_ADAPTER
+    OCStackResult OCPlatform_impl::findKeepAliveResource(std::string host, KeepAliveCallback resultCallback)
+    {
+        return checked_guard(m_client, &IClientWrapper::findKeepAliveResource, host, resultCallback);
+    }
 
+    OCStackResult OCPlatform_impl::sendKeepAliveRequest(std::string host, const OCRepresentation& rep,
+                                                        KeepAliveCallback resultCallback)
+    {
+        return checked_guard(m_client, &IClientWrapper::sendKeepAliveRequest, host,
+                             rep, resultCallback);
+    }
+#endif
     OCStackResult OCPlatform_impl::getDeviceId(OCUUIdentity *myUuid)
     {
         return OCGetDeviceId(myUuid);