//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+#include "iotivity_config.h"
#include <stdio.h>
#include <string.h>
#include <string>
#include <stdlib.h>
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
#include <signal.h>
+#ifdef HAVE_PTHREAD_H
#include <pthread.h>
+#endif
#include <array>
+#include "oic_malloc.h"
+#include <getopt.h>
#include "ocstack.h"
#include "logger.h"
-#include "cJSON.h"
+#include "ocpayload.h"
#include "ocserver.h"
+#include "common.h"
//string length of "/a/light/" + std::numeric_limits<int>::digits10 + '\0'"
// 9 + 9 + 1 = 19
int gQuitFlag = 0;
int gLightUnderObservation = 0;
+#ifdef WITH_PROCESS_EVENT
+static oc_event processEvent = NULL;
+#endif
static LightResource Light;
// This variable determines instance number of the Light resource.
Observers interestedObservers[SAMPLE_MAX_NUM_OBSERVATIONS];
+pthread_t threadId_observe;
+pthread_t threadId_presence;
+
+static bool observeThreadStarted = false;
+
#ifdef WITH_PRESENCE
-static int stopPresenceCount = 10;
#define numPresenceResources (2)
#endif
-//TODO: Follow the pattern used in constructJsonResponse() when the payload is decided.
-const char responsePayloadDeleteOk[] =
- "{App determines payload: Delete Resource operation succeeded.}";
-const char responsePayloadDeleteNotOK[] =
- "{App determines payload: Delete Resource operation failed.}";
-const char responsePayloadResourceDoesNotExist[] =
- "{App determines payload: The resource does not exist.}";
-const char responsePayloadDeleteResourceNotSupported[] =
- "{App determines payload: The request is received for a non-support resource.}";
-
-
char *gResourceUri= (char *)"/a/light";
-const char *dateOfManufacture = "myDateOfManufacture";
+const char *dateOfManufacture = "2016-01-15";
const char *deviceName = "myDeviceName";
-const char *deviceUUID = "myDeviceUUID";
+const char *deviceUUID = "51b55ddc-ccbb-4cb3-a57f-494eeca13a21";
const char *firmwareVersion = "myFirmwareVersion";
const char *manufacturerName = "myName";
const char *operatingSystemVersion = "myOS";
const char *hardwareVersion = "myHardwareVersion";
-const char* platformID = "myPlatformID";
-const char *manufacturerUrl = "myManufacturerUrl";
+const char *platformID = "0A3E0D6F-DBF5-404E-8719-D6880042463A";
+const char *manufacturerLink = "https://www.iotivity.org";
const char *modelNumber = "myModelNumber";
const char *platformVersion = "myPlatformVersion";
-const char *supportUrl = "mySupportUrl";
+const char *supportLink = "https://www.iotivity.org";
const char *version = "myVersion";
const char *systemTime = "2015-05-15T11.04";
+const char *specVersion = "core.1.1.0";
+const char *dataModelVersions = "res.1.1.0,sh.1.1.0";
// Entity handler should check for resourceTypeName and ResourceInterface in order to GET
// the existence of a known resource
OCPlatformInfo platformInfo;
OCDeviceInfo deviceInfo;
+OCRepPayload* getPayload(const char* uri, int64_t power, bool state)
+{
+ OCRepPayload* payload = OCRepPayloadCreate();
+ if(!payload)
+ {
+ OIC_LOG(ERROR, TAG, PCF("Failed to allocate Payload"));
+ return nullptr;
+ }
+
+ OCRepPayloadSetUri(payload, uri);
+ OCRepPayloadSetPropBool(payload, "state", state);
+ OCRepPayloadSetPropInt(payload, "power", power);
+
+ return payload;
+}
+
//This function takes the request as an input and returns the response
-//in JSON format.
-char* constructJsonResponse (OCEntityHandlerRequest *ehRequest)
+OCRepPayload* constructResponse(OCEntityHandlerRequest *ehRequest)
{
- cJSON *json = cJSON_CreateObject();
- cJSON *format;
- char *jsonResponse;
+ if(ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
+ {
+ OIC_LOG(ERROR, TAG, PCF("Incoming payload not a representation"));
+ return nullptr;
+ }
+
+ OCRepPayload* input = reinterpret_cast<OCRepPayload*>(ehRequest->payload);
+
LightResource *currLightResource = &Light;
if (ehRequest->resource == gLightInstance[0].handle)
if(OC_REST_PUT == ehRequest->method)
{
- // Get cJSON pointer to query
- cJSON *putJson = cJSON_Parse(ehRequest->reqJSONPayload);
-
- if(!putJson)
- {
- OC_LOG_V(ERROR, TAG, "Failed to parse JSON: %s", ehRequest->reqJSONPayload);
- return NULL;
- }
-
- // Get root of JSON payload, then the 1st resource.
- cJSON* carrier = cJSON_GetObjectItem(putJson, "oic");
- carrier = cJSON_GetArrayItem(carrier, 0);
- carrier = cJSON_GetObjectItem(carrier, "rep");
-
- cJSON* prop = cJSON_GetObjectItem(carrier,"power");
- if (prop)
+ // Get pointer to query
+ int64_t pow;
+ if(OCRepPayloadGetPropInt(input, "power", &pow))
{
- currLightResource->power =prop->valueint;
+ currLightResource->power =pow;
}
- prop = cJSON_GetObjectItem(carrier,"state");
- if (prop)
+ bool state;
+ if(OCRepPayloadGetPropBool(input, "state", &state))
{
- currLightResource->state = prop->valueint;
+ currLightResource->state = state;
}
- cJSON_Delete(putJson);
}
- cJSON_AddStringToObject(json,"href",gResourceUri);
- cJSON_AddItemToObject(json, "rep", format=cJSON_CreateObject());
- cJSON_AddBoolToObject(format, "state", currLightResource->state);
- cJSON_AddNumberToObject(format, "power", currLightResource->power);
-
- jsonResponse = cJSON_Print(json);
- cJSON_Delete(json);
-
- return jsonResponse;
+ return getPayload(gResourceUri, currLightResource->power, currLightResource->state);
}
/*
int powerRequested = atoi(pointerToOperator + 1);
if (Light.power > powerRequested)
{
- OC_LOG_V(INFO, TAG, "Current power: %d. Requested: <%d", Light.power
+ OIC_LOG_V(INFO, TAG, "Current power: %d. Requested: <%d", Light.power
, powerRequested);
return false;
}
*/
OCEntityHandlerResult ValidateQueryParams (OCEntityHandlerRequest *entityHandlerRequest)
{
- OC_LOG_V(INFO, TAG, PCF("Received query %s"), entityHandlerRequest->query);
- OC_LOG(INFO, TAG, PCF("Not processing query"));
+ OIC_LOG_V(INFO, TAG, PCF("Received query %s"), entityHandlerRequest->query);
+ OIC_LOG(INFO, TAG, PCF("Not processing query"));
return OC_EH_OK;
}
OCEntityHandlerResult ProcessGetRequest (OCEntityHandlerRequest *ehRequest,
- char *payload, uint16_t maxPayloadSize)
+ OCRepPayload **payload)
{
OCEntityHandlerResult ehResult;
bool queryPassed = checkIfQueryForPowerPassed(ehRequest->query);
// Empty payload if the query has no match.
if (queryPassed)
{
- char *getResp = constructJsonResponse(ehRequest);
+ OCRepPayload *getResp = constructResponse(ehRequest);
if(!getResp)
{
- OC_LOG(ERROR, TAG, "constructJsonResponse failed");
+ OIC_LOG(ERROR, TAG, "constructResponse failed");
return OC_EH_ERROR;
}
- if (maxPayloadSize > strlen (getResp))
- {
- strncpy(payload, getResp, strlen(getResp));
- ehResult = OC_EH_OK;
- }
- else
- {
- OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small",
- maxPayloadSize);
- ehResult = OC_EH_ERROR;
- }
-
- free(getResp);
+ *payload = getResp;
+ ehResult = OC_EH_OK;
}
else
{
}
OCEntityHandlerResult ProcessPutRequest (OCEntityHandlerRequest *ehRequest,
- char *payload, uint16_t maxPayloadSize)
+ OCRepPayload** payload)
{
OCEntityHandlerResult ehResult;
- char *putResp = constructJsonResponse(ehRequest);
+ OCRepPayload *putResp = constructResponse(ehRequest);
if(!putResp)
{
- OC_LOG(ERROR, TAG, "Failed to construct Json response");
+ OIC_LOG(ERROR, TAG, "Failed to construct Json response");
return OC_EH_ERROR;
}
- if (maxPayloadSize > strlen ((char *)putResp))
- {
- strncpy(payload, putResp, strlen((char *)putResp));
- ehResult = OC_EH_OK;
- }
- else
- {
- OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small",
- maxPayloadSize);
- ehResult = OC_EH_ERROR;
- }
-
- free(putResp);
+ *payload = putResp;
+ ehResult = OC_EH_OK;
return ehResult;
}
OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest,
- OCEntityHandlerResponse *response, char *payload, uint16_t maxPayloadSize)
+ OCEntityHandlerResponse *response, OCRepPayload** payload)
{
OCEntityHandlerResult ehResult = OC_EH_OK;
- char *respPLPost_light = NULL;
- cJSON *json;
- cJSON *format;
+ OCRepPayload *respPLPost_light = nullptr;
/*
* The entity handler determines how to process a POST request.
char newLightUri[URI_MAXSIZE];
snprintf(newLightUri, URI_MAXSIZE, "/a/light/%d", gCurrLightInstance);
- json = cJSON_CreateObject();
- cJSON_AddStringToObject(json,"href",gResourceUri);
- cJSON_AddItemToObject(json, "rep", format=cJSON_CreateObject());
- cJSON_AddStringToObject(format, "createduri", (char *) newLightUri);
+ respPLPost_light = OCRepPayloadCreate();
+ OCRepPayloadSetUri(respPLPost_light, gResourceUri);
+ OCRepPayloadSetPropString(respPLPost_light, "createduri", newLightUri);
if (0 == createLightResource (newLightUri, &gLightInstance[gCurrLightInstance]))
{
- OC_LOG (INFO, TAG, "Created new Light instance\n");
+ OIC_LOG (INFO, TAG, "Created new Light instance\n");
gLightInstance[gCurrLightInstance].state = 0;
gLightInstance[gCurrLightInstance].power = 0;
gCurrLightInstance++;
- respPLPost_light = cJSON_Print(json);
strncpy ((char *)response->resourceUri, newLightUri, MAX_URI_LENGTH);
ehResult = OC_EH_RESOURCE_CREATED;
}
-
- cJSON_Delete(json);
}
else
{
// Update repesentation of /a/light
Light.state = true;
Light.power = 11;
- respPLPost_light = constructJsonResponse(ehRequest);
+ respPLPost_light = constructResponse(ehRequest);
}
}
else
gLightInstance[i].power = 22;
if (i == 0)
{
- respPLPost_light = constructJsonResponse(ehRequest);
+ respPLPost_light = constructResponse(ehRequest);
break;
}
else if (i == 1)
{
- respPLPost_light = constructJsonResponse(ehRequest);
+ respPLPost_light = constructResponse(ehRequest);
}
}
}
}
- if ((respPLPost_light != NULL) && (maxPayloadSize > strlen ((char *)respPLPost_light)))
+ if ((respPLPost_light != NULL))
{
- strncpy(payload, respPLPost_light, strlen((char *)respPLPost_light));
+ *payload = respPLPost_light;
}
else
{
- OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small",
- maxPayloadSize);
+ OIC_LOG(INFO, TAG, "Payload was NULL");
ehResult = OC_EH_ERROR;
}
- free(respPLPost_light);
return ehResult;
}
-OCEntityHandlerResult ProcessDeleteRequest (OCEntityHandlerRequest *ehRequest,
- char *payload, uint16_t maxPayloadSize)
+OCEntityHandlerResult ProcessDeleteRequest (OCEntityHandlerRequest *ehRequest)
{
if(ehRequest == NULL)
{
- OC_LOG(INFO, TAG, "The ehRequest is NULL");
+ OIC_LOG(INFO, TAG, "The ehRequest is NULL");
return OC_EH_ERROR;
}
OCEntityHandlerResult ehResult = OC_EH_OK;
- OC_LOG_V(INFO, TAG, "\n\nExecuting %s for resource %d ", __func__, ehRequest->resource);
+ OIC_LOG_V(INFO, TAG, "\n\nExecuting %s for resource %p ", __func__, ehRequest->resource);
/*
* In the sample below, the application will:
* 2. optionally, app removes observers out of its array 'interestedObservers'
*/
- const char* deleteResponse = NULL;
-
if ((ehRequest != NULL) && (ehRequest->resource == Light.handle))
{
//Step 1: Ask stack to do the work.
if (result == OC_STACK_OK)
{
- OC_LOG (INFO, TAG, "\n\nDelete Resource operation succeeded.");
+ OIC_LOG (INFO, TAG, "\n\nDelete Resource operation succeeded.");
ehResult = OC_EH_OK;
- deleteResponse = responsePayloadDeleteOk;
//Step 2: clear observers who wanted to observe this resource at the app level.
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
}
else if (result == OC_STACK_NO_RESOURCE)
{
- OC_LOG(INFO, TAG, "\n\nThe resource doesn't exist or it might have been deleted.");
- deleteResponse = responsePayloadResourceDoesNotExist;
+ OIC_LOG(INFO, TAG, "\n\nThe resource doesn't exist or it might have been deleted.");
ehResult = OC_EH_RESOURCE_DELETED;
}
else
{
- OC_LOG(INFO, TAG, "\n\nEncountered error from OCDeleteResource().");
- deleteResponse = responsePayloadDeleteNotOK;
+ OIC_LOG(INFO, TAG, "\n\nEncountered error from OCDeleteResource().");
ehResult = OC_EH_ERROR;
}
}
{
//Let's this app not supporting DELETE on some resources so
//consider the DELETE request is received for a non-support resource.
- OC_LOG_V(INFO, TAG, "\n\nThe request is received for a non-support resource.");
- deleteResponse = responsePayloadDeleteResourceNotSupported;
+ OIC_LOG_V(INFO, TAG, "\n\nThe request is received for a non-support resource.");
ehResult = OC_EH_FORBIDDEN;
}
- if (maxPayloadSize > strlen ((char *)deleteResponse))
- {
- strncpy(payload, deleteResponse, strlen((char *)deleteResponse));
- }
- else
- {
- OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small",
- maxPayloadSize);
- ehResult = OC_EH_ERROR;
- }
-
return ehResult;
}
-OCEntityHandlerResult ProcessNonExistingResourceRequest(OCEntityHandlerRequest *ehRequest,
- char *payload, uint16_t maxPayloadSize)
+OCEntityHandlerResult ProcessNonExistingResourceRequest(OCEntityHandlerRequest * /*ehRequest*/)
{
- OC_LOG_V(INFO, TAG, "\n\nExecuting %s ", __func__);
-
- const char* response = NULL;
- response = responsePayloadResourceDoesNotExist;
-
- if ( (ehRequest != NULL) &&
- (maxPayloadSize > strlen ((char *)response)) )
- {
- strncpy((char *)payload, response, strlen((char *)response));
- }
- else
- {
- OC_LOG_V (ERROR, TAG, "Response buffer: %d bytes is too small",
- maxPayloadSize);
- }
+ OIC_LOG_V(INFO, TAG, "\n\nExecuting %s ", __func__);
return OC_EH_RESOURCE_NOT_FOUND;
}
void ProcessObserveRegister (OCEntityHandlerRequest *ehRequest)
{
- OC_LOG_V (INFO, TAG, "Received observation registration request with observation Id %d",
+ OIC_LOG_V (INFO, TAG, "Received observation registration request with observation Id %d",
ehRequest->obsInfo.obsId);
+
+ if (!observeThreadStarted)
+ {
+ pthread_create (&threadId_observe, NULL, ChangeLightRepresentation, (void *)NULL);
+ observeThreadStarted = 1;
+ }
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
{
if (interestedObservers[i].valid == false)
{
bool clientStillObserving = false;
- OC_LOG_V (INFO, TAG, "Received observation deregistration request for observation Id %d",
+ OIC_LOG_V (INFO, TAG, "Received observation deregistration request for observation Id %d",
ehRequest->obsInfo.obsId);
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
{
OCEntityHandlerResult
OCDeviceEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest, char* uri)
+ OCEntityHandlerRequest *entityHandlerRequest,
+ char* uri,
+ void* /*callbackParam*/)
{
- OC_LOG_V (INFO, TAG, "Inside device default entity handler - flags: 0x%x, uri: %s", flag, uri);
+ OIC_LOG_V (INFO, TAG, "Inside device default entity handler - flags: 0x%x, uri: %s", flag, uri);
OCEntityHandlerResult ehResult = OC_EH_OK;
OCEntityHandlerResponse response;
- char payload[MAX_RESPONSE_LENGTH] = {0};
// Validate pointer
if (!entityHandlerRequest)
{
- OC_LOG (ERROR, TAG, "Invalid request pointer");
+ OIC_LOG (ERROR, TAG, "Invalid request pointer");
return OC_EH_ERROR;
}
// Initialize certain response fields
memset(response.sendVendorSpecificHeaderOptions, 0,
sizeof response.sendVendorSpecificHeaderOptions);
memset(response.resourceUri, 0, sizeof response.resourceUri);
+ OCRepPayload* payload = nullptr;
if (flag & OC_REQUEST_FLAG)
{
- OC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
+ OIC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
if (entityHandlerRequest->resource == NULL)
{
- OC_LOG (INFO, TAG, "Received request from client to a non-existing resource");
- ehResult = ProcessNonExistingResourceRequest(entityHandlerRequest,
- payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received request from client to a non-existing resource");
+ ehResult = ProcessNonExistingResourceRequest(entityHandlerRequest);
}
else if (OC_REST_GET == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
- ehResult = ProcessGetRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_GET from client");
+ ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_PUT == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
- ehResult = ProcessPutRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
+ ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_DELETE == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
- ehResult = ProcessDeleteRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
+ ehResult = ProcessDeleteRequest (entityHandlerRequest);
}
else
{
- OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
+ OIC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
entityHandlerRequest->method);
ehResult = OC_EH_ERROR;
}
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehResult;
- response.payload = payload;
- response.payloadSize = strlen(payload);
+ response.payload = reinterpret_cast<OCPayload*>(payload);
// Indicate that response is NOT in a persistent buffer
response.persistentBufferFlag = 0;
// Send the response
if (OCDoResponse(&response) != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "Error sending response");
+ OIC_LOG(ERROR, TAG, "Error sending response");
ehResult = OC_EH_ERROR;
}
}
}
if (flag & OC_OBSERVE_FLAG)
{
- OC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
+ OIC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
{
- OC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
+ OIC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
}
else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
{
- OC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
+ OIC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
}
}
+ OCPayloadDestroy(response.payload);
return ehResult;
}
OCEntityHandlerResult
-OCNOPEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+OCNOPEntityHandlerCb (OCEntityHandlerFlag /*flag*/,
+ OCEntityHandlerRequest * /*entityHandlerRequest*/,
+ void* /*callbackParam*/)
{
// This is callback is associated with the 2 presence notification
// resources. They are non-operational.
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
- OCEntityHandlerRequest *entityHandlerRequest)
+ OCEntityHandlerRequest *entityHandlerRequest, void* /*callback*/)
{
- OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
+ OIC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OCEntityHandlerResult ehResult = OC_EH_OK;
- OCEntityHandlerResponse response;
- char payload[MAX_RESPONSE_LENGTH] = {0};
+ OCEntityHandlerResponse response = { 0, 0, OC_EH_ERROR, 0, 0, { },{ 0 }, false };
// Validate pointer
if (!entityHandlerRequest)
{
- OC_LOG (ERROR, TAG, "Invalid request pointer");
+ OIC_LOG (ERROR, TAG, "Invalid request pointer");
return OC_EH_ERROR;
}
memset(response.sendVendorSpecificHeaderOptions,
0, sizeof response.sendVendorSpecificHeaderOptions);
memset(response.resourceUri, 0, sizeof response.resourceUri);
+ OCRepPayload* payload = nullptr;
if (flag & OC_REQUEST_FLAG)
{
- OC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
+ OIC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
if (OC_REST_GET == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
- ehResult = ProcessGetRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_GET from client");
+ ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_PUT == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
- ehResult = ProcessPutRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
+ ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_POST == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_POST from client");
- ehResult = ProcessPostRequest (entityHandlerRequest, &response, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_POST from client");
+ ehResult = ProcessPostRequest (entityHandlerRequest, &response, &payload);
}
else if (OC_REST_DELETE == entityHandlerRequest->method)
{
- OC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
- ehResult = ProcessDeleteRequest (entityHandlerRequest, payload, sizeof(payload) - 1);
+ OIC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
+ ehResult = ProcessDeleteRequest (entityHandlerRequest);
}
else
{
- OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
+ OIC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
entityHandlerRequest->method);
ehResult = OC_EH_ERROR;
}
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehResult;
- response.payload = payload;
- response.payloadSize = strlen(payload);
+ response.payload = reinterpret_cast<OCPayload*>(payload);
// Indicate that response is NOT in a persistent buffer
response.persistentBufferFlag = 0;
if(entityHandlerRequest->rcvdVendorSpecificHeaderOptions &&
entityHandlerRequest->numRcvdVendorSpecificHeaderOptions)
{
- OC_LOG (INFO, TAG, "Received vendor specific options");
+ OIC_LOG (INFO, TAG, "Received vendor specific options");
uint8_t i = 0;
OCHeaderOption * rcvdOptions =
entityHandlerRequest->rcvdVendorSpecificHeaderOptions;
{
if(((OCHeaderOption)rcvdOptions[i]).protocolID == OC_COAP_ID)
{
- OC_LOG_V(INFO, TAG, "Received option with OC_COAP_ID and ID %u with",
+ OIC_LOG_V(INFO, TAG, "Received option with OC_COAP_ID and ID %u with",
((OCHeaderOption)rcvdOptions[i]).optionID );
- OC_LOG_BUFFER(INFO, TAG, ((OCHeaderOption)rcvdOptions[i]).optionData,
+ OIC_LOG_BUFFER(INFO, TAG, ((OCHeaderOption)rcvdOptions[i]).optionData,
MAX_HEADER_OPTION_DATA_LENGTH);
}
}
- OCHeaderOption * sendOptions = response.sendVendorSpecificHeaderOptions;
- uint8_t option2[] = {21,22,23,24,25,26,27,28,29,30};
- uint8_t option3[] = {31,32,33,34,35,36,37,38,39,40};
- sendOptions[0].protocolID = OC_COAP_ID;
- sendOptions[0].optionID = 2248;
- memcpy(sendOptions[0].optionData, option2, sizeof(option2));
- sendOptions[0].optionLength = 10;
- sendOptions[1].protocolID = OC_COAP_ID;
- sendOptions[1].optionID = 2600;
- memcpy(sendOptions[1].optionData, option3, sizeof(option3));
- sendOptions[1].optionLength = 10;
+
+ OCHeaderOption* sendOptions = response.sendVendorSpecificHeaderOptions;
+ size_t numOptions = response.numSendVendorSpecificHeaderOptions;
+ // Check if the option header has already existed before adding it in.
+ uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
+ size_t optionDataSize = sizeof(optionData);
+ uint16_t actualDataSize = 0;
+ OCGetHeaderOption(response.sendVendorSpecificHeaderOptions,
+ response.numSendVendorSpecificHeaderOptions,
+ 2248,
+ optionData,
+ optionDataSize,
+ &actualDataSize);
+ if (actualDataSize == 0)
+ {
+ uint8_t option2[] = {21,22,23,24,25,26,27,28,29,30};
+ uint16_t optionID2 = 2248;
+ size_t optionDataSize2 = sizeof(option2);
+ OCSetHeaderOption(sendOptions,
+ &numOptions,
+ optionID2,
+ option2,
+ optionDataSize2);
+ }
+
+ OCGetHeaderOption(response.sendVendorSpecificHeaderOptions,
+ response.numSendVendorSpecificHeaderOptions,
+ 2600,
+ optionData,
+ optionDataSize,
+ &actualDataSize);
+ if (actualDataSize == 0)
+ {
+ uint8_t option3[] = {31,32,33,34,35,36,37,38,39,40};
+ uint16_t optionID3 = 2600;
+ size_t optionDataSize3 = sizeof(option3);
+ OCSetHeaderOption(sendOptions,
+ &numOptions,
+ optionID3,
+ option3,
+ optionDataSize3);
+ }
response.numSendVendorSpecificHeaderOptions = 2;
}
// Send the response
if (OCDoResponse(&response) != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "Error sending response");
+ OIC_LOG(ERROR, TAG, "Error sending response");
ehResult = OC_EH_ERROR;
}
}
}
if (flag & OC_OBSERVE_FLAG)
{
- OC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
+ OIC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
{
- OC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
+ OIC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
ProcessObserveRegister (entityHandlerRequest);
}
else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
{
- OC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
+ OIC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
ProcessObserveDeregister (entityHandlerRequest);
}
}
+ OCPayloadDestroy(response.payload);
return ehResult;
}
if (signum == SIGINT)
{
gQuitFlag = 1;
+#ifdef WITH_PROCESS_EVENT
+ if (processEvent)
+ oc_event_signal(processEvent);
+#endif
}
}
OCStackResult result = OC_STACK_ERROR;
uint8_t j = 0;
- uint8_t numNotifies = (SAMPLE_MAX_NUM_OBSERVATIONS)/2;
- OCObservationId obsNotify[numNotifies];
+ OCObservationId obsNotify[(SAMPLE_MAX_NUM_OBSERVATIONS)/2];
while (!gQuitFlag)
{
Light.power += 5;
if (gLightUnderObservation)
{
- OC_LOG_V(INFO, TAG, " =====> Notifying stack of new power level %d\n", Light.power);
+ OIC_LOG_V(INFO, TAG, " =====> Notifying stack of new power level %d\n", Light.power);
if (gObserveNotifyType == 1)
{
// Notify list of observers. Alternate observers on the list will be notified.
}
}
- cJSON *json = cJSON_CreateObject();
- cJSON *format;
- cJSON_AddStringToObject(json,"href",gResourceUri);
- cJSON_AddItemToObject(json, "rep", format=cJSON_CreateObject());
- cJSON_AddBoolToObject(format, "state", Light.state);
- cJSON_AddNumberToObject(format, "power", Light.power);
-
- char * obsResp = cJSON_Print(json);
- cJSON_Delete(json);
+ OCRepPayload* payload = getPayload(gResourceUri, Light.power, Light.state);
result = OCNotifyListOfObservers (Light.handle, obsNotify, j,
- obsResp, OC_NA_QOS);
- free(obsResp);
+ payload, OC_NA_QOS);
+ OCRepPayloadDestroy(payload);
}
else if (gObserveNotifyType == 0)
{
result = OCNotifyAllObservers (Light.handle, OC_NA_QOS);
if (OC_STACK_NO_OBSERVERS == result)
{
- OC_LOG (INFO, TAG,
+ OIC_LOG (INFO, TAG,
"=======> No more observers exist, stop sending observations");
gLightUnderObservation = 0;
}
}
else
{
- OC_LOG (ERROR, TAG, "Incorrect notification type selected");
+ OIC_LOG (ERROR, TAG, "Incorrect notification type selected");
}
}
-#ifdef WITH_PRESENCE
- if(stopPresenceCount > 0)
- {
- OC_LOG_V(INFO, TAG, "================ Counting down to stop presence %d", stopPresenceCount);
- }
- if(!stopPresenceCount--)
- {
- OC_LOG(INFO, TAG, "================ stopping presence");
- OCStopPresence();
- }
-#endif
}
return NULL;
}
#ifdef WITH_PRESENCE
void *presenceNotificationGenerator(void *param)
{
- sleep(10);
+ uint8_t secondsBeforePresence = 10;
+ OIC_LOG_V(INFO, TAG, "Will send out presence in %u seconds", secondsBeforePresence);
+ sleep(secondsBeforePresence);
(void)param;
OCDoHandle presenceNotificationHandles[numPresenceResources];
OCStackResult res = OC_STACK_OK;
OC_RSRVD_INTERFACE_DEFAULT,
presenceNotificationUris.at(i).c_str(),
OCNOPEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
}
if(res != OC_STACK_OK)
{
- OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to create resource "
+ OIC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to create resource "
"%s with result %s.", presenceNotificationResources.at(i).c_str(),
getResult(res));
break;
}
- OC_LOG_V(INFO, TAG, PCF("Created %s for presence notification"),
+ OIC_LOG_V(INFO, TAG, PCF("Created %s for presence notification"),
presenceNotificationUris[i].c_str());
}
sleep(5);
}
if(res != OC_STACK_OK)
{
- OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to delete "\
+ OIC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to delete "\
"resource %s.", presenceNotificationResources.at(i).c_str());
break;
}
- OC_LOG_V(INFO, TAG, PCF("Deleted %s for presence notification"),
+ OIC_LOG_V(INFO, TAG, PCF("Deleted %s for presence notification"),
presenceNotificationUris[i].c_str());
}
+
+ OIC_LOG(INFO, TAG, "================ stopping presence");
+ OCStopPresence();
+
return NULL;
}
#endif
{
if (!uri)
{
- OC_LOG(ERROR, TAG, "Resource URI cannot be NULL");
+ OIC_LOG(ERROR, TAG, "Resource URI cannot be NULL");
return -1;
}
"oc.mi.def",
uri,
OCEntityHandlerCb,
+ NULL,
OC_DISCOVERABLE|OC_OBSERVABLE);
- OC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
+ OIC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
return 0;
}
void DeleteDeviceInfo()
{
free (deviceInfo.deviceName);
+ free (deviceInfo.specVersion);
+ OCFreeOCStringLL (deviceInfo.dataModelVersions);
}
bool DuplicateString(char** targetString, const char* sourceString)
bool success = true;
- if(manufacturerName != NULL && (strlen(manufacturerName) > MAX_MANUFACTURER_NAME_LENGTH))
+ if(manufacturerName != NULL && (strlen(manufacturerName) > MAX_PLATFORM_NAME_LENGTH))
{
return OC_STACK_INVALID_PARAM;
}
- if(manufacturerUrl != NULL && (strlen(manufacturerUrl) > MAX_MANUFACTURER_URL_LENGTH))
+ if(manufacturerUrl != NULL && (strlen(manufacturerUrl) > MAX_PLATFORM_URL_LENGTH))
{
return OC_STACK_INVALID_PARAM;
}
return OC_STACK_ERROR;
}
-OCStackResult SetDeviceInfo(const char* deviceName)
+OCStackResult SetDeviceInfo(const char* deviceName, const char* specVersion, const char* dataModelVersions)
{
if(!DuplicateString(&deviceInfo.deviceName, deviceName))
{
return OC_STACK_ERROR;
}
+ if(!DuplicateString(&deviceInfo.specVersion, specVersion))
+ {
+ return OC_STACK_ERROR;
+ }
+ OCFreeOCStringLL(deviceInfo.dataModelVersions);
+ deviceInfo.dataModelVersions = OCCreateOCStringLL(dataModelVersions);
+ if (!deviceInfo.dataModelVersions)
+ {
+ return OC_STACK_ERROR;
+ }
return OC_STACK_OK;
}
static void PrintUsage()
{
- OC_LOG(INFO, TAG, "Usage : ocserver -o <0|1>");
- OC_LOG(INFO, TAG, "-o 0 : Notify all observers");
- OC_LOG(INFO, TAG, "-o 1 : Notify list of observers");
+ OIC_LOG(INFO, TAG, "Usage : ocserver -o <0|1>");
+ OIC_LOG(INFO, TAG, "-o 0 : Notify all observers");
+ OIC_LOG(INFO, TAG, "-o 1 : Notify list of observers");
}
+#ifdef RA_ADAPTER
+static void jidbound(char *jid)
+{
+ OIC_LOG_V(INFO, TAG, "\n\n Bound JID: %s\n\n", jid);
+}
+#endif
+
int main(int argc, char* argv[])
{
- pthread_t threadId;
- pthread_t threadId_presence;
- int opt;
- while ((opt = getopt(argc, argv, "o:")) != -1)
+#ifdef RA_ADAPTER
+ char host[] = "localhost";
+ char user[] = "test1";
+ char pass[] = "intel123";
+ char empstr[] = "";
+ OCRAInfo_t rainfo = {};
+
+ rainfo.hostname = host;
+ rainfo.port = 5222;
+ rainfo.xmpp_domain = host;
+ rainfo.username = user;
+ rainfo.password = pass;
+ rainfo.resource = empstr;
+ rainfo.user_jid = empstr;
+ rainfo.jidbound = jidbound;
+#endif
+
+ int opt = 0;
+ while ((opt = getopt(argc, argv, "o:s:p:d:u:w:r:j:")) != -1)
{
switch(opt)
{
case 'o':
gObserveNotifyType = atoi(optarg);
break;
+#ifdef RA_ADAPTER
+ case 's':
+ rainfo.hostname = optarg;
+ break;
+ case 'p':
+ rainfo.port = atoi(optarg);
+ break;
+ case 'd':
+ rainfo.xmpp_domain = optarg;
+ break;
+ case 'u':
+ rainfo.username = optarg;
+ break;
+ case 'w':
+ rainfo.password = optarg;
+ break;
+ case 'j':
+ rainfo.user_jid = optarg;
+ break;
+ case 'r':
+ rainfo.resource = optarg;
+ break;
+#endif
default:
PrintUsage();
return -1;
return -1;
}
- OC_LOG(DEBUG, TAG, "OCServer is starting...");
+#ifdef RA_ADAPTER
+ OCSetRAInfo(&rainfo);
+#endif
+
+ OIC_LOG(DEBUG, TAG, "OCServer is starting...");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "OCStack init error");
+ OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
#ifdef WITH_PRESENCE
if (OCStartPresence(0) != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "OCStack presence/discovery error");
+ OIC_LOG(ERROR, TAG, "OCStack presence/discovery error");
return 0;
}
#endif
- OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb);
+ OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb, NULL);
OCStackResult registrationResult =
- SetPlatformInfo(platformID, manufacturerName, manufacturerUrl, modelNumber,
+ SetPlatformInfo(platformID, manufacturerName, manufacturerLink, modelNumber,
dateOfManufacture, platformVersion, operatingSystemVersion, hardwareVersion,
- firmwareVersion, supportUrl, systemTime);
+ firmwareVersion, supportLink, systemTime);
if (registrationResult != OC_STACK_OK)
{
- OC_LOG(INFO, TAG, "Platform info setting failed locally!");
+ OIC_LOG(INFO, TAG, "Platform info setting failed locally!");
exit (EXIT_FAILURE);
}
if (registrationResult != OC_STACK_OK)
{
- OC_LOG(INFO, TAG, "Platform Registration failed!");
+ OIC_LOG(INFO, TAG, "Platform Registration failed!");
exit (EXIT_FAILURE);
}
- registrationResult = SetDeviceInfo(deviceName);
+ registrationResult = SetDeviceInfo(deviceName, specVersion, dataModelVersions);
if (registrationResult != OC_STACK_OK)
{
- OC_LOG(INFO, TAG, "Device info setting failed locally!");
+ OIC_LOG(INFO, TAG, "Device info setting failed locally!");
exit (EXIT_FAILURE);
}
+ OCResourcePayloadAddStringLL(&deviceInfo.types, "oic.d.tv");
+
registrationResult = OCSetDeviceInfo(deviceInfo);
if (registrationResult != OC_STACK_OK)
{
- OC_LOG(INFO, TAG, "Device Registration failed!");
+ OIC_LOG(INFO, TAG, "Device Registration failed!");
+ exit (EXIT_FAILURE);
+ }
+#ifdef WITH_PROCESS_EVENT
+ processEvent = oc_event_new();
+ if (!processEvent)
+ {
+ OIC_LOG(INFO, TAG, "oc_event_new failed!");
exit (EXIT_FAILURE);
}
+ OCRegisterProcessEvent(processEvent);
+#endif
+
/*
* Declare and create the example resource: Light
*/
interestedObservers[i].valid = false;
}
- /*
- * Create a thread for changing the representation of the Light
- */
- pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)NULL);
/*
* Create a thread for generating changes that cause presence notifications
#endif
// Break from loop with Ctrl-C
- OC_LOG(INFO, TAG, "Entering ocserver main loop...");
+ OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
DeletePlatformInfo();
DeleteDeviceInfo();
while (!gQuitFlag)
{
+#ifdef WITH_PROCESS_EVENT
+ uint32_t nextEventTime;
+ if (OCProcessEvent(&nextEventTime) != OC_STACK_OK)
+ {
+ OIC_LOG(ERROR, TAG, "OCStack process error");
+ break;
+ }
+ oc_event_wait_for(processEvent, nextEventTime);
+#else
if (OCProcess() != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "OCStack process error");
+ OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
+#endif
+ }
- sleep(2);
+ if (observeThreadStarted)
+ {
+#ifdef HAVE_PTHREAD_H
+ pthread_cancel(threadId_observe);
+ pthread_join(threadId_observe, NULL);
+#endif
}
- /*
- * Cancel the Light thread and wait for it to terminate
- */
- pthread_cancel(threadId);
- pthread_join(threadId, NULL);
+#ifdef HAVE_PTHREAD_H
pthread_cancel(threadId_presence);
pthread_join(threadId_presence, NULL);
+#endif
+
+ OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
- OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
+#ifdef WITH_PROCESS_EVENT
+ if (processEvent)
+ {
+ oc_event_free(processEvent);
+ processEvent = NULL;
+ }
+#endif
if (OCStop() != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "OCStack process error");
+ OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
projects / platform / upstream / iotivity.git / blobdiff