X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fsrc%2FInProcServerWrapper.cpp;h=b4b799ea79a5894e07c0a602f7ef680e79b1670e;hb=c61070f121f5300b9e0dd8f6570fef7ad4f9d586;hp=769de247eba8aee85bf56d570fd18eb9cd1e7dd5;hpb=15e34b0beec1996d5956275d2dc7c55d60cf78cd;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/src/InProcServerWrapper.cpp b/resource/src/InProcServerWrapper.cpp index 769de24..b4b799e 100644 --- a/resource/src/InProcServerWrapper.cpp +++ b/resource/src/InProcServerWrapper.cpp @@ -32,10 +32,15 @@ #include #include #include +#include + #include #include #include #include +#include "logger.h" + +#define TAG "OIC_SERVER_WRAPPER" using namespace std; using namespace OC; @@ -47,7 +52,7 @@ namespace OC std::mutex serverWrapperLock; std::map entityHandlerMap; std::map resourceUriMap; - EntityHandler defaultDeviceEntityHandler = 0; + EntityHandler defaultDeviceEntityHandler; } } @@ -59,6 +64,7 @@ void formResourceRequest(OCEntityHandlerFlag flag, { pRequest->setRequestHandle(entityHandlerRequest->requestHandle); pRequest->setResourceHandle(entityHandlerRequest->resource); + pRequest->setMessageID(entityHandlerRequest->messageID); } if(flag & OC_REQUEST_FLAG) @@ -81,16 +87,17 @@ void formResourceRequest(OCEntityHandlerFlag flag, { //Set the header options here. uint16_t optionID; - std::string optionData; + char optionData[MAX_HEADER_OPTION_DATA_LENGTH + 1]; HeaderOptions headerOptions; + optionData[MAX_HEADER_OPTION_DATA_LENGTH] = '\0'; for(int i = 0; i < entityHandlerRequest->numRcvdVendorSpecificHeaderOptions; i++) { optionID = entityHandlerRequest->rcvdVendorSpecificHeaderOptions[i].optionID; - optionData = reinterpret_cast - (entityHandlerRequest->rcvdVendorSpecificHeaderOptions[i].optionData); + memcpy(optionData, entityHandlerRequest->rcvdVendorSpecificHeaderOptions[i].optionData, + MAX_HEADER_OPTION_DATA_LENGTH); HeaderOption::OCHeaderOption headerOption(optionID, optionData); headerOptions.push_back(headerOption); } @@ -104,14 +111,12 @@ void formResourceRequest(OCEntityHandlerFlag flag, else if(OC_REST_PUT == entityHandlerRequest->method) { pRequest->setRequestType(OC::PlatformCommands::PUT); - pRequest->setPayload(std::string(reinterpret_cast - (entityHandlerRequest->reqJSONPayload))); + pRequest->setPayload(entityHandlerRequest->payload); } else if(OC_REST_POST == entityHandlerRequest->method) { pRequest->setRequestType(OC::PlatformCommands::POST); - pRequest->setPayload(std::string(reinterpret_cast - (entityHandlerRequest->reqJSONPayload))); + pRequest->setPayload(entityHandlerRequest->payload); } else if(OC_REST_DELETE == entityHandlerRequest->method) { @@ -130,6 +135,12 @@ void formResourceRequest(OCEntityHandlerFlag flag, OC::ObservationInfo observationInfo; observationInfo.action = (OC::ObserveAction) entityHandlerRequest->obsInfo.action; observationInfo.obsId = entityHandlerRequest->obsInfo.obsId; + + observationInfo.connectivityType = static_cast( + (entityHandlerRequest->devAddr.adapter << CT_ADAPTER_SHIFT) | + (entityHandlerRequest->devAddr.flags & CT_MASK_FLAGS)); + observationInfo.address = entityHandlerRequest->devAddr.addr; + observationInfo.port = entityHandlerRequest->devAddr.port; pRequest->setObservationInfo(observationInfo); } } @@ -138,7 +149,7 @@ void formResourceRequest(OCEntityHandlerFlag flag, OCEntityHandlerResult DefaultEntityHandlerWrapper(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, char* uri, - void * callbackParam) + void * /*callbackParam*/) { OCEntityHandlerResult result = OC_EH_ERROR; @@ -178,7 +189,7 @@ OCEntityHandlerResult DefaultEntityHandlerWrapper(OCEntityHandlerFlag flag, OCEntityHandlerResult EntityHandlerWrapper(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest, - void* callbackParam) + void* /*callbackParam*/) { OCEntityHandlerResult result = OC_EH_ERROR; @@ -247,33 +258,74 @@ namespace OC { InProcServerWrapper::InProcServerWrapper( std::weak_ptr 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 (m_cfg.mode == ModeType::Gateway) + { + initType = OC_GATEWAY; + } else { throw InitializeException(OC::InitException::NOT_CONFIGURED_AS_SERVER, - OC_STACK_INVALID_PARAM); + OC_STACK_INVALID_PARAM); } - OCStackResult result = OCInit(cfg.ipAddress.c_str(), cfg.port, initType); + OCTransportFlags serverFlags = + static_cast(m_cfg.serverConnectivity & CT_MASK_FLAGS); + OCTransportFlags clientFlags = + static_cast(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() @@ -310,7 +362,7 @@ namespace OC return result; } - OCStackResult InProcServerWrapper::registerPlatformInfo(const OCPlatformInfo platformInfo) + OCStackResult InProcServerWrapper::registerPlatformInfo(const OCPlatformInfo platformInfo) { auto cLock = m_csdkLock.lock(); OCStackResult result = OC_STACK_ERROR; @@ -322,6 +374,32 @@ namespace OC return result; } + OCStackResult InProcServerWrapper::setPropertyValue(OCPayloadType type, const std::string& propName, + const std::string& propValue) + { + auto cLock = m_csdkLock.lock(); + OCStackResult result = OC_STACK_ERROR; + if (cLock) + { + std::lock_guard lock(*cLock); + result = OCSetPropertyValue(type, propName.c_str(), (void *)propValue.c_str()); + } + return result; + } + + OCStackResult InProcServerWrapper::getPropertyValue(OCPayloadType type, const std::string& propName, + std::string& propValue) + { + auto cLock = m_csdkLock.lock(); + OCStackResult result = OC_STACK_ERROR; + if (cLock) + { + std::lock_guard lock(*cLock); + result = OCGetPropertyValue(type, propName.c_str(), (void **)propValue.c_str()); + } + return result; + } + OCStackResult InProcServerWrapper::registerResource( OCResourceHandle& resourceHandle, std::string& resourceURI, @@ -456,6 +534,28 @@ namespace OC return result; } + OCStackResult InProcServerWrapper::resetResourceTypes(const OCResourceHandle& resourceHandle, + const std::string& newResourceType) + { + auto cLock = m_csdkLock.lock(); + OCStackResult result; + if(cLock) + { + std::lock_guard lock(*cLock); + result = OCResetResourceTypes(resourceHandle, newResourceType.c_str()); + } + else + { + result = OC_STACK_ERROR; + } + + if (result != OC_STACK_OK) + { + throw OCException(OC::Exception::BIND_TYPE_FAILED, result); + } + return result; + } + OCStackResult InProcServerWrapper::bindInterfaceToResource( const OCResourceHandle& resourceHandle, const std::string& resourceInterfaceName) @@ -480,6 +580,30 @@ namespace OC return result; } + OCStackResult InProcServerWrapper::resetResourceInterfaces( + const OCResourceHandle& resourceHandle, + const std::string& newResourceInterface) + { + auto cLock = m_csdkLock.lock(); + OCStackResult result; + if(cLock) + { + std::lock_guard lock(*cLock); + result = OCResetResourceInterfaces(resourceHandle, + newResourceInterface.c_str()); + } + else + { + result = OC_STACK_ERROR; + } + + if (result != OC_STACK_OK) + { + throw OCException(OC::Exception::BIND_INTERFACE_FAILED, result); + } + return result; + } + OCStackResult InProcServerWrapper::startPresence(const unsigned int seconds) { auto cLock = m_csdkLock.lock(); @@ -528,23 +652,15 @@ namespace OC else { OCEntityHandlerResponse response; - std::string payLoad = pResponse->getPayload(); +// OCRepPayload* payLoad = pResponse->getPayload(); HeaderOptions serverHeaderOptions = pResponse->getHeaderOptions(); response.requestHandle = pResponse->getRequestHandle(); response.resourceHandle = pResponse->getResourceHandle(); response.ehResult = pResponse->getResponseResult(); - response.payload = static_cast(OICMalloc(payLoad.length() + 1)); - if(!response.payload) - { - result = OC_STACK_NO_MEMORY; - throw OCException(OC::Exception::NO_MEMORY, OC_STACK_NO_MEMORY); - } + response.payload = reinterpret_cast(pResponse->getPayload()); - payLoad.copy(response.payload, payLoad.length()); - response.payload[payLoad.length()] = '\0'; - response.payloadSize = payLoad.length() + 1; response.persistentBufferFlag = 0; response.numSendVendorSpecificHeaderOptions = serverHeaderOptions.size(); @@ -556,8 +672,9 @@ namespace OC static_cast(it->getOptionID()); response.sendVendorSpecificHeaderOptions[i].optionLength = (it->getOptionData()).length() + 1; - std::copy(it->getOptionData().begin(), - it->getOptionData().end(), + std::string optionData = it->getOptionData(); + std::copy(optionData.begin(), + optionData.end(), response.sendVendorSpecificHeaderOptions[i].optionData); response.sendVendorSpecificHeaderOptions[i].optionData[it->getOptionData().length()] = '\0'; @@ -578,7 +695,6 @@ namespace OC } else { - OICFree(response.payload); result = OC_STACK_ERROR; } @@ -586,19 +702,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 lock(*cLock); + result = OCNotifyAllObservers(resourceHandle, static_cast(QoS)); } - OCStop(); + return result; + } + + OCStackResult InProcServerWrapper::notifyListOfObservers(OCResourceHandle resourceHandle, + ObservationIds& observationIds, + const std::shared_ptr pResponse, + QualityOfService QoS) + { + if (!pResponse) + { + return OC_STACK_ERROR; + } + + auto cLock = m_csdkLock.lock(); + OCStackResult result = OC_STACK_ERROR; + if (cLock) + { + std::lock_guard lock(*cLock); + + OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload(); + result = OCNotifyListOfObservers(resourceHandle, + &observationIds[0], + observationIds.size(), + pl, + static_cast(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; + } + } +}