#include "oic_malloc.h"
#include "oic_string.h"
#include "logger.h"
-#include "cJSON.h"
#include "ocpayload.h"
#include "secureresourcemanager.h"
#include "cacommon.h"
#include "cainterface.h"
#include "ocpayload.h"
-#include "oickeepalive.h"
+#include "oickeepaliveinternal.h"
#include "platform_features.h"
#include "payload_logging.h"
#ifdef ROUTING_GATEWAY
* Resource and device filters in the SAME query are NOT validated
* and resources will likely not clear filters.
*/
-static OCStackResult ExtractFiltersFromQuery(char *query, char **filterOne, char **filterTwo)
+OCStackResult ExtractFiltersFromQuery(const char *query, char **filterOne, char **filterTwo)
{
+ if (!query)
+ {
+ OIC_LOG_V(ERROR, TAG, "Query is empty!");
+ return OC_STACK_INVALID_QUERY;
+ }
char *key = NULL;
char *value = NULL;
char *queryDup = NULL;
*filterOne = NULL;
*filterTwo = NULL;
- #ifdef WITH_PRESENCE
+#ifdef WITH_PRESENCE
if (uri == OC_PRESENCE)
{
//Nothing needs to be done, except for pass a OC_PRESENCE query through as OC_STACK_OK.
OIC_LOG(INFO, TAG, "OC_PRESENCE Request for virtual resource.");
return OC_STACK_OK;
}
- #endif
+#endif
OCStackResult result = OC_STACK_OK;
return false;
}
-OCStackResult BuildResponseRepresentation(const OCResource *resourcePtr,
- OCRepPayload** payload, OCDevAddr *devAddr, bool addDeviceId)
+static OCStackResult BuildDevicePlatformPayload(const OCResource *resourcePtr, OCRepPayload** payload, bool addDeviceId)
{
- OCRepPayload *tempPayload = OCRepPayloadCreate();
-
if (!resourcePtr)
{
- OCRepPayloadDestroy(tempPayload);
return OC_STACK_INVALID_PARAM;
}
- if(!tempPayload)
+ OCRepPayload *tempPayload = OCRepPayloadCreate();
+ if (!tempPayload)
{
return OC_STACK_NO_MEMORY;
}
- OCRepPayloadSetUri(tempPayload, resourcePtr->uri);
if (addDeviceId)
{
const char *deviceId = OCGetServerInstanceIDString();
}
OCRepPayloadSetPropString(tempPayload, OC_RSRVD_DEVICE_ID, deviceId);
}
+
OCResourceType *resType = resourcePtr->rsrcType;
while(resType)
{
resAttrib = resAttrib->next;
}
+ if(!*payload)
+ {
+ *payload = tempPayload;
+ }
+ else
+ {
+ OCRepPayloadAppend(*payload, tempPayload);
+ }
+
+ return OC_STACK_OK;
+}
+
+OCStackResult BuildResponseRepresentation(const OCResource *resourcePtr,
+ OCRepPayload** payload, OCDevAddr *devAddr)
+{
+ if (!resourcePtr)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ OCRepPayload *tempPayload = OCRepPayloadCreate();
+ if(!tempPayload)
+ {
+ return OC_STACK_NO_MEMORY;
+ }
+
+ OCRepPayloadSetPropString(tempPayload, OC_RSRVD_HREF, resourcePtr->uri);
+
+ uint8_t numElement = 0;
+ if (OC_STACK_OK == OCGetNumberOfResourceTypes((OCResource *)resourcePtr, &numElement))
+ {
+ size_t rtDim[MAX_REP_ARRAY_DEPTH] = {numElement, 0, 0};
+ char **rt = (char **)OICMalloc(sizeof(char *) * numElement);
+ if (!rt)
+ {
+ OIC_LOG(ERROR, TAG, "Resource type allocation failed.");
+ OCRepPayloadDestroy(tempPayload);
+ return OC_STACK_NO_MEMORY;
+ }
+ for (uint8_t i = 0; i < numElement; ++i)
+ {
+ const char *value = OCGetResourceTypeName((OCResource *)resourcePtr, i);
+ OIC_LOG_V(DEBUG, TAG, "value: %s", value);
+ rt[i] = OICStrdup(value);
+ }
+ OCRepPayloadSetStringArrayAsOwner(tempPayload, OC_RSRVD_RESOURCE_TYPE, rt, rtDim);
+ }
+
+ numElement = 0;
+ if (OC_STACK_OK == OCGetNumberOfResourceInterfaces((OCResource *)resourcePtr, &numElement))
+ {
+ size_t ifDim[MAX_REP_ARRAY_DEPTH] = {numElement, 0, 0};
+ char **itf = (char **)OICMalloc(sizeof(char *) * numElement);
+ if (!itf)
+ {
+ OIC_LOG(ERROR, TAG, "Resource interface allocation failed.");
+ OCRepPayloadDestroy(tempPayload);
+ return OC_STACK_NO_MEMORY;
+ }
+ for (uint8_t i = 0; i < numElement; ++i)
+ {
+ const char *value = OCGetResourceInterfaceName((OCResource *)resourcePtr, i);
+ OIC_LOG_V(DEBUG, TAG, "value: %s", value);
+ itf[i] = OICStrdup(value);
+ }
+ OCRepPayloadSetStringArrayAsOwner(tempPayload, OC_RSRVD_INTERFACE, itf, ifDim);
+ }
+
+ for (OCAttribute *resAttrib = resourcePtr->rsrcAttributes; resAttrib; resAttrib = resAttrib->next)
+ {
+ if (resAttrib->attrName && resAttrib->attrValue)
+ {
+ if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, resAttrib->attrName))
+ {
+ char *dmv = OCCreateString((OCStringLL *)resAttrib->attrValue);
+ if (dmv)
+ {
+ OCRepPayloadSetPropString(tempPayload, resAttrib->attrName, dmv);
+ OICFree(dmv);
+ }
+ }
+ else
+ {
+ OCRepPayloadSetPropString(tempPayload, resAttrib->attrName, (char *)resAttrib->attrValue);
+ }
+ }
+ }
+
if (devAddr)
{
OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)resourcePtr);
OCRepPayloadSetPropObjectAsOwner(tempPayload, OC_RSRVD_POLICY, policy);
}
- if(!*payload)
+ if (!*payload)
{
*payload = tempPayload;
}
return OC_STACK_OK;
}
-uint8_t IsCollectionResource (OCResource *resource)
-{
- if(!resource)
- {
- return 0;
- }
-
- if(resource->rsrcChildResourcesHead != NULL)
- {
- return 1;
- }
-
- return 0;
-}
-
OCResource *FindResourceByUri(const char* resourceUri)
{
if(!resourceUri)
return NULL;
}
-
OCStackResult DetermineResourceHandling (const OCServerRequest *request,
ResourceHandling *handling,
OCResource **resource)
return OC_STACK_NO_RESOURCE;
}
- if (IsCollectionResource (resourcePtr))
+ if (resourcePtr && resourcePtr->rsrcChildResourcesHead != NULL)
{
// Collection resource
if (resourcePtr->entityHandler != defaultResourceEHandler)
case OC_EH_FORBIDDEN:
result = OC_STACK_FORBIDDEN_REQ;
break;
- case OC_EH_INTERNAL_SERVER_ERROR:
- result = OC_STACK_INTERNAL_SERVER_ERROR;
- break;
case OC_EH_RESOURCE_CREATED:
result = OC_STACK_RESOURCE_CREATED;
break;
case OC_EH_RESOURCE_NOT_FOUND:
result = OC_STACK_NO_RESOURCE;
break;
+ case OC_EH_INTERNAL_SERVER_ERROR:
+ result = OC_STACK_INTERNAL_SERVER_ERROR;
+ break;
+ case OC_EH_NOT_IMPLEMENTED:
+ result = OC_STACK_NOT_IMPLEMENTED;
+ break;
+ case OC_EH_BAD_GATEWAY:
+ result = OC_STACK_BAD_GATEWAY;
+ break;
+ case OC_EH_SERVICE_UNAVAILABLE:
+ result = OC_STACK_SERVICE_UNAVAILABLE;
+ break;
+ case OC_EH_RETRANSMIT_TIMEOUT:
+ result = OC_STACK_GATEWAY_TIMEOUT;
+ break;
+ case OC_EH_PROXY_NOT_SUPPORTED:
+ result = OC_STACK_PROXY_NOT_SUPPORTED;
+ break;
default:
result = OC_STACK_ERROR;
}
return false;
}
- // Null or empty is analogous to no filter.
- if (resourceTypeFilter == NULL || *resourceTypeFilter == 0)
+ // Null is analogous to no filter.
+ if (NULL == resourceTypeFilter)
{
return true;
}
- OCResourceType *resourceTypePtr = resource->rsrcType;
+ // Empty resourceType filter is analogous to error query
+ if (0 == strlen(resourceTypeFilter))
+ {
+ return false;
+ }
- while (resourceTypePtr)
+ for (OCResourceType *rtPtr = resource->rsrcType; rtPtr; rtPtr = rtPtr->next)
{
- if (strcmp (resourceTypePtr->resourcetypename, resourceTypeFilter) == 0)
+ if (0 == strcmp(rtPtr->resourcetypename, resourceTypeFilter))
{
return true;
}
- resourceTypePtr = resourceTypePtr->next;
}
OIC_LOG_V(INFO, TAG, "%s does not contain rt=%s.", resource->uri, resourceTypeFilter);
return false;
}
- // Null or empty is analogous to no filter.
- if (interfaceFilter == NULL || *interfaceFilter == 0)
+ // Null is analogous to no filter.
+ if (NULL == interfaceFilter)
{
return true;
}
- OCResourceInterface *interfacePtr = resource->rsrcInterface;
+ // Empty interface filter is analogous to error query
+ if (0 == strlen(interfaceFilter))
+ {
+ return false;
+ }
- while (interfacePtr)
+ for (OCResourceInterface *ifPtr = resource->rsrcInterface; ifPtr; ifPtr = ifPtr->next)
{
- if (strcmp (interfacePtr->name, interfaceFilter) == 0 ||
- strcmp (OC_RSRVD_INTERFACE_LL, interfaceFilter) == 0 ||
- strcmp (OC_RSRVD_INTERFACE_DEFAULT, interfaceFilter) == 0)
+ if (0 == strcmp(ifPtr->name, interfaceFilter) ||
+ 0 == strcmp(OC_RSRVD_INTERFACE_LL, interfaceFilter) ||
+ 0 == strcmp(OC_RSRVD_INTERFACE_DEFAULT, interfaceFilter))
{
return true;
}
- interfacePtr = interfacePtr->next;
}
OIC_LOG_V(INFO, TAG, "%s does not contain if=%s.", resource->uri, interfaceFilter);
*/
if (!(resourceTypeFilter && *resourceTypeFilter))
{
- OIC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE \
+ OIC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE\
resource", resource->uri);
return false;
}
}
- else if ( !(resource->resourceProperties & OC_ACTIVE) ||
+ else if (!(resource->resourceProperties & OC_ACTIVE) ||
!(resource->resourceProperties & OC_DISCOVERABLE))
{
OIC_LOG_V(INFO, TAG, "%s not ACTIVE or DISCOVERABLE", resource->uri);
return resourceMatchesIFFilter(resource, interfaceFilter) &&
resourceMatchesRTFilter(resource, resourceTypeFilter);
-
}
OCStackResult SendNonPersistantDiscoveryResponse(OCServerRequest *request, OCResource *resource,
return OCDoResponse(&response);
}
+
+static OCStackResult EHRequest(OCEntityHandlerRequest *ehRequest, OCPayloadType type,
+ OCServerRequest *request, OCResource *resource)
+{
+ return FormOCEntityHandlerRequest(ehRequest,
+ (OCRequestHandle)request->requestId,
+ request->method,
+ &request->devAddr,
+ (OCResourceHandle)resource,
+ request->query,
+ type,
+ request->payload,
+ request->payloadSize,
+ request->numRcvdVendorSpecificHeaderOptions,
+ request->rcvdVendorSpecificHeaderOptions,
+ (OCObserveAction)request->observationOption,
+ (OCObservationId)0,
+ request->coapID);
+}
+
#ifdef RD_SERVER
/**
* Find resource at the resource directory server. This resource is not local resource but a
{
if (*payload)
{
- OIC_LOG_V(DEBUG, TAG, "Payload is already allocated");
+ OIC_LOG(DEBUG, TAG, "Payload is already allocated");
return OC_STACK_OK;
}
*/
static OCStackResult addDiscoveryBaselineCommonProperties(OCDiscoveryPayload *discPayload)
{
- discPayload->uri = OICStrdup(OC_RSRVD_WELL_KNOWN_URI);
- VERIFY_PARAM_NON_NULL(TAG, discPayload->uri, "Failed adding href to discovery payload.");
+ if (!discPayload)
+ {
+ OIC_LOG(ERROR, TAG, "Payload is not allocated");
+ return OC_STACK_ERROR;
+ }
- OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", (void **)&discPayload->name);
+ OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, (void **)&discPayload->name);
discPayload->type = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
VERIFY_PARAM_NON_NULL(TAG, discPayload->type, "Failed adding rt to discovery payload.");
return OC_STACK_NO_MEMORY;
}
+static bool isUnicast(OCServerRequest *request)
+{
+ bool isMulticast = request->devAddr.flags & OC_MULTICAST;
+ return (isMulticast == false &&
+ (request->devAddr.adapter != OC_ADAPTER_RFCOMM_BTEDR) &&
+ (request->devAddr.adapter != OC_ADAPTER_GATT_BTLE));
+}
+
static OCStackResult HandleVirtualResource (OCServerRequest *request, OCResource* resource)
{
if (!request || !resource)
OCPayload* payload = NULL;
char *interfaceQuery = NULL;
char *resourceTypeQuery = NULL;
- char *dataModelVersions = NULL;
OIC_LOG(INFO, TAG, "Entering HandleVirtualResource");
{
// Received request for a keepalive
OIC_LOG(INFO, TAG, "Request is for KeepAlive Request");
- return HandleKeepAliveRequest(request, resource);
+ return OCHandleKeepAliveRequest(request, resource);
}
#endif
#endif
)
{
- discoveryResult = getQueryParamsForFiltering (virtualUriInRequest, request->query,
+ discoveryResult = getQueryParamsForFiltering(virtualUriInRequest, request->query,
&interfaceQuery, &resourceTypeQuery);
VERIFY_SUCCESS(discoveryResult);
+
if (!interfaceQuery && !resourceTypeQuery)
{
// If no query is sent, default interface is used i.e. oic.if.ll.
interfaceQuery = OICStrdup(OC_RSRVD_INTERFACE_LL);
}
- bool baselineQuery = false;
- if (interfaceQuery && 0 == strcmp(interfaceQuery, OC_RSRVD_INTERFACE_DEFAULT))
- {
- baselineQuery = true;
- }
-
discoveryResult = discoveryPayloadCreateAndAddDeviceId(&payload);
VERIFY_PARAM_NON_NULL(TAG, payload, "Failed creating Discovery Payload.");
VERIFY_SUCCESS(discoveryResult);
OCDiscoveryPayload *discPayload = (OCDiscoveryPayload *)payload;
- if (baselineQuery)
+ if (interfaceQuery && 0 == strcmp(interfaceQuery, OC_RSRVD_INTERFACE_DEFAULT))
{
discoveryResult = addDiscoveryBaselineCommonProperties(discPayload);
VERIFY_SUCCESS(discoveryResult);
#endif
for (; resource && discoveryResult == OC_STACK_OK; resource = resource->next)
{
- discoveryResult = OC_STACK_NO_RESOURCE;
-#ifdef RD_SERVER
- discoveryResult = findResourceAtRD(resource, interfaceQuery, resourceTypeQuery,
- discPayload);
-#endif
- if (OC_STACK_NO_RESOURCE == discoveryResult)
+ // This case will handle when no resource type and it is oic.if.ll.
+ // Do not assume check if the query is ll
+ if (!resourceTypeQuery &&
+ (interfaceQuery && 0 == strcmp(interfaceQuery, OC_RSRVD_INTERFACE_LL)))
{
- // This case will handle when no resource type and it is oic.if.ll.
- if (!resourceTypeQuery && !baselineQuery && (resource->resourceProperties & prop))
- {
- discoveryResult = BuildVirtualResourceResponse(resource, discPayload, &request->devAddr);
- }
- else if (includeThisResourceInResponse(resource, interfaceQuery, resourceTypeQuery))
+ // Only include discoverable type
+ if (resource->resourceProperties & prop)
{
discoveryResult = BuildVirtualResourceResponse(resource, discPayload, &request->devAddr);
}
- else
- {
- discoveryResult = OC_STACK_OK;
- }
+ }
+ else if (includeThisResourceInResponse(resource, interfaceQuery, resourceTypeQuery))
+ {
+ discoveryResult = BuildVirtualResourceResponse(resource, discPayload, &request->devAddr);
+ }
+ else
+ {
+ discoveryResult = OC_STACK_OK;
}
}
if (discPayload->resources == NULL)
{
OCResource *resourcePtr = FindResourceByUri(OC_RSRVD_DEVICE_URI);
VERIFY_PARAM_NON_NULL(TAG, resourcePtr, "Device URI not found.");
- discoveryResult = BuildResponseRepresentation(resourcePtr, (OCRepPayload **)&payload, NULL, true);
-
+ discoveryResult = BuildDevicePlatformPayload(resourcePtr, (OCRepPayload **)&payload, true);
}
else if (virtualUriInRequest == OC_PLATFORM_URI)
{
OCResource *resourcePtr = FindResourceByUri(OC_RSRVD_PLATFORM_URI);
VERIFY_PARAM_NON_NULL(TAG, resourcePtr, "Platform URI not found.");
- discoveryResult = BuildResponseRepresentation(resourcePtr, (OCRepPayload **)&payload, NULL, false);
+ discoveryResult = BuildDevicePlatformPayload(resourcePtr, (OCRepPayload **)&payload, false);
}
#ifdef ROUTING_GATEWAY
else if (OC_GATEWAY_URI == virtualUriInRequest)
OIC_LOG_PAYLOAD(DEBUG, payload);
if(discoveryResult == OC_STACK_OK)
{
+
SendNonPersistantDiscoveryResponse(request, resource, payload, OC_EH_OK);
}
- else if(((request->devAddr.flags & OC_MULTICAST) == false) &&
- (request->devAddr.adapter != OC_ADAPTER_RFCOMM_BTEDR) &&
- (request->devAddr.adapter != OC_ADAPTER_GATT_BTLE))
+ else // Error handling
{
- OIC_LOG_V(ERROR, TAG, "Sending a (%d) error to (%d) discovery request",
- discoveryResult, virtualUriInRequest);
- SendNonPersistantDiscoveryResponse(request, resource, NULL,
- (discoveryResult == OC_STACK_NO_RESOURCE) ?
+ if (isUnicast(request))
+ {
+ OIC_LOG_V(ERROR, TAG, "Sending a (%d) error to (%d) discovery request",
+ discoveryResult, virtualUriInRequest);
+ SendNonPersistantDiscoveryResponse(request, resource, NULL,
+ (discoveryResult == OC_STACK_NO_RESOURCE) ?
OC_EH_RESOURCE_NOT_FOUND : OC_EH_ERROR);
- }
- else
- {
- // Ignoring the discovery request as per RFC 7252, Section #8.2
- OIC_LOG(INFO, TAG, "Silently ignoring the request since no useful data to send.");
- // the request should be removed.
- // since it never remove and causes a big memory waste.
- FindAndDeleteServerRequest(request);
+ }
+ else // Multicast
+ {
+ // Ignoring the discovery request as per RFC 7252, Section #8.2
+ OIC_LOG(INFO, TAG, "Silently ignoring the request since no useful data to send.");
+ // the request should be removed.
+ // since it never remove and causes a big memory waste.
+ FindAndDeleteServerRequest(request);
+ }
+ discoveryResult = OC_STACK_CONTINUE;
}
}
OICFree(resourceTypeQuery);
}
OCPayloadDestroy(payload);
- if (dataModelVersions)
- {
- OICFree(dataModelVersions);
- }
+
+ // To ignore the message, OC_STACK_CONTINUE is sent
return discoveryResult;
}
static OCStackResult
-HandleDefaultDeviceEntityHandler (OCServerRequest *request)
+HandleDefaultDeviceEntityHandler(OCServerRequest *request)
{
- if(!request)
+ if (!request)
{
return OC_STACK_INVALID_PARAM;
}
- OCStackResult result = OC_STACK_OK;
OCEntityHandlerResult ehResult = OC_EH_ERROR;
OCEntityHandlerRequest ehRequest = {0};
-
OIC_LOG(INFO, TAG, "Entering HandleResourceWithDefaultDeviceEntityHandler");
- result = FormOCEntityHandlerRequest(&ehRequest,
- (OCRequestHandle) request->requestId,
- request->method,
- &request->devAddr,
- (OCResourceHandle) NULL, request->query,
- PAYLOAD_TYPE_REPRESENTATION,
- request->payload,
- request->payloadSize,
- request->numRcvdVendorSpecificHeaderOptions,
- request->rcvdVendorSpecificHeaderOptions,
- (OCObserveAction)request->observationOption,
- (OCObservationId)0,
- request->coapID);
+ OCStackResult result = EHRequest(&ehRequest, PAYLOAD_TYPE_REPRESENTATION, request, NULL);
VERIFY_SUCCESS(result);
// At this point we know for sure that defaultDeviceHandler exists
}
static OCStackResult
-HandleResourceWithEntityHandler (OCServerRequest *request,
- OCResource *resource,
- uint8_t collectionResource)
+HandleResourceWithEntityHandler(OCServerRequest *request,
+ OCResource *resource)
{
- OC_UNUSED(collectionResource);
-
if(!request || ! resource)
{
return OC_STACK_INVALID_PARAM;
type = PAYLOAD_TYPE_SECURITY;
}
- result = FormOCEntityHandlerRequest(&ehRequest,
- (OCRequestHandle)request->requestId,
- request->method,
- &request->devAddr,
- (OCResourceHandle)resource,
- request->query,
- type,
- request->payload,
- request->payloadSize,
- request->numRcvdVendorSpecificHeaderOptions,
- request->rcvdVendorSpecificHeaderOptions,
- (OCObserveAction)request->observationOption,
- 0,
- request->coapID);
+ result = EHRequest(&ehRequest, type, request, resource);
VERIFY_SUCCESS(result);
if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
{
// Stack does not contain this observation request
// Either token is incorrect or observation list is corrupted
- result = OC_STACK_ERROR;
+ result = OC_STACK_NO_RESOURCE;
goto exit;
}
ehRequest.obsInfo.obsId = resObs->observeId;
return result;
}
-static OCStackResult
-HandleCollectionResourceDefaultEntityHandler (OCServerRequest *request,
- OCResource *resource)
+static OCStackResult HandleCollectionResourceDefaultEntityHandler(OCServerRequest *request,
+ OCResource *resource)
{
- if(!request || !resource)
+ if (!request || !resource)
{
return OC_STACK_INVALID_PARAM;
}
- OCStackResult result = OC_STACK_ERROR;
OCEntityHandlerRequest ehRequest = {0};
-
- result = FormOCEntityHandlerRequest(&ehRequest,
- (OCRequestHandle)request->requestId,
- request->method,
- &request->devAddr,
- (OCResourceHandle)resource,
- request->query,
- PAYLOAD_TYPE_REPRESENTATION,
- request->payload,
- request->payloadSize,
- request->numRcvdVendorSpecificHeaderOptions,
- request->rcvdVendorSpecificHeaderOptions,
- (OCObserveAction)request->observationOption,
- (OCObservationId)0,
- request->coapID);
+ OCStackResult result = EHRequest(&ehRequest, PAYLOAD_TYPE_REPRESENTATION, request, resource);
if(result == OC_STACK_OK)
{
result = DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest);
}
case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
{
- ret = HandleResourceWithEntityHandler (request, resource, 0);
+ ret = HandleResourceWithEntityHandler (request, resource);
break;
}
case OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER:
{
- ret = HandleResourceWithEntityHandler (request, resource, 1);
+ ret = HandleResourceWithEntityHandler (request, resource);
break;
}
case OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER:
{
dataModelVersion = OCCreateOCStringLL(OC_DATA_MODEL_VERSION);
VERIFY_SUCCESS(OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersion));
+#ifdef __TIZENRT__
+ OCFreeOCStringLL(dataModelVersion);
+#endif
}
OIC_LOG(INFO, TAG, "Device parameter initialized successfully.");
return OC_STACK_OK;
OCStackResult OCSetPropertyValue(OCPayloadType type, const char *prop, const void *value)
{
- if (!prop)
+ if (!prop || !value)
{
return OC_STACK_INVALID_PARAM;
}
{
OIC_LOG(ERROR, TAG, "Resource does not exist.");
}
- if (value)
+ else
{
res = OCSetAttribute(resource, prop, value);
}
projects / platform / upstream / iotivity.git / blobdiff