OCDevAddr *devAddr, char * requestUri,
char * resourceTypeName, uint32_t ttl)
{
- if(!clientCB || !cbData || !handle || !requestUri || tokenLength > CA_MAX_TOKEN_LEN)
+ if (!clientCB || !cbData || !handle || !requestUri || tokenLength > CA_MAX_TOKEN_LEN)
{
return OC_STACK_INVALID_PARAM;
}
ClientCB *cbNode = NULL;
#ifdef WITH_PRESENCE
- if(method == OC_REST_PRESENCE)
+ if (method == OC_REST_PRESENCE)
{ // Retrieve the presence callback structure for this specific requestUri.
cbNode = GetClientCB(NULL, 0, NULL, requestUri);
}
-#endif // WITH_PRESENCE
- if(!cbNode)// If it does not already exist, create new node.
+ if (!cbNode)// If it does not already exist, create new node.
+#endif // WITH_PRESENCE
{
cbNode = (ClientCB*) OICMalloc(sizeof(ClientCB));
- if(!cbNode)
+ if (!cbNode)
{
*clientCB = NULL;
goto exit;
cbNode->handle = *handle;
cbNode->method = method;
cbNode->sequenceNumber = 0;
- #ifdef WITH_PRESENCE
+#ifdef WITH_PRESENCE
cbNode->presence = NULL;
cbNode->filterResourceType = NULL;
- #endif // WITH_PRESENCE
+#endif // WITH_PRESENCE
if (method == OC_REST_PRESENCE ||
method == OC_REST_OBSERVE ||
*clientCB = cbNode;
}
}
+#ifdef WITH_PRESENCE
else
{
// Ensure that the handle the SDK hands back up to the application layer for the
*handle = cbNode->handle;
}
-#ifdef WITH_PRESENCE
- if(method == OC_REST_PRESENCE && resourceTypeName)
+ if (method == OC_REST_PRESENCE && resourceTypeName)
{
// Amend the found or created node by adding a new resourceType to it.
return InsertResourceTypeFilter(cbNode,(char *)resourceTypeName);
return OC_STACK_OK;
exit:
- return OC_STACK_NO_MEMORY;
+ return OC_STACK_NO_MEMORY;
}
void DeleteClientCB(ClientCB * cbNode)
{
- if(cbNode)
+ if (cbNode)
{
LL_DELETE(cbList, cbNode);
OC_LOG (INFO, TAG, "Deleting token");
OICFree(cbNode->handle);
OC_LOG_V (INFO, TAG, "Deleting callback with uri %s", cbNode->requestUri);
OICFree(cbNode->requestUri);
- if(cbNode->deleteCallback)
+ if (cbNode->deleteCallback)
{
cbNode->deleteCallback(cbNode->context);
}
#ifdef WITH_PRESENCE
- if(cbNode->presence)
+ if (cbNode->presence)
{
OICFree(cbNode->presence->timeOut);
OICFree(cbNode->presence);
}
- if(cbNode->method == OC_REST_PRESENCE)
+ if (cbNode->method == OC_REST_PRESENCE)
{
OCResourceType * pointer = cbNode->filterResourceType;
OCResourceType * next = NULL;
ClientCB* GetClientCB(const CAToken_t token, uint8_t tokenLength,
OCDoHandle handle, const char * requestUri)
{
-
ClientCB* out = NULL;
- if(token && *token && tokenLength <= CA_MAX_TOKEN_LEN && tokenLength > 0)
+ if (token && *token && tokenLength <= CA_MAX_TOKEN_LEN && tokenLength > 0)
{
OC_LOG (INFO, TAG, "Looking for token");
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
{
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->token, tokenLength);
- if(memcmp(out->token, token, tokenLength) == 0)
+ if (memcmp(out->token, token, tokenLength) == 0)
{
return out;
}
CheckAndDeleteTimedOutCB(out);
}
}
- else if(handle)
+ else if (handle)
{
LL_FOREACH(cbList, out)
{
- if(out->handle == handle)
+ if (out->handle == handle)
{
return out;
}
CheckAndDeleteTimedOutCB(out);
}
}
- else if(requestUri)
+ else if (requestUri)
{
OC_LOG_V(INFO, TAG, "Looking for uri %s", requestUri);
LL_FOREACH(cbList, out)
{
OC_LOG_V(INFO, TAG, "\tFound %s", out->requestUri);
- if(out->requestUri && strcmp(out->requestUri, requestUri ) == 0)
+ if (out->requestUri && strcmp(out->requestUri, requestUri ) == 0)
{
return out;
}
OCStackResult InsertResourceTypeFilter(ClientCB * cbNode, char * resourceTypeName)
{
OCResourceType * newResourceType = NULL;
- if(cbNode && resourceTypeName)
+ if (cbNode && resourceTypeName)
{
// Form a new resourceType member.
newResourceType = (OCResourceType *) OICMalloc(sizeof(OCResourceType));
- if(!newResourceType)
+ if (!newResourceType)
{
return OC_STACK_NO_MEMORY;
}
void FindAndDeleteClientCB(ClientCB * cbNode)
{
ClientCB* tmp;
- if(cbNode)
+ if (cbNode)
{
LL_FOREACH(cbList, tmp)
{
OCStackResult AddMCPresenceNode(OCMulticastNode** outnode, char* uri, uint32_t nonce)
{
- if(!outnode)
+ if (!outnode)
{
return OC_STACK_INVALID_PARAM;
}
- OCMulticastNode *node;
-
- node = (OCMulticastNode*) OICMalloc(sizeof(OCMulticastNode));
-
+ OCMulticastNode *node = (OCMulticastNode*) OICMalloc(sizeof(*node));
if (node)
{
node->nonce = nonce;
OCMulticastNode* GetMCPresenceNode(const char * uri)
{
- OCMulticastNode* out = NULL;
-
- if(uri)
+ if (uri)
{
+ OCMulticastNode* out = NULL;
LL_FOREACH(mcPresenceNodes, out)
{
- if(out->uri && strcmp(out->uri, uri) == 0)
+ if (out->uri && strcmp(out->uri, uri) == 0)
{
return out;
}
OC_LOG(INFO, TAG, "MulticastNode Not found !!");
return NULL;
}
-
static OCStackResult CheckRTParamSupport(const OCResource* resource, const char* rtPtr)
{
- if(!resource || !rtPtr)
+ if (!resource || !rtPtr)
{
return OC_STACK_INVALID_PARAM;
}
OCResourceType* rTPointer = resource->rsrcType;
while (rTPointer)
{
- if( strcmp (rTPointer->resourcetypename, rtPtr) == 0)
+ if (strcmp(rTPointer->resourcetypename, rtPtr) == 0)
{
return OC_STACK_OK;
}
static OCStackResult CheckIFParamSupport(const OCResource* resource, const char* ifPtr)
{
- if(!resource || !ifPtr)
+ if (!resource || !ifPtr)
{
return OC_STACK_INVALID_PARAM;
}
OCResourceInterface* iFPointer = resource->rsrcInterface;
while (iFPointer)
{
- if( strcmp (iFPointer->name, ifPtr) == 0)
+ if (strcmp(iFPointer->name, ifPtr) == 0)
{
return OC_STACK_OK;
}
static OCStackResult
ValidateQuery (const char *query, OCResourceHandle resource,
- OCStackIfTypes *ifParam, char **rtParam)
+ OCStackIfTypes *ifParam, char **rtParam)
{
uint8_t numFields = 0;
uint8_t numParam;
return OC_STACK_ERROR;
}
- if(!ifParam || !rtParam)
+ if (!ifParam || !rtParam)
{
return OC_STACK_INVALID_PARAM;
}
if (ifPtr)
{
- if(CheckIFParamSupport((OCResource *)resource, ifPtr) != OC_STACK_OK)
+ if (CheckIFParamSupport((OCResource *)resource, ifPtr) != OC_STACK_OK)
{
return OC_STACK_INVALID_QUERY;
}
{
*ifParam = STACK_IF_BATCH;
}
- else if(strcmp (ifPtr, OC_RSRVD_INTERFACE_GROUP) == 0)
+ else if (strcmp (ifPtr, OC_RSRVD_INTERFACE_GROUP) == 0)
{
*ifParam = STACK_IF_GROUP;
}
{
(void)filterOn;
(void)filterValue;
- if(!ehRequest)
+ 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);
- }
-
+ OCStackResult ret = BuildResponseRepresentation(collResource, &payload);
if (ret == OC_STACK_OK)
{
- for (int i = 0; i < MAX_CONTAINED_RESOURCES && ret == OC_STACK_OK; i++)
+ for (size_t i = 0; i < MAX_CONTAINED_RESOURCES && ret == OC_STACK_OK; i++)
{
- OCResource* temp = collResource->rsrcResources[i];
- if (temp)
+ if (collResource)
{
- //TODO : Add resource type filtering once collections
- // start supporting queries.
- ret = BuildResponseRepresentation(temp, &payload);
+ 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)
+ if (ret == OC_STACK_OK)
{
OCEntityHandlerResponse response = {0};
response.ehResult = OC_EH_OK;
return OC_STACK_INVALID_PARAM;
}
- OCStackResult stackRet = OC_STACK_OK;
- OCEntityHandlerResult ehResult = OC_EH_ERROR;
OCResource * collResource = (OCResource *) ehRequest->resource;
OCRepPayload* payload = OCRepPayloadCreate();
- if(!payload)
+ if (!payload)
{
- stackRet = OC_STACK_NO_MEMORY;
+ return OC_STACK_NO_MEMORY;
}
- if(stackRet == OC_STACK_OK)
+ if (collResource)
{
- if (collResource)
- {
- OCRepPayloadSetUri(payload, collResource->uri);
- }
+ OCRepPayloadSetUri(payload, collResource->uri);
}
- if(stackRet == 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;
- stackRet = OCDoResponse(&response);
- }
+ 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++)
+ for (uint8_t i = 0; i < MAX_CONTAINED_RESOURCES; i++)
{
OCResource* temp = collResource->rsrcResources[i];
if (temp)
// is ehRequest->resource
ehRequest->resource = (OCResourceHandle) temp;
- ehResult = temp->entityHandler(OC_REQUEST_FLAG, ehRequest,
- temp->entityHandlerCallbackParam);
+ OCEntityHandlerResult ehResult = temp->entityHandler(OC_REQUEST_FLAG, ehRequest,
+ temp->entityHandlerCallbackParam);
// The default collection handler is returning as OK
- if(stackRet != OC_STACK_SLOW_RESOURCE)
+ 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)
+ if (ehResult == OC_EH_SLOW)
{
OC_LOG(INFO, TAG, "This is a slow resource");
((OCServerRequest *)ehRequest->requestHandle)->slowFlag = 1;
uint8_t GetNumOfResourcesInCollection (OCResource *resource)
{
- if(resource)
+ if (resource)
{
uint8_t num = 0;
for (uint8_t i = 0; i < MAX_CONTAINED_RESOURCES; i++)
OCStackResult DefaultCollectionEntityHandler (OCEntityHandlerFlag flag,
OCEntityHandlerRequest *ehRequest)
{
- if(!ehRequest || !ehRequest->query)
+ if (!ehRequest || !ehRequest->query)
{
return OC_STACK_INVALID_PARAM;
}
- OCStackResult result = OC_STACK_ERROR;
- OCStackIfTypes ifQueryParam = STACK_IF_INVALID;
- char *rtQueryParam = NULL;
-
OC_LOG_V(INFO, TAG, "DefaultCollectionEntityHandler with query %s", ehRequest->query);
if (flag != OC_REQUEST_FLAG)
return OC_STACK_ERROR;
}
- result = ValidateQuery (ehRequest->query,
- ehRequest->resource, &ifQueryParam, &rtQueryParam);
+ OCStackIfTypes ifQueryParam = STACK_IF_INVALID;
+ char *rtQueryParam = NULL;
+ OCStackResult result = ValidateQuery (ehRequest->query,
+ ehRequest->resource, &ifQueryParam, &rtQueryParam);
if (result != OC_STACK_OK)
{
#define VERIFY_NON_NULL(arg) { if (!arg) {OC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
-static struct ResourceObserver * serverObsList = NULL;
+static struct ResourceObserver * g_serverObsList = NULL;
/**
* Determine observe QOS based on the QOS of the request.
* The qos passed as a parameter overrides what the client requested.
static OCQualityOfService DetermineObserverQoS(OCMethod method,
ResourceObserver * resourceObserver, OCQualityOfService appQoS)
{
- if(!resourceObserver)
+ if (!resourceObserver)
{
OC_LOG(ERROR, TAG, "DetermineObserverQoS called with invalid resourceObserver");
return OC_NA_QOS;
}
OCQualityOfService decidedQoS = appQoS;
- if(appQoS == OC_NA_QOS)
+ if (appQoS == OC_NA_QOS)
{
decidedQoS = resourceObserver->qos;
}
- if(appQoS != OC_HIGH_QOS)
+ if (appQoS != OC_HIGH_QOS)
{
OC_LOG_V(INFO, TAG, "Current NON count for this observer is %d",
resourceObserver->lowQosCount);
#ifdef WITH_PRESENCE
- if((resourceObserver->forceHighQos \
+ if ((resourceObserver->forceHighQos \
|| resourceObserver->lowQosCount >= MAX_OBSERVER_NON_COUNT) \
&& method != OC_REST_PRESENCE)
#else
- if(resourceObserver->forceHighQos \
+ if (resourceObserver->forceHighQos \
|| resourceObserver->lowQosCount >= MAX_OBSERVER_NON_COUNT)
#endif
{
#endif
{
OC_LOG(INFO, TAG, "Entering SendObserverNotification");
- if(!resPtr)
+ if (!resPtr)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult result = OC_STACK_ERROR;
- ResourceObserver * resourceObserver = serverObsList;
+ ResourceObserver * resourceObserver = g_serverObsList;
uint8_t numObs = 0;
OCServerRequest * request = NULL;
OCEntityHandlerRequest ehRequest = {0};
{
numObs++;
#ifdef WITH_PRESENCE
- if(method != OC_REST_PRESENCE)
+ if (method != OC_REST_PRESENCE)
{
#endif
qos = DetermineObserverQoS(method, resourceObserver, qos);
resourceObserver->resUri, 0, resourceObserver->acceptFormat,
&resourceObserver->devAddr);
- if(request)
+ if (request)
{
request->observeResult = OC_STACK_OK;
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
result = FormOCEntityHandlerRequest(
&ehRequest,
request->rcvdVendorSpecificHeaderOptions,
OC_OBSERVE_NO_OPTION,
0);
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
ehResult = resPtr->entityHandler(OC_REQUEST_FLAG, &ehRequest,
resPtr->entityHandlerCallbackParam);
- if(ehResult == OC_EH_ERROR)
+ if (ehResult == OC_EH_ERROR)
{
FindAndDeleteServerRequest(request);
}
resourceObserver->resUri, 0, resourceObserver->acceptFormat,
&resourceObserver->devAddr);
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
OCPresencePayload* presenceResBuf = OCPresencePayloadCreate(
resPtr->sequenceNum, maxAge, trigger,
resourceType ? resourceType->resourcetypename : NULL);
- if(!presenceResBuf)
+ if (!presenceResBuf)
{
return OC_STACK_NO_MEMORY;
}
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
ehResponse.ehResult = OC_EH_OK;
ehResponse.payload = (OCPayload*)presenceResBuf;
OCQualityOfService qos)
{
(void)maxAge;
- if(!resource || !obsIdList || !payload)
+ if (!resource || !obsIdList || !payload)
{
return OC_STACK_INVALID_PARAM;
}
while(numIds)
{
observer = GetObserverUsingId (*obsIdList);
- if(observer)
+ if (observer)
{
// Found observer - verify if it matches the resource handle
if (observer->resource == resource)
observer->resUri, 0, observer->acceptFormat,
&observer->devAddr);
- if(request)
+ if (request)
{
request->observeResult = OC_STACK_OK;
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
OCEntityHandlerResponse ehResponse = {0};
ehResponse.ehResult = OC_EH_OK;
ehResponse.payload = (OCPayload*)OCRepPayloadCreate();
- if(!ehResponse.payload)
+ if (!ehResponse.payload)
{
FindAndDeleteServerRequest(request);
continue;
ehResponse.requestHandle = (OCRequestHandle) request;
ehResponse.resourceHandle = (OCResourceHandle) resource;
result = OCDoResponse(&ehResponse);
- if(result == OC_STACK_OK)
+ if (result == OC_STACK_OK)
{
OC_LOG_V(INFO, TAG, "Observer id %d notified.", *obsIdList);
numIds--;
}
- if(numSentNotification == numberOfIds && !observeErrorFlag)
+ if (numSentNotification == numberOfIds && !observeErrorFlag)
{
return OC_STACK_OK;
}
- else if(numSentNotification == 0)
+ else if (numSentNotification == 0)
{
return OC_STACK_NO_OBSERVERS;
}
{
return OC_STACK_RESOURCE_ERROR;
}
- ResourceObserver *obsNode = NULL;
- if(!resUri || !token || !*token)
+ if (!resUri || !token || !*token)
{
return OC_STACK_INVALID_PARAM;
}
- obsNode = (ResourceObserver *) OICCalloc(1, sizeof(ResourceObserver));
+ ResourceObserver *obsNode = (ResourceObserver *) OICCalloc(1, sizeof(ResourceObserver));
if (obsNode)
{
obsNode->observeId = obsId;
obsNode->qos = qos;
obsNode->acceptFormat = acceptFormat;
- if(query)
+ if (query)
{
obsNode->query = OICStrdup(query);
VERIFY_NON_NULL (obsNode->query);
}
// If tokenLength is zero, the return value depends on the
// particular library implementation (it may or may not be a null pointer).
- if(tokenLength)
+ if (tokenLength)
{
obsNode->token = (CAToken_t)OICMalloc(tokenLength);
VERIFY_NON_NULL (obsNode->token);
obsNode->devAddr = *devAddr;
obsNode->resource = resHandle;
- LL_APPEND (serverObsList, obsNode);
+ LL_APPEND (g_serverObsList, obsNode);
return OC_STACK_OK;
}
if (observeId)
{
- LL_FOREACH (serverObsList, out)
+ LL_FOREACH (g_serverObsList, out)
{
if (out->observeId == observeId)
{
{
ResourceObserver *out = NULL;
- if(token && *token)
+ if (token && *token)
{
OC_LOG(INFO, TAG, "Looking for token");
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
OC_LOG(INFO, TAG, "\tFound token:");
- LL_FOREACH (serverObsList, out)
+ LL_FOREACH (g_serverObsList, out)
{
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->token, tokenLength);
- if((memcmp(out->token, token, tokenLength) == 0))
+ if ((memcmp(out->token, token, tokenLength) == 0))
{
return out;
}
OCStackResult DeleteObserverUsingToken (CAToken_t token, uint8_t tokenLength)
{
- if(!token || !*token)
+ if (!token || !*token)
{
return OC_STACK_INVALID_PARAM;
}
- ResourceObserver *obsNode = NULL;
-
- obsNode = GetObserverUsingToken (token, tokenLength);
+ ResourceObserver *obsNode = GetObserverUsingToken (token, tokenLength);
if (obsNode)
{
OC_LOG_V(INFO, TAG, "deleting observer id %u with token", obsNode->observeId);
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)obsNode->token, tokenLength);
- LL_DELETE (serverObsList, obsNode);
+ LL_DELETE (g_serverObsList, obsNode);
OICFree(obsNode->resUri);
OICFree(obsNode->query);
OICFree(obsNode->token);
{
ResourceObserver *out = NULL;
ResourceObserver *tmp = NULL;
- LL_FOREACH_SAFE (serverObsList, out, tmp)
+ LL_FOREACH_SAFE (g_serverObsList, out, tmp)
{
- if(out)
+ if (out)
{
DeleteObserverUsingToken ((out->token), out->tokenLength);
}
}
- serverObsList = NULL;
+ g_serverObsList = NULL;
}
/*
uint8_t numOptions,
uint8_t observeFlag)
{
- if(!caHdrOpt)
+ if (!caHdrOpt)
{
return OC_STACK_INVALID_PARAM;
}
CAHeaderOption_t *options,
uint8_t * numOptions)
{
- if(!observationOption)
+ if (!observationOption)
{
return OC_STACK_INVALID_PARAM;
}
- if(!options || !numOptions)
+ if (!options || !numOptions)
{
OC_LOG (INFO, TAG, "No options present");
return OC_STACK_OK;
for(uint8_t i = 0; i < *numOptions; i++)
{
- if(options[i].protocolID == CA_COAP_ID &&
+ if (options[i].protocolID == CA_COAP_ID &&
options[i].optionID == COAP_OPTION_OBSERVE)
{
*observationOption = options[i].optionData[0];
void OCPayloadDestroy(OCPayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
{
OCRepPayload* payload = (OCRepPayload*)OICCalloc(1, sizeof(OCRepPayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
void OCRepPayloadAppend(OCRepPayload* parent, OCRepPayload* child)
{
- if(!parent)
+ if (!parent)
{
return;
}
static OCRepPayloadValue* OCRepPayloadFindValue(const OCRepPayload* payload, const char* name)
{
- if(!payload || !name)
+ if (!payload || !name)
{
return NULL;
}
OCRepPayloadValue* val = payload->values;
while(val)
{
- if(0 == strcmp(val->name, name))
+ if (0 == strcmp(val->name, name))
{
return val;
}
}
return NULL;
-
}
static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
- if(!dest || !source)
+ if (!dest || !source)
{
return;
}
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val)
{
- if(!val)
+ if (!val)
{
return;
}
- if(val->type == OCREP_PROP_STRING)
+ if (val->type == OCREP_PROP_STRING)
{
OICFree(val->str);
}
- else if(val->type == OCREP_PROP_BYTE_STRING)
+ else if (val->type == OCREP_PROP_BYTE_STRING)
{
OICFree(val->ocByteStr.bytes);
}
OICFree(val->arr.iArray);
break;
case OCREP_PROP_STRING:
- for(size_t i = 0; i< dimTotal;++i)
+ for(size_t i = 0; i< dimTotal; ++i)
{
OICFree(val->arr.strArray[i]);
}
OICFree(val->arr.ocByteStrArray);
break;
case OCREP_PROP_OBJECT:
- for(size_t i = 0; i< dimTotal;++i)
+ for(size_t i = 0; i< dimTotal; ++i)
{
OCRepPayloadDestroy(val->arr.objArray[i]);
}
static void OCFreeRepPayloadValue(OCRepPayloadValue* val)
{
- if(!val)
+ if (!val)
{
return;
}
static OCRepPayloadValue* OCRepPayloadFindAndSetValue(OCRepPayload* payload, const char* name,
OCRepPayloadPropType type)
{
- if(!payload || !name)
+ if (!payload || !name)
{
return NULL;
}
OCRepPayloadValue* val = payload->values;
- if(val == NULL)
+ if (val == NULL)
{
payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
- if(!payload->values)
+ if (!payload->values)
{
return NULL;
}
payload->values->name = OICStrdup(name);
- if(!payload->values->name)
+ if (!payload->values->name)
{
OICFree(payload->values);
payload->values = NULL;
while(val)
{
- if(0 == strcmp(val->name, name))
+ if (0 == strcmp(val->name, name))
{
OCFreeRepPayloadValueContents(val);
val->type = type;
return val;
}
- else if(val->next == NULL)
+ else if (val->next == NULL)
{
val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
- if(!val->next)
+ if (!val->next)
{
return NULL;
}
val->next->name = OICStrdup(name);
- if(!val->next->name)
+ if (!val->next->name)
{
OICFree(val->next);
val->next = NULL;
bool OCRepPayloadAddResourceTypeAsOwner(OCRepPayload* payload, char* resourceType)
{
- if(!payload || !resourceType)
+ if (!payload || !resourceType)
{
return false;
}
- if(payload->types)
+ if (payload->types)
{
OCStringLL* cur = payload->types;
while(cur->next)
}
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!cur->next)
+ if (!cur->next)
{
return false;
}
else
{
payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!payload->types)
+ if (!payload->types)
{
return false;
}
bool OCRepPayloadAddInterfaceAsOwner(OCRepPayload* payload, char* interface)
{
- if(!payload || !interface)
+ if (!payload || !interface)
{
return false;
}
- if(payload->interfaces)
+ if (payload->interfaces)
{
OCStringLL* cur = payload->interfaces;
while(cur->next)
}
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!cur->next)
+ if (!cur->next)
{
return false;
}
else
{
payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!payload->interfaces)
+ if (!payload->interfaces)
{
return false;
}
bool OCRepPayloadSetUri(OCRepPayload* payload, const char* uri)
{
- if(!payload)
+ if (!payload)
{
return false;
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val)
+ if (!val)
{
return false;
}
void* value, OCRepPayloadPropType type)
{
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, type);
- if(!val)
+ if (!val)
{
return false;
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_INT)
+ if (!val || val->type != OCREP_PROP_INT)
{
return false;
}
}
bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
- const char* name, double value)
+ const char* name, double value)
{
return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_DOUBLE);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_DOUBLE)
+ if (!val || val->type != OCREP_PROP_DOUBLE)
{
return false;
}
char* temp = OICStrdup(value);
bool b = OCRepPayloadSetPropStringAsOwner(payload, name, temp);
- if(!b)
+ if (!b)
{
OICFree(temp);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_STRING)
+ if (!val || val->type != OCREP_PROP_STRING)
{
return false;
}
.bytes = (uint8_t*)OICMalloc(value.len * sizeof(uint8_t)),
.len = value.len };
- if(!ocByteStr.bytes)
+ if (!ocByteStr.bytes)
{
return false;
}
bool b = OCRepPayloadSetPropByteStringAsOwner(payload, name, &ocByteStr);
- if(!b)
+ if (!b)
{
OICFree(ocByteStr.bytes);
}
}
bool OCRepPayloadSetPropBool(OCRepPayload* payload,
- const char* name, bool value)
+ const char* name, bool value)
{
return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_BOOL);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_BOOL)
+ if (!val || val->type != OCREP_PROP_BOOL)
{
return false;
}
OCRepPayload* temp = OCRepPayloadClone(value);
bool b = OCRepPayloadSetPropObjectAsOwner(payload, name, temp);
- if(!b)
+ if (!b)
{
OCRepPayloadDestroy(temp);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_OBJECT)
+ if (!val || val->type != OCREP_PROP_OBJECT)
{
return false;
}
size_t calcDimTotal(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
- if(dimensions[0] == 0)
+ if (dimensions[0] == 0)
{
return 0;
}
{
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
- if(!val)
+ if (!val)
{
return false;
}
const int64_t* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
size_t dimTotal = calcDimTotal(dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
int64_t* newArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
- if(!newArray)
+ if (!newArray)
{
return false;
}
bool b = OCRepPayloadSetIntArrayAsOwner(payload, name, newArray, dimensions);
- if(!b)
+ if (!b)
{
OICFree(newArray);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
+ if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_INT
|| !val->arr.iArray)
{
return false;
}
size_t dimTotal = calcDimTotal(val->arr.dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
*array = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
- if(!*array)
+ if (!*array)
{
return false;
}
{
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
- if(!val)
+ if (!val)
{
return false;
}
const double* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
size_t dimTotal = calcDimTotal(dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
double* newArray = (double*)OICMalloc(dimTotal * sizeof(double));
- if(!newArray)
+ if (!newArray)
{
return false;
}
memcpy(newArray, array, dimTotal * sizeof(double));
bool b = OCRepPayloadSetDoubleArrayAsOwner(payload, name, newArray, dimensions);
- if(!b)
+ if (!b)
{
OICFree(newArray);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
+ if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_DOUBLE
|| !val->arr.dArray)
{
return false;
}
size_t dimTotal = calcDimTotal(val->arr.dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
*array = (double*)OICMalloc(dimTotal * sizeof(double));
- if(!*array)
+ if (!*array)
{
return false;
}
{
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
- if(!val)
+ if (!val)
{
return false;
}
const char** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
size_t dimTotal = calcDimTotal(dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
char** newArray = (char**)OICMalloc(dimTotal * sizeof(char*));
- if(!newArray)
+ if (!newArray)
{
return false;
}
bool b = OCRepPayloadSetStringArrayAsOwner(payload, name, newArray, dimensions);
- if(!b)
+ if (!b)
{
for(size_t i = 0; i < dimTotal; ++i)
{
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
+ if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_STRING
|| !val->arr.strArray)
{
return false;
}
size_t dimTotal = calcDimTotal(val->arr.dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
*array = (char**)OICMalloc(dimTotal * sizeof(char*));
- if(!*array)
+ if (!*array)
{
return false;
}
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
- if(!val)
+ if (!val)
{
return false;
}
const bool* array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
size_t dimTotal = calcDimTotal(dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
bool* newArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
- if(!newArray)
+ if (!newArray)
{
return false;
}
bool b = OCRepPayloadSetBoolArrayAsOwner(payload, name, newArray, dimensions);
- if(!b)
+ if (!b)
{
OICFree(newArray);
}
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
+ if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_BOOL
|| !val->arr.bArray)
{
return false;
}
size_t dimTotal = calcDimTotal(val->arr.dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
*array = (bool*)OICMalloc(dimTotal * sizeof(bool));
- if(!*array)
+ if (!*array)
{
return false;
}
{
OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_ARRAY);
- if(!val)
+ if (!val)
{
return false;
}
const OCRepPayload** array, size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
size_t dimTotal = calcDimTotal(dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
OCRepPayload** newArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
- if(!newArray)
+ if (!newArray)
{
return false;
}
bool b = OCRepPayloadSetPropObjectArrayAsOwner(payload, name, newArray, dimensions);
- if(!b)
+ if (!b)
{
for(size_t i = 0; i < dimTotal; ++i)
{
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
- if(!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
+ if (!val || val->type != OCREP_PROP_ARRAY || val->arr.type != OCREP_PROP_OBJECT
|| !val->arr.objArray)
{
return false;
}
size_t dimTotal = calcDimTotal(val->arr.dimensions);
- if(dimTotal == 0)
+ if (dimTotal == 0)
{
return false;
}
*array = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
- if(!*array)
+ if (!*array)
{
return false;
}
void OCFreeOCStringLL(OCStringLL* ll)
{
- if(!ll)
+ if (!ll)
{
return;
}
void OCRepPayloadDestroy(OCRepPayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
{
OCDiscoveryPayload* payload = (OCDiscoveryPayload*)OICCalloc(1, sizeof(OCDiscoveryPayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
{
OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
void OCSecurityPayloadDestroy(OCSecurityPayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
OCResourcePayload* p = payload->resources;
while(p)
{
- if(i == index)
+ if (i == index)
{
return p;
}
static OCResourcePayload* OCCopyResource(const OCResource* res, uint16_t port)
{
OCResourcePayload* pl = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
- if(!pl)
+ if (!pl)
{
return NULL;
}
pl->uri = OICStrdup(res->uri);
- if(!pl->uri)
+ if (!pl->uri)
{
FreeOCDiscoveryResource(pl);
return NULL;
// types
OCResourceType* typePtr = res->rsrcType;
- if(typePtr != NULL)
+ if (typePtr != NULL)
{
pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!pl->types)
+ if (!pl->types)
{
FreeOCDiscoveryResource(pl);
return NULL;
}
pl->types->value = OICStrdup(typePtr->resourcetypename);
- if(!pl->types->value)
+ if (!pl->types->value)
{
FreeOCDiscoveryResource(pl);
return NULL;
while(typePtr)
{
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!cur->next)
+ if (!cur->next)
{
FreeOCDiscoveryResource(pl);
return NULL;
}
cur->next->value = OICStrdup(typePtr->resourcetypename);
- if(!cur->next->value)
+ if (!cur->next->value)
{
FreeOCDiscoveryResource(pl);
return NULL;
// interfaces
OCResourceInterface* ifPtr = res->rsrcInterface;
- if(ifPtr != NULL)
+ if (ifPtr != NULL)
{
pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!pl->interfaces)
+ if (!pl->interfaces)
{
FreeOCDiscoveryResource(pl);
return NULL;
}
pl->interfaces->value = OICStrdup(ifPtr->name);
- if(!pl->interfaces->value)
+ if (!pl->interfaces->value)
{
FreeOCDiscoveryResource(pl);
return NULL;
while(ifPtr && cur)
{
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
- if(!cur->next)
+ if (!cur->next)
{
FreeOCDiscoveryResource(pl);
return NULL;
}
cur->next->value = OICStrdup(ifPtr->name);
- if(!cur->next->value)
+ if (!cur->next->value)
{
FreeOCDiscoveryResource(pl);
return NULL;
bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType)
{
- if (!resourceType)
+ if (!resourceType || !payload)
{
return false;
}
bool OCResourcePayloadAddInterface(OCResourcePayload* payload, const char* interface)
{
- if (!interface)
+ if (!interface || !payload)
{
return false;
}
void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
{
- if(!payload->resources)
+ if (!payload)
+ {
+ return;
+ }
+
+ if (!payload->resources)
{
payload->resources = res;
}
static void FreeOCDiscoveryResource(OCResourcePayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
}
void OCDiscoveryPayloadDestroy(OCDiscoveryPayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
OCDevicePayload* payload = (OCDevicePayload*)OICCalloc(1, sizeof(OCDevicePayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
payload->base.type = PAYLOAD_TYPE_DEVICE;
- if(sid)
+ if (sid)
{
payload->sid = (uint8_t*)OICMalloc(UUID_SIZE);
- if(!payload->sid)
+ if (!payload->sid)
{
goto exit;
}
}
payload->deviceName = OICStrdup(dname);
- if(dname && !payload->deviceName)
+ if (dname && !payload->deviceName)
{
goto exit;
}
payload->specVersion = OICStrdup(specVer);
- if(specVer && !payload->specVersion)
+ if (specVer && !payload->specVersion)
{
goto exit;
}
payload->dataModelVersion = OICStrdup(dmVer);
- if(dmVer && !payload->dataModelVersion)
+ if (dmVer && !payload->dataModelVersion)
{
goto exit;
}
void OCDevicePayloadDestroy(OCDevicePayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
{
- if(!platformInfo || !target)
+ if (!platformInfo || !target)
{
return;
}
OCPlatformPayload* OCPlatformPayloadCreateAsOwner(OCPlatformInfo* platformInfo)
{
OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
{
OCPlatformPayload* payload = (OCPlatformPayload*)OICCalloc(1, sizeof(OCPlatformPayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
void OCPlatformPayloadDestroy(OCPlatformPayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
OCPresenceTrigger trigger, const char* resourceType)
{
OCPresencePayload* payload = (OCPresencePayload*)OICCalloc(1, sizeof(OCPresencePayload));
- if(!payload)
+ if (!payload)
{
return NULL;
}
void OCPresencePayloadDestroy(OCPresencePayload* payload)
{
- if(!payload)
+ if (!payload)
{
return;
}
void MessageContainer::setPayload(const OCPayload* rep)
{
+ if (rep == nullptr)
+ {
+ return;
+ }
+
switch(rep->type)
{
case PAYLOAD_TYPE_REPRESENTATION:
void MessageContainer::setPayload(const OCDevicePayload* payload)
{
+ if (payload == nullptr)
+ {
+ return;
+ }
+
OCRepresentation rep;
char uuidString[UUID_STRING_SIZE];
- if(payload->sid && RAND_UUID_OK == OCConvertUuidToString(payload->sid, uuidString))
+ if (payload->sid && RAND_UUID_OK == OCConvertUuidToString(payload->sid, uuidString))
{
rep[OC_RSRVD_DEVICE_ID] = std::string(uuidString);
}
void MessageContainer::setPayload(const OCPlatformPayload* payload)
{
+ if (payload == nullptr)
+ {
+ return;
+ }
+
OCRepresentation rep;
rep[OC_RSRVD_PLATFORM_ID] = payload->info.platformID ?
std::string(payload->info.platformID) :
OCRepPayload* root = nullptr;
for(const auto& r : representations())
{
- if(!root)
+ if (!root)
{
root = r.getPayload();
}
OCRepPayload* OCRepresentation::getPayload() const
{
OCRepPayload* root = OCRepPayloadCreate();
- if(!root)
+ if (!root)
{
throw std::bad_alloc();
}
size_t calcArrayDepth(const size_t dimensions[MAX_REP_ARRAY_DEPTH])
{
- if(dimensions[0] == 0)
+ if (dimensions[0] == 0)
{
throw std::logic_error("invalid calcArrayDepth");
}
- else if(dimensions[1] == 0)
+ else if (dimensions[1] == 0)
{
return 1;
}
template<typename T>
void OCRepresentation::payload_array_helper(const OCRepPayloadValue* pl, size_t depth)
{
- if(depth == 1)
+ if (depth == 1)
{
std::vector<T> val(pl->arr.dimensions[0]);
// child of a default or link item.
// Our values array is only printed in the if we are the child of a Batch resource,
// the parent in a 'default' situation, or not in a child/parent relationship.
- if(!m_uri.empty())
+ if (!m_uri.empty())
{
return false;
}
{
return false;
}
- else if((m_interfaceType == InterfaceType::None
+ else if ((m_interfaceType == InterfaceType::None
|| m_interfaceType == InterfaceType::BatchChild
|| m_interfaceType == InterfaceType::DefaultParent)
&& m_values.size()>0)
return false;
}
- if(m_children.size() > 0)
+ if (m_children.size() > 0)
{
return false;
}
{
auto x = m_values.find(str);
- if(m_values.end() != x)
+ if (m_values.end() != x)
{
return x->second.which() == AttributeValueNullIndex;
}
OCRepresentation::iterator& OCRepresentation::iterator::operator++()
{
m_iterator++;
- if(m_iterator != m_item.m_values.end())
+ if (m_iterator != m_item.m_values.end())
{
m_item.m_attrName = m_iterator->first;
}
OCRepresentation::const_iterator& OCRepresentation::const_iterator::operator++()
{
m_iterator++;
- if(m_iterator != m_item.m_values.end())
+ if (m_iterator != m_item.m_values.end())
{
m_item.m_attrName = m_iterator->first;
}
std::string OCRepresentation::getValueToString(const std::string& key) const
{
auto x = m_values.find(key);
- if(x != m_values.end())
+ if (x != m_values.end())
{
to_string_visitor vis;
boost::apply_visitor(vis, x->second);
return os;
}
}
-
projects / platform / upstream / iotivity.git / commitdiff