void notify_result_of_reset(things_resource_s *target_resource, bool result)
{
THINGS_LOG_D(TAG, THINGS_FUNC_ENTRY);
OCEntityHandlerResult eh_result = OC_EH_ERROR;
if (target_resource == NULL) {
THINGS_LOG_D(TAG, "Not exist remote-client.");
return;
}
if (result == true) { // reset Success.
OCRepPayload *rep_payload = target_resource->things_get_rep_payload(target_resource);
eh_result = send_response(target_resource->request_handle, // reqInfo->reqHandle,
target_resource->resource_handle, // reqInfo->resHandle,
target_resource->error, target_resource->uri, rep_payload);
OCPayloadDestroy((OCPayload *) rep_payload);
rep_payload = NULL;
} else {
THINGS_LOG_E(TAG, "Handing Request Failed, Sending ERROR Response");
send_response(target_resource->request_handle, target_resource->resource_handle, eh_result, target_resource->uri, NULL);
}
things_release_resource_inst(target_resource);
THINGS_LOG_D(TAG, THINGS_FUNC_EXIT);
}
int InitObserveRequest(OCClientResponse * clientResponse)
{
OCStackResult ret;
OCCallbackData cbData;
OCDoHandle handle;
std::ostringstream obsReg;
obsReg << getQueryStrForGetPut();
cbData.cb = getReqCB;
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
cbData.cd = NULL;
OIC_LOG_V(INFO, TAG, "OBSERVE payload from client =");
OCPayload* payload = putPayload();
OIC_LOG_PAYLOAD(INFO, payload);
OCPayloadDestroy(payload);
ret = OCDoResource(&handle, OC_REST_OBSERVE, obsReg.str().c_str(),
&clientResponse->devAddr, 0, ConnType,
OC_LOW_QOS, &cbData, NULL, 0);
if (ret != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack resource error");
}
else
{
gObserveDoHandle = handle;
}
return ret;
}
OCStackResult InvokeOCDoResource(std::ostringstream &query,
OCMethod method,
const OCDevAddr *dest,
OCQualityOfService qos,
OCClientResponseHandler cb,
OCHeaderOption * options, uint8_t numOptions)
{
OCStackResult ret;
OCCallbackData cbData;
cbData.cb = cb;
cbData.context = NULL;
cbData.cd = NULL;
OCPayload* payload = (method == OC_REST_PUT || method == OC_REST_POST) ? putPayload() : NULL;
ret = OCDoRequest(NULL, method, query.str().c_str(), dest,
payload, ocConnType, qos, &cbData, options, numOptions);
OCPayloadDestroy(payload);
if (ret != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCDoResource returns error %d with method %d", ret, method);
}
return ret;
}
int InitPutRequest(OCClientResponse * clientResponse)
{
OCStackResult ret;
OCCallbackData cbData;
//* Make a PUT query*/
std::ostringstream getQuery;
getQuery << "coap://" << clientResponse->devAddr.addr << ":" <<
clientResponse->devAddr.port <<
"/a/room" << queryInterface[TestType].text;
cbData.cb = putReqCB;
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
cbData.cd = NULL;
OIC_LOG_V(INFO, TAG, "PUT payload from client = ");
OCPayload* payload = putPayload();
OIC_LOG_PAYLOAD(INFO, payload);
OCPayloadDestroy(payload);
ret = OCDoResource(NULL, OC_REST_PUT, getQuery.str().c_str(),
&clientResponse->devAddr, putPayload(), ConnType,
OC_LOW_QOS, &cbData, NULL, 0);
if (ret != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack resource error");
}
return ret;
}
TEST_F(CborByteStringTest, ByteStringArrayConvertParseTest )
{
OCRepPayloadSetUri(payload_in, "/a/quake_sensor");
OCRepPayloadSetPropInt(payload_in, "scale", 4);
size_t dimensions_in[MAX_REP_ARRAY_DEPTH] = { 3, 0, 0};
uint8_t binval1[] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19};
uint8_t binval2[] = {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29};
uint8_t binval3[] = {0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39};
OCByteString quakedata_in[3] = {{binval1, sizeof(binval1)},
{binval2, sizeof(binval2)},
{binval3, sizeof(binval3)}};
EXPECT_EQ(true, OCRepPayloadSetByteStringArray(payload_in, "quakedata",
quakedata_in, dimensions_in));
// Convert OCPayload to CBOR
uint8_t *payload_cbor = NULL;
size_t payload_cbor_size = 0;
EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*) payload_in, &payload_cbor, &payload_cbor_size));
#ifdef CBOR_BIN_STRING_DEBUG
FILE *fp = fopen("binstringarr.cbor", "wb+");
if (fp)
{
fwrite(payload_cbor, 1, payload_cbor_size, fp);
fclose(fp);
}
#endif //CBOR_BIN_STRING_DEBUG
// Parse CBOR back to OCPayload
OCPayload* payload_out = NULL;
EXPECT_EQ(OC_STACK_OK, OCParsePayload(&payload_out, PAYLOAD_TYPE_REPRESENTATION,
payload_cbor, payload_cbor_size));
OCByteString* quakedata_out = NULL;
size_t dimensions_out[MAX_REP_ARRAY_DEPTH] = {0};
ASSERT_EQ(true, OCRepPayloadGetByteStringArray((OCRepPayload*)payload_out, "quakedata",
&quakedata_out, dimensions_out));
for(size_t i = 0; i < dimensions_in[0]; i++)
{
EXPECT_EQ(quakedata_in[i].len, quakedata_out[i].len);
EXPECT_EQ(0, memcmp(quakedata_in[i].bytes, quakedata_out[i].bytes, quakedata_in[i].len));
}
// Cleanup
OICFree(payload_cbor);
for(size_t i = 0; i < dimensions_out[0]; i++)
{
OICFree(quakedata_out[i].bytes);
}
OICFree(quakedata_out);
OCPayloadDestroy((OCPayload*)payload_out);
}
/**
* Delete a server response from the server response list
*
* @param serverResponse - server response to delete
*/
static void DeleteServerResponse(OCServerResponse * serverResponse)
{
if(serverResponse)
{
LL_DELETE(serverResponseList, serverResponse);
OCPayloadDestroy(serverResponse->payload);
OICFree(serverResponse);
OIC_LOG(INFO, TAG, "Server Response Removed!!");
}
}
//Cred DELETE request
TEST(CredEntityHandlerTest, CredEntityHandlerDeleteTest)
{
OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
static OCPersistentStorage ps = OCPersistentStorage();
const OicSecCred_t* subjectCred1 = NULL;
const OicSecCred_t* subjectCred2 = NULL;
char *jsonStr = NULL;
OCEntityHandlerResult ehRet = OC_EH_ERROR;
char query[] = "sub=c3ViamVjdDE=";
SetPersistentHandler(&ps, true);
OicSecCred_t *cred = getCredList();
VERIFY_NON_NULL(TAG, cred, ERROR);
jsonStr = BinToCredJSON(cred);
VERIFY_NON_NULL(TAG, jsonStr, ERROR);
// Create Entity Handler POST request payload
ehReq.method = OC_REST_POST;
ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq);
EXPECT_TRUE(OC_EH_ERROR == ehRet);
// Verify if SRM contains Credential for the subject
subjectCred1 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL != subjectCred1);
// Create Entity Handler DELETE request
ehReq.method = OC_REST_DELETE;
ehReq.query = (char*)OICMalloc(strlen(query)+1);
VERIFY_NON_NULL(TAG, ehReq.query, ERROR);
OICStrcpy(ehReq.query, strlen(query)+1, query);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq);
EXPECT_TRUE(OC_EH_ERROR == ehRet);
// Verify if SRM has deleted ACE for the subject
subjectCred2 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL == subjectCred2);
exit:
// Perform cleanup
OICFree(ehReq.query);
OICFree(jsonStr);
OCPayloadDestroy(ehReq.payload);
if(NULL != cred)
{
DeInitCredResource();
DeleteCredList(cred);
}
}
void things_release_representation_inst(things_representation_s *rep)
{
if (rep != NULL) {
if (rep->children_payload != NULL) {
THINGS_LOG_D(TAG, "Representation has %lld Children.", rep->num_children);
for (int64_t iter = 0; iter < rep->num_children; iter++) {
if ((rep->children_payload[iter]) != NULL) {
THINGS_LOG_D(TAG, "\t RELEASED.");
OCPayloadDestroy((OCPayload *)(rep->children_payload[iter]));
rep->children_payload[iter] = NULL;
}
}
}
if (rep->payload != NULL) {
OCPayloadDestroy((OCPayload *)(rep->payload));
rep->payload = NULL;
}
things_free(rep);
rep = NULL;
}
}
int main(int argc, char* argv[])
{
OC_LOG(DEBUG, TAG, "OCServer is starting...");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
// Declare and create the example resource: LED
createLEDResource(gResourceUri, &LED, false, 42);
// Initialize slow response alarm
signal(SIGALRM, AlarmHandler);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
// Free requests
if (!gRequestList.empty())
{
for (auto iter = gRequestList.begin(); iter != gRequestList.end(); ++iter)
{
OICFree((*iter)->query);
OCPayloadDestroy((*iter)->payload);
OICFree(*iter);
}
gRequestList.clear();
}
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
OCEntityHandlerResult handle_message(things_resource_s *target_resource)
{
OCEntityHandlerResult eh_result = OC_EH_ERROR;
if (NULL == target_resource) {
THINGS_LOG_D(TAG, "Request Item is NULL.");
return OC_EH_ERROR;
}
THINGS_LOG_D(TAG, "Request Handle : %x, Resource Handle : %x", target_resource->request_handle, target_resource->resource_handle);
if (target_resource->req_type == OC_REST_GET) {
THINGS_LOG_V(TAG, "\t\tReq. : GET on %s", target_resource->uri);
THINGS_LOG_V(TAG, "\t\tQuery: %s", target_resource->query);
eh_result = process_get_request(target_resource);
} else if (target_resource->req_type == OC_REST_POST) {
THINGS_LOG_V(TAG, "\t\tReq. : POST on %s", target_resource->uri);
THINGS_LOG_V(TAG, "\t\tQuery: %s", target_resource->query);
eh_result = process_post_request(&target_resource);
} else {
THINGS_LOG_E(TAG, " Invalid Request Received : %d", target_resource->req_type);
}
THINGS_LOG_D(TAG, " @@@@@ target_resource ->size : %d", target_resource->size);
if (is_can_not_response_case(target_resource, target_resource->req_type, eh_result) == false) {
if (eh_result != OC_EH_OK && eh_result != OC_EH_SLOW) {
THINGS_LOG_E(TAG, "Handing Request Failed, Sending ERROR Response");
send_response(target_resource->request_handle, target_resource->resource_handle, eh_result, target_resource->uri, NULL);
eh_result = OC_EH_OK;
} else {
OCRepPayload *rep_payload = target_resource->things_get_rep_payload(target_resource);
eh_result = send_response(target_resource->request_handle, // reqInfo->reqHandle,
target_resource->resource_handle, // reqInfo->resHandle,
target_resource->error, target_resource->uri, rep_payload);
OCPayloadDestroy((OCPayload *) rep_payload);
rep_payload = NULL;
}
}
// Need to design How to release memory allocated for the things_resource_s list.
things_release_resource_inst(target_resource);
return eh_result;
}
OCStackResult InvokeOCDoResource(std::ostringstream &query,
OCMethod method,
OCQualityOfService qos,
OCClientResponseHandler cb,
OCHeaderOption * options,
uint8_t numOptions)
{
OCCallbackData cbData;
OCDoHandle handle;
cbData.cb = cb;
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
cbData.cd = NULL;
OCPayload* payload = (method == OC_REST_PUT) ? putPayload() : NULL;
OCStackResult ret = OCDoRequest(&handle,
method,
query.str().c_str(),
&responseAddr,
payload,
CT_ADAPTER_REMOTE_ACCESS,
qos,
&cbData,
options,
numOptions);
OCPayloadDestroy(payload);
if (ret != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCDoResource returns error %d with method %d", ret, method);
}
else if (method == OC_REST_OBSERVE || method == OC_REST_OBSERVE_ALL)
{
gObserveDoHandle = handle;
}
#ifdef WITH_PRESENCE
else if (method == OC_REST_PRESENCE)
{
gPresenceHandle = handle;
}
#endif
return ret;
}
TEST_F(CborByteStringTest, ByteStringConvertParseTest)
{
OCRepPayloadSetUri(payload_in, "/a/quake_sensor");
OCRepPayloadSetPropInt(payload_in, "scale", 4);
uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x0, 0xA, 0xB, 0xC,
0xD, 0xE, 0xF};
OCByteString quakedata_in = { binval, sizeof(binval)};
// Set ByteString in Payload
EXPECT_EQ(true, OCRepPayloadSetPropByteString(payload_in, "quakedata", quakedata_in));
// Convert OCPayload to CBOR
uint8_t *payload_cbor = NULL;
size_t payload_cbor_size = 0;
EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*) payload_in, &payload_cbor, &payload_cbor_size));
#ifdef CBOR_BIN_STRING_DEBUG
FILE *fp = fopen("binstring.cbor", "wb+");
if (fp)
{
fwrite(payload_cbor, 1, payload_cbor_size, fp);
fclose(fp);
}
#endif //CBOR_BIN_STRING_DEBUG
// Parse CBOR back to OCPayload
OCPayload* payload_out = NULL;
EXPECT_EQ(OC_STACK_OK, OCParsePayload(&payload_out, PAYLOAD_TYPE_REPRESENTATION,
payload_cbor, payload_cbor_size));
OCByteString quakedata_out = {NULL, 0};
ASSERT_EQ(true, OCRepPayloadGetPropByteString((OCRepPayload*)payload_out, "quakedata", &quakedata_out));
// Compare input and output data
EXPECT_EQ(quakedata_in.len, quakedata_out.len);
EXPECT_EQ(0, memcmp(quakedata_in.bytes, quakedata_out.bytes, quakedata_in.len));
// Cleanup
OICFree(payload_cbor);
OICFree(quakedata_out.bytes);
OCPayloadDestroy((OCPayload*)payload_out);
}
// SIGINT alarm handler: alarm set by entity handler. Does
// slow response when fired
void AlarmHandler(int sig)
{
if (sig == SIGALRM)
{
OC_LOG (INFO, TAG, "Server starting slow response");
if (gRequestList.empty())
{
OC_LOG (INFO, TAG, "No requests to service");
return;
}
// Get the request from the list
OCEntityHandlerRequest *entityHandlerRequest = gRequestList.front();
gRequestList.pop_front();
if (entityHandlerRequest->method == OC_REST_GET)
{
OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
ProcessGetPutRequest (entityHandlerRequest);
}
else if (entityHandlerRequest->method == OC_REST_PUT)
{
OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
ProcessGetPutRequest (entityHandlerRequest);
}
else
{
OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
entityHandlerRequest->method);
}
// Free the request
OICFree(entityHandlerRequest->query);
OCPayloadDestroy(entityHandlerRequest->payload);
OICFree(entityHandlerRequest);
// If there are more requests in list, re-arm the alarm signal
if (gRequestList.empty())
{
alarm(SLOW_RESPONSE_DELAY_SEC);
}
}
}
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
OCEntityHandlerRequest *entityHandlerRequest,
void* callbackParam)
{
OIC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
(void)callbackParam;
OCEntityHandlerResult ehResult = OC_EH_ERROR;
OCEntityHandlerResponse response;
memset(&response, 0, sizeof(response));
// Validate pointer
if (!entityHandlerRequest)
{
OIC_LOG (ERROR, TAG, "Invalid request pointer");
return OC_EH_ERROR;
}
OCRepPayload* payload = NULL;
if (flag & OC_REQUEST_FLAG)
{
OIC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
if (entityHandlerRequest)
{
if (OC_REST_GET == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_GET from client");
ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_PUT == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_POST == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_POST from client");
ehResult = ProcessPostRequest (entityHandlerRequest, &response, &payload);
}
else
{
OIC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
entityHandlerRequest->method);
ehResult = OC_EH_ERROR;
}
if (ehResult == OC_EH_OK && ehResult != OC_EH_FORBIDDEN)
{
// Format the response. Note this requires some info about the request
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehResult;
response.payload = (OCPayload*)(payload);
response.numSendVendorSpecificHeaderOptions = 0;
memset(response.sendVendorSpecificHeaderOptions, 0,
sizeof(response.sendVendorSpecificHeaderOptions));
memset(response.resourceUri, 0, sizeof(response.resourceUri));
// Indicate that response is NOT in a persistent buffer
response.persistentBufferFlag = 0;
// Send the response
if (OCDoResponse(&response) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "Error sending response");
ehResult = OC_EH_ERROR;
}
}
}
}
OCPayloadDestroy(response.payload);
return ehResult;
}
virtual void TearDown() {
OCPayloadDestroy((OCPayload*)payload_in);
}
//Cred DELETE request
TEST(CredResourceTest, CredEntityHandlerDeleteTest)
{
OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
static OCPersistentStorage ps = OCPersistentStorage();
const OicSecCred_t* subjectCred1 = NULL;
const OicSecCred_t* subjectCred2 = NULL;
OCEntityHandlerResult ehRet = OC_EH_ERROR;
char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
SetPersistentHandler(&ps, true);
OicSecCred_t *cred = getCredList();
ASSERT_TRUE(NULL != cred);
uint8_t *payload = NULL;
size_t size = 0;
EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
if (!payload)
{
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != payload);
// Create Entity Handler POST request payload
ehReq.method = OC_REST_POST;
ehReq.payload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
if (!ehReq.payload)
{
OICFree(payload);
DeleteCredList(cred);
}
ASSERT_TRUE( NULL != ehReq.payload);
EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
// Verify if SRM contains Credential for the subject
subjectCred1 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL != subjectCred1);
// Create Entity Handler DELETE request
ehReq.method = OC_REST_DELETE;
ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
if (!ehReq.query)
{
OICFree(payload);
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != ehReq.query);
OICStrcpy(ehReq.query, strlen(query)+1, query);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
EXPECT_EQ(OC_EH_ERROR, ehRet);
// Verify if SRM has deleted ACE for the subject
subjectCred2 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL == subjectCred2);
// Perform cleanup
OICFree(ehReq.query);
OICFree(payload);
DeInitCredResource();
DeleteCredList(cred);
OCPayloadDestroy((OCPayload *)ehReq.payload);
}
static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal)
{
if (!outPayload)
{
return OC_STACK_INVALID_PARAM;
}
bool err = false;
if(cbor_value_is_map(arrayVal))
{
uint64_t seqNum = 0;
uint64_t maxAge = 0;
OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
char* tempStr = NULL;
size_t len = 0;
CborValue curVal;
// Sequence Number
err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal);
err = err || cbor_value_get_uint64(&curVal, &seqNum);
// Max Age
err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal);
err = err || cbor_value_get_uint64(&curVal, &maxAge);
// Trigger
err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal);
err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
trigger = convertTriggerStringToEnum(tempStr);
OICFree(tempStr);
tempStr = NULL;
// Resource type name
err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_RESOURCE_TYPE, &curVal);
if(cbor_value_is_valid(&curVal))
{
err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
}
err = err || cbor_value_advance(arrayVal);
if(!err)
{
*outPayload = (OCPayload*)OCPresencePayloadCreate(seqNum, maxAge, trigger, tempStr);
}
OICFree(tempStr);
if(err)
{
OCPayloadDestroy(*outPayload);
OC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
return OC_STACK_MALFORMED_RESPONSE;
}
if(!*outPayload)
{
return OC_STACK_NO_MEMORY;
}
return OC_STACK_OK;
}
else
{
OC_LOG(ERROR, TAG, "Root presence node was not a map");
return OC_STACK_MALFORMED_RESPONSE;
}
}
OCEntityHandlerResult
OCEntityHandlerCb (OCEntityHandlerFlag flag,
OCEntityHandlerRequest *entityHandlerRequest, void* /*callback*/)
{
OIC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OCEntityHandlerResult ehResult = OC_EH_OK;
OCEntityHandlerResponse response = { 0, 0, OC_EH_ERROR, 0, 0, { },{ 0 }, false };
// Validate pointer
if (!entityHandlerRequest)
{
OIC_LOG (ERROR, TAG, "Invalid request pointer");
return OC_EH_ERROR;
}
// Initialize certain response fields
response.numSendVendorSpecificHeaderOptions = 0;
memset(response.sendVendorSpecificHeaderOptions,
0, sizeof response.sendVendorSpecificHeaderOptions);
memset(response.resourceUri, 0, sizeof response.resourceUri);
OCRepPayload* payload = nullptr;
if (flag & OC_REQUEST_FLAG)
{
OIC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
if (OC_REST_GET == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_GET from client");
ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_PUT == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
}
else if (OC_REST_POST == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_POST from client");
ehResult = ProcessPostRequest (entityHandlerRequest, &response, &payload);
}
else if (OC_REST_DELETE == entityHandlerRequest->method)
{
OIC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
ehResult = ProcessDeleteRequest (entityHandlerRequest);
}
else
{
OIC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
entityHandlerRequest->method);
ehResult = OC_EH_ERROR;
}
// If the result isn't an error or forbidden, send response
if (!((ehResult == OC_EH_ERROR) || (ehResult == OC_EH_FORBIDDEN)))
{
// Format the response. Note this requires some info about the request
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehResult;
response.payload = reinterpret_cast<OCPayload*>(payload);
// Indicate that response is NOT in a persistent buffer
response.persistentBufferFlag = 0;
// Handle vendor specific options
if(entityHandlerRequest->rcvdVendorSpecificHeaderOptions &&
entityHandlerRequest->numRcvdVendorSpecificHeaderOptions)
{
OIC_LOG (INFO, TAG, "Received vendor specific options");
uint8_t i = 0;
OCHeaderOption * rcvdOptions =
entityHandlerRequest->rcvdVendorSpecificHeaderOptions;
for( i = 0; i < entityHandlerRequest->numRcvdVendorSpecificHeaderOptions; i++)
{
if(((OCHeaderOption)rcvdOptions[i]).protocolID == OC_COAP_ID)
{
OIC_LOG_V(INFO, TAG, "Received option with OC_COAP_ID and ID %u with",
((OCHeaderOption)rcvdOptions[i]).optionID );
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;
response.numSendVendorSpecificHeaderOptions = 2;
}
// Send the response
if (OCDoResponse(&response) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "Error sending response");
ehResult = OC_EH_ERROR;
}
}
}
if (flag & OC_OBSERVE_FLAG)
{
OIC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
{
OIC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
ProcessObserveRegister (entityHandlerRequest);
}
else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
{
OIC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
ProcessObserveDeregister (entityHandlerRequest);
}
}
OCPayloadDestroy(response.payload);
return ehResult;
}
/**
* Entity handler callback that fills the resPayload of the entityHandlerRequest.
*/
OCEntityHandlerResult PluginInterfaceEntityHandler(OCEntityHandlerFlag flag,
OCEntityHandlerRequest * entityHandlerRequest,
void* callbackParam)
{
if (!entityHandlerRequest)
{
OIC_LOG (ERROR, TAG, "Invalid request pointer");
return OC_EH_ERROR;
}
OCEntityHandlerResult ehResult = OC_EH_ERROR;
OCStackResult result = OC_STACK_ERROR;
PIPluginBase * plugin = (PIPluginBase *) callbackParam;
OCEntityHandlerResponse * response =
(OCEntityHandlerResponse *) OICCalloc(1, sizeof(*response));
if (!response)
{
return OC_EH_ERROR;
}
OCRepPayload* payload = (OCRepPayload *) entityHandlerRequest->payload;
if (flag & OC_REQUEST_FLAG)
{
if (plugin->processEHRequest)
{
ehResult = plugin->processEHRequest(plugin, entityHandlerRequest, &payload);
}
}
// If the result isn't an error or forbidden, send response
if (!((ehResult == OC_EH_ERROR) || (ehResult == OC_EH_FORBIDDEN)))
{
// Format the response. Note this requires some info about the request
response->requestHandle = entityHandlerRequest->requestHandle;
response->resourceHandle = entityHandlerRequest->resource;
response->ehResult = ehResult;
response->payload = (OCPayload*) payload;
// Indicate that response is NOT in a persistent buffer
response->persistentBufferFlag = 0;
result = OCDoResponse(response);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "Error sending response %u", result);
ehResult = OC_EH_ERROR;
}
}
else
{
OIC_LOG_V(ERROR, TAG, "Error handling request %u", ehResult);
PIResource * piResource = NULL;
result = GetResourceFromHandle(plugin, &piResource, response->resourceHandle);
OIC_LOG_V(ERROR, TAG, "Deleting resource \"%s\" because of failed request.", piResource->uri);
result = DeleteResource(plugin, piResource);
if(result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "Failed to delete resource after failed request.");
ehResult = OC_EH_ERROR;
}
}
OCPayloadDestroy(response->payload);
OICFree(response);
return ehResult;
}
OCStackResult SendAllObserverNotification (OCMethod method, OCResource *resPtr, uint32_t maxAge,
OCQualityOfService qos)
#endif
{
OC_LOG(INFO, TAG, "Entering SendObserverNotification");
if(!resPtr)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult result = OC_STACK_ERROR;
ResourceObserver * resourceObserver = serverObsList;
uint8_t numObs = 0;
OCServerRequest * request = NULL;
OCEntityHandlerRequest ehRequest = {0};
OCEntityHandlerResult ehResult = OC_EH_ERROR;
bool observeErrorFlag = false;
// Find clients that are observing this resource
while (resourceObserver)
{
if (resourceObserver->resource == resPtr)
{
numObs++;
#ifdef WITH_PRESENCE
if(method != OC_REST_PRESENCE)
{
#endif
qos = DetermineObserverQoS(method, resourceObserver, qos);
result = AddServerRequest(&request, 0, 0, 1, OC_REST_GET,
0, resPtr->sequenceNum, qos, resourceObserver->query,
NULL, NULL,
resourceObserver->token, resourceObserver->tokenLength,
resourceObserver->resUri, 0, resourceObserver->acceptFormat,
&resourceObserver->devAddr);
if(request)
{
request->observeResult = OC_STACK_OK;
if(result == OC_STACK_OK)
{
result = FormOCEntityHandlerRequest(
&ehRequest,
(OCRequestHandle) request,
request->method,
&request->devAddr,
(OCResourceHandle) resPtr,
request->query,
PAYLOAD_TYPE_REPRESENTATION,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
request->rcvdVendorSpecificHeaderOptions,
OC_OBSERVE_NO_OPTION,
0);
if(result == OC_STACK_OK)
{
ehResult = resPtr->entityHandler(OC_REQUEST_FLAG, &ehRequest,
resPtr->entityHandlerCallbackParam);
if(ehResult == OC_EH_ERROR)
{
FindAndDeleteServerRequest(request);
}
}
OCPayloadDestroy(ehRequest.payload);
}
}
#ifdef WITH_PRESENCE
}
else
{
OCEntityHandlerResponse ehResponse = {0};
//This is effectively the implementation for the presence entity handler.
OC_LOG(DEBUG, TAG, "This notification is for Presence");
result = AddServerRequest(&request, 0, 0, 1, OC_REST_GET,
0, resPtr->sequenceNum, qos, resourceObserver->query,
NULL, NULL,
resourceObserver->token, resourceObserver->tokenLength,
resourceObserver->resUri, 0, resourceObserver->acceptFormat,
&resourceObserver->devAddr);
if(result == OC_STACK_OK)
{
OCPresencePayload* presenceResBuf = OCPresencePayloadCreate(
resPtr->sequenceNum, maxAge, trigger,
resourceType ? resourceType->resourcetypename : NULL);
if(!presenceResBuf)
{
return OC_STACK_NO_MEMORY;
}
if(result == OC_STACK_OK)
{
ehResponse.ehResult = OC_EH_OK;
ehResponse.payload = (OCPayload*)presenceResBuf;
ehResponse.persistentBufferFlag = 0;
ehResponse.requestHandle = (OCRequestHandle) request;
ehResponse.resourceHandle = (OCResourceHandle) resPtr;
OICStrcpy(ehResponse.resourceUri, sizeof(ehResponse.resourceUri),
resourceObserver->resUri);
result = OCDoResponse(&ehResponse);
}
OCPresencePayloadDestroy(presenceResBuf);
}
}
#endif
// Since we are in a loop, set an error flag to indicate at least one error occurred.
if (result != OC_STACK_OK)
{
observeErrorFlag = true;
}
}
resourceObserver = resourceObserver->next;
}
if (numObs == 0)
{
OC_LOG(INFO, TAG, "Resource has no observers");
result = OC_STACK_NO_OBSERVERS;
}
else if (observeErrorFlag)
{
OC_LOG(ERROR, TAG, "Observer notification error");
result = OC_STACK_ERROR;
}
return result;
}
