// For POSIX.1-2001 base specification,
// Refer http://pubs.opengroup.org/onlinepubs/009695399/
#define _POSIX_C_SOURCE 200112L
-#include "ocresource.h"
#include <string.h>
+#include "ocresource.h"
#include "ocresourcehandler.h"
#include "ocobserve.h"
#include "occollection.h"
#include "logger.h"
#include "cJSON.h"
#include "ocpayload.h"
-
+#include "secureresourcemanager.h"
#include "cacommon.h"
#include "cainterface.h"
+#include "rdpayload.h"
+
+#ifdef WITH_RD
+#include "rd_server.h"
+#endif
+#ifdef ROUTING_GATEWAY
+#include "routingmanager.h"
+#endif
/// Module Name
-#define TAG PCF("ocresource")
+#define TAG "ocresource"
#define VERIFY_SUCCESS(op, successCode) { if (op != successCode) \
{OC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
#define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OC_LOG((logLevel), \
- TAG, PCF(#arg " is NULL")); return (retVal); } }
+ TAG, #arg " is NULL"); return (retVal); } }
extern OCResource *headResource;
-static OCPlatformInfo savedPlatformInfo = {};
-static OCDeviceInfo savedDeviceInfo = {};
+static OCPlatformInfo savedPlatformInfo = {0};
+static OCDeviceInfo savedDeviceInfo = {0};
//-----------------------------------------------------------------------------
// Default resource entity handler function
{
if (numKeyValuePairsParsed >= 2)
{
- OC_LOG(ERROR, TAG, PCF("More than 2 queries params in URI."));
+ OC_LOG(ERROR, TAG, "More than 2 queries params in URI.");
return OC_STACK_INVALID_QUERY;
}
{
return OC_RESOURCE_TYPES_URI;
}
+#ifdef ROUTING_GATEWAY
+ else if (0 == strcmp(uriInRequest, OC_RSRVD_GATEWAY_URI))
+ {
+ return OC_GATEWAY_URI;
+ }
+#endif
#ifdef WITH_PRESENCE
else if (strcmp(uriInRequest, OC_RSRVD_PRESENCE_URI) == 0)
{
if (uri == OC_PRESENCE)
{
//Nothing needs to be done, except for pass a OC_PRESENCE query through as OC_STACK_OK.
- OC_LOG(INFO, TAG, PCF("OC_PRESENCE Request for virtual resource."));
+ OC_LOG(INFO, TAG, "OC_PRESENCE Request for virtual resource.");
return OC_STACK_OK;
}
#endif
return OC_STACK_OK;
}
+OCStackResult BuildVirtualCollectionResourceResponse(const OCResourceCollectionPayload *resourcePtr,
+ OCDiscoveryPayload *payload, OCDevAddr *devAddr)
+{
+ if (!resourcePtr || !payload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+ if (resourcePtr->tags && (resourcePtr->tags->bitmap & OC_SECURE))
+ {
+ if (GetSecurePortInfo(devAddr, &resourcePtr->tags->port) != OC_STACK_OK)
+ {
+ OC_LOG(ERROR, TAG, "Failed setting secure port.");
+ }
+ }
+ if (resourcePtr->tags && !resourcePtr->tags->baseURI)
+ {
+ resourcePtr->tags->baseURI = OICStrdup(devAddr->addr);
+ }
+ OCDiscoveryCollectionPayloadAddResource(payload, resourcePtr->tags, resourcePtr->setLinks);
+ return OC_STACK_OK;
+}
uint8_t IsCollectionResource (OCResource *resource)
{
}
else
{
- OCResource *resourcePtr = NULL;
- resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
+ OCResource *resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
*resource = resourcePtr;
if (!resourcePtr)
{
resourceTypePtr = resourceTypePtr->next;
}
- OC_LOG_V(INFO, TAG, PCF("%s does not contain rt=%s."), resource->uri, resourceTypeFilter);
+ OC_LOG_V(INFO, TAG, "%s does not contain rt=%s.", resource->uri, resourceTypeFilter);
return false;
}
interfacePtr = interfacePtr->next;
}
- OC_LOG_V(INFO, TAG, PCF("%s does not contain if=%s."), resource->uri, interfaceFilter);
+ OC_LOG_V(INFO, TAG, "%s does not contain if=%s.", resource->uri, interfaceFilter);
return false;
}
{
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Invalid resource"));
+ OC_LOG(ERROR, TAG, "Invalid resource");
return false;
}
if (!((interfaceFilter && *interfaceFilter ) ||
(resourceTypeFilter && *resourceTypeFilter)))
{
- OC_LOG_V(INFO, TAG, PCF("%s no query string for EXPLICIT_DISCOVERABLE \
- resource"), resource->uri);
+ OC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE \
+ resource", resource->uri);
return false;
}
}
else if ( !(resource->resourceProperties & OC_ACTIVE) ||
!(resource->resourceProperties & OC_DISCOVERABLE))
{
- OC_LOG_V(INFO, TAG, PCF("%s not ACTIVE or DISCOVERABLE"), resource->uri);
+ OC_LOG_V(INFO, TAG, "%s not ACTIVE or DISCOVERABLE", resource->uri);
return false;
}
OCStackResult SendNonPersistantDiscoveryResponse(OCServerRequest *request, OCResource *resource,
OCPayload *discoveryPayload, OCEntityHandlerResult ehResult)
{
- OCEntityHandlerResponse response = {};
+ OCEntityHandlerResponse response = {0};
response.ehResult = ehResult;
response.payload = discoveryPayload;
return OCDoResponse(&response);
}
+#ifdef WITH_RD
+static OCStackResult checkResourceExistsAtRD(const char *interfaceType, const char *resourceType,
+ OCResourceCollectionPayload **repPayload)
+{
+ if (OCRDCheckPublishedResource(interfaceType, resourceType, repPayload) == OC_STACK_OK)
+ {
+ return OC_STACK_OK;
+ }
+ else
+ {
+ OC_LOG_V(ERROR, TAG, "The resource type or interface type doe not exist \
+ on the resource directory");
+ }
+ return OC_STACK_ERROR;
+}
+#endif
+
static OCStackResult HandleVirtualResource (OCServerRequest *request, OCResource* resource)
{
if (!request || !resource)
bool bMulticast = false; // Was the discovery request a multicast request?
OCPayload* payload = NULL;
- OC_LOG(INFO, TAG, PCF("Entering HandleVirtualResource"));
+ OC_LOG(INFO, TAG, "Entering HandleVirtualResource");
OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
if(payload)
{
+ bool foundResourceAtRD = false;
for(;resource && discoveryResult == OC_STACK_OK; resource = resource->next)
{
- if(includeThisResourceInResponse(resource, filterOne, filterTwo))
+#ifdef WITH_RD
+ if (strcmp(resource->uri, OC_RSRVD_RD_URI) == 0)
+ {
+ OCResourceCollectionPayload *repPayload;
+ discoveryResult = checkResourceExistsAtRD(filterOne, filterTwo, &repPayload);
+ if (discoveryResult != OC_STACK_OK)
+ {
+ break;
+ }
+ discoveryResult = BuildVirtualCollectionResourceResponse(repPayload,
+ (OCDiscoveryPayload*)payload,
+ &request->devAddr);
+ foundResourceAtRD = true;
+ }
+#endif
+ if(!foundResourceAtRD && includeThisResourceInResponse(resource, filterOne, filterTwo))
{
discoveryResult = BuildVirtualResourceResponse(resource,
(OCDiscoveryPayload*)payload,
&request->devAddr);
}
}
- // Set discoveryResult appropriately if no 'valid' resources are available.
- if (((OCDiscoveryPayload*)payload)->resources == NULL)
+ // Set discoveryResult appropriately if no 'valid' resources are available
+ if (((OCDiscoveryPayload*)payload)->resources == NULL && !foundResourceAtRD)
{
discoveryResult = OC_STACK_NO_RESOURCE;
}
}
else if (virtualUriInRequest == OC_DEVICE_URI)
{
- payload = (OCPayload*)OCDevicePayloadCreate(OC_RSRVD_DEVICE_URI,
- OCGetServerInstanceID(), savedDeviceInfo.deviceName,
- OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
- if (!payload)
+ const OicUuid_t* deviceId = OCGetServerInstanceID();
+ if (!deviceId)
{
- discoveryResult = OC_STACK_NO_MEMORY;
+ discoveryResult = OC_STACK_ERROR;
}
else
{
- discoveryResult = OC_STACK_OK;
+ payload = (OCPayload*) OCDevicePayloadCreate(OC_RSRVD_DEVICE_URI,
+ (const uint8_t*) &deviceId->id, savedDeviceInfo.deviceName,
+ OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
+ if (!payload)
+ {
+ discoveryResult = OC_STACK_NO_MEMORY;
+ }
+ else
+ {
+ discoveryResult = OC_STACK_OK;
+ }
}
}
else if (virtualUriInRequest == OC_PLATFORM_URI)
discoveryResult = OC_STACK_OK;
}
}
+#ifdef ROUTING_GATEWAY
+ else if (OC_GATEWAY_URI == virtualUriInRequest)
+ {
+ // Received request for a gateway
+ OC_LOG(INFO, TAG, "Request is for Gateway Virtual Request");
+ discoveryResult = RMHandleGatewayRequest(request, resource);
+
+ }
+#endif
/**
* Step 2: Send the discovery response
* request is unicast, it should send an error(RESOURCE_NOT_FOUND - 404) response.
*/
- #ifdef WITH_PRESENCE
+#ifdef WITH_PRESENCE
if ((virtualUriInRequest == OC_PRESENCE) &&
(resource->resourceProperties & OC_ACTIVE))
{
}
else
#endif
+#ifdef ROUTING_GATEWAY
+ // Gateway uses the RMHandleGatewayRequest to respond to the request.
+ if (OC_GATEWAY != virtualUriInRequest)
+#endif
{
if(discoveryResult == OC_STACK_OK)
{
else
{
// Ignoring the discovery request as per RFC 7252, Section #8.2
- OC_LOG_V(INFO, TAG, "Silently ignoring the request since device does not have \
+ OC_LOG(INFO, TAG, "Silently ignoring the request since device does not have \
any useful data to send");
}
}
OCStackResult result = OC_STACK_OK;
OCEntityHandlerResult ehResult = OC_EH_ERROR;
- OCEntityHandlerRequest ehRequest = {};
+ OCEntityHandlerRequest ehRequest = {0};
- OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithDefaultDeviceEntityHandler"));
+ OC_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,
(char*) request->resourceUrl, defaultDeviceHandlerCallbackParameter);
if(ehResult == OC_EH_SLOW)
{
- OC_LOG(INFO, TAG, PCF("This is a slow resource"));
+ OC_LOG(INFO, TAG, "This is a slow resource");
request->slowFlag = 1;
}
else if(ehResult == OC_EH_ERROR)
}
result = EntityHandlerCodeToOCStackCode(ehResult);
exit:
+ OCPayloadDestroy(ehRequest.payload);
return result;
}
OCEntityHandlerFlag ehFlag = OC_REQUEST_FLAG;
ResourceObserver *resObs = NULL;
- OCEntityHandlerRequest ehRequest = {};
+ OCEntityHandlerRequest ehRequest = {0};
+
+ OC_LOG(INFO, TAG, "Entering HandleResourceWithEntityHandler");
+ OCPayloadType type = PAYLOAD_TYPE_REPRESENTATION;
+ // check the security resource
+ if (request && request->resourceUrl && SRMIsSecurityResourceURI(request->resourceUrl))
+ {
+ type = PAYLOAD_TYPE_SECURITY;
+
+ }
- OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithEntityHandler"));
+ if (request && strcmp(request->resourceUrl, OC_RSRVD_RD_URI) == 0)
+ {
+ type = PAYLOAD_TYPE_RD;
+ }
result = FormOCEntityHandlerRequest(&ehRequest,
(OCRequestHandle)request,
&request->devAddr,
(OCResourceHandle)resource,
request->query,
+ type,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
{
- OC_LOG(INFO, TAG, PCF("No observation requested"));
+ OC_LOG(INFO, TAG, "No observation requested");
ehFlag = OC_REQUEST_FLAG;
}
else if(ehRequest.obsInfo.action == OC_OBSERVE_REGISTER && !collectionResource)
{
- OC_LOG(INFO, TAG, PCF("Observation registration requested"));
+ OC_LOG(INFO, TAG, "Observation registration requested");
+
+ ResourceObserver *obs = GetObserverUsingToken (request->requestToken,
+ request->tokenLength);
+
+ if (obs)
+ {
+ OC_LOG (INFO, TAG, "Observer with this token already present");
+ OC_LOG (INFO, TAG, "Possibly re-transmitted CON OBS request");
+ OC_LOG (INFO, TAG, "Not adding observer. Not responding to client");
+ OC_LOG (INFO, TAG, "The first request for this token is already ACKED.");
+
+ // server requests are usually free'd when the response is sent out
+ // for the request in ocserverrequest.c : HandleSingleResponse()
+ // Since we are making an early return and not responding, the server request
+ // needs to be deleted.
+ FindAndDeleteServerRequest (request);
+ return OC_STACK_OK;
+ }
result = GenerateObserverId(&ehRequest.obsInfo.obsId);
VERIFY_SUCCESS(result, OC_STACK_OK);
result = AddObserver ((const char*)(request->resourceUrl),
(const char *)(request->query),
ehRequest.obsInfo.obsId, request->requestToken, request->tokenLength,
- resource, request->qos,
+ resource, request->qos, request->acceptFormat,
&request->devAddr);
if(result == OC_STACK_OK)
{
- OC_LOG(INFO, TAG, PCF("Added observer successfully"));
+ OC_LOG(INFO, TAG, "Added observer successfully");
request->observeResult = OC_STACK_OK;
ehFlag = (OCEntityHandlerFlag)(OC_REQUEST_FLAG | OC_OBSERVE_FLAG);
}
// The error in observeResult for the request will be used when responding to this
// request by omitting the observation option/sequence number.
request->observeResult = OC_STACK_ERROR;
- OC_LOG(ERROR, TAG, PCF("Observer Addition failed"));
+ OC_LOG(ERROR, TAG, "Observer Addition failed");
ehFlag = OC_REQUEST_FLAG;
}
else if(ehRequest.obsInfo.action == OC_OBSERVE_DEREGISTER &&
!collectionResource)
{
- OC_LOG(INFO, TAG, PCF("Deregistering observation requested"));
+ OC_LOG(INFO, TAG, "Deregistering observation requested");
resObs = GetObserverUsingToken (request->requestToken, request->tokenLength);
if(result == OC_STACK_OK)
{
- OC_LOG(INFO, TAG, PCF("Removed observer successfully"));
+ OC_LOG(INFO, TAG, "Removed observer successfully");
request->observeResult = OC_STACK_OK;
}
else
{
result = OC_STACK_OK;
request->observeResult = OC_STACK_ERROR;
- OC_LOG(ERROR, TAG, PCF("Observer Removal failed"));
+ OC_LOG(ERROR, TAG, "Observer Removal failed");
}
}
else
ehResult = resource->entityHandler(ehFlag, &ehRequest, resource->entityHandlerCallbackParam);
if(ehResult == OC_EH_SLOW)
{
- OC_LOG(INFO, TAG, PCF("This is a slow resource"));
+ OC_LOG(INFO, TAG, "This is a slow resource");
request->slowFlag = 1;
}
else if(ehResult == OC_EH_ERROR)
}
result = EntityHandlerCodeToOCStackCode(ehResult);
exit:
+ OCPayloadDestroy(ehRequest.payload);
return result;
}
}
OCStackResult result = OC_STACK_ERROR;
- OCEntityHandlerRequest ehRequest = {};
+ OCEntityHandlerRequest ehRequest = {0};
result = FormOCEntityHandlerRequest(&ehRequest,
(OCRequestHandle)request,
&request->devAddr,
(OCResourceHandle)resource,
request->query,
+ PAYLOAD_TYPE_REPRESENTATION,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
request->rcvdVendorSpecificHeaderOptions,
(OCObserveAction)request->observationOption,
(OCObservationId)0);
- if(result != OC_STACK_OK)
+ if(result == OC_STACK_OK)
{
- return result;
+ result = DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest);
}
- return (DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest));
+ OCPayloadDestroy(ehRequest.payload);
+ return result;
}
OCStackResult
}
case OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER:
{
- OC_LOG(INFO, TAG, PCF("OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER"));
+ OC_LOG(INFO, TAG, "OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER");
return OC_STACK_ERROR;
}
case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
}
default:
{
- OC_LOG(INFO, TAG, PCF("Invalid Resource Determination"));
+ OC_LOG(INFO, TAG, "Invalid Resource Determination");
return OC_STACK_ERROR;
}
}
void DeletePlatformInfo()
{
- OC_LOG(INFO, TAG, PCF("Deleting platform info."));
+ OC_LOG(INFO, TAG, "Deleting platform info.");
OICFree(savedPlatformInfo.platformID);
savedPlatformInfo.platformID = NULL;
if (res != OC_STACK_OK)
{
- OC_LOG_V(ERROR, TAG, PCF("Failed to save platform info. errno(%d)"), res);
+ OC_LOG_V(ERROR, TAG, "Failed to save platform info. errno(%d)", res);
}
else
{
- OC_LOG(ERROR, TAG, PCF("Platform info saved."));
+ OC_LOG(INFO, TAG, "Platform info saved.");
}
return res;
void DeleteDeviceInfo()
{
- OC_LOG(INFO, TAG, PCF("Deleting device info."));
+ OC_LOG(INFO, TAG, "Deleting device info.");
OICFree(savedDeviceInfo.deviceName);
savedDeviceInfo.deviceName = NULL;
if(OCGetServerInstanceID() == NULL)
{
- OC_LOG(INFO, TAG, PCF("Device ID generation failed"));
+ OC_LOG(INFO, TAG, "Device ID generation failed");
res = OC_STACK_ERROR;
goto exit;
}
- OC_LOG(INFO, TAG, PCF("Device initialized successfully."));
+ OC_LOG(INFO, TAG, "Device initialized successfully.");
return OC_STACK_OK;
- exit:
- DeleteDeviceInfo();
- return res;
-
+exit:
+ DeleteDeviceInfo();
+ return res;
}