/**
* @brief Create and loads the payload
*
* @return the created payload
*/
OCRepPayload *getPayload(OCEntityHandlerRequest *ehRequest, OCBaseResourceT *resource)
{
OIC_LOG(DEBUG, TAG, "Getting Payload");
if(ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
{
OIC_LOG(ERROR, TAG, "Incoming payload not a representation");
return NULL;
}
OCRepPayload *payload = OCRepPayloadCreate();
if(!payload)
{
OIC_LOG(ERROR, TAG, "Failed to allocate Payload");
return NULL;
}
OCRepPayloadSetUri(payload, resource->uri);
//OCRepPayloadSetPropString(payload, "name", resource->name);
return payload;
}
OCStackResult ProvisionEnrollee(OCQualityOfService qos, const char *query, const char *resUri,
OCDevAddr *destination, int pauseBeforeStart) {
// This sleep is required in case of BLE provisioning due to packet drop issue.
OIC_LOG_V(INFO, ES_PROV_TAG, "Sleeping for %d seconds", pauseBeforeStart);
sleep(pauseBeforeStart);
OIC_LOG_V(INFO, ES_PROV_TAG, "\n\nExecuting ProvisionEnrollee%s", __func__);
OCRepPayload *payload = OCRepPayloadCreate();
OCRepPayloadSetUri(payload, resUri);
OCRepPayloadSetPropString(payload, OC_RSRVD_ES_TNN, netProvInfo->netAddressInfo.WIFI.ssid);
OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CD, netProvInfo->netAddressInfo.WIFI.pwd);
OIC_LOG_V(DEBUG, ES_PROV_TAG, "OCPayload ready for ProvisionEnrollee");
OCStackResult ret = InvokeOCDoResource(query, OC_REST_PUT, destination, qos,
ProvisionEnrolleeResponse, payload, NULL, 0);
return ret;
}
//Client should call refresh before expiresin or when receive 4.01 during sign-in
OCStackResult OCCloudRefresh(const char *host, const char *query, const char *uId,
const char *deviceId, const char *refreshtoken, OCClientResponseHandler response)
{
char targetUri[MAX_URI_LENGTH * 2] = { 0, };
snprintf(targetUri, MAX_URI_LENGTH * 2, "%s%s", host, query);
OCCallbackData cbData;
memset(&cbData, 0, sizeof(OCCallbackData));
cbData.cb = response;
cbData.cd = NULL;
cbData.context = (void *)DEFAULT_CONTEXT_VALUE;
OCRepPayload *refreshPayload = OCRepPayloadCreate();
OCRepPayloadSetPropString(refreshPayload, "uid", uId);
OCRepPayloadSetPropString(refreshPayload, "di", deviceId);
OCRepPayloadSetPropString(refreshPayload, "granttype", "refresh_token");
OCRepPayloadSetPropString(refreshPayload, "refreshtoken", refreshtoken);
return OCDoResource(NULL, OC_REST_POST, targetUri, NULL, (OCPayload *)refreshPayload,
CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
}
OCRepPayload* constructResponse(OCEntityHandlerRequest *ehRequest)
{
OCRepPayload* payload = OCRepPayloadCreate();
if (!payload)
{
OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
return NULL;
}
if (ehRequest->resource == gProvResource.handle)
{
OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PS, gProvResource.ps);
OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_TNT, gProvResource.tnt);
}
else if (ehRequest->requestHandle == gNetResource.handle)
{
OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_NET);
OCRepPayloadSetPropInt(payload, "ant", gNetResource.ant[0]);
}
return payload;
}
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 OCStackResult
HandleBatchInterface(OCEntityHandlerRequest *ehRequest)
{
if (!ehRequest)
{
return OC_STACK_INVALID_PARAM;
}
OCResource * collResource = (OCResource *) ehRequest->resource;
OCRepPayload* payload = OCRepPayloadCreate();
if (!payload)
{
return OC_STACK_NO_MEMORY;
}
if (collResource)
{
OCRepPayloadSetUri(payload, collResource->uri);
}
OCEntityHandlerResponse response = {0};
response.ehResult = OC_EH_OK;
response.payload = (OCPayload*)payload;
response.persistentBufferFlag = 0;
response.requestHandle = (OCRequestHandle) ehRequest->requestHandle;
response.resourceHandle = (OCResourceHandle) collResource;
OCStackResult stackRet = OCDoResponse(&response);
if (stackRet == OC_STACK_OK)
{
for (uint8_t i = 0; i < MAX_CONTAINED_RESOURCES; i++)
{
OCResource* temp = collResource->rsrcResources[i];
if (temp)
{
// Note that all entity handlers called through a collection
// will get the same pointer to ehRequest, the only difference
// is ehRequest->resource
ehRequest->resource = (OCResourceHandle) temp;
OCEntityHandlerResult ehResult = temp->entityHandler(OC_REQUEST_FLAG, ehRequest,
temp->entityHandlerCallbackParam);
// The default collection handler is returning as OK
if (stackRet != OC_STACK_SLOW_RESOURCE)
{
stackRet = OC_STACK_OK;
}
// if a single resource is slow, then entire response will be treated
// as slow response
if (ehResult == OC_EH_SLOW)
{
OC_LOG(INFO, TAG, "This is a slow resource");
((OCServerRequest *)ehRequest->requestHandle)->slowFlag = 1;
stackRet = EntityHandlerCodeToOCStackCode(ehResult);
}
}
else
{
break;
}
}
ehRequest->resource = (OCResourceHandle) collResource;
}
return stackRet;
}
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;
}
// This is the entity handler for the registered resource.
// This is invoked by OCStack whenever it recevies a request for this resource.
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, "/a/light");
OCRepPayloadSetPropBool(payload, "state", true);
OCRepPayloadSetPropInt(payload, "power", 10);
}
else if(OC_REST_PUT == entityHandlerRequest->method)
{
//Do something with the 'put' payload
OCRepPayloadSetUri(payload, "/a/light");
OCRepPayloadSetPropBool(payload, "state", false);
OCRepPayloadSetPropInt(payload, "power", 0);
}
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"));
}
}
return ehRet;
}
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;
}
OCStackResult SendListObserverNotification (OCResource * resource,
OCObservationId *obsIdList, uint8_t numberOfIds,
const OCRepPayload *payload,
uint32_t maxAge,
OCQualityOfService qos)
{
(void)maxAge;
if(!resource || !obsIdList || !payload)
{
return OC_STACK_INVALID_PARAM;
}
uint8_t numIds = numberOfIds;
ResourceObserver *observer = NULL;
uint8_t numSentNotification = 0;
OCServerRequest * request = NULL;
OCStackResult result = OC_STACK_ERROR;
bool observeErrorFlag = false;
OC_LOG(INFO, TAG, "Entering SendListObserverNotification");
while(numIds)
{
observer = GetObserverUsingId (*obsIdList);
if(observer)
{
// Found observer - verify if it matches the resource handle
if (observer->resource == resource)
{
qos = DetermineObserverQoS(OC_REST_GET, observer, qos);
result = AddServerRequest(&request, 0, 0, 1, OC_REST_GET,
0, resource->sequenceNum, qos, observer->query,
NULL, NULL, observer->token, observer->tokenLength,
observer->resUri, 0, observer->acceptFormat,
&observer->devAddr);
if(request)
{
request->observeResult = OC_STACK_OK;
if(result == OC_STACK_OK)
{
OCEntityHandlerResponse ehResponse = {0};
ehResponse.ehResult = OC_EH_OK;
ehResponse.payload = (OCPayload*)OCRepPayloadCreate();
if(!ehResponse.payload)
{
FindAndDeleteServerRequest(request);
continue;
}
memcpy(ehResponse.payload, payload, sizeof(*payload));
ehResponse.persistentBufferFlag = 0;
ehResponse.requestHandle = (OCRequestHandle) request;
ehResponse.resourceHandle = (OCResourceHandle) resource;
result = OCDoResponse(&ehResponse);
if(result == OC_STACK_OK)
{
OC_LOG_V(INFO, TAG, "Observer id %d notified.", *obsIdList);
// Increment only if OCDoResponse is successful
numSentNotification++;
OICFree(ehResponse.payload);
FindAndDeleteServerRequest(request);
}
else
{
OC_LOG_V(INFO, TAG, "Error notifying observer id %d.", *obsIdList);
}
}
else
{
FindAndDeleteServerRequest(request);
}
}
// Since we are in a loop, set an error flag to indicate
// at least one error occurred.
if (result != OC_STACK_OK)
{
observeErrorFlag = true;
}
}
}
obsIdList++;
numIds--;
}
if(numSentNotification == numberOfIds && !observeErrorFlag)
{
return OC_STACK_OK;
}
else if(numSentNotification == 0)
{
return OC_STACK_NO_OBSERVERS;
}
else
{
OC_LOG(ERROR, TAG, "Observer notification error");
return OC_STACK_ERROR;
}
}
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;
}
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 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;
}
OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest,
OCEntityHandlerResponse *response, OCRepPayload** payload)
{
OCEntityHandlerResult ehResult = OC_EH_OK;
OCRepPayload *respPLPost_light = nullptr;
/*
* The entity handler determines how to process a POST request.
* Per the REST paradigm, POST can also be used to update representation of existing
* resource or create a new resource.
* In the sample below, if the POST is for /a/light then a new instance of the Light
* resource is created with default representation (if representation is included in
* POST payload it can be used as initial values) as long as the instance is
* lesser than max new instance count. Once max instance count is reached, POST on
* /a/light updated the representation of /a/light (just like PUT)
*/
if (ehRequest->resource == Light.handle)
{
if (gCurrLightInstance < SAMPLE_MAX_NUM_POST_INSTANCE)
{
// Create new Light instance
char newLightUri[URI_MAXSIZE];
snprintf(newLightUri, URI_MAXSIZE, "/a/light/%d", gCurrLightInstance);
respPLPost_light = OCRepPayloadCreate();
OCRepPayloadSetUri(respPLPost_light, gResourceUri);
OCRepPayloadSetPropString(respPLPost_light, "createduri", newLightUri);
if (0 == createLightResource (newLightUri, &gLightInstance[gCurrLightInstance]))
{
OIC_LOG (INFO, TAG, "Created new Light instance\n");
gLightInstance[gCurrLightInstance].state = 0;
gLightInstance[gCurrLightInstance].power = 0;
gCurrLightInstance++;
strncpy ((char *)response->resourceUri, newLightUri, MAX_URI_LENGTH);
ehResult = OC_EH_RESOURCE_CREATED;
}
}
else
{
// Update repesentation of /a/light
Light.state = true;
Light.power = 11;
respPLPost_light = constructResponse(ehRequest);
}
}
else
{
for (int i = 0; i < SAMPLE_MAX_NUM_POST_INSTANCE; i++)
{
if (ehRequest->resource == gLightInstance[i].handle)
{
gLightInstance[i].state = true;
gLightInstance[i].power = 22;
if (i == 0)
{
respPLPost_light = constructResponse(ehRequest);
break;
}
else if (i == 1)
{
respPLPost_light = constructResponse(ehRequest);
}
}
}
}
if ((respPLPost_light != NULL))
{
*payload = respPLPost_light;
}
else
{
OIC_LOG(INFO, TAG, "Payload was NULL");
ehResult = OC_EH_ERROR;
}
return ehResult;
}
OCEntityHandlerResult BuzzerOCEntityHandlerCb(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/buzzer");
OCRepPayloadSetPropInt(payload, "tone", buzzer.tone);
} else if(OC_REST_PUT == entityHandlerRequest->method) {
int64_t tone;
OC_LOG(INFO, TAG, ("PUT request"));
OCRepPayload *rep = (OCRepPayload *)entityHandlerRequest->payload;
OCRepPayloadGetPropInt(rep, "tone", &tone);
if(tone > 1915)
tone = 1915;
else if(tone < 956)
tone = 956;
buzzer.tone = (int)tone;
OC_LOG_V(INFO, TAG, "Buzzer tone: %d", buzzer.tone);
buzzer_put();
OCRepPayloadSetPropInt(payload, "tone", buzzer.tone);
}
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;
}
void CHPJsonToRepPayload(cJSON* rootJSon, OCRepPayload* payload)
{
cJSON* dataJson = rootJSon->child;
while (dataJson)
{
switch (dataJson->type)
{
case cJSON_String:
OCRepPayloadSetPropString(payload, dataJson->string, dataJson->valuestring);
break;
case cJSON_Number:
if (dataJson->valueint == dataJson->valuedouble)
{
OCRepPayloadSetPropInt(payload, dataJson->string, dataJson->valueint);
}
else
{
OCRepPayloadSetPropDouble(payload, dataJson->string, dataJson->valuedouble);
}
break;
case cJSON_False:
OCRepPayloadSetPropBool(payload, dataJson->string, false);
break;
case cJSON_True:
OCRepPayloadSetPropBool(payload, dataJson->string, true);
break;
case cJSON_Object:
{
OCRepPayload* childPayload = OCRepPayloadCreate();
CHPJsonToRepPayload(dataJson,childPayload);
OCRepPayloadSetPropObject(payload, dataJson->string,childPayload );
break;
}
case cJSON_Array:
{
int size = cJSON_GetArraySize(dataJson);
size_t dimensions[MAX_REP_ARRAY_DEPTH];
dimensions[0] = size;
dimensions[1] = dimensions[2] = 0;
int i = 0;
int type = cJSON_IsReference;
int numType = 0; // int:1, double:2
const int intType = 1;
const int doubleType = 2;
int64_t intArray[size];
double doubleArray[size];
char* strArray[size];
OCRepPayload* objPayloadArray[size];
for (; i < size ; ++i)
{
cJSON* subitem = cJSON_GetArrayItem(dataJson, i);
if (subitem == NULL)
{
continue;
}
if ((type != cJSON_IsReference) && (type != subitem->type))
{
continue;
}
else
{
type = subitem->type;
switch (type)
{
case cJSON_Number:
if (subitem->valueint == subitem->valuedouble)
{
numType = intType;
intArray[i] = (int64_t) subitem->valueint;
}
else
{
numType = doubleType;
doubleArray[i] = subitem->valuedouble;
}
break;
case cJSON_String:
strArray[i] = subitem->valuestring;
break;
case cJSON_Object:
objPayloadArray[i] = OCRepPayloadCreate();
CHPJsonToRepPayload(subitem,objPayloadArray[i]);
break;
default:
OIC_LOG(ERROR, TAG, "wrong ArrayType in JsonToRepPayload()");
break;
}
}
}
switch (type)
{
case cJSON_Number:
if (numType == intType)
{
OCRepPayloadSetIntArray(payload, dataJson->string,(const int64_t*)intArray,
dimensions);
}
else if (numType == doubleType)
{
OCRepPayloadSetDoubleArray(payload, dataJson->string,
(const double*)doubleArray,
dimensions);
}
break;
case cJSON_String:
OCRepPayloadSetStringArray(payload, dataJson->string,
(const char**)strArray,
dimensions);
break;
case cJSON_Object:
OCRepPayloadSetPropObjectArray(payload, dataJson->string,
(const OCRepPayload**)objPayloadArray,
dimensions);
break;
default:
OIC_LOG(ERROR, TAG, "wrong ArrayType in JsonToRepPayload()");
break;
}
break;
}
}
dataJson = dataJson->next;
}
}
virtual void SetUp() {
// Create Payload
payload_in = OCRepPayloadCreate();
ASSERT_TRUE(payload_in != NULL);
}
OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest,
OCEntityHandlerResponse *response, OCRepPayload **payload)
{
OCRepPayload *respPLPost_led = NULL;
OCEntityHandlerResult ehResult = OC_EH_OK;
/*
* The entity handler determines how to process a POST request.
* Per the REST paradigm, POST can also be used to update representation of existing
* resource or create a new resource.
* In the sample below, if the POST is for /a/led then a new instance of the LED
* resource is created with default representation (if representation is included in
* POST payload it can be used as initial values) as long as the instance is
* lesser than max new instance count. Once max instance count is reached, POST on
* /a/led updated the representation of /a/led (just like PUT)
*/
if (ehRequest->resource == LED.handle)
{
if (gCurrLedInstance < SAMPLE_MAX_NUM_POST_INSTANCE)
{
// Create new LED instance
char newLedUri[15] = "/a/led/";
int newLedUriLength = strlen(newLedUri);
snprintf (newLedUri + newLedUriLength, sizeof(newLedUri)-newLedUriLength, "%d", gCurrLedInstance);
respPLPost_led = OCRepPayloadCreate();
OCRepPayloadSetUri(respPLPost_led, gResourceUri);
OCRepPayloadSetPropString(respPLPost_led, "createduri", newLedUri);
if (0 == createLEDResource (newLedUri, &gLedInstance[gCurrLedInstance], false, 0))
{
OIC_LOG (INFO, TAG, "Created new LED instance");
gLedInstance[gCurrLedInstance].state = 0;
gLedInstance[gCurrLedInstance].power = 0;
gCurrLedInstance++;
strncpy ((char *)response->resourceUri, newLedUri, MAX_URI_LENGTH);
ehResult = OC_EH_RESOURCE_CREATED;
}
}
else
{
respPLPost_led = constructResponse(ehRequest);
}
}
else
{
for (int i = 0; i < SAMPLE_MAX_NUM_POST_INSTANCE; i++)
{
if (ehRequest->resource == gLedInstance[i].handle)
{
if (i == 0)
{
respPLPost_led = constructResponse(ehRequest);
break;
}
else if (i == 1)
{
respPLPost_led = constructResponse(ehRequest);
}
}
}
}
if (respPLPost_led != NULL)
{
*payload = respPLPost_led;
ehResult = OC_EH_OK;
}
else
{
OIC_LOG_V (INFO, TAG, "Payload was NULL");
ehResult = OC_EH_ERROR;
}
return ehResult;
}
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;
}
