static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
{
if (!val)
{
return;
}
if (val->type == OCREP_PROP_STRING)
{
OICFree(val->str);
}
else if (val->type == OCREP_PROP_BYTE_STRING)
{
OICFree(val->ocByteStr.bytes);
}
else if (val->type == OCREP_PROP_OBJECT)
{
OCRepPayloadDestroy(val->obj);
}
else if (val->type == OCREP_PROP_ARRAY)
{
size_t dimTotal = calcDimTotal(val->arr.dimensions);
switch(val->arr.type)
{
case OCREP_PROP_INT:
case OCREP_PROP_DOUBLE:
case OCREP_PROP_BOOL:
// Since this is a union, iArray will
// point to all of the above
OICFree(val->arr.iArray);
break;
case OCREP_PROP_STRING:
for(size_t i = 0; i< dimTotal; ++i)
{
OICFree(val->arr.strArray[i]);
}
OICFree(val->arr.strArray);
break;
case OCREP_PROP_BYTE_STRING:
for (size_t i = 0; i< dimTotal; ++i)
{
OICFree(val->arr.ocByteStrArray[i].bytes);
}
OICFree(val->arr.ocByteStrArray);
break;
case OCREP_PROP_OBJECT: // This case is the temporary fix for string input
for(size_t i = 0; i< dimTotal; ++i)
{
OCRepPayloadDestroy(val->arr.objArray[i]);
}
OICFree(val->arr.objArray);
break;
case OCREP_PROP_NULL:
case OCREP_PROP_ARRAY:
OIC_LOG_V(ERROR, TAG, "FreeRepPayloadValueContents: Illegal type\
inside an array: %d", val->arr.type);
break;
}
}
void OCPayloadDestroy(OCPayload* payload)
{
if(!payload)
{
return;
}
switch(payload->type)
{
case PAYLOAD_TYPE_REPRESENTATION:
OCRepPayloadDestroy((OCRepPayload*)payload);
break;
case PAYLOAD_TYPE_DISCOVERY:
OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
break;
case PAYLOAD_TYPE_DEVICE:
OCDevicePayloadDestroy((OCDevicePayload*)payload);
break;
case PAYLOAD_TYPE_PLATFORM:
OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
break;
case PAYLOAD_TYPE_PRESENCE:
OCPresencePayloadDestroy((OCPresencePayload*)payload);
break;
case PAYLOAD_TYPE_SECURITY:
OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
break;
default:
OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
OICFree(payload);
break;
}
}
OCStackApplicationResult icd_ioty_ocprocess_encap_get_cb(void *ctx, OCDoHandle handle,
OCClientResponse *resp)
{
int ret;
struct icd_encap_get_context *encap_get_ctx;
RETV_IF(NULL == resp, OC_STACK_DELETE_TRANSACTION);
encap_get_ctx = calloc(1, sizeof(struct icd_encap_get_context));
if (NULL == encap_get_ctx) {
ERR("calloc() Fail(%d)", errno);
return OC_STACK_DELETE_TRANSACTION;
}
encap_get_ctx->ret = resp->result;
encap_get_ctx->oic_payload = OCRepPayloadClone((OCRepPayload*)resp->payload);
encap_get_ctx->uri_path = ic_utils_strdup(resp->resourceUri);
memcpy(&encap_get_ctx->dev_addr, &resp->devAddr, sizeof(OCDevAddr));
ret = _ocprocess_worker_start(_worker_encap_get_cb, encap_get_ctx,
_icd_encap_get_context_free);
if (IOTCON_ERROR_NONE != ret) {
ERR("_ocprocess_worker_start() Fail(%d)", ret);
OCRepPayloadDestroy((OCRepPayload*)encap_get_ctx->oic_payload);
_icd_encap_get_context_free(encap_get_ctx);
return OC_STACK_DELETE_TRANSACTION;
}
return OC_STACK_DELETE_TRANSACTION;
}
OCEntityHandlerResult LcdOCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
void *callbackParam)
{
OCEntityHandlerResult ehRet = OC_EH_OK;
OCEntityHandlerResponse response = {0};
OCRepPayload* payload = OCRepPayloadCreate();
if(!payload) {
OC_LOG(ERROR, TAG, ("Failed to allocate Payload"));
return OC_EH_ERROR;
}
if(entityHandlerRequest && (flag & OC_REQUEST_FLAG)) {
OC_LOG (INFO, TAG, ("Flag includes OC_REQUEST_FLAG"));
if(OC_REST_GET == entityHandlerRequest->method) {
OCRepPayloadSetUri(payload, "/grove/lcd");
OCRepPayloadSetPropString(payload, "lcd", (const char *)lcd.str);
} else if(OC_REST_PUT == entityHandlerRequest->method) {
OC_LOG(INFO, TAG, ("PUT request"));
OCRepPayload *rep = (OCRepPayload *)entityHandlerRequest->payload;
OCRepPayloadGetPropString(rep, "lcd", &lcd.str);
OC_LOG_V(INFO, TAG, "LCD string: %s", lcd.str);
lcd_put();
OCRepPayloadSetPropString(payload, "lcd", (const char *)lcd.str);
}
if (ehRet == OC_EH_OK) {
// Format the response. Note this requires some info about the request
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehRet;
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) {
OC_LOG(ERROR, TAG, "Error sending response");
ehRet = OC_EH_ERROR;
}
}
}
if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG)) {
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action) {
OC_LOG (INFO, TAG, ("Received OC_OBSERVE_REGISTER from client"));
gLightUnderObservation = 1;
} else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action) {
OC_LOG (INFO, TAG, ("Received OC_OBSERVE_DEREGISTER from client"));
gLightUnderObservation = 0;
}
}
OCRepPayloadDestroy(payload);
return ehRet;
}
// This is the entity handler for the registered resource.
// This is invoked by OCStack whenever it recevies a request for this resource.
OCEntityHandlerResult SensorOCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
void *callbackParam)
{
OCEntityHandlerResult ehRet = OC_EH_OK;
OCEntityHandlerResponse response = {0};
OCRepPayload* payload = OCRepPayloadCreate();
if(!payload) {
OC_LOG(ERROR, TAG, ("Failed to allocate Payload"));
return OC_EH_ERROR;
}
if(entityHandlerRequest && (flag & OC_REQUEST_FLAG)) {
OC_LOG (INFO, TAG, ("Flag includes OC_REQUEST_FLAG"));
if(OC_REST_GET == entityHandlerRequest->method) {
//sensor_get();
OCRepPayloadSetUri(payload, "/grove/sensor");
OCRepPayloadSetPropDouble(payload, "temperature", sensor.temp);
OCRepPayloadSetPropInt(payload, "light", sensor.light);
OCRepPayloadSetPropInt(payload, "sound", sensor.sound);
} else if(OC_REST_PUT == entityHandlerRequest->method) {
OC_LOG(ERROR, TAG, ("Un-supported request for Sensor: PUT"));
}
if (ehRet == OC_EH_OK) {
// Format the response. Note this requires some info about the request
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehRet;
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) {
OC_LOG(ERROR, TAG, "Error sending response");
ehRet = OC_EH_ERROR;
}
}
}
if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG)) {
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action) {
OC_LOG (INFO, TAG, ("Received OC_OBSERVE_REGISTER from client"));
gLightUnderObservation = 1;
} else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action) {
OC_LOG (INFO, TAG, ("Received OC_OBSERVE_DEREGISTER from client"));
gLightUnderObservation = 0;
}
}
OCRepPayloadDestroy(payload);
return ehRet;
}
OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
void *callbackParam)
{
OCEntityHandlerResult ehResult = OC_EH_OK;
OCEntityHandlerResponse response = { 0, 0, OC_EH_ERROR, 0, 0, { },{ 0 }, false };
OCBaseResourceT *resource = (OCBaseResourceT*) callbackParam;
OCRepPayload* payload = NULL;
// Check the request type
if(entityHandlerRequest && (flag & OC_REQUEST_FLAG))
{
OCRepPayloadDestroy(payload);
ehResult = requestHandler(entityHandlerRequest, resource, &payload);
}
if(ehResult == OC_EH_ERROR)
{
OIC_LOG(ERROR, TAG, "ERROR getting request handler and setting paylaod");
return ehResult;
}
// Send the response
ehResult = responseHandler(&response, entityHandlerRequest, payload, ehResult);
if(ehResult == OC_EH_OK)
{
OIC_LOG(DEBUG, TAG, "Response sent successfully");
}
else
{
OIC_LOG(ERROR, TAG, "ERROR Sending the response");
}
if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
{
OIC_LOG(DEBUG, TAG, "Observer flag");
ehResult = observerHandler(entityHandlerRequest, resource);
}
OCRepPayloadDestroy(payload);
return ehResult;
}
OCRepPayload* icd_payload_representation_from_gvariant(GVariant *var)
{
int ret;
GVariant *child;
OCRepPayload *repr, *cur;
char *uri_path, *resource_iface, *resource_type;
GVariantIter *resource_types, *resource_ifaces, *repr_gvar, *children;
repr = OCRepPayloadCreate();
g_variant_get(var, "(&sasasa{sv}av)", &uri_path, &resource_ifaces, &resource_types,
&repr_gvar, &children);
if (IC_STR_EQUAL != strcmp(IC_STR_NULL, uri_path))
OCRepPayloadSetUri(repr, uri_path);
while (g_variant_iter_loop(resource_ifaces, "s", &resource_iface))
OCRepPayloadAddInterface(repr, resource_iface);
while (g_variant_iter_loop(resource_types, "s", &resource_type))
OCRepPayloadAddResourceType(repr, resource_type);
ret = _icd_state_value_from_gvariant(repr, repr_gvar);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_value_from_gvariant() Fail(%d)", ret);
OCRepPayloadDestroy(repr);
return NULL;
}
cur = repr;
while (g_variant_iter_loop(children, "v", &child)) {
cur->next = icd_payload_representation_from_gvariant(child);
if (NULL == cur->next) {
ERR("icd_payload_representation_from_gvariant() Fail");
OCRepPayloadDestroy(repr);
return NULL;
}
cur = cur->next;
}
return repr;
}
void *ChangeLightRepresentation (void *param)
{
(void)param;
OCStackResult result = OC_STACK_ERROR;
uint8_t j = 0;
uint8_t numNotifies = (SAMPLE_MAX_NUM_OBSERVATIONS)/2;
OCObservationId obsNotify[numNotifies];
while (!gQuitFlag)
{
sleep(3);
Light.power += 5;
if (gLightUnderObservation)
{
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.
j = 0;
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; (i=i+2))
{
if (interestedObservers[i].valid == true)
{
obsNotify[j] = interestedObservers[i].observationId;
j++;
}
}
OCRepPayload* payload = getPayload(gResourceUri, Light.power, Light.state);
result = OCNotifyListOfObservers (Light.handle, obsNotify, j,
payload, OC_NA_QOS);
OCRepPayloadDestroy(payload);
}
else if (gObserveNotifyType == 0)
{
// Notifying all observers
result = OCNotifyAllObservers (Light.handle, OC_NA_QOS);
if (OC_STACK_NO_OBSERVERS == result)
{
OIC_LOG (INFO, TAG,
"=======> No more observers exist, stop sending observations");
gLightUnderObservation = 0;
}
}
else
{
OIC_LOG (ERROR, TAG, "Incorrect notification type selected");
}
}
}
return NULL;
}
OCStackResult BuildResponseRepresentation(const OCResource *resourcePtr,
OCRepPayload** payload)
{
OCRepPayload *tempPayload = OCRepPayloadCreate();
if (!resourcePtr)
{
OCRepPayloadDestroy(tempPayload);
return OC_STACK_INVALID_PARAM;
}
if(!tempPayload)
{
return OC_STACK_NO_MEMORY;
}
OCRepPayloadSetUri(tempPayload, resourcePtr->uri);
OCResourceType *resType = resourcePtr->rsrcType;
while(resType)
{
OCRepPayloadAddResourceType(tempPayload, resType->resourcetypename);
resType = resType->next;
}
OCResourceInterface *resInterface = resourcePtr->rsrcInterface;
while(resInterface)
{
OCRepPayloadAddInterface(tempPayload, resInterface->name);
resInterface = resInterface->next;
}
OCAttribute *resAttrib = resourcePtr->rsrcAttributes;
while(resAttrib)
{
OCRepPayloadSetPropString(tempPayload, resAttrib->attrName,
resAttrib->attrValue);
resAttrib = resAttrib->next;
}
if(!*payload)
{
*payload = tempPayload;
}
else
{
OCRepPayloadAppend(*payload, tempPayload);
}
return OC_STACK_OK;
}
bool things_get_object_value(struct things_representation_s *mother, char *key, struct things_representation_s *child)
{
OCRepPayload *payload = NULL;
bool ret = OCRepPayloadGetPropObject(mother->payload, key, &payload);
if (true == ret && NULL != payload) {
if (child->payload) {
OCRepPayloadDestroy(child->payload);
child->payload = NULL;
}
child->payload = payload;
}
return ret;
}
static OCStackResult
HandleLinkedListInterface(OCEntityHandlerRequest *ehRequest,
uint8_t filterOn,
char *filterValue)
{
(void)filterOn;
(void)filterValue;
if(!ehRequest)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult ret = OC_STACK_OK;
OCResource *collResource = (OCResource *)ehRequest->resource;
OCRepPayload* payload = NULL;
if(ret == OC_STACK_OK)
{
ret = BuildResponseRepresentation(collResource, &payload);
}
if (ret == OC_STACK_OK)
{
for (int i = 0; i < MAX_CONTAINED_RESOURCES && ret == OC_STACK_OK; i++)
{
OCResource* temp = collResource->rsrcResources[i];
if (temp)
{
//TODO : Add resource type filtering once collections
// start supporting queries.
ret = BuildResponseRepresentation(temp, &payload);
}
}
}
if(ret == OC_STACK_OK)
{
OCEntityHandlerResponse response = {0};
response.ehResult = OC_EH_OK;
response.payload = (OCPayload*)payload;
response.persistentBufferFlag = 0;
response.requestHandle = (OCRequestHandle) ehRequest->requestHandle;
response.resourceHandle = (OCResourceHandle) collResource;
ret = OCDoResponse(&response);
}
OCRepPayloadDestroy(payload);
return ret;
}
static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal)
{
if (!outPayload)
{
return OC_STACK_INVALID_PARAM;
}
bool err = false;
OCRepPayload* rootPayload = NULL;
OCRepPayload* curPayload = NULL;
OCRepPayload* temp = NULL;
while(!err && cbor_value_is_map(arrayVal))
{
err = err || OCParseSingleRepPayload(&temp, arrayVal);
if(rootPayload == NULL)
{
rootPayload = temp;
curPayload = temp;
}
else
{
curPayload->next = temp;
curPayload = curPayload->next;
}
err = err || cbor_value_advance(arrayVal);
if(err)
{
OCRepPayloadDestroy(rootPayload);
OC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
return OC_STACK_MALFORMED_RESPONSE;
}
}
*outPayload = (OCPayload*)rootPayload;
return OC_STACK_OK;
}
bool things_get_arrayvalue(struct things_representation_s *mother, char *key, int *length, struct things_representation_s ***children)
{
//THINGS_LOG_E(TAG, "NOt Supported This Function Yet");
bool find_value = false;
THINGS_LOG_D(TAG, "There're (%d) Number of children resources in the Payload : %d", mother->num_children);
// if( OCRepPayloadGetPropInt((OCRepPayload*)(mother->payload), SEC_ATTRIBUTE_LENGTH, &(mother->num_children) ) )
OCRepPayloadValue *payload_value = things_rep_payload_find_values((OCRepPayload *)(mother->payload), key);
if (NULL != payload_value) {
OCRepPayload **payload_values = NULL;
size_t dimension_size = calcDimTotal(payload_value->arr.dimensions);
size_t dimensions[3] = { dimension_size, 0, 0 };
THINGS_LOG_D(TAG, "Dimension size in the Payload : %d", dimension_size);
// This is testing code only... will be removed...
find_value = OCRepPayloadGetPropObjectArray((OCRepPayload *)(mother->payload), key, &payload_values, dimensions);
THINGS_LOG_D(TAG, "Find Value : %d", find_value);
if (find_value) {
*children = (things_representation_s **) things_malloc(sizeof(things_representation_s *) *dimension_size);
for (int iter = 0; iter < dimension_size; iter++) {
(*children)[iter] = things_create_representation_inst(payload_values[iter]);
/*! Added by st_things for memory Leak fix
*/
OCRepPayloadDestroy(payload_values[iter]);
}
/*! Added by st_things for memory Leak fix
*/
things_free(payload_values);
*length = mother->num_children = dimension_size;
}
} else {
THINGS_LOG_E(TAG, "DATA NOT EXIST~!!!!");
}
return find_value;
}
static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue *objMap)
{
if (!outPayload)
{
return false;
}
bool err = false;
if (cbor_value_is_map(objMap))
{
if (!*outPayload)
{
*outPayload = OCRepPayloadCreate();
if(!*outPayload)
{
return CborErrorOutOfMemory;
}
}
OCRepPayload* curPayload = *outPayload;
size_t len;
CborValue repMap;
err = err || cbor_value_enter_container(objMap, &repMap);
while(!err && cbor_value_is_valid(&repMap))
{
char* name;
err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
err = err || cbor_value_advance(&repMap);
CborType type = cbor_value_get_type(&repMap);
switch(type)
{
case CborNullType:
err = !OCRepPayloadSetNull(curPayload, name);
break;
case CborIntegerType:
{
int64_t intval = 0;
err = err || cbor_value_get_int64(&repMap, &intval);
if (!err)
{
err = !OCRepPayloadSetPropInt(curPayload, name, intval);
}
}
break;
case CborDoubleType:
{
double doubleval = 0;
err = err || cbor_value_get_double(&repMap, &doubleval);
if (!err)
{
err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
}
}
break;
case CborBooleanType:
{
bool boolval = false;
err = err || cbor_value_get_boolean(&repMap, &boolval);
if (!err)
{
err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
}
}
break;
case CborTextStringType:
{
char* strval = NULL;
err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
if (!err)
{
err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
}
}
break;
case CborByteStringType:
{
uint8_t* bytestrval = NULL;
err = err || cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
if (!err)
{
OCByteString tmp = {.bytes = bytestrval, .len = len};
err = !OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
}
}
break;
case CborMapType:
{
OCRepPayload *pl = NULL;
err = err || OCParseSingleRepPayload(&pl, &repMap);
if (!err)
{
err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
}
}
break;
case CborArrayType:
err = err || OCParseArray(curPayload, name, &repMap);
break;
default:
OC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
err = true;
}
if (type != CborMapType && cbor_value_is_valid(&repMap))
{
err = err || cbor_value_advance(&repMap);
}
OICFree(name);
}
err = err || cbor_value_leave_container(objMap, &repMap);
if(err)
{
OCRepPayloadDestroy(*outPayload);
*outPayload = NULL;
}
}
static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
{
OCRepPayloadPropType type;
size_t dimensions[MAX_REP_ARRAY_DEPTH];
bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
if (err)
{
OC_LOG(ERROR, TAG, "Array details weren't clear");
return err;
}
if (type == OCREP_PROP_NULL)
{
err = err || OCRepPayloadSetNull(out, name);
err = err || cbor_value_advance(container);
return err;
}
size_t dimTotal = calcDimTotal(dimensions);
size_t allocSize = getAllocSize(type);
void* arr = OICCalloc(dimTotal, allocSize);
if (!arr)
{
OC_LOG(ERROR, TAG, "Array Parse allocation failed");
return true;
}
err = err || OCParseArrayFillArray(container, dimensions, type, arr);
switch (type)
{
case OCREP_PROP_INT:
if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
{
OICFree(arr);
err = true;
}
break;
case OCREP_PROP_DOUBLE:
if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
{
OICFree(arr);
err = true;
}
break;
case OCREP_PROP_BOOL:
if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
{
OICFree(arr);
err = true;
}
break;
case OCREP_PROP_STRING:
if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
{
for(size_t i = 0; i < dimTotal; ++i)
{
OICFree(((char**)arr)[i]);
}
OICFree(arr);
err = true;
}
break;
case OCREP_PROP_OBJECT:
if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
{
for(size_t i = 0; i < dimTotal; ++i)
{
OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
}
OICFree(arr);
err = true;
}
break;
default:
OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
err = true;
break;
}
return err;
}
static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent)
{
if (!outPayload)
{
return false;
}
*outPayload = OCRepPayloadCreate();
OCRepPayload* curPayload = *outPayload;
bool err = false;
if(!*outPayload)
{
return CborErrorOutOfMemory;
}
size_t len;
CborValue curVal;
err = err || cbor_value_map_find_value(repParent, OC_RSRVD_HREF, &curVal);
if(cbor_value_is_valid(&curVal))
{
err = err || cbor_value_dup_text_string(&curVal, &curPayload->uri, &len,
NULL);
}
err = err || cbor_value_map_find_value(repParent, OC_RSRVD_PROPERTY, &curVal);
if(cbor_value_is_valid(&curVal))
{
CborValue insidePropValue = {0};
err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE,
&insidePropValue);
if(cbor_value_is_text_string(&insidePropValue))
{
char* allRt = NULL;
err = err || cbor_value_dup_text_string(&insidePropValue, &allRt, &len, NULL);
char* savePtr;
if (allRt)
{
char* curPtr = strtok_r(allRt, " ", &savePtr);
while (curPtr)
{
char* trimmed = InPlaceStringTrim(curPtr);
if (trimmed[0] != '\0')
{
OCRepPayloadAddResourceType(curPayload, curPtr);
}
curPtr = strtok_r(NULL, " ", &savePtr);
}
}
OICFree(allRt);
}
err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &insidePropValue);
if(cbor_value_is_text_string(&insidePropValue))
{
char* allIf = NULL;
err = err || cbor_value_dup_text_string(&insidePropValue, &allIf, &len, NULL);
char* savePtr;
if (allIf)
{
char* curPtr = strtok_r(allIf, " ", &savePtr);
while (curPtr)
{
char* trimmed = InPlaceStringTrim(curPtr);
if (trimmed[0] != '\0')
{
OCRepPayloadAddInterface(curPayload, curPtr);
}
curPtr = strtok_r(NULL, " ", &savePtr);
}
}
OICFree(allIf);
}
}
err = err || cbor_value_map_find_value(repParent, OC_RSRVD_REPRESENTATION, &curVal);
if(cbor_value_is_map(&curVal))
{
CborValue repMap;
err = err || cbor_value_enter_container(&curVal, &repMap);
while(!err && cbor_value_is_valid(&repMap))
{
char* name;
err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
err = err || cbor_value_advance(&repMap);
int64_t intval = 0;
bool boolval = false;
char* strval = NULL;
double doubleval = 0;
OCRepPayload* pl;
switch(cbor_value_get_type(&repMap))
{
case CborNullType:
err = !OCRepPayloadSetNull(curPayload, name);
break;
case CborIntegerType:
err = err || cbor_value_get_int64(&repMap, &intval);
if (!err)
{
err = !OCRepPayloadSetPropInt(curPayload, name, intval);
}
break;
case CborDoubleType:
err = err || cbor_value_get_double(&repMap, &doubleval);
if (!err)
{
err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
}
break;
case CborBooleanType:
err = err || cbor_value_get_boolean(&repMap, &boolval);
if (!err)
{
err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
}
break;
case CborTextStringType:
err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
if (!err)
{
err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
}
break;
case CborMapType:
err = err || OCParseSingleRepPayload(&pl, &repMap);
if (!err)
{
err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
}
break;
case CborArrayType:
err = err || OCParseArray(curPayload, name, &repMap);
break;
default:
OC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
err = true;
}
err = err || cbor_value_advance(&repMap);
OICFree(name);
}
err = err || cbor_value_leave_container(&curVal, &repMap);
}
if(err)
{
OCRepPayloadDestroy(*outPayload);
*outPayload = NULL;
}
return err;
}
OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
void *callbackParam)
{
OCEntityHandlerResult ehRet = OC_EH_OK;
OCEntityHandlerResponse response = {0};
OCRepPayload* payload = OCRepPayloadCreate();
if(!payload)
{
//OC_LOG(ERROR, TAG, PCF("Failed to allocate Payload"));
return OC_EH_ERROR;
}
if(entityHandlerRequest && (flag & OC_REQUEST_FLAG))
{
//OC_LOG (INFO, TAG, PCF("Flag includes OC_REQUEST_FLAG"));
if(OC_REST_GET == entityHandlerRequest->method)
{
OCRepPayloadSetUri(payload, "/iotar/speaker");
OCRepPayloadSetPropInt(payload, "state", speaker.state);
OCRepPayloadSetPropInt(payload, "volume",speaker.volume);
OCRepPayloadSetPropInt(payload, "time", speaker.time);
OCRepPayloadSetPropInt(payload, "present_song",speaker.present_song);
OCRepPayloadSetPropInt(payload, "next_song", speaker.next_song);
}
else if(OC_REST_PUT == entityHandlerRequest->method)
{
//OC_LOG_V(DEBUG, TAG, "put \n");
//풋 올때 데이터 어떻게 받지??
OCRepPayload* pay = (OCRepPayload*) entityHandlerRequest-> payload;
int64_t order = 0;
int64_t temp = 0;
char in[10];
OCRepPayloadGetPropInt(pay, "order", &order);
if(order == 30){ //재생
OCRepPayloadGetPropInt(pay, "temp", &temp);
makeString('a', temp, (char*)&in);
speaker.present_song = temp;
Serial1.println(in);
millis_prv = millis();
save_time = 0;
speaker.state = 1;
}else if(order == 31){ //볼륨 설정
OCRepPayloadGetPropInt(pay, "temp", &temp);
makeString('v', temp, (char*)&in);
speaker.volume = temp;
Serial1.println(in);
}else if(order == 32){ //다음 노래 설정
OCRepPayloadGetPropInt(pay, "temp", &temp);
makeString('d', temp, (char*)&in);
speaker.next_song = temp;
Serial1.println(in);
}else if(order == 33){ // 현재 아무일 안하고 있으면 0, 재생중 1, 일시정지 2. 로 세팅.
Serial1.println('x');
}else if(order == 34) { //정지.
Serial1.println('s');
}else if(order == 35) { // +1 볼륨.
speaker.volume++;
if(speaker.volume >= 100){
speaker.volume = 100;
}
makeString('v', speaker.volume, (char*)&in);
Serial1.println(in);
}else if(order == 36) { // -1 볼륨.
speaker.volume--;
if(speaker.volume < 1){
speaker.volume = 1;
}
makeString('v', speaker.volume, (char*)&in);
Serial1.println(in);
}else if(order == 37){ // 일시정지, 일시정지 풀기.
Serial1.println('p');
if(speaker.state == 1){
speaker.state = 2;
save_time = speaker.time+2;
}else{
speaker.state = 1;
millis_prv = millis();
}
}else if(order == 38){ //다음노래 재생
speaker.present_song++;
if(speaker.present_song > MAX_SONG){
speaker.present_song = 1;
}
makeString('a', speaker.present_song, (char*)&in);
Serial1.println(in);
millis_prv = millis();
save_time = 0;
speaker.state = 1;
}else if(order == 39){ // 이전 노래 재생
speaker.present_song--;
if(speaker.present_song < 1){
speaker.present_song = MAX_SONG;
}
makeString('a', speaker.present_song, (char*)&in);
Serial1.println(in);
millis_prv = millis();
save_time = 0;
speaker.state = 1;
}
OCRepPayloadSetUri(payload, "/iotar/speaker");
OCRepPayloadSetPropInt(payload, "time", speaker.time);
}
if (ehRet == OC_EH_OK)
{
// Format the response. Note this requires some info about the request
response.requestHandle = entityHandlerRequest->requestHandle;
response.resourceHandle = entityHandlerRequest->resource;
response.ehResult = ehRet;
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)
{
// OC_LOG(ERROR, TAG, "Error sending response");
ehRet = OC_EH_ERROR;
}
}
}
if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
{
if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
{
// OC_LOG (INFO, TAG, PCF("Received OC_OBSERVE_REGISTER from client"));
gLightUnderObservation = 1;
}
else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
{
// OC_LOG (INFO, TAG, PCF("Received OC_OBSERVE_DEREGISTER from client"));
gLightUnderObservation = 0;
}
}
OCRepPayloadDestroy(payload);
return ehRet;
}
static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
{
OCStackResult ret = OC_STACK_INVALID_PARAM;
CborError err;
OCRepPayload *temp = NULL;
OCRepPayload *rootPayload = NULL;
OCRepPayload *curPayload = NULL;
CborValue rootMap = *root;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
VERIFY_PARAM_NON_NULL(TAG, root, "Invalid Parameter root");
*outPayload = NULL;
if (cbor_value_is_array(root))
{
err = cbor_value_enter_container(root, &rootMap);
}
while (cbor_value_is_valid(&rootMap))
{
temp = OCRepPayloadCreate();
ret = OC_STACK_NO_MEMORY;
VERIFY_PARAM_NON_NULL(TAG, temp, "Failed allocating memory");
CborValue curVal;
ret = OC_STACK_MALFORMED_RESPONSE;
if (cbor_value_is_map(&rootMap))
{
err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
if (cbor_value_is_valid(&curVal))
{
size_t len = 0;
err = cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
}
}
// Resource types
if (cbor_value_is_map(&rootMap))
{
if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal))
{
err = OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->types);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find rt type tag/value");
}
}
// Interface Types
if (cbor_value_is_map(&rootMap))
{
if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal))
{
err = OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->interfaces);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
}
}
if (cbor_value_is_map(&rootMap))
{
err = OCParseSingleRepPayload(&temp, &rootMap, true);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
}
if(rootPayload == NULL)
{
rootPayload = temp;
curPayload = temp;
}
else
{
curPayload->next = temp;
curPayload = curPayload->next;
}
if (cbor_value_is_array(&rootMap))
{
err = cbor_value_advance(&rootMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to advance single rep payload");
}
}
*outPayload = (OCPayload *)rootPayload;
return OC_STACK_OK;
exit:
OCRepPayloadDestroy(temp);
OCRepPayloadDestroy(rootPayload);
OIC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
return ret;
}
/*
* Adds the common properties of resource such as 'rt', 'if'.
* 'links' property will be added in the response payload for collection resources.
* If it fails for any reason, the resp_payload which is partially updated by this function will not be reset.
* The caller of this method will have to release the payload and return an error response to the client.
*/
bool add_common_props(things_resource_s *rsrc, bool collection, OCRepPayload *resp_payload)
{
RET_FALSE_IF_PARAM_IS_NULL(TAG, rsrc);
RET_FALSE_IF_PARAM_IS_NULL(TAG, resp_payload);
// Set resource types.
int rt_count = 0;
char **res_types = NULL;
if (!get_resource_types(rsrc, &res_types, &rt_count)) {
THINGS_LOG_E(TAG, "Failed to get the resource types of the given resource(%s).", rsrc->uri);
return false;
}
for (int i = 0; i < rt_count; i++) {
if (!OCRepPayloadAddResourceType(resp_payload, res_types[i])) {
THINGS_LOG_E(TAG, "Failed to add the resource type in the response payload.");
// Release memory allocated for resource types.
things_free_str_array(res_types, rt_count);
return false;
}
}
things_free_str_array(res_types, rt_count);
// Set interface types.
int if_count = 0;
char **if_types = NULL;
if (!get_interface_types(rsrc, &if_types, &if_count)) {
THINGS_LOG_E(TAG, "Failed to get the interface types of the given resource(%s).", rsrc->uri);
return false;
}
for (int i = 0; i < if_count; i++) {
if (!OCRepPayloadAddInterface(resp_payload, if_types[i])) {
THINGS_LOG_E(TAG, "Failed to add the interface type in the response payload.");
// Release memory allocated for interface types.
things_free_str_array(if_types, if_count);
return false;
}
}
things_free_str_array(if_types, if_count);
#ifdef CONFIG_ST_THINGS_COLLECTION
// Set "links"(only for collection).
if (collection) {
size_t count = 0;
OCRepPayload **links = NULL;
if (!form_collection_links(rsrc, &links, &count)) {
THINGS_LOG_E(TAG, "Failed to form links for the given collection resource(%s).", rsrc->uri);
return false;
}
THINGS_LOG_D(TAG, "Formed links for collection.");
size_t dimensions[MAX_REP_ARRAY_DEPTH] = { count, 0, 0 };
bool result = OCRepPayloadSetPropObjectArray(resp_payload, OC_RSRVD_LINKS, links, dimensions);
if (!result) {
THINGS_LOG_E(TAG, "Failed to add the links in the response payload.");
for (size_t i = 0; i < count && NULL != links[i]; i++) {
OCRepPayloadDestroy(links[i]);
}
things_free(links);
return false;
}
}
#endif
return true;
}
static int _icd_state_value_from_gvariant(OCRepPayload *repr, GVariantIter *iter)
{
int ret;
char *key;
GVariant *var;
const char *str_value;
OCRepPayload *repr_value;
struct icd_state_list_s value_list = {0};
while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
if (g_variant_is_of_type(var, G_VARIANT_TYPE_BOOLEAN)) {
OCRepPayloadSetPropBool(repr, key, g_variant_get_boolean(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_INT32)) {
OCRepPayloadSetPropInt(repr, key, g_variant_get_int32(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_DOUBLE)) {
OCRepPayloadSetPropDouble(repr, key, g_variant_get_double(var));
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_STRING)) {
str_value = g_variant_get_string(var, NULL);
if (NULL == str_value) {
ERR("g_variant_get_string() Fail");
_icd_payload_state_list_destroy(&value_list);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
if (IC_STR_EQUAL == strcmp(IC_STR_NULL, str_value))
OCRepPayloadSetNull(repr, key);
else
OCRepPayloadSetPropString(repr, key, str_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE("ay"))) {
OCByteString byte_value;
byte_value.bytes = (uint8_t*)g_variant_get_data(var);
byte_value.len = g_variant_get_size(var);
OCRepPayloadSetPropByteString(repr, key, byte_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE("a{sv}"))) {
GVariantIter state_iter;
repr_value = OCRepPayloadCreate();
g_variant_iter_init(&state_iter, var);
ret = _icd_state_value_from_gvariant(repr_value, &state_iter);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_value_from_gvariant() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
OCRepPayloadDestroy(repr_value);
return ret;
}
OCRepPayloadSetPropObjectAsOwner(repr, key, repr_value);
} else if (g_variant_is_of_type(var, G_VARIANT_TYPE_ARRAY)) {
memset(&value_list, 0, sizeof(struct icd_state_list_s));
ret = _icd_state_list_from_gvariant(var, &value_list, 0);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_list_from_gvariant() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
return ret;
}
ret = _icd_state_array_from_list(repr, &value_list, key);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_array_from_list() Fail(%d)", ret);
_icd_payload_state_list_destroy(&value_list);
return ret;
}
} else {
ERR("Invalid type(%s)", g_variant_get_type_string(var));
return IOTCON_ERROR_INVALID_TYPE;
}
}
return IOTCON_ERROR_NONE;
}
static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap, bool isRoot)
{
CborError err = CborUnknownError;
char *name = NULL;
bool res;
VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
VERIFY_PARAM_NON_NULL(TAG, objMap, "Invalid Parameter objMap");
if (cbor_value_is_map(objMap))
{
if (!*outPayload)
{
*outPayload = OCRepPayloadCreate();
if (!*outPayload)
{
return CborErrorOutOfMemory;
}
}
OCRepPayload *curPayload = *outPayload;
size_t len = 0;
CborValue repMap;
err = cbor_value_enter_container(objMap, &repMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
while (!err && cbor_value_is_valid(&repMap))
{
if (cbor_value_is_text_string(&repMap))
{
err = cbor_value_dup_text_string(&repMap, &name, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding tag name in the map");
err = cbor_value_advance(&repMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing rootMap");
if (name &&
isRoot &&
((0 == strcmp(OC_RSRVD_HREF, name)) ||
(0 == strcmp(OC_RSRVD_RESOURCE_TYPE, name)) ||
(0 == strcmp(OC_RSRVD_INTERFACE, name))))
{
err = cbor_value_advance(&repMap);
OICFree(name);
continue;
}
}
CborType type = cbor_value_get_type(&repMap);
switch (type)
{
case CborNullType:
res = OCRepPayloadSetNull(curPayload, name);
break;
case CborIntegerType:
{
int64_t intval = 0;
err = cbor_value_get_int64(&repMap, &intval);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting int value");
res = OCRepPayloadSetPropInt(curPayload, name, intval);
}
break;
case CborDoubleType:
{
double doubleval = 0;
err = cbor_value_get_double(&repMap, &doubleval);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting double value");
res = OCRepPayloadSetPropDouble(curPayload, name, doubleval);
}
break;
case CborBooleanType:
{
bool boolval = false;
err = cbor_value_get_boolean(&repMap, &boolval);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting boolean value");
res = OCRepPayloadSetPropBool(curPayload, name, boolval);
}
break;
case CborTextStringType:
{
char *strval = NULL;
err = cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting string value");
res = OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
}
break;
case CborByteStringType:
{
uint8_t* bytestrval = NULL;
err = cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting byte string value");
OCByteString tmp = {.bytes = bytestrval, .len = len};
res = OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
}
break;
case CborMapType:
{
OCRepPayload *pl = NULL;
err = OCParseSingleRepPayload(&pl, &repMap, false);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep");
res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
}
break;
case CborArrayType:
err = OCParseArray(curPayload, name, &repMap);
break;
default:
OIC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
res = false;
}
if (type != CborArrayType)
{
err = (CborError) !res;
}
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
if (type != CborMapType && cbor_value_is_valid(&repMap))
{
err = cbor_value_advance(&repMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advance repMap");
}
OICFree(name);
name = NULL;
}
if (cbor_value_is_container(objMap))
{
err = cbor_value_leave_container(objMap, &repMap);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to leave container");
}
return err;
}
exit:
OICFree(name);
OCRepPayloadDestroy(*outPayload);
*outPayload = NULL;
return err;
}
NSResult NSSendNotification(NSMessage *msg)
{
NS_LOG(DEBUG, "NSSendMessage - IN");
OCResourceHandle rHandle;
OCObservationId obArray[255] = { 0, };
int obCount = 0, i;
if (NSPutMessageResource(msg, &rHandle) != NS_OK)
{
NS_LOG(ERROR, "fail to Put notification resource");
return NS_ERROR;
}
OCRepPayload* payload = NULL;
if (NSSetMessagePayload(msg, &payload) != NS_OK)
{
NS_LOG(ERROR, "fail to Get message payload");
return NS_ERROR;
}
#ifdef WITH_MQ
if (NSGetMQServerInfo())
{
NSProviderPublishTopic(OCRepPayloadClone(payload), NSProviderPublishMQResponseCB);
}
#endif
if (consumerSubList->head == NULL)
{
NS_LOG(ERROR, "SubList->head is NULL, empty SubList");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
NSCacheElement * it = consumerSubList->head;
while (it)
{
NSCacheSubData * subData = (NSCacheSubData *) it->data;
NS_LOG_V(INFO_PRIVATE, "message subData->id = %s", subData->id);
NS_LOG_V(DEBUG, "subData->messageId = %d", subData->messageObId);
NS_LOG_V(DEBUG, "subData->cloud_messageId = %d", subData->remote_messageObId);
NS_LOG_V(DEBUG, "subData->syncId = %d", subData->syncObId);
NS_LOG_V(DEBUG, "subData->cloud_syncId = %d", subData->remote_syncObId);
NS_LOG_V(DEBUG, "subData->isWhite = %d", subData->isWhite);
if (subData->isWhite)
{
if(subData->messageObId != 0)
{
if (msg->topic && (msg->topic)[0] != '\0')
{
NS_LOG_V(DEBUG, "this is topic message: %s", msg->topic);
if (NSProviderIsTopicSubScribed(consumerTopicList->head, subData->id, msg->topic))
{
obArray[obCount++] = subData->messageObId;
}
}
else
{
obArray[obCount++] = subData->messageObId;
}
}
#if (defined WITH_CLOUD)
if (subData->remote_messageObId != 0)
{
if (msg->topic && (msg->topic)[0] != '\0')
{
NS_LOG_V(DEBUG, "this is topic message via remote server: %s", msg->topic);
if (NSProviderIsTopicSubScribed(consumerTopicList->head, subData->id, msg->topic))
{
obArray[obCount++] = subData->remote_messageObId;
}
}
else
{
obArray[obCount++] = subData->remote_messageObId;
}
}
#endif
}
it = it->next;
}
for (i = 0; i < obCount; ++i)
{
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
NS_LOG_V(DEBUG, "SubScription WhiteList[%d] = %d", i, obArray[i]);
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
if (!obCount)
{
NS_LOG(ERROR, "observer count is zero");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray, obCount, payload,
OC_LOW_QOS);
NS_LOG_V(DEBUG, "Message ocstackResult = %d", ocstackResult);
if (ocstackResult != OC_STACK_OK)
{
NS_LOG(ERROR, "fail to send message");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
NS_LOG(DEBUG, "NSSendMessage - OUT");
return NS_OK;
}
static bool add_property_in_post_req_msg(st_things_set_request_message_s *req_msg, OCRepPayload *req_payload, things_attribute_info_s *prop)
{
RET_FALSE_IF_PARAM_IS_NULL(TAG, req_msg);
RET_FALSE_IF_PARAM_IS_NULL(TAG, req_msg->rep);
RET_FALSE_IF_PARAM_IS_NULL(TAG, req_msg->rep->payload);
RET_FALSE_IF_PARAM_IS_NULL(TAG, req_payload);
RET_FALSE_IF_PARAM_IS_NULL(TAG, prop);
OCRepPayload *resp_payload = req_msg->rep->payload;
THINGS_LOG_D(TAG, "Property Key is %s", prop->key);
THINGS_LOG_D(TAG, "Property type is %d", prop->type);
// Based on the property type, call appropriate methods to copy
// the property from request payload to request representation.
bool result = false;
switch (prop->type) {
case BOOL_ID: {
bool value = false;
if (OCRepPayloadGetPropBool(req_payload, prop->key, &value)) {
result = OCRepPayloadSetPropBool(resp_payload, prop->key, value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the boolean value of '%s' in request message.", prop->key);
}
} else {
THINGS_LOG_E(TAG, "Failed to get the boolean value of '%s' for request message.", prop->key);
}
}
break;
case INT_ID: {
int64_t value = 0;
if (OCRepPayloadGetPropInt(req_payload, prop->key, &value)) {
result = OCRepPayloadSetPropInt(resp_payload, prop->key, value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the integer value of '%s' in request message", prop->key);
}
} else {
THINGS_LOG_E(TAG, "Failed to get the integer value of '%s' for request message", prop->key);
}
}
break;
case DOUBLE_ID: {
double value = 0.0;
if (OCRepPayloadGetPropDouble(req_payload, prop->key, &value)) {
result = OCRepPayloadSetPropDouble(resp_payload, prop->key, value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the double value of '%s' in request message", prop->key);
}
} else {
THINGS_LOG_E(TAG, "Failed to get the double value of '%s' for request message", prop->key);
}
}
break;
case STRING_ID: {
char *value = NULL;
if (OCRepPayloadGetPropString(req_payload, prop->key, &value)) {
result = OCRepPayloadSetPropString(resp_payload, prop->key, value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the string value of '%s' in request message", prop->key);
}
things_free(value);
} else {
THINGS_LOG_E(TAG, "Failed to get the string value of '%s' for request message", prop->key);
}
}
break;
case OBJECT_ID: {
OCRepPayload *value = NULL;
if (OCRepPayloadGetPropObject(req_payload, prop->key, &value)) {
result = OCRepPayloadSetPropObject(resp_payload, prop->key, value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the object value of '%s' in request message", prop->key);
}
OCRepPayloadDestroy(value);
} else {
THINGS_LOG_E(TAG, "Failed to get the object value of '%s' for request message", prop->key);
}
}
break;
case BYTE_ID: {
OCByteString byte_value;
if (OCRepPayloadGetPropByteString(req_payload, prop->key, &byte_value)) {
result = OCRepPayloadSetPropByteString(resp_payload, prop->key, byte_value);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the byte string value of '%s' in request message", prop->key);
}
things_free(byte_value.bytes);
} else {
THINGS_LOG_E(TAG, "Failed to get the byte string value of '%s' for request message", prop->key);
}
}
break;
case INT_ARRAY_ID: {
int64_t *value = NULL;
size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
if (OCRepPayloadGetIntArray(req_payload, prop->key, &value, dimensions)) {
result = OCRepPayloadSetIntArray(resp_payload, prop->key, value, dimensions);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the integer array value of '%s' in request message", prop->key);
}
things_free(value);
} else {
THINGS_LOG_E(TAG, "Failed to get the integer array value of '%s' for request message", prop->key);
}
}
break;
case DOUBLE_ARRAY_ID: {
double *value = NULL;
size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
if (OCRepPayloadGetDoubleArray(req_payload, prop->key, &value, dimensions)) {
result = OCRepPayloadSetDoubleArray(resp_payload, prop->key, value, dimensions);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the double array value of '%s' in request message", prop->key);
}
things_free(value);
} else {
THINGS_LOG_E(TAG, "Failed to get the double array value of '%s' for request message", prop->key);
}
}
break;
case STRING_ARRAY_ID: {
char **value = NULL;
size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
if (OCRepPayloadGetStringArray(req_payload, prop->key, &value, dimensions)) {
result = OCRepPayloadSetStringArray(resp_payload, prop->key, value, dimensions);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the string array value of '%s' in request message", prop->key);
}
size_t len = calcDimTotal(dimensions);
things_free_str_array(value, len);
} else {
THINGS_LOG_E(TAG, "Failed to get the string array value of '%s' for request message", prop->key);
}
}
break;
case OBJECT_ARRAY_ID: {
OCRepPayload **value = NULL;
size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
if (OCRepPayloadGetPropObjectArray(req_payload, prop->key, &value, dimensions)) {
result = OCRepPayloadSetPropObjectArray(resp_payload, prop->key, value, dimensions);
if (!result) {
THINGS_LOG_E(TAG, "Failed to set the object array value of '%s' in request message", prop->key);
}
size_t len = calcDimTotal(dimensions);
for (size_t index = 0; index < len; index++) {
OCRepPayloadDestroy(value[index]);
}
things_free(value);
} else {
THINGS_LOG_E(TAG, "Failed to get the object array value of '%s' for request message", prop->key);
}
}
break;
default:
THINGS_LOG_E(TAG, "Invalid property type (%d).", prop->type);
break;
}
return result;
}
static int _worker_encap_get_cb(void *context)
{
int ret, conn_type;
char *host_address;
icd_encap_info_s *encap_info;
GVariant *monitoring_value, *caching_value;
iotcon_remote_resource_state_e resource_state;
struct icd_encap_get_context *encap_get_ctx = context;
/* GET ENCAP INFO */
ret = icd_ioty_get_host_address(&encap_get_ctx->dev_addr, &host_address, &conn_type);
if (IOTCON_ERROR_NONE != ret) {
ERR("icd_ioty_get_host_address() Fail");
return ret;
}
encap_info = _icd_ioty_encap_table_get_info(encap_get_ctx->uri_path, host_address);
if (NULL == encap_info) {
ERR("_icd_ioty_encap_table_get_info() Fail");
free(host_address);
return IOTCON_ERROR_NO_DATA;
}
free(host_address);
/* MONITORING */
if (0 < encap_info->monitoring_count) {
switch (encap_get_ctx->ret) {
case OC_STACK_OK:
resource_state = IOTCON_REMOTE_RESOURCE_ALIVE;
break;
case OC_STACK_ERROR:
default:
resource_state = IOTCON_REMOTE_RESOURCE_LOST_SIGNAL;
}
if (resource_state != encap_info->resource_state) {
encap_info->resource_state = resource_state;
monitoring_value = g_variant_new("(i)", resource_state);
ret = _ocprocess_response_signal(NULL, IC_DBUS_SIGNAL_MONITORING,
encap_info->signal_number, monitoring_value);
if (IOTCON_ERROR_NONE != ret) {
ERR("_ocprocess_response_signal() Fail(%d)", ret);
OCRepPayloadDestroy(encap_get_ctx->oic_payload);
return ret;
}
}
}
/* CACHING */
if (0 < encap_info->caching_count) {
if (OC_STACK_OK != encap_get_ctx->ret) {
OCRepPayloadDestroy(encap_get_ctx->oic_payload);
return IOTCON_ERROR_NONE;
}
ret = icd_payload_representation_compare(encap_info->oic_payload,
encap_get_ctx->oic_payload);
if (IC_EQUAL == ret) {
OCRepPayloadDestroy(encap_get_ctx->oic_payload);
return IOTCON_ERROR_NONE;
}
encap_info->oic_payload = encap_get_ctx->oic_payload;
caching_value = icd_payload_to_gvariant((OCPayload*)encap_get_ctx->oic_payload);
ret = _ocprocess_response_signal(NULL, IC_DBUS_SIGNAL_CACHING,
encap_info->signal_number, caching_value);
if (IOTCON_ERROR_NONE != ret) {
ERR("_ocprocess_response_signal() Fail(%d)", ret);
return ret;
}
}
return IOTCON_ERROR_NONE;
}
static int _icd_state_list_from_gvariant(GVariant *var,
struct icd_state_list_s *value_list, int depth)
{
int ret;
GVariantIter iter;
const GVariantType *type;
union icd_state_value_u *value;
type = g_variant_get_type(var);
g_variant_iter_init(&iter, var);
value_list->dimensions[depth] = g_variant_iter_n_children(&iter);
DBG("[%d]list dim : %d", depth, value_list->dimensions[depth]);
if (g_variant_type_equal(G_VARIANT_TYPE("ab"), type)) {
bool b;
value_list->type = OCREP_PROP_BOOL;
while (g_variant_iter_loop(&iter, "b", &b)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->b = b;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("ai"), type)) {
int i;
value_list->type = OCREP_PROP_INT;
while (g_variant_iter_loop(&iter, "i", &i)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->i = i;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("ad"), type)) {
double d;
value_list->type = OCREP_PROP_DOUBLE;
while (g_variant_iter_loop(&iter, "d", &d)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->d = d;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("as"), type)) {
char *s;
value_list->type = OCREP_PROP_STRING;
while (g_variant_iter_next(&iter, "s", &s))
value_list->list = g_list_append(value_list->list, s);
} else if (g_variant_type_equal(G_VARIANT_TYPE("av"), type)) {
GVariant *value;
if (g_variant_iter_loop(&iter, "v", &value)) {
if (g_variant_is_of_type(value, G_VARIANT_TYPE("a{sv}"))) {
OCRepPayload *repr;
GVariantIter state_iter;
value_list->type = OCREP_PROP_OBJECT;
do {
repr = OCRepPayloadCreate();
g_variant_iter_init(&state_iter, value);
ret = _icd_state_value_from_gvariant(repr, &state_iter);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_value_from_gvariant() Fail(%d)", ret);
OCRepPayloadDestroy(repr);
return ret;
}
value_list->list = g_list_append(value_list->list, repr);
} while (g_variant_iter_loop(&iter, "v", &value));
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE("ay"))) {
OCByteString *byte_str;
value_list->type = OCREP_PROP_BYTE_STRING;
do {
byte_str = calloc(1, sizeof(OCByteString));
if (NULL == byte_str) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
byte_str->len = g_variant_get_size(value);
byte_str->bytes = calloc(byte_str->len, sizeof(uint8_t));
if (NULL == byte_str->bytes) {
ERR("calloc() Fail(%d)", errno);
free(byte_str);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
memcpy(byte_str->bytes, g_variant_get_data(value), byte_str->len);
value_list->list = g_list_append(value_list->list, byte_str);
} while (g_variant_iter_loop(&iter, "v", &value));
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_ARRAY)) {
do {
ret = _icd_state_list_from_gvariant(value, value_list, depth + 1);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_list_from_gvariant() Fail(%d)", ret);
return ret;
}
} while (g_variant_iter_loop(&iter, "v", &value));
}
}
}
return IOTCON_ERROR_NONE;
}
static void _icd_payload_object_destroy(gpointer node)
{
OCRepPayloadDestroy(node);
}
NSResult NSSendSync(NSSyncInfo *sync)
{
NS_LOG(DEBUG, "NSSendSync - IN");
OCObservationId obArray[255] = { 0, };
int obCount = 0;
int i;
OCResourceHandle rHandle;
if (NSPutSyncResource(sync, &rHandle) != NS_OK)
{
NS_LOG(ERROR, PCF("Fail to put sync resource"));
return NS_ERROR;
}
NSCacheElement * it = consumerSubList->head;
while (it)
{
NSCacheSubData * subData = (NSCacheSubData *) it->data;
NS_LOG_V(INFO_PRIVATE, "sync subData->id = %s", subData->id);
NS_LOG_V(DEBUG, "subData->messageId = %d", subData->messageObId);
NS_LOG_V(DEBUG, "subData->cloud_messageId = %d", subData->remote_messageObId);
NS_LOG_V(DEBUG, "subData->syncId = %d", subData->syncObId);
NS_LOG_V(DEBUG, "subData->cloud_syncId = %d", subData->remote_syncObId);
NS_LOG_V(DEBUG, "subData->isWhite = %d", subData->isWhite);
if (subData->isWhite)
{
if (subData->syncObId != 0)
{
obArray[obCount++] = subData->syncObId;
}
#if (defined WITH_CLOUD)
if (subData->remote_syncObId != 0)
{
obArray[obCount++] = subData->remote_syncObId;
}
#endif
}
it = it->next;
}
OCRepPayload* payload = NULL;
if (NSSetSyncPayload(sync, &payload) != NS_OK)
{
NS_LOG(ERROR, "Failed to allocate payload");
return NS_ERROR;
}
#ifdef WITH_MQ
if (NSGetMQServerInfo())
{
OCRepPayload* MQPayload = OCRepPayloadClone(payload);
NSMessageType MQType = 0;
if (sync->state == NS_SYNC_READ)
{
MQType = NS_MESSAGE_READ;
}
else if (sync->state == NS_SYNC_DELETED)
{
MQType = NS_MESSAGE_DELETED;
}
OCRepPayloadSetPropInt(MQPayload, NS_ATTRIBUTE_TYPE, (int64_t) MQType);
NSProviderPublishTopic(MQPayload, NSProviderPublishMQResponseCB);
}
#endif
for (i = 0; i < obCount; ++i)
{
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
NS_LOG_V(DEBUG, "Sync WhiteList[%d] = %d", i, obArray[i]);
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray,
obCount, payload, OC_LOW_QOS);
NS_LOG_V(DEBUG, "Sync ocstackResult = %d", ocstackResult);
if (ocstackResult != OC_STACK_OK)
{
NS_LOG(ERROR, "fail to send Sync");
OCRepPayloadDestroy(payload);
return NS_ERROR;
}
OCRepPayloadDestroy(payload);
NS_LOG(DEBUG, "NSSendSync - OUT");
return NS_OK;
}
static CborError OCParseArrayFillArray(const CborValue *parent,
size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType type, void *targetArray)
{
CborValue insideArray;
size_t i = 0;
char *tempStr = NULL;
OCByteString ocByteStr = { .bytes = NULL, .len = 0};
size_t tempLen = 0;
OCRepPayload *tempPl = NULL;
size_t newdim[MAX_REP_ARRAY_DEPTH];
newdim[0] = dimensions[1];
newdim[1] = dimensions[2];
newdim[2] = 0;
CborError err = cbor_value_enter_container(parent, &insideArray);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container");
while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
{
bool noAdvance = false;
if (cbor_value_get_type(&insideArray) != CborNullType)
{
switch (type)
{
case OCREP_PROP_INT:
if (dimensions[1] == 0)
{
err = cbor_value_get_int64(&insideArray, &(((int64_t*)targetArray)[i]));
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((int64_t*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_DOUBLE:
if (dimensions[1] == 0)
{
err = cbor_value_get_double(&insideArray, &(((double*)targetArray)[i]));
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((double*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_BOOL:
if (dimensions[1] == 0)
{
err = cbor_value_get_boolean(&insideArray, &(((bool*)targetArray)[i]));
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((bool*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_STRING:
if (dimensions[1] == 0)
{
err = cbor_value_dup_text_string(&insideArray, &tempStr, &tempLen, NULL);
((char**)targetArray)[i] = tempStr;
tempStr = NULL;
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((char**)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_BYTE_STRING:
if (dimensions[1] == 0)
{
err = cbor_value_dup_byte_string(&insideArray, &(ocByteStr.bytes),
&(ocByteStr.len), NULL);
((OCByteString*)targetArray)[i] = ocByteStr;
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((OCByteString*)targetArray)[arrayStep(dimensions, i)]));
}
break;
case OCREP_PROP_OBJECT:
if (dimensions[1] == 0)
{
err = OCParseSingleRepPayload(&tempPl, &insideArray, false);
((OCRepPayload**)targetArray)[i] = tempPl;
tempPl = NULL;
noAdvance = true;
}
else
{
err = OCParseArrayFillArray(&insideArray, newdim, type,
&(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)]));
}
break;
default:
OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
err = CborErrorUnknownType;
break;
}
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting repPayload");
}
++i;
if (!noAdvance && cbor_value_is_valid(&insideArray))
{
err = cbor_value_advance(&insideArray);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advnce insideArray");
}
}
exit:
return err;
}
static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *container)
{
void *arr = NULL;
OCRepPayloadPropType type;
size_t dimensions[MAX_REP_ARRAY_DEPTH];
size_t dimTotal;
size_t allocSize;
bool res = true;
CborError err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
VERIFY_CBOR_SUCCESS(TAG, err, "Array details weren't clear");
if (type == OCREP_PROP_NULL)
{
res = OCRepPayloadSetNull(out, name);
err = (CborError) !res;
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
err = cbor_value_advance(container);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing container");
return err;
}
dimTotal = calcDimTotal(dimensions);
allocSize = getAllocSize(type);
arr = OICCalloc(dimTotal, allocSize);
VERIFY_PARAM_NON_NULL(TAG, arr, "Array Parse allocation failed");
res = OCParseArrayFillArray(container, dimensions, type, arr);
VERIFY_CBOR_SUCCESS(TAG, err, "Failed parse array");
switch (type)
{
case OCREP_PROP_INT:
res = OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t *)arr, dimensions);
break;
case OCREP_PROP_DOUBLE:
res = OCRepPayloadSetDoubleArrayAsOwner(out, name, (double *)arr, dimensions);
break;
case OCREP_PROP_BOOL:
res = OCRepPayloadSetBoolArrayAsOwner(out, name, (bool *)arr, dimensions);
break;
case OCREP_PROP_STRING:
res = OCRepPayloadSetStringArrayAsOwner(out, name, (char **)arr, dimensions);
break;
case OCREP_PROP_BYTE_STRING:
res = OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString *)arr, dimensions);
break;
case OCREP_PROP_OBJECT:
res = OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions);
break;
default:
OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
break;
}
err = (CborError) !res;
VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting array parameter");
return CborNoError;
exit:
if (type == OCREP_PROP_STRING)
{
for(size_t i = 0; i < dimTotal; ++i)
{
OICFree(((char**)arr)[i]);
}
}
if (type == OCREP_PROP_BYTE_STRING)
{
for(size_t i = 0; i < dimTotal; ++i)
{
OICFree(((OCByteString*)arr)[i].bytes);
}
}
if (type == OCREP_PROP_OBJECT)
{
for(size_t i = 0; i < dimTotal; ++i)
{
OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
}
}
OICFree(arr);
return err;
}
