1 //******************************************************************
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 // Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
22 // causes header files to expose definitions
23 // corresponding to the POSIX.1-2001 base
24 // specification (excluding the XSI extension).
25 // For POSIX.1-2001 base specification,
26 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
27 #define _POSIX_C_SOURCE 200112L
28 #include "ocresource.h"
30 #include "ocresourcehandler.h"
31 #include "ocobserve.h"
32 #include "occollection.h"
38 #include "cainterface.h"
42 #define TAG PCF("ocresource")
43 #define VERIFY_SUCCESS(op, successCode) { if (op != successCode) \
44 {OC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
46 #define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OC_LOG((logLevel), \
47 TAG, PCF(#arg " is NULL")); return (retVal); } }
49 extern OCResource *headResource;
50 static cJSON *savedDeviceInfo = NULL;
52 static const char * VIRTUAL_RSRCS[] =
62 //-----------------------------------------------------------------------------
63 // Default resource entity handler function
64 //-----------------------------------------------------------------------------
65 OCEntityHandlerResult defaultResourceEHandler(OCEntityHandlerFlag flag,
66 OCEntityHandlerRequest * request)
68 //TODO ("Implement me!!!!");
69 // TODO: remove silence unused param warnings
72 return OC_EH_OK; // Making sure that the Default EH and the Vendor EH have matching signatures
75 /* This method will retrieve the port at which the secure resource is hosted */
76 static OCStackResult GetSecurePortInfo(CATransportType_t connType, uint16_t *port)
78 CALocalConnectivity_t* info = NULL;
80 OCStackResult ret = OC_STACK_ERROR;
82 CAResult_t caResult = CAGetNetworkInformation(&info, &size);
83 if ((caResult == CA_STATUS_OK) && info && size)
87 if (info[size].isSecured && info[size].type == connType)
89 if (info[size].type == CA_IPV4)
91 *port = info[size].addressInfo.IP.port;
103 static OCStackResult ValidateUrlQuery (char *url, char *query,
104 uint8_t *filterOn, char **filterValue)
106 if(!filterOn || !filterValue)
108 return OC_STACK_INVALID_PARAM;
111 char *filterParam = NULL;
113 OC_LOG(INFO, TAG, PCF("Entering ValidateUrlQuery"));
116 return OC_STACK_INVALID_URI;
119 if (strcmp ((char *)url, GetVirtualResourceUri(OC_WELL_KNOWN_URI)) == 0 ||
120 strcmp ((char *)url, GetVirtualResourceUri(OC_DEVICE_URI)) == 0)
122 *filterOn = STACK_RES_DISCOVERY_NOFILTER;
125 char* strTokPtr = NULL;
126 filterParam = strtok_r((char *)query, "=", &strTokPtr);
127 *filterValue = strtok_r(NULL, " ", &strTokPtr);
129 if (!(*filterValue) || ! filterParam)
131 return OC_STACK_INVALID_QUERY;
133 else if (strcmp (filterParam, OC_RSRVD_INTERFACE) == 0)
135 // Resource discovery with interface filter
136 *filterOn = STACK_RES_DISCOVERY_IF_FILTER;
138 else if (strcmp (filterParam, OC_RSRVD_RESOURCE_TYPE) == 0)
140 // Resource discovery with resource type filter
141 *filterOn = STACK_RES_DISCOVERY_RT_FILTER;
143 else if (strcmp (filterParam, OC_RSRVD_DEVICE_ID) == 0)
146 *filterOn = STACK_DEVICE_DISCOVERY_DI_FILTER;
148 else if (strcmp (filterParam, OC_RSRVD_DEVICE_NAME) == 0)
151 *filterOn = STACK_DEVICE_DISCOVERY_DN_FILTER;
155 // Other filter types not supported
156 return OC_STACK_INVALID_QUERY;
161 else if (strcmp((char *)url, GetVirtualResourceUri(OC_PRESENCE)) == 0)
163 //Nothing needs to be done, except for pass a OC_PRESENCE query through as OC_STACK_OK.
164 OC_LOG(INFO, TAG, PCF("OC_PRESENCE Request"));
165 *filterOn = STACK_RES_DISCOVERY_NOFILTER;
170 // Other URIs not yet supported
171 return OC_STACK_INVALID_URI;
173 OC_LOG(INFO, TAG, PCF("Exiting ValidateUrlQuery"));
179 BuildVirtualResourceResponse(const OCResource *resourcePtr, uint8_t filterOn,
180 const char *filterValue, char *out, uint16_t *remaining,
181 CATransportType_t connType )
183 if(!resourcePtr || !out || !remaining)
185 return OC_STACK_INVALID_PARAM;
188 OCResourceType *resourceTypePtr = NULL;
189 OCResourceInterface *interfacePtr = NULL;
190 cJSON *resObj = NULL;
191 cJSON *propObj = NULL;
192 cJSON *rtArray = NULL;
193 char *jsonStr = NULL;
194 uint8_t encodeRes = 0;
195 OCStackResult ret = OC_STACK_OK;
196 uint16_t jsonLen = 0;
198 OC_LOG(INFO, TAG, PCF("Entering BuildVirtualResourceResponse"));
199 resObj = cJSON_CreateObject();
204 if ((filterOn == STACK_RES_DISCOVERY_RT_FILTER) && filterValue)
206 resourceTypePtr = resourcePtr->rsrcType;
207 while (resourceTypePtr)
209 if (strcmp (resourceTypePtr->resourcetypename, filterValue) == 0)
214 resourceTypePtr = resourceTypePtr->next;
217 else if ((filterOn == STACK_RES_DISCOVERY_IF_FILTER) && filterValue)
219 interfacePtr = resourcePtr->rsrcInterface;
222 if (strcmp (interfacePtr->name, filterValue) == 0)
227 interfacePtr = interfacePtr->next;
230 else if (filterOn == STACK_RES_DISCOVERY_NOFILTER)
236 //TODO: Unsupported query filter
237 return OC_STACK_INVALID_QUERY;
243 cJSON_AddItemToObject (resObj, OC_RSRVD_HREF, cJSON_CreateString(resourcePtr->uri));
245 // Add server instance id
246 cJSON_AddItemToObject (resObj,
247 OC_RSRVD_SERVER_INSTANCE_ID,
248 cJSON_CreateString(OCGetServerInstanceIDString()));
250 cJSON_AddItemToObject (resObj, OC_RSRVD_PROPERTY, propObj = cJSON_CreateObject());
251 // Add resource types
252 cJSON_AddItemToObject (propObj, OC_RSRVD_RESOURCE_TYPE, rtArray = cJSON_CreateArray());
253 resourceTypePtr = resourcePtr->rsrcType;
254 while (resourceTypePtr)
256 cJSON_AddItemToArray (rtArray,
257 cJSON_CreateString(resourceTypePtr->resourcetypename));
258 resourceTypePtr = resourceTypePtr->next;
260 // Add interface types
261 cJSON_AddItemToObject (propObj, OC_RSRVD_INTERFACE, rtArray = cJSON_CreateArray());
262 interfacePtr = resourcePtr->rsrcInterface;
265 cJSON_AddItemToArray (rtArray, cJSON_CreateString(interfacePtr->name));
266 interfacePtr = interfacePtr->next;
268 // If resource is observable, set observability flag.
269 // Resources that are not observable will not have the flag.
270 if (resourcePtr->resourceProperties & OC_OBSERVABLE)
272 cJSON_AddItemToObject (propObj, OC_RSRVD_OBSERVABLE,
273 cJSON_CreateNumber(OC_RESOURCE_OBSERVABLE));
275 // Set secure flag for secure resources
276 if (resourcePtr->resourceProperties & OC_SECURE)
278 cJSON_AddNumberToObject (propObj, OC_RSRVD_SECURE, OC_RESOURCE_SECURE);
279 //Set the IP port also as secure resources are hosted on a different port
281 if (GetSecurePortInfo (connType, &port) == OC_STACK_OK)
283 cJSON_AddNumberToObject (propObj, OC_RSRVD_HOSTING_PORT, port);
289 jsonStr = cJSON_PrintUnformatted (resObj);
293 cJSON_Delete(resObj);
294 return OC_STACK_NO_MEMORY;
297 jsonLen = strlen(jsonStr);
298 if (jsonLen < *remaining)
300 strcpy(out, jsonStr);
301 *remaining = *remaining - jsonLen;
305 ret = OC_STACK_ERROR;
307 cJSON_Delete (resObj);
310 OC_LOG(INFO, TAG, PCF("Exiting BuildVirtualResourceResponse"));
314 OCStackResult BuildVirtualResourceResponseForDevice(uint8_t filterOn, char *filterValue,
315 char *out, uint16_t *remaining)
317 if(!out || !remaining)
319 return OC_STACK_INVALID_PARAM;
322 OCStackResult ret = OC_STACK_ERROR;
324 if (savedDeviceInfo != NULL)
326 char *jsonStr = NULL;
327 uint16_t jsonLen = 0;
328 cJSON *repObj = cJSON_GetObjectItem(savedDeviceInfo, OC_RSRVD_REPRESENTATION);
330 OC_LOG(INFO, TAG, PCF("Entering BuildVirtualResourceResponseForDevice"));
332 if ((filterOn == STACK_DEVICE_DISCOVERY_DI_FILTER) && filterValue)
334 if((cJSON_GetObjectItem(repObj,OC_RSRVD_DEVICE_ID) != NULL) &&
335 strcmp(cJSON_GetObjectItem(repObj,OC_RSRVD_DEVICE_ID)->valuestring, filterValue)
341 else if ((filterOn == STACK_DEVICE_DISCOVERY_DN_FILTER) && filterValue)
343 if((cJSON_GetObjectItem(repObj,OC_RSRVD_DEVICE_NAME) != NULL) &&
344 strcmp(cJSON_GetObjectItem(repObj,OC_RSRVD_DEVICE_NAME)->valuestring,
350 else if (filterOn == STACK_RES_DISCOVERY_NOFILTER)
356 ret = OC_STACK_INVALID_QUERY;
359 if (ret == OC_STACK_OK)
361 jsonStr = cJSON_PrintUnformatted (savedDeviceInfo);
365 jsonLen = strlen(jsonStr);
367 if (jsonLen < *remaining)
369 strncpy(out, jsonStr, (jsonLen + 1));
370 *remaining = *remaining - jsonLen;
375 ret = OC_STACK_ERROR;
382 ret = OC_STACK_ERROR;
387 ret = OC_STACK_INVALID_DEVICE_INFO;
392 //error so that stack won't respond with empty payload
393 ret = OC_STACK_INVALID_DEVICE_INFO;
396 OC_LOG(INFO, TAG, PCF("Exiting BuildVirtualResourceResponseForDevice"));
400 const char * GetVirtualResourceUri( OCVirtualResources resource)
402 if (resource < OC_MAX_VIRTUAL_RESOURCES)
404 return VIRTUAL_RSRCS[resource];
410 bool IsVirtualResource(const char* resourceUri)
417 for (int i = 0; i < OC_MAX_VIRTUAL_RESOURCES; i++)
419 if (strcmp(resourceUri, GetVirtualResourceUri((OCVirtualResources)i)) == 0)
427 uint8_t IsCollectionResource (OCResource *resource)
434 for (int i = 0; i < MAX_CONTAINED_RESOURCES; i++)
436 if (resource->rsrcResources[i])
444 OCResource *FindResourceByUri(const char* resourceUri)
451 OCResource * pointer = headResource;
454 if (strcmp(resourceUri, pointer->uri) == 0)
458 pointer = pointer->next;
460 OC_LOG(INFO, TAG, PCF("Resource not found"));
465 OCStackResult DetermineResourceHandling (const OCServerRequest *request,
466 ResourceHandling *handling,
467 OCResource **resource)
469 if(!request || !handling || !resource)
471 return OC_STACK_INVALID_PARAM;
474 OC_LOG(INFO, TAG, PCF("Entering DetermineResourceHandling"));
476 // Check if virtual resource
477 if (IsVirtualResource((const char*)request->resourceUrl))
479 *handling = OC_RESOURCE_VIRTUAL;
480 *resource = headResource;
483 if (NULL == request->resourceUrl || (strlen((const char*)(request->resourceUrl)) == 0))
485 // Resource URL not specified
486 *handling = OC_RESOURCE_NOT_SPECIFIED;
487 return OC_STACK_NO_RESOURCE;
491 OCResource *resourcePtr = NULL;
492 resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
493 *resource = resourcePtr;
496 if(defaultDeviceHandler)
498 *handling = OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER;
502 // Resource does not exist
503 // and default device handler does not exist
504 *handling = OC_RESOURCE_NOT_SPECIFIED;
505 return OC_STACK_NO_RESOURCE;
508 // secure resource will entertain only authorized requests
509 if ((resourcePtr->resourceProperties & OC_SECURE) && (request->secured == 0))
511 OC_LOG(ERROR, TAG, PCF("Un-authorized request. Ignoring"));
512 return OC_STACK_RESOURCE_ERROR;
515 if (IsCollectionResource (resourcePtr))
517 // Collection resource
518 if (resourcePtr->entityHandler != defaultResourceEHandler)
520 *handling = OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER;
525 *handling = OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER;
531 // Resource not a collection
532 if (resourcePtr->entityHandler != defaultResourceEHandler)
534 *handling = OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER;
539 *handling = OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER;
546 OCStackResult EntityHandlerCodeToOCStackCode(OCEntityHandlerResult ehResult)
548 OCStackResult result;
553 result = OC_STACK_OK;
556 result = OC_STACK_SLOW_RESOURCE;
559 result = OC_STACK_ERROR;
561 case OC_EH_FORBIDDEN:
562 result = OC_STACK_RESOURCE_ERROR;
564 case OC_EH_RESOURCE_CREATED:
565 result = OC_STACK_RESOURCE_CREATED;
567 case OC_EH_RESOURCE_DELETED:
568 result = OC_STACK_RESOURCE_DELETED;
570 case OC_EH_RESOURCE_NOT_FOUND:
571 result = OC_STACK_NO_RESOURCE;
574 result = OC_STACK_ERROR;
581 HandleVirtualResource (OCServerRequest *request, OCResource* resource)
583 if(!request || !resource)
585 return OC_STACK_INVALID_PARAM;
588 OCStackResult result = OC_STACK_ERROR;
589 char *filterValue = NULL;
590 uint8_t filterOn = 0;
591 uint16_t remaining = 0;
593 uint8_t firstLoopDone = 0;
594 char discoveryResBuf[MAX_RESPONSE_LENGTH] = {};
596 OC_LOG(INFO, TAG, PCF("Entering HandleVirtualResource"));
598 result = ValidateUrlQuery (request->resourceUrl,
599 request->query, &filterOn,
602 if (result == OC_STACK_OK)
604 if (strcmp ((char *)request->resourceUrl, GetVirtualResourceUri(OC_WELL_KNOWN_URI)) == 0)
606 ptr = discoveryResBuf;
607 remaining = MAX_RESPONSE_LENGTH;
609 // Check if valid resource and enough space in buffer for atleast
610 // the null character.
611 while(resource && (remaining > 1))
613 if((resource->resourceProperties & OC_ACTIVE)
614 && (resource->resourceProperties & OC_DISCOVERABLE))
616 // if there is data on the buffer, we have already added a response,
617 // so we need to add a comma before we do anything
619 && remaining >= (sizeof(OC_JSON_SEPARATOR)+1))
621 *ptr = OC_JSON_SEPARATOR;
626 result = BuildVirtualResourceResponse(resource, filterOn, filterValue,
627 (char*)ptr, &remaining, request->connectivityType );
629 if (result != OC_STACK_OK)
631 // if this failed, we need to remove the comma added above.
640 ptr += strlen((char *)ptr);
642 resource = resource->next;
645 if(strlen((const char *)discoveryResBuf) > 0)
647 OCEntityHandlerResponse response = {};
649 response.ehResult = OC_EH_OK;
650 response.payload = discoveryResBuf;
651 response.payloadSize = strlen((const char *)discoveryResBuf) + 1;
652 response.persistentBufferFlag = 0;
653 response.requestHandle = (OCRequestHandle) request;
654 response.resourceHandle = (OCResourceHandle) resource;
656 result = OCDoResponse(&response);
659 else if (strcmp ((char *)request->resourceUrl, GetVirtualResourceUri(OC_DEVICE_URI)) == 0)
661 remaining = MAX_RESPONSE_LENGTH;
662 ptr = discoveryResBuf;
664 result = BuildVirtualResourceResponseForDevice(filterOn, filterValue,
665 (char*)ptr, &remaining);
667 if(result == OC_STACK_OK)
669 ptr += strlen((char*)ptr);
672 if(remaining < MAX_RESPONSE_LENGTH)
674 OCEntityHandlerResponse response = {0};
676 response.ehResult = OC_EH_OK;
677 response.payload = discoveryResBuf;
678 response.payloadSize = strlen((const char *)discoveryResBuf) + 1;
679 response.persistentBufferFlag = 0;
680 response.requestHandle = (OCRequestHandle) request;
681 response.resourceHandle = (OCResourceHandle) resource;
683 result = OCDoResponse(&response);
689 if(resource->resourceProperties & OC_ACTIVE){
690 SendPresenceNotification(NULL);
695 result = OC_STACK_OK;
700 HandleDefaultDeviceEntityHandler (OCServerRequest *request)
704 return OC_STACK_INVALID_PARAM;
707 OCStackResult result = OC_STACK_OK;
708 OCEntityHandlerResult ehResult = OC_EH_ERROR;
709 OCEntityHandlerRequest ehRequest = {};
711 OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithDefaultDeviceEntityHandler"));
712 result = FormOCEntityHandlerRequest(&ehRequest, (OCRequestHandle) request,
713 request->method, (OCResourceHandle) NULL, request->query,
714 request->reqJSONPayload, request->numRcvdVendorSpecificHeaderOptions,
715 request->rcvdVendorSpecificHeaderOptions,
716 (OCObserveAction)request->observationOption, (OCObservationId)0);
717 VERIFY_SUCCESS(result, OC_STACK_OK);
719 // At this point we know for sure that defaultDeviceHandler exists
720 ehResult = defaultDeviceHandler(OC_REQUEST_FLAG, &ehRequest,
721 (char*) request->resourceUrl);
722 if(ehResult == OC_EH_SLOW)
724 OC_LOG(INFO, TAG, PCF("This is a slow resource"));
725 request->slowFlag = 1;
727 else if(ehResult == OC_EH_ERROR)
729 FindAndDeleteServerRequest(request);
731 result = EntityHandlerCodeToOCStackCode(ehResult);
737 HandleResourceWithEntityHandler (OCServerRequest *request,
738 OCResource *resource,
739 uint8_t collectionResource)
741 if(!request || ! resource)
743 return OC_STACK_INVALID_PARAM;
746 OCStackResult result = OC_STACK_ERROR;
747 OCEntityHandlerResult ehResult = OC_EH_ERROR;
748 OCEntityHandlerFlag ehFlag = OC_REQUEST_FLAG;
749 ResourceObserver *resObs = NULL;
751 OCEntityHandlerRequest ehRequest = {};
753 OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithEntityHandler"));
754 result = FormOCEntityHandlerRequest(&ehRequest, (OCRequestHandle) request,
755 request->method, (OCResourceHandle) resource, request->query,
756 request->reqJSONPayload, request->numRcvdVendorSpecificHeaderOptions,
757 request->rcvdVendorSpecificHeaderOptions,
758 (OCObserveAction)request->observationOption, 0);
759 VERIFY_SUCCESS(result, OC_STACK_OK);
761 if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
763 OC_LOG(INFO, TAG, PCF("No observation requested"));
764 ehFlag = OC_REQUEST_FLAG;
766 else if(ehRequest.obsInfo.action == OC_OBSERVE_REGISTER &&
769 OC_LOG(INFO, TAG, PCF("Registering observation requested"));
770 result = GenerateObserverId(&ehRequest.obsInfo.obsId);
771 VERIFY_SUCCESS(result, OC_STACK_OK);
773 result = AddObserver ((const char*)(request->resourceUrl),
774 (const char *)(request->query),
775 ehRequest.obsInfo.obsId, request->requestToken, request->tokenLength,
776 resource, request->qos,
777 &request->addressInfo, request->connectivityType);
779 if(result == OC_STACK_OK)
781 OC_LOG(INFO, TAG, PCF("Added observer successfully"));
782 request->observeResult = OC_STACK_OK;
783 ehFlag = (OCEntityHandlerFlag)(OC_REQUEST_FLAG | OC_OBSERVE_FLAG);
787 result = OC_STACK_OK;
788 // The error in observeResult for the request will be
789 // used when responding to this request by omitting
790 // the observation option/sequence number.
791 request->observeResult = OC_STACK_ERROR;
792 OC_LOG(ERROR, TAG, PCF("Observer Addition failed"));
793 ehFlag = OC_REQUEST_FLAG;
797 else if(ehRequest.obsInfo.action == OC_OBSERVE_DEREGISTER &&
800 OC_LOG(INFO, TAG, PCF("Deregistering observation requested"));
802 resObs = GetObserverUsingToken (request->requestToken, request->tokenLength);
806 // Stack does not contain this observation request
807 // Either token is incorrect or observation list is corrupted
808 result = OC_STACK_ERROR;
811 ehRequest.obsInfo.obsId = resObs->observeId;
812 ehFlag = (OCEntityHandlerFlag)(ehFlag | OC_OBSERVE_FLAG);
814 result = DeleteObserverUsingToken (request->requestToken, request->tokenLength);
816 if(result == OC_STACK_OK)
818 OC_LOG(INFO, TAG, PCF("Removed observer successfully"));
819 request->observeResult = OC_STACK_OK;
823 result = OC_STACK_OK;
824 request->observeResult = OC_STACK_ERROR;
825 OC_LOG(ERROR, TAG, PCF("Observer Removal failed"));
830 result = OC_STACK_ERROR;
834 ehResult = resource->entityHandler(ehFlag, &ehRequest);
835 if(ehResult == OC_EH_SLOW)
837 OC_LOG(INFO, TAG, PCF("This is a slow resource"));
838 request->slowFlag = 1;
840 else if(ehResult == OC_EH_ERROR)
842 FindAndDeleteServerRequest(request);
844 result = EntityHandlerCodeToOCStackCode(ehResult);
850 HandleCollectionResourceDefaultEntityHandler (OCServerRequest *request,
851 OCResource *resource)
853 if(!request || !resource)
855 return OC_STACK_INVALID_PARAM;
858 OCStackResult result = OC_STACK_ERROR;
859 OCEntityHandlerRequest ehRequest = {};
861 result = FormOCEntityHandlerRequest(&ehRequest, (OCRequestHandle) request,
862 request->method, (OCResourceHandle) resource, request->query,
863 request->reqJSONPayload, request->numRcvdVendorSpecificHeaderOptions,
864 request->rcvdVendorSpecificHeaderOptions,
865 (OCObserveAction)request->observationOption, (OCObservationId) 0);
866 if(result != OC_STACK_OK)
871 return (DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest));
875 ProcessRequest(ResourceHandling resHandling, OCResource *resource, OCServerRequest *request)
877 OCStackResult ret = OC_STACK_OK;
881 case OC_RESOURCE_VIRTUAL:
883 ret = HandleVirtualResource (request, resource);
886 case OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER:
888 ret = HandleDefaultDeviceEntityHandler(request);
891 case OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER:
893 OC_LOG(INFO, TAG, PCF("OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER"));
894 return OC_STACK_ERROR;
896 case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
898 ret = HandleResourceWithEntityHandler (request, resource, 0);
901 case OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER:
903 ret = HandleResourceWithEntityHandler (request, resource, 1);
906 case OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER:
908 ret = HandleCollectionResourceDefaultEntityHandler (request, resource);
911 case OC_RESOURCE_NOT_SPECIFIED:
913 ret = OC_STACK_NO_RESOURCE;
918 OC_LOG(INFO, TAG, PCF("Invalid Resource Determination"));
919 return OC_STACK_ERROR;
925 void DeleteDeviceInfo()
929 cJSON_Delete(savedDeviceInfo);
933 OCStackResult SaveDeviceInfo(OCDeviceInfo deviceInfo)
937 savedDeviceInfo = cJSON_CreateObject();
938 cJSON *repObj = NULL;
940 cJSON_AddItemToObject (savedDeviceInfo, OC_RSRVD_HREF,
941 cJSON_CreateString(GetVirtualResourceUri(OC_DEVICE_URI)));
943 cJSON_AddItemToObject (savedDeviceInfo, OC_RSRVD_REPRESENTATION, repObj = cJSON_CreateObject());
945 if (deviceInfo.contentType)
947 cJSON_AddItemToObject (repObj, OC_RSRVD_CONTENT_TYPE,
948 cJSON_CreateString(deviceInfo.contentType));
951 if (deviceInfo.dateOfManufacture)
953 cJSON_AddItemToObject (repObj, OC_RSRVD_MFG_DATE,
954 cJSON_CreateString(deviceInfo.dateOfManufacture));
957 if (deviceInfo.deviceName)
959 cJSON_AddItemToObject (repObj, OC_RSRVD_DEVICE_NAME,
960 cJSON_CreateString(deviceInfo.deviceName));
963 if (deviceInfo.deviceUUID)
965 cJSON_AddItemToObject (repObj, OC_RSRVD_DEVICE_ID,
966 cJSON_CreateString(deviceInfo.deviceUUID));
969 if (deviceInfo.firmwareVersion)
971 cJSON_AddItemToObject (repObj, OC_RSRVD_FW_VERSION,
972 cJSON_CreateString(deviceInfo.firmwareVersion));
975 if (deviceInfo.hostName)
977 cJSON_AddItemToObject (repObj, OC_RSRVD_HOST_NAME,
978 cJSON_CreateString(deviceInfo.hostName));
981 if (deviceInfo.manufacturerName)
983 if(strlen(deviceInfo.manufacturerName) > MAX_MANUFACTURER_NAME_LENGTH)
986 return OC_STACK_INVALID_PARAM;
989 cJSON_AddItemToObject (repObj, OC_RSRVD_MFG_NAME,
990 cJSON_CreateString(deviceInfo.manufacturerName));
993 if (deviceInfo.manufacturerUrl)
995 if(strlen(deviceInfo.manufacturerUrl) > MAX_MANUFACTURER_URL_LENGTH)
998 return OC_STACK_INVALID_PARAM;
1001 cJSON_AddItemToObject (repObj, OC_RSRVD_MFG_URL,
1002 cJSON_CreateString(deviceInfo.manufacturerUrl));
1005 if (deviceInfo.modelNumber)
1007 cJSON_AddItemToObject (repObj, OC_RSRVD_MODEL_NUM,
1008 cJSON_CreateString(deviceInfo.modelNumber));
1011 if (deviceInfo.platformVersion)
1013 cJSON_AddItemToObject (repObj, OC_RSRVD_PLATFORM_VERSION,
1014 cJSON_CreateString(deviceInfo.platformVersion));
1017 if (deviceInfo.supportUrl)
1019 cJSON_AddItemToObject (repObj, OC_RSRVD_SUPPORT_URL,
1020 cJSON_CreateString(deviceInfo.supportUrl));
1023 if (deviceInfo.version)
1025 cJSON_AddItemToObject (repObj, OC_RSRVD_VERSION,
1026 cJSON_CreateString(deviceInfo.version));