#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 "oickeepaliveinternal.h"
#include "platform_features.h"
#include "payload_logging.h"
#ifdef ROUTING_GATEWAY
#include "routingmanager.h"
#endif
-#ifdef RD_SERVER
-#include "rd_database.h"
-#endif
-
/// Module Name
#define TAG "OIC_RI_RESOURCE"
#ifdef TCP_ADAPTER
/* This method will retrieve the tcp port */
-static OCStackResult GetTCPPortInfo(OCDevAddr *endpoint, uint16_t *port)
+static OCStackResult GetTCPPortInfo(OCDevAddr *endpoint, uint16_t *port, bool secured)
{
uint16_t p = 0;
{
if (endpoint->flags & OC_IP_USE_V4)
{
- p = caglobals.tcp.ipv4.port;
+ p = secured ? caglobals.tcp.ipv4s.port : caglobals.tcp.ipv4.port;
}
else if (endpoint->flags & OC_IP_USE_V6)
{
- p = caglobals.tcp.ipv6.port;
+ p = secured ? caglobals.tcp.ipv6s.port : caglobals.tcp.ipv6.port;
}
}
* 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)
+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();
+ if (!deviceId)
+ {
+ OIC_LOG(ERROR, TAG, "Failed retrieving device id.");
+ return OC_STACK_ERROR;
+ }
+ OCRepPayloadSetPropString(tempPayload, OC_RSRVD_DEVICE_ID, deviceId);
+ }
OCResourceType *resType = resourcePtr->rsrcType;
while(resType)
{
if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, resAttrib->attrName))
{
- appendOCStringLL(tempPayload, (OCStringLL *)resAttrib->attrValue);
+ char *dmv = OCCreateString((OCStringLL *)resAttrib->attrValue);
+ if (dmv)
+ {
+ OCRepPayloadSetPropString(tempPayload, resAttrib->attrName, dmv);
+ OICFree(dmv);
+ }
}
else
{
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);
+ OCRepPayload *policy = OCRepPayloadCreate();
+ if (!policy)
+ {
+ OCPayloadDestroy((OCPayload *)tempPayload);
+ return OC_STACK_NO_MEMORY;
+ }
+ OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP, ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
+ if (p & OC_SECURE)
+ {
+ OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
+ uint16_t securePort = 0;
+ if (GetSecurePortInfo(devAddr, &securePort) != OC_STACK_OK)
+ {
+ securePort = 0;
+ }
+ OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
+ }
+ OCRepPayloadSetPropObjectAsOwner(tempPayload, OC_RSRVD_POLICY, policy);
+ }
+
+ if (!*payload)
+ {
+ *payload = tempPayload;
+ }
+ else
+ {
+ OCRepPayloadAppend(*payload, tempPayload);
+ }
+
+ return OC_STACK_OK;
+}
+
OCStackResult BuildVirtualResourceResponse(const OCResource *resourcePtr,
OCDiscoveryPayload *payload, OCDevAddr *devAddr)
{
#ifdef TCP_ADAPTER
uint16_t tcpPort = 0;
- if (GetTCPPortInfo(devAddr, &tcpPort) != OC_STACK_OK)
- {
- tcpPort = 0;
- }
+ GetTCPPortInfo(devAddr, &tcpPort, (resourcePtr->resourceProperties & OC_SECURE));
+
OCDiscoveryPayloadAddResource(payload, resourcePtr, securePort, tcpPort);
#else
OCDiscoveryPayloadAddResource(payload, resourcePtr, securePort);
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,
response.ehResult = ehResult;
response.payload = discoveryPayload;
response.persistentBufferFlag = 0;
- response.requestHandle = (OCRequestHandle) request;
+ response.requestHandle = (OCRequestHandle) request->requestId;
response.resourceHandle = (OCResourceHandle) 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);
- VERIFY_PARAM_NON_NULL(TAG, discPayload->name, "Failed adding name to discovery payload.");
+ 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)
return OC_STACK_INVALID_PARAM;
}
+ OCPayload* payload = NULL;
+ char *interfaceQuery = NULL;
+ char *resourceTypeQuery = NULL;
+
+ OIC_LOG(INFO, TAG, "Entering HandleVirtualResource");
+
+ OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
+
+#ifdef TCP_ADAPTER
+ if (OC_KEEPALIVE_RESOURCE_URI == virtualUriInRequest)
+ {
+ // Received request for a keepalive
+ OIC_LOG(INFO, TAG, "Request is for KeepAlive Request");
+ return OCHandleKeepAliveRequest(request, resource);
+ }
+#endif
+
OCStackResult discoveryResult = OC_STACK_ERROR;
if (request->method == OC_REST_PUT || request->method == OC_REST_POST ||
request->method == OC_REST_DELETE)
return OC_STACK_UNAUTHORIZED_REQ;
}
- OCPayload* payload = NULL;
- char *interfaceQuery = NULL;
- char *resourceTypeQuery = NULL;
- char *dataModelVersions = NULL;
-
- OIC_LOG(INFO, TAG, "Entering HandleVirtualResource");
-
- OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
-
// Step 1: Generate the response to discovery request
if (virtualUriInRequest == OC_WELL_KNOWN_URI
#ifdef MQ_BROKER
#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_LL))
- {
- 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)))
{
- if ((!baselineQuery && (resource->resourceProperties & prop)) ||
- (baselineQuery && (includeThisResourceInResponse(resource, interfaceQuery,
- resourceTypeQuery))))
- {
- discoveryResult = BuildVirtualResourceResponse(resource, discPayload,
- &request->devAddr);
- }
- else
+ // Only include discoverable type
+ if (resource->resourceProperties & prop)
{
- discoveryResult = OC_STACK_OK;
+ discoveryResult = BuildVirtualResourceResponse(resource, discPayload, &request->devAddr);
}
}
+ 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);
+ 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);
+ discoveryResult = BuildDevicePlatformPayload(resourcePtr, (OCRepPayload **)&payload, false);
}
#ifdef ROUTING_GATEWAY
else if (OC_GATEWAY_URI == virtualUriInRequest)
discoveryResult = RMHandleGatewayRequest(request, resource);
}
#endif
-#ifdef TCP_ADAPTER
- else if (OC_KEEPALIVE_RESOURCE_URI == virtualUriInRequest)
- {
- // Received request for a keepalive
- OIC_LOG(INFO, TAG, "Request is for KeepAlive Request");
- discoveryResult = HandleKeepAliveRequest(request, resource);
- }
-#endif
+
/**
* Step 2: Send the discovery response
*
if (OC_GATEWAY_URI != virtualUriInRequest)
#endif
{
-#if TCP_ADAPTER
- // KeepAlive uses the HandleKeepAliveRequest to respond to the request.
- if (OC_KEEPALIVE_RESOURCE_URI != virtualUriInRequest)
-#endif
+ OIC_LOG_PAYLOAD(DEBUG, payload);
+ if(discoveryResult == OC_STACK_OK)
{
- 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))
+
+ SendNonPersistantDiscoveryResponse(request, resource, payload, OC_EH_OK);
+ }
+ else // Error handling
+ {
+ 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);
+ OC_EH_RESOURCE_NOT_FOUND : OC_EH_ERROR);
}
- else
+ 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.");
// 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,
- 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;
if (request && request->resourceUrl && SRMIsSecurityResourceURI(request->resourceUrl))
{
type = PAYLOAD_TYPE_SECURITY;
-
}
- result = FormOCEntityHandlerRequest(&ehRequest,
- (OCRequestHandle)request,
- 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,
- 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 OCSetAttribute(OCResource* resource, const char* attribute, const void* value)
{
- OCAttribute *resAttrib = (OCAttribute *)OICCalloc(1, sizeof(OCAttribute));
- VERIFY_PARAM_NON_NULL(TAG, resAttrib, "Failed allocation OCAttribute");
- resAttrib->attrName = OICStrdup(attribute);
- VERIFY_PARAM_NON_NULL(TAG, resAttrib->attrName, "Failed allocating attribute name");
- // A special case when value is of type OCStringLL
- if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, attribute))
+ // See if the attribute already exists in the list.
+ OCAttribute *resAttrib;
+ for (resAttrib = resource->rsrcAttributes; resAttrib; resAttrib = resAttrib->next)
{
- resAttrib->attrValue = CloneOCStringLL((OCStringLL *)value);
+ if (0 == strcmp(attribute, resAttrib->attrName))
+ {
+ // Found, free the old value.
+ if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, resAttrib->attrName))
+ {
+ OCFreeOCStringLL((OCStringLL *)resAttrib->attrValue);
+ }
+ else
+ {
+ OICFree((char *)resAttrib->attrValue);
+ }
+ break;
+ }
}
- else
+
+ // If not already in the list, add it.
+ if (NULL == resAttrib)
{
- resAttrib->attrValue = OICStrdup((char *)value);
+ resAttrib = (OCAttribute *)OICCalloc(1, sizeof(OCAttribute));
+ VERIFY_PARAM_NON_NULL(TAG, resAttrib, "Failed allocating OCAttribute");
+ resAttrib->attrName = OICStrdup(attribute);
+ VERIFY_PARAM_NON_NULL(TAG, resAttrib->attrName, "Failed allocating attribute name");
+ resAttrib->next = resource->rsrcAttributes;
+ resource->rsrcAttributes = resAttrib;
}
- VERIFY_PARAM_NON_NULL(TAG, resAttrib->attrValue, "Failed allocating attribute value");
- resAttrib->next = NULL;
- if (!resource->rsrcAttributes)
+ // Fill in the new value.
+ if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, attribute))
{
- resource->rsrcAttributes = resAttrib;
+ resAttrib->attrValue = CloneOCStringLL((OCStringLL *)value);
}
else
{
- OCAttribute *temp = resource->rsrcAttributes;
- for (; temp->next; temp = temp->next)
- {
- if (0 == strcmp(attribute, temp->attrName))
- {
- if (0 == strcmp(OC_RSRVD_DATA_MODEL_VERSION, temp->attrName))
- {
- OCFreeOCStringLL((OCStringLL *)temp->attrValue);
- }
- {
- OICFree((char *)temp->attrValue);
- }
- break;
- }
- }
- temp->next = resAttrib;
+ resAttrib->attrValue = OICStrdup((char *)value);
}
+ VERIFY_PARAM_NON_NULL(TAG, resAttrib->attrValue, "Failed allocating attribute value");
+
return OC_STACK_OK;
exit:
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