static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
if (!dest || !source)
{
return;
}
size_t dimTotal = calcDimTotal(source->arr.dimensions);
switch(source->arr.type)
{
case OCREP_PROP_INT:
dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.iArray, "Failed allocating memory");
memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
break;
case OCREP_PROP_DOUBLE:
dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.dArray, "Failed allocating memory");
memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
break;
case OCREP_PROP_BOOL:
dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.bArray, "Failed allocating memory");
memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
break;
case OCREP_PROP_STRING:
dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.strArray, "Failed allocating memory");
for(size_t i = 0; i < dimTotal; ++i)
{
dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
}
break;
case OCREP_PROP_OBJECT:
dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
for(size_t i = 0; i < dimTotal; ++i)
{
dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
}
break;
case OCREP_PROP_ARRAY:
dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
for(size_t i = 0; i < dimTotal; ++i)
{
dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
}
break;
default:
OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
break;
}
exit:
return;
}
static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
{
if (!source || !dest)
{
return;
}
switch(source->type)
{
case OCREP_PROP_STRING:
dest->str = OICStrdup(source->str);
break;
case OCREP_PROP_BYTE_STRING:
dest->ocByteStr.bytes = (uint8_t*)OICMalloc(source->ocByteStr.len * sizeof(uint8_t));
VERIFY_PARAM_NON_NULL(TAG, dest->ocByteStr.bytes, "Failed allocating memory");
dest->ocByteStr.len = source->ocByteStr.len;
memcpy(dest->ocByteStr.bytes, source->ocByteStr.bytes, dest->ocByteStr.len);
break;
case OCREP_PROP_OBJECT:
dest->obj = OCRepPayloadClone(source->obj);
break;
case OCREP_PROP_ARRAY:
OCCopyPropertyValueArray(dest, source);
break;
default:
// Nothing to do for the trivially copyable types.
break;
}
exit:
return;
}
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;
}
void /*OCRepPayload */ *create_payload(struct things_resource_s *res, char *query)
{
// To provide identical pattern for handling the result
// allocating new memory for the payload to delete later
OCRepPayload *payload = OCRepPayloadClone((OCRepPayload *)(res->rep->payload));
THINGS_LOG_D(TAG, "Query : %s", query);
if (query == NULL || (query != NULL && strlen(query) < 1)
|| strstr(query, OIC_INTERFACE_ACTUATOR) != NULL || strstr(query, OIC_INTERFACE_SENSOR) != NULL) {
THINGS_LOG_D(TAG, "Including properties & its values only");
// Do nothing..
} else if (strstr(query, OIC_INTERFACE_BASELINE)) {
THINGS_LOG_D(TAG, "Including all the properties & its values");
uint8_t index = 0;
uint8_t number_of_interfaces = 0;
uint8_t number_of_resource_type = 0;
OCGetNumberOfResourceInterfaces((OCResourceHandle) res->resource_handle, &number_of_interfaces);
THINGS_LOG_D(TAG, "@@ IF # : %d ", number_of_interfaces);
//2.a Find interface type(s) & insert it/them into payload
for (index = 0; index < number_of_interfaces; index++) {
const char *interface = OCGetResourceInterfaceName((OCResourceHandle) res->resource_handle, index);
THINGS_LOG_D(TAG, "=====> IF : %s ", interface);
OCRepPayloadAddInterface(payload, interface);
}
//3.a Find resource type & insert it into payload
OCGetNumberOfResourceTypes((OCResourceHandle) res->resource_handle, &number_of_resource_type);
THINGS_LOG_D(TAG, "@@ RT # : %d ", number_of_resource_type);
for (index = 0; index < number_of_resource_type; index++) {
const char *rt = OCGetResourceTypeName((OCResourceHandle) res->resource_handle, index);
THINGS_LOG_D(TAG, "=====> RT : %s ", rt);
OCRepPayloadAddResourceType(payload, rt);
}
} else if (strstr(query, OC_RSRVD_INTERFACE_BATCH)) {
THINGS_LOG_D(TAG, "Batch only supported by Collection Resource");
} else if (strstr(query, OC_RSRVD_INTERFACE_LL)) {
THINGS_LOG_D(TAG, "Link-List only supported by Collection Resource");
} else {
THINGS_LOG_D(TAG, "Not supporting Interface type : %s", query);
}
return payload;
}
OCEntityHandlerRequest *CopyRequest(OCEntityHandlerRequest *entityHandlerRequest)
{
OC_LOG(INFO, TAG, "Copying received request for slow response");
OCEntityHandlerRequest *copyOfRequest =
(OCEntityHandlerRequest *)OICMalloc(sizeof(OCEntityHandlerRequest));
if (copyOfRequest)
{
// Do shallow copy
memcpy(copyOfRequest, entityHandlerRequest, sizeof(OCEntityHandlerRequest));
if (copyOfRequest->query)
{
copyOfRequest->query = OICStrdup(entityHandlerRequest->query);
if(!copyOfRequest->query)
{
OC_LOG(ERROR, TAG, "Copy failed due to allocation failure");
OICFree(copyOfRequest);
return NULL;
}
}
if (entityHandlerRequest->payload)
{
copyOfRequest->payload = reinterpret_cast<OCPayload*>
(OCRepPayloadClone ((OCRepPayload*) entityHandlerRequest->payload));
}
// Ignore vendor specific header options for example
copyOfRequest->numRcvdVendorSpecificHeaderOptions = 0;
copyOfRequest->rcvdVendorSpecificHeaderOptions = NULL;
}
if (copyOfRequest)
{
OC_LOG(INFO, TAG, "Copied client request");
}
else
{
OC_LOG(ERROR, TAG, "Error copying client request");
}
return copyOfRequest;
}
things_representation_s *things_create_representation_inst(void *rep_payload)
{
things_representation_s *rep = (things_representation_s *) things_malloc(sizeof(things_representation_s));
if (NULL == rep) {
THINGS_LOG_E(TAG, THINGS_MEMORY_ERROR);
return NULL;
}
rep->things_set_value = &things_set_value;
rep->things_set_bool_value = &things_set_bool_value;
rep->things_set_double_value = &things_set_double_value;
rep->things_set_int_value = &things_set_int_value;
rep->things_set_byte_value = &things_set_byte_value;
rep->things_set_object_value = &things_set_object_value;
rep->things_set_arrayvalue = &things_set_arrayvalue;
rep->things_get_arrayvalue = &things_get_arrayvalue;
rep->things_set_string_arrayvalue = &things_set_string_arrayvalue;
rep->things_get_string_arrayvalue = &things_get_string_arrayvalue;
rep->things_set_double_arrayvalue = &things_set_double_arrayvalue;
rep->things_get_double_arrayvalue = &things_get_double_arrayvalue;
rep->things_set_int_arrayvalue = &things_set_int_arrayvalue;
rep->things_get_int_arrayvalue = &things_get_int_arrayvalue;
rep->things_get_value = &things_get_value;
rep->things_get_bool_value = &things_get_bool_value;
rep->things_get_int_value = &things_get_int_value;
rep->things_get_double_value = &things_get_double_value;
rep->things_get_byte_value = &things_get_byte_value;
rep->things_get_object_value = &things_get_object_value;
rep->payload = NULL;
rep->children_payload = NULL;
rep->children = NULL;
rep->num_children = 0;
if (rep_payload != NULL) {
rep->payload = OCRepPayloadClone((OCRepPayload *) rep_payload);
} else {
rep->payload = OCRepPayloadCreate();
}
return rep;
}
static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
{
if (!source || !dest)
{
return;
}
switch(source->type)
{
case OCREP_PROP_STRING:
dest->str = OICStrdup(source->str);
break;
case OCREP_PROP_OBJECT:
dest->obj = OCRepPayloadClone(source->obj);
break;
case OCREP_PROP_ARRAY:
OCCopyPropertyValueArray(dest, source);
break;
default:
// Nothing to do for the trivially copyable types.
break;
}
}
static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
size_t dimTotal = calcDimTotal(source->arr.dimensions);
switch(source->arr.type)
{
case OCREP_PROP_INT:
dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
break;
case OCREP_PROP_DOUBLE:
dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
break;
case OCREP_PROP_BOOL:
dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
break;
case OCREP_PROP_STRING:
dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
for(size_t i = 0; i < dimTotal; ++i)
{
dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
}
break;
case OCREP_PROP_ARRAY:
dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
for(size_t i = 0; i < dimTotal; ++i)
{
dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
}
break;
default:
OC_LOG(ERROR, TAG, PCF("CopyPropertyValueArray invalid type"));
break;
}
}
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;
}
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 int _icd_state_array_from_list(OCRepPayload *repr,
struct icd_state_list_s *value_list, const char *key)
{
int i, len;
GList *node;
bool *b_arr;
double *d_arr;
char **str_arr;
int64_t *i_arr;
OCByteString *byte_arr;
union icd_state_value_u *value;
struct OCRepPayload **state_arr;
len = calcDimTotal(value_list->dimensions);
switch (value_list->type) {
case OCREP_PROP_INT:
i_arr = calloc(len, sizeof(int64_t));
if (NULL == i_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++) {
value = node->data;
i_arr[i] = value->i;
}
g_list_free_full(value_list->list, free);
OCRepPayloadSetIntArrayAsOwner(repr, key, i_arr, value_list->dimensions);
break;
case OCREP_PROP_BOOL:
b_arr = calloc(len, sizeof(bool));
if (NULL == b_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++) {
value = node->data;
b_arr[i] = value->b;
}
g_list_free_full(value_list->list, free);
OCRepPayloadSetBoolArrayAsOwner(repr, key, b_arr, value_list->dimensions);
break;
case OCREP_PROP_DOUBLE:
d_arr = calloc(len, sizeof(double));
if (NULL == d_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++) {
value = node->data;
d_arr[i] = value->d;
}
g_list_free_full(value_list->list, free);
OCRepPayloadSetDoubleArrayAsOwner(repr, key, d_arr, value_list->dimensions);
break;
case OCREP_PROP_STRING:
str_arr = calloc(len, sizeof(char *));
if (NULL == str_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++)
str_arr[i] = strdup(node->data);
g_list_free_full(value_list->list, free);
OCRepPayloadSetStringArrayAsOwner(repr, key, str_arr, value_list->dimensions);
break;
case OCREP_PROP_BYTE_STRING:
byte_arr = calloc(len, sizeof(OCByteString));
if (NULL == byte_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++) {
OCByteString *byte_str = node->data;
byte_arr[i].bytes = byte_str->bytes;
byte_arr[i].len = byte_str->len;
}
g_list_free(value_list->list);
OCRepPayloadSetByteStringArray(repr, key, byte_arr, value_list->dimensions);
break;
case OCREP_PROP_OBJECT:
state_arr = calloc(len, sizeof(struct OCRepPayload *));
if (NULL == state_arr) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
for (node = value_list->list, i = 0; node; node = node->next, i++)
state_arr[i] = OCRepPayloadClone(node->data);
g_list_free_full(value_list->list, _icd_payload_object_destroy);
OCRepPayloadSetPropObjectArrayAsOwner(repr, key, state_arr,
value_list->dimensions);
break;
case OCREP_PROP_ARRAY:
case OCREP_PROP_NULL:
default:
ERR("Invalid Type(%d)", value_list->type);
return IOTCON_ERROR_INVALID_TYPE;
}
return IOTCON_ERROR_NONE;
}
