char* result = OICStrdup(param);
- ASSERT_TRUE(result != NULL);
+ EXPECT_TRUE(result != NULL);
// ensure not the same pointer
EXPECT_NE(param, result);
char* result = OICStrcpy(target, sizeof(target) - 5, source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
EXPECT_EQ(sizeof(target) - 1 - 5, strlen(target));
EXPECT_STREQ(source, result);
char* result = OICStrcpy(target, sizeof(target), source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
EXPECT_EQ(sizeof(source) - 1, strlen(result));
EXPECT_STREQ(source, result);
char *result = OICStrcpy(target, sizeof(target), source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
EXPECT_EQ(sizeof(target) - 1, strlen(result));
EXPECT_STREQ("123456789", result);
char *result = OICStrcpy(target, sizeof(target) - 5, source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
EXPECT_EQ(sizeof(target) - 1 - 5, strlen(result));
EXPECT_STREQ("123456789", result);
char *result = OICStrcpy(target, sizeof(target), source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
EXPECT_EQ(sizeof(source) - 1, strlen(result));
EXPECT_STREQ("", result);
char *result = OICStrcpy(target, sizeof(target) - 5, source);
+ if (!result)
+ {
+ FAIL() << "OICStrcpy returned NULL";
+ }
+
EXPECT_EQ(target, result);
for(size_t i = 0; i < sizeof(target); ++i)
#include "cacommon.h"
#include "cainterface.h"
+#include "oic_string.h"
#ifdef __WITH_DTLS__
#include "ocsecurityconfig.h"
#endif
uint8_t tokenLength = CA_MAX_TOKEN_LEN;
res = CAGenerateToken(&token, tokenLength);
- if ((CA_STATUS_OK != res) || (!token))
+ if (CA_STATUS_OK != res)
{
printf("Token generate error, error code : %d\n", res);
goto exit;
if (endpoint->flags & CA_SECURE)
{
+ if(!responseData.resourceUri)
+ {
+ printf("resourceUri not available in SECURE\n");
+ return;
+ }
printf("Sending response on secure communication\n");
uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(responseData.resourceUri);
}
else
{
+ if(!responseData.resourceUri)
+ {
+ printf("resourceUri not available in NON-SECURE\n");
+ return;
+ }
uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(responseData.resourceUri);
responseData.payload = (CAPayload_t) calloc(length, sizeof(char));
if (NULL == responseData.payload)
}
char portStr[6] = {0};
- memcpy(portStr, startPos + 1, (endPos - 1) - startPos);
-
+ OICStrcpyPartial(portStr, sizeof(portStr), startPos + 1, (endPos - 1) - startPos);
printf("secured port is: %s\n", portStr);
return atoi(portStr);
}
if (endPos - startPos <= length)
{
- memcpy(resourceURI, startPos + 1, endPos - startPos);
+ OICStrcpyPartial(resourceURI, length, startPos + 1, endPos - startPos);
}
printf("URI: %s, ResourceURI:%s\n", URI, resourceURI);
printf("there is no headerOption!\n");
return NULL;
}
+ else if (optionNum > MAX_OPT_LEN)
+ {
+ printf("Too many header options!\n");
+ return NULL;
+ }
else
{
- headerOpt = (CAHeaderOption_t *)calloc(1, optionNum * sizeof(CAHeaderOption_t));
+ headerOpt = (CAHeaderOption_t *)calloc(optionNum, sizeof(CAHeaderOption_t));
if (NULL == headerOpt)
{
printf("Memory allocation failed!\n");
return NULL;
}
- memcpy(headerOpt[i].optionData, optionData, strlen(optionData));
+ OICStrcpy(headerOpt[i].optionData, sizeof(headerOpt[i].optionData), optionData);
headerOpt[i].optionLength = (uint16_t) strlen(optionData);
}
{
if(ipLen && ipLen < sizeof(outAddress->ipAddress))
{
- strncpy(outAddress->ipAddress, pAddress, ipLen);
- outAddress->ipAddress[ipLen] = '\0';
+ OICStrcpy(outAddress->ipAddress, sizeof(outAddress->ipAddress), pAddress);
}
else if (!ipLen && len < sizeof(outAddress->ipAddress))
{
- strncpy(outAddress->ipAddress, pAddress, len);
- outAddress->ipAddress[len] = '\0';
+ OICStrcpy(outAddress->ipAddress, sizeof(outAddress->ipAddress), pAddress);
}
else
{
void create_file(CAPayload_t bytes, size_t length)
{
FILE *fp = fopen("sample_output.txt", "wb");
- if (!fp)
+ if (fp)
{
fwrite(bytes, 1, length, fp);
+ fclose(fp);
}
- fclose(fp);
}
bool read_file(const char* name, CAPayload_t* bytes, size_t* length)
// Read file contents into buffer
size_t ret = fread(buffer, fileLen, 1, file);
- if (ret < 0)
+ if (ret != 1)
{
printf("Failed to read data from file, %s\n", name);
fclose(file);
CALEGetSenderInfo(newSender->remoteEndpoint->addr, NULL, &senderIndex))
{
OIC_LOG(ERROR, CALEADAPTER_TAG, "Existing sender index not found!!");
- OICFree(senderInfo->defragData);
- OICFree(senderInfo);
+ OICFree(newSender->defragData);
+ CAFreeEndpoint(newSender->remoteEndpoint);
+ OICFree(newSender);
ca_mutex_unlock(g_bleReceiveDataMutex);
return;
}
#define TAG "CA_BWT"
-#define BLOCKWISE_OPTION_BUFFER 3
+#define BLOCKWISE_OPTION_BUFFER (sizeof(unsigned int))
#define BLOCK_NUMBER_IDX 4
#define BLOCK_M_BIT_IDX 3
#define PORT_LENGTH 2
g_context.sendThreadFunc(cloneData);
ca_mutex_unlock(g_context.blockDataSenderMutex);
}
+ else
+ {
+ CADestroyDataSet(cloneData);
+ }
return CA_STATUS_OK;
}
}
OIC_LOG(DEBUG, TAG, "set ACK message");
}
- else
+ else if (data->sentData)
{
- cloneData = CACreateNewDataSet(pdu, CACloneEndpoint(data->sentData->remoteEndpoint));
+ cloneData = CACreateNewDataSet(pdu, data->sentData->remoteEndpoint);
+
+ if(!cloneData)
+ {
+ OIC_LOG(ERROR, TAG, PCF("CACreateNewDataSet failed"));
+ return CA_MEMORY_ALLOC_FAILED;
+ }
+
cloneData->responseInfo->info.type = CA_MSG_CONFIRM;
cloneData->responseInfo->result = responseResult;
OIC_LOG(DEBUG, TAG, "set CON message");
}
+ else
+ {
+ OIC_LOG(ERROR, TAG, "data has no sent-data");
+ return CA_MEMORY_ALLOC_FAILED;
+ }
// add data to send thread
if (g_context.sendThreadFunc)
g_context.sendThreadFunc(cloneData);
ca_mutex_unlock(g_context.blockDataSenderMutex);
}
+ else
+ {
+ CADestroyDataSet(cloneData);
+ }
// if error code is 4.08, remove the stored payload and initialize block number
if (CA_BLOCK_INCOMPLETE == status)
if (CA_STATUS_OK != res)
{
OIC_LOG(ERROR, TAG, "update has failed");
+ CADestroyDataSet(cloneData);
return CA_STATUS_FAILED;
}
}
{
g_context.receivedThreadFunc(cloneData);
}
+ else
+ {
+ CADestroyDataSet(cloneData);
+ }
return CA_STATUS_OK;
}
error:
OIC_LOG_V(ERROR, TAG, "error : %d", code);
- coap_add_data(*pdu, strlen(coap_response_phrase(code)),
- (unsigned char *) coap_response_phrase(code));
+
+ char* phrase = coap_response_phrase(code);
+ if(phrase)
+ {
+ coap_add_data(*pdu, strlen(phrase),
+ (unsigned char *) phrase);
+ }
return CA_STATUS_FAILED;
}
if (NULL == responseInfo)
{
OIC_LOG(ERROR, TAG, "out of memory");
+ OICFree(responseData.token);
return NULL;
}
responseInfo->info = responseData;
OIC_LOG(ERROR, TAG, "out of memory");
return NULL;
}
- memcpy(clone, data, sizeof(CAData_t));
+ *clone = *data;
if (data->requestInfo)
{
data->block1.szx = CA_DEFAULT_BLOCK_SIZE;
data->block2.szx = CA_DEFAULT_BLOCK_SIZE;
data->sentData = CACloneCAData(sendData);
+ if(!data->sentData)
+ {
+ OIC_LOG(ERROR, TAG, PCF("memory alloc has failed"));
+ OICFree(data);
+ return NULL;
+ }
CAToken_t token = NULL;
uint8_t tokenLength = 0;
info = &response->info;
cadata->responseInfo = response;
}
+ else
+ {
+ OIC_LOG(ERROR, TAG, "CAPrepareSendData unknown data type");
+ OICFree(cadata);
+ return NULL;
+ }
if (NULL != info->options && 0 < info->numOptions)
{
OICFree(outInfo->token);
return CA_MEMORY_ALLOC_FAILED;
}
- memcpy(outInfo->resourceUri, optionResult, length);
- outInfo->resourceUri[length] = '\0';
+ OICStrcpy(outInfo->resourceUri, length + 1, optionResult);
OIC_LOG_V(DEBUG, TAG, "made URL : %s, %s", optionResult, outInfo->resourceUri);
OIC_LOG(DEBUG, TAG, "OUT");
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
+ if (!ifitem)
+ {
+ continue;
+ }
if ((ifitem->flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
{
continue;
for (uint32_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
+ if (!ifitem)
+ {
+ continue;
+ }
+
if (ifitem->index != newIndex)
{
continue;
OIC_LOG_V(INFO, TAG, "IPv6 multicast scope invalid: %d", scope);
return;
}
- strncpy(endpoint->addr, ipv6mcname, MAX_ADDR_STR_SIZE_CA);
+ OICStrcpy(endpoint->addr, sizeof(endpoint->addr), ipv6mcname);
int fd = caglobals.ip.u6.fd;
uint32_t len = u_arraylist_length(iflist);
for (uint32_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
+ if (!ifitem)
+ {
+ continue;
+ }
if ((ifitem->flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
{
continue;
const void *data, uint32_t datalen)
{
struct ip_mreq mreq = { IPv4MulticastAddress };
- strncpy(endpoint->addr, IPv4_MULTICAST, MAX_ADDR_STR_SIZE_CA);
+ OICStrcpy(endpoint->addr, sizeof(endpoint->addr), IPv4_MULTICAST);
int fd = caglobals.ip.u4.fd;
uint32_t len = u_arraylist_length(iflist);
for (uint32_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
+ if (!ifitem)
+ {
+ continue;
+ }
if ((ifitem->flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
{
continue;
mreq.imr_interface = inaddr;
if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof (mreq)))
{
- OIC_LOG_V(ERROR, TAG, "send IP_MULTICAST_IF failed: %s (using defualt)", strerror(errno));
+ OIC_LOG_V(ERROR, TAG, "send IP_MULTICAST_IF failed: %s (using defualt)",
+ strerror(errno));
}
sendData(fd, endpoint, data, datalen, "multicast", "ipv4");
}
for (uint32_t i = 0, j = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
+ if(!ifitem)
+ {
+ continue;
+ }
OICStrcpy(eps[j].addr, CA_INTERFACE_NAME_SIZE, ifitem->name);
eps[j].flags = ifitem->family == AF_INET6 ? CA_IPV6 : CA_IPV4;
for (int i = length-1; i >= 0; i--)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
- if (ifitem->index == ifindex && ifitem->family == family)
+
+ if (ifitem && ifitem->index == ifindex && ifitem->family == family)
{
already = true;
break;
responseData.type = CA_MSG_NONCONFIRM;
responseData.messageId = 1;
responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
+
+ EXPECT_TRUE(responseData.payload != NULL);
+ if(!responseData.payload)
+ {
+ CADestroyEndpoint(tempRep);
+ return;
+ }
+
memcpy(responseData.payload, "response payload", sizeof("response payload"));
responseData.payloadSize = sizeof("response payload");
responseData.type = CA_MSG_NONCONFIRM;
responseData.messageId = 1;
responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
+ EXPECT_TRUE(responseData.payload != NULL);
+
+ if(!responseData.payload)
+ {
+ CADestroyEndpoint(tempRep);
+ return;
+ }
+
memcpy(responseData.payload, "response payload", sizeof("response payload"));
responseData.payloadSize = sizeof("response payload");
memset(&responseData, 0, sizeof(CAInfo_t));
responseData.type = CA_MSG_NONCONFIRM;
responseData.payload = (CAPayload_t)malloc(sizeof("Temp Notification Data"));
+
+ EXPECT_TRUE(responseData.payload != NULL);
+ if(!responseData.payload)
+ {
+ CADestroyEndpoint(tempRep);
+ return;
+ }
+
memcpy(responseData.payload, "Temp Notification Data", sizeof("Temp Notification Data"));
responseData.payloadSize = sizeof("Temp Notification Data");
#include "resourcemanager.h"
#include "credresource.h"
#include "policyengine.h"
+#include "oic_string.h"
#include <string.h>
#define TAG PCF("SRM")
if (position > 0)
{
char newUri[MAX_URI_LENGTH + 1];
- strncpy(newUri, requestInfo->info.resourceUri, (position));
- newUri[position] = '\0';
+ OICStrcpyPartial(newUri, MAX_URI_LENGTH + 1, requestInfo->info.resourceUri, position);
//Skip query and pass the newUri.
response = CheckPermission(&g_policyEngineContext, &subjectId,
newUri,
#include <linux/limits.h>
#include <sys/stat.h>
#include "ocstack.h"
+#include "ocpayload.h"
#include "oic_malloc.h"
#include "cJSON.h"
#include "cainterface.h"
// Create Entity Handler POST request payload
ehReq.method = OC_REST_POST;
- ehReq.payload = (OCPayload*)calloc(1, sizeof(OCSecurityPayload));
- ehReq.payload->type = PAYLOAD_TYPE_SECURITY;
- ((OCSecurityPayload*)ehReq.payload)->securityData = jsonStr;
+ ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr);
OCEntityHandlerResult ehRet = ACLEntityHandler(OC_REQUEST_FLAG, &ehReq);
EXPECT_TRUE(OC_EH_ERROR == ehRet);
// Perform cleanup
DeleteACLList(acl);
DeInitACLResource();
+ OCPayloadDestroy(ehReq.payload);
OICFree(jsonStr);
}
}
OicSecCred_t * getCredList()
{
OicSecCred_t * cred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
+ if(!cred)
+ {
+ return NULL;
+ }
cred->credId = 1234;
OICStrcpy((char *)cred->subject.id, sizeof(cred->subject.id), "subject1");
cred->credType = 1;
cred->ownersLen = 1;
cred->owners = (OicUuid_t*)OICCalloc(cred->ownersLen, sizeof(OicUuid_t));
+ if(!cred->owners)
+ {
+ OICFree(cred);
+ return NULL;
+ }
OICStrcpy((char *)cred->owners[0].id, sizeof(cred->owners[0].id), "ownersId11");
cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
+ if(!cred->next)
+ {
+ OICFree(cred->owners);
+ OICFree(cred);
+ return NULL;
+ }
cred->next->credId = 5678;
OICStrcpy((char *)cred->next->subject.id, sizeof(cred->next->subject.id), "subject2");
#if 0
cred->next->credType = 1;
size_t data_size = strlen("My private Key21") + 1;
cred->next->privateData.data = (char *)OICCalloc(1, data_size);
+ if(!cred->next->privateData.data)
+ {
+ OICFree(cred->next);
+ OICFree(cred->owners);
+ OICFree(cred);
+ return NULL;
+ }
OICStrcpy(cred->next->privateData.data, data_size,"My private Key21");
#if 0
cred->next->publicData.data = (char *)OICCalloc(1, strlen("My Public Key123") + 1);
#endif
cred->next->ownersLen = 2;
cred->next->owners = (OicUuid_t*)OICCalloc(cred->next->ownersLen, sizeof(OicUuid_t));
+ if(!cred->next->owners)
+ {
+ OICFree(cred->next->privateData.data);
+ OICFree(cred->next);
+ OICFree(cred->owners);
+ OICFree(cred);
+ return NULL;
+ }
OICStrcpy((char *)cred->next->owners[0].id, sizeof(cred->next->owners[0].id), "ownersId21");
OICStrcpy((char *)cred->next->owners[1].id, sizeof(cred->next->owners[1].id), "ownersId22");
return cred;
json = BinToCredJSON(cred);
- printf("BinToCredJSON:%s\n", json);
EXPECT_TRUE(json != NULL);
DeleteCredList(cred);
OICFree(json);
#include "srmresourcestrings.h"
#include "doxmresource.h"
#include "ocserverrequest.h"
+#include "oic_string.h"
#include "oic_malloc.h"
#ifdef __cplusplus
OicSecDoxm_t * getBinDoxm()
{
OicSecDoxm_t * doxm = (OicSecDoxm_t*)OICCalloc(1, sizeof(OicSecDoxm_t));
+ if(!doxm)
+ {
+ return NULL;
+ }
doxm->oxmTypeLen = 1;
doxm->oxmType = (OicUrn_t *)OICCalloc(doxm->oxmTypeLen, sizeof(char *));
+ if(!doxm->oxmType)
+ {
+ OICFree(doxm);
+ return NULL;
+ }
doxm->oxmType[0] = (char*)OICMalloc(strlen(OXM_JUST_WORKS) + 1);
+ if(!doxm->oxmType[0])
+ {
+ OICFree(doxm->oxmType);
+ OICFree(doxm);
+ return NULL;
+ }
+
strcpy(doxm->oxmType[0], OXM_JUST_WORKS);
doxm->oxmLen = 1;
- doxm->oxm = (OicSecOxm_t *)OICCalloc(doxm->oxmLen, sizeof(short));
+ doxm->oxm = (OicSecOxm_t *)OICCalloc(doxm->oxmLen, sizeof(OicSecOxm_t));
+ if(!doxm->oxm)
+ {
+ OICFree(doxm->oxmType[0]);
+ OICFree(doxm->oxmType);
+ OICFree(doxm);
+ return NULL;
+ }
+
doxm->oxm[0] = OIC_JUST_WORKS;
doxm->oxmSel = OIC_JUST_WORKS;
doxm->owned = true;
char query[] = "oxm=0&owned=false&owner=owner1";
OCEntityHandlerRequest req = {};
req.method = OC_REST_GET;
- req.query = (char*)OICMalloc(strlen(query) + 1);
- strcpy((char *)req.query, query);
+ req.query = OICStrdup(query);
EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
OICFree(req.query);
OicSecDoxm_t * doxm = getBinDoxm();
char * json = BinToDoxmJSON(doxm);
- printf("BinToDoxmJSON:%s\n", json);
EXPECT_TRUE(json != NULL);
DeleteDoxmBinData(doxm);
EXPECT_TRUE(doxm2 != NULL);
DeleteDoxmBinData(doxm1);
+ DeleteDoxmBinData(doxm2);
OICFree(json);
}
#include "base64.h"
#include "cainterface.h"
#include "secureresourcemanager.h"
+#include "ocpayload.h"
#include <unistd.h>
#ifdef __cplusplus
extern "C" {
{
OCEntityHandlerRequest req;
req.method = OC_REST_POST;
- req.payload = (OCPayload*)calloc(1, sizeof(OCSecurityPayload));
- req.payload->type = PAYLOAD_TYPE_SECURITY;
- ((OCSecurityPayload*)req.payload)->securityData =
- (char*)"{ \"pstat\": { \"tm\": 0, \"om\": 3 }}";
+ req.payload = reinterpret_cast<OCPayload*>(
+ OCSecurityPayloadCreate("{ \"pstat\": { \"tm\": 0, \"om\": 3 }}"));
EXPECT_EQ(OC_EH_ERROR, PstatEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));
+ OCPayloadDestroy(req.payload);
}
TEST(PstatEntityHandlerTest, PstatEntityHandlerInvalidRequest)
pstat.om = SINGLE_SERVICE_CLIENT_DRIVEN;
pstat.smLen = 2;
pstat.sm = (OicSecDpom_t*)OICCalloc(pstat.smLen, sizeof(OicSecDpom_t));
+ if(!pstat.sm)
+ {
+ FAIL() << "Failed to allocate the pstat.sm";
+ }
pstat.sm[0] = SINGLE_SERVICE_CLIENT_DRIVEN;
pstat.sm[1] = SINGLE_SERVICE_SERVER_DRIVEN;
char* jsonPstat = BinToPstatJSON(&pstat);
+ if(!jsonPstat)
+ {
+ OICFree(pstat.sm);
+ FAIL() << "Failed to convert BinToPstatJSON";
+ return;
+ }
printf("BinToJSON Dump:\n%s\n\n", jsonPstat);
EXPECT_TRUE(jsonPstat != NULL);
OicSecPstat_t *pstat1 = JSONToPstatBin(jsonPstat);
EXPECT_TRUE(pstat1 != NULL);
- OICFree(pstat1->sm);
+ if(pstat1)
+ {
+ OICFree(pstat1->sm);
+ }
OICFree(pstat1);
OICFree(jsonPstat);
OICFree(pstat.sm);
EXPECT_TRUE(NULL != pstat);
char* jsonStr2 = BinToPstatJSON(pstat);
- printf("BinToPstatJSON Dump:\n%s\n\n", jsonStr2);
EXPECT_STRNE(jsonStr1, jsonStr2);
OICFree(jsonStr1);
#include "gtest/gtest.h"
#include "ocstack.h"
#include "srmutility.h"
+#include "oic_string.h"
//ParseRestQuery Tests
ParseQueryIterInit(query, &parseIter);
EXPECT_NE((OicParseQueryIter_t *)NULL, GetNextQuery(&parseIter));
- strncpy(attr, (char *)parseIter.attrPos, parseIter.attrLen);
- strncpy(val, (char *)parseIter.valPos, parseIter.valLen);
- attr[parseIter.attrLen] = '\0';
- val[parseIter.valLen] = '\0';
+ OICStrcpyPartial(attr, sizeof(attr), (char *)parseIter.attrPos, parseIter.attrLen);
+ OICStrcpyPartial(val, sizeof(val), (char *)parseIter.valPos, parseIter.valLen);
printf("\nAttribute: %s value: %s\n\n", attr, val);
}
{
EXPECT_NE(static_cast<size_t>(0), parseIter.pi.segment_length);
- strncpy(attr, (char *)parseIter.attrPos, parseIter.attrLen);
- strncpy(val, (char *)parseIter.valPos, parseIter.valLen);
- attr[parseIter.attrLen] = '\0';
- val[parseIter.valLen] = '\0';
+ OICStrcpyPartial(attr, sizeof(attr), (char *)parseIter.attrPos, parseIter.attrLen);
+ OICStrcpyPartial(val, sizeof(val), (char *)parseIter.valPos, parseIter.valLen);
printf("Attribute: %s value: %s\n", attr, val);
}
// Discovery Payload
OCDiscoveryPayload* OCDiscoveryPayloadCreate();
-OCSecurityPayload* OCSecurityPayloadCreate(char* securityData);
+OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData);
void OCSecurityPayloadDestroy(OCSecurityPayload* payload);
void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
}
else
{
- strcpy(szQueryUri, MULTICAST_RESOURCE_DISCOVERY_QUERY);
+ OICStrcpy(szQueryUri, sizeof(szQueryUri), MULTICAST_RESOURCE_DISCOVERY_QUERY);
}
cbData.cb = discoveryReqCB;
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
OC_LOG_V(INFO, TAG, "port = %s", iter->port);
switch (iter->connType & CT_MASK_ADAPTER)
{
- case CT_ADAPTER_IP:
+ case OC_ADAPTER_IP:
OC_LOG(INFO, TAG, "connType = Default (IPv4)");
break;
case OC_ADAPTER_GATT_BTLE:
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
cbData.cd = NULL;
OC_LOG_V(INFO, TAG, "OBSERVE payload from client =");
- OC_LOG_PAYLOAD(INFO, TAG, putPayload());
+ OCPayload* payload = putPayload();
+ OC_LOG_PAYLOAD(INFO, TAG, payload);
+ OCPayloadDestroy(payload);
ret = OCDoResource(&handle, OC_REST_OBSERVE, obsReg.str().c_str(), 0, 0, OC_CONNTYPE,
OC_LOW_QOS, &cbData, NULL, 0);
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
cbData.cd = NULL;
OC_LOG_V(INFO, TAG, "PUT payload from client = ");
- OC_LOG_PAYLOAD(INFO, TAG, putPayload());
+ OCPayload* payload = putPayload();
+ OC_LOG_PAYLOAD(INFO, TAG, payload);
+ OCPayloadDestroy(payload);
ret = OCDoResource(NULL, OC_REST_PUT, getQuery.str().c_str(), 0, putPayload(),
OC_CONNTYPE, OC_LOW_QOS, &cbData, NULL, 0);
}
}
if ((TEST <= TEST_INVALID || TEST >= MAX_TESTS) ||
- (CONNECTIVITY < CT_ADAPTER_DEFAULT || CONNECTIVITY >= MAX_CT))
+ CONNECTIVITY >= MAX_CT)
{
PrintUsage();
return -1;
#include "ocstack.h"
#include "logger.h"
#include "occlientslow.h"
+#include "oic_string.h"
#include "ocpayload.h"
// Tracking user input
}
else
{
- strcpy(szQueryUri, MULTICAST_RESOURCE_DISCOVERY_QUERY);
+ OICStrcpy(szQueryUri, sizeof(szQueryUri), MULTICAST_RESOURCE_DISCOVERY_QUERY);
}
cbData.cb = discoveryReqCB;
cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OCEntityHandlerResult ehResult = OC_EH_ERROR;
- OCEntityHandlerResponse response;
+ OCEntityHandlerResponse response = {};
// Validate pointer
if (!entityHandlerRequest)
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
- OCRepPayload* payload = OCRepPayloadCreate();
OC_LOG_V(INFO, TAG, "Callback for Room");
PrintReceivedMsgInfo(flag, ehRequest );
if(ehRequest && flag == OC_REQUEST_FLAG )
{
std::string query = (const char*)ehRequest->query;
+ OCRepPayload* payload = OCRepPayloadCreate();
if(OC_REST_GET == ehRequest->method)
{
{
OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
ehRequest->method);
+ OCRepPayloadDestroy(payload);
ret = OC_EH_ERROR;
}
}
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
- OCRepPayload* payload = OCRepPayloadCreate();
OC_LOG_V(INFO, TAG, "Callback for Light");
PrintReceivedMsgInfo(flag, ehRequest );
if(ehRequest && flag == OC_REQUEST_FLAG)
{
+ OCRepPayload* payload = OCRepPayloadCreate();
if(OC_REST_GET == ehRequest->method)
{
OCRepPayloadSetUri(payload, gLightResourceUri);
ret = OC_EH_ERROR;
}
}
+ else
+ {
+ OCRepPayloadDestroy(payload);
+ }
}
else if (ehRequest && flag == OC_OBSERVE_FLAG)
{
{
OCEntityHandlerResult ret = OC_EH_OK;
OCEntityHandlerResponse response;
- OCRepPayload* payload = OCRepPayloadCreate();
OC_LOG_V(INFO, TAG, "Callback for Fan");
PrintReceivedMsgInfo(flag, ehRequest );
if(ehRequest && flag == OC_REQUEST_FLAG)
{
+ OCRepPayload* payload = OCRepPayloadCreate();
+
if(OC_REST_GET == ehRequest->method)
{
OCRepPayloadSetUri(payload, gFanResourceUri);
ret = OC_EH_ERROR;
}
}
+ OCRepPayloadDestroy(payload);
}
else if (ehRequest && flag == OC_OBSERVE_FLAG)
#include <list>
#include "ocstack.h"
#include "oic_malloc.h"
+#include "oic_string.h"
#include "logger.h"
#include "cJSON.h"
#include "ocserverslow.h"
if (copyOfRequest->query)
{
- // Do deep copy of query
- copyOfRequest->query = (char *) OICMalloc(
- strlen((const char *)entityHandlerRequest->query) + 1);
-
- strcpy((char *)copyOfRequest->query, (const char *)entityHandlerRequest->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)
#include "logger.h"
#include "occlientbasicops.h"
#include "ocpayload.h"
+#include "oic_string.h"
#include "common.h"
#define TAG "occlientbasicops"
{
//Send discovery request on Wifi and Ethernet interface
discoveryReqConnType = CT_DEFAULT;
- strcpy(szQueryUri, MULTICAST_DISCOVERY_QUERY);
+ OICStrcpy(szQueryUri, sizeof(szQueryUri), MULTICAST_DISCOVERY_QUERY);
method = OC_REST_DISCOVER;
}
OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
OCEntityHandlerResult ehResult = OC_EH_ERROR;
- OCEntityHandlerResponse response;
+ OCEntityHandlerResponse response = {};
// Validate pointer
if (!entityHandlerRequest)
FindAndDeleteServerRequest(request);
}
}
+ OCPayloadDestroy(ehRequest.payload);
}
}
#ifdef WITH_PRESENCE
#define TAG "OCPayload"
static void OCFreeRepPayloadValueContents(OCRepPayloadValue* val);
+static void FreeOCDiscoveryResource(OCResourcePayload* payload);
void OCPayloadDestroy(OCPayload* payload)
{
if(val == NULL)
{
payload->values = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
+ if(!payload->values)
+ {
+ return NULL;
+ }
payload->values->name = OICStrdup(name);
+ if(!payload->values->name)
+ {
+ OICFree(payload->values);
+ payload->values = NULL;
+ return NULL;
+ }
payload->values->type =type;
return payload->values;
}
else if(val->next == NULL)
{
val->next = (OCRepPayloadValue*)OICCalloc(1, sizeof(OCRepPayloadValue));
+ if(!val->next)
+ {
+ return NULL;
+ }
val->next->name = OICStrdup(name);
+ if(!val->next->name)
+ {
+ OICFree(val->next);
+ val->next = NULL;
+ return NULL;
+ }
val->next->type =type;
return val->next;
}
return payload;
}
-OCSecurityPayload* OCSecurityPayloadCreate(char* securityData)
+OCSecurityPayload* OCSecurityPayloadCreate(const char* securityData)
{
OCSecurityPayload* payload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
pl->uri = OICStrdup(res->uri);
pl->sid = (uint8_t*)OICCalloc(1, UUID_SIZE);
+ if(!pl->uri || ! pl->sid)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
memcpy(pl->sid, OCGetServerInstanceID(), UUID_SIZE);
// types
if(typePtr != NULL)
{
pl->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!pl->types)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
pl->types->value = OICStrdup(typePtr->resourcetypename);
+ if(!pl->types->value)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
OCStringLL* cur = pl->types;
typePtr = typePtr->next;
while(typePtr)
{
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!cur->next)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
cur->next->value = OICStrdup(typePtr->resourcetypename);
+ if(!cur->next->value)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
cur = cur->next;
typePtr = typePtr->next;
}
if(ifPtr != NULL)
{
pl->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!pl->interfaces)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
pl->interfaces->value = OICStrdup(ifPtr->name);
+ if(!pl->interfaces->value)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
OCStringLL* cur = pl->interfaces;
ifPtr = ifPtr->next;
while(ifPtr)
{
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!cur->next)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
cur->next->value = OICStrdup(ifPtr->name);
+ if(!cur->next->value)
+ {
+ FreeOCDiscoveryResource(pl);
+ return NULL;
+ }
cur = cur->next;
ifPtr = ifPtr->next;
}
}
}
-void FreeOCDiscoveryResource(OCResourcePayload* payload)
+static void FreeOCDiscoveryResource(OCResourcePayload* payload)
{
if(!payload)
{
{
CborEncoder map;
OCResourcePayload* resource = OCDiscoveryPayloadGetResource(payload, i);
+
+ if(!resource)
+ {
+ OICFree(*outPayload);
+ return OC_STACK_INVALID_PARAM;
+ }
+
err = err || cbor_encoder_create_map(&rootArray, &map, 3);
// Uri
err = err || AddTextStringToMap(&map, OC_RSRVD_HREF,
// enter the array
err = err || cbor_value_enter_container(&rootValue, &arrayValue);
- int payloadType;
+ int payloadType = 0;
err = err || cbor_value_get_int(&arrayValue, &payloadType);
err = err || cbor_value_advance_fixed(&arrayValue);
if(!resource)
{
OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
CborValue curVal;
llPtr = resource->types;
if(!llPtr)
{
- OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OC_LOG(ERROR, TAG, PCF("Memory allocation failed"));
OICFree(resource->uri);
OICFree(resource->sid);
OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
}
- else
+ else if(llPtr)
{
llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
llPtr = llPtr->next;
if(!llPtr)
{
- OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OC_LOG(ERROR, TAG, PCF("Memory allocation failed"));
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
-
+ }
+ else
+ {
+ OC_LOG(ERROR, TAG, PCF("Unknown state in resource type copying"));
+ OICFree(resource->uri);
+ OICFree(resource->sid);
+ OCFreeOCStringLL(resource->types);
+ OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
+ return OC_STACK_NO_MEMORY;
}
err = err || cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
}
- else
+ else if (llPtr)
{
llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
llPtr = llPtr->next;
OCFreeOCStringLL(resource->types);
OCFreeOCStringLL(resource->interfaces);
OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
}
+ else
+ {
+ OC_LOG(ERROR, TAG, PCF("Unknown state in resource interfaces copying"));
+ OICFree(resource->uri);
+ OICFree(resource->sid);
+ OCFreeOCStringLL(resource->types);
+ OICFree(resource);
+ OCDiscoveryPayloadDestroy(out);
+ return OC_STACK_NO_MEMORY;
+ }
err = err || cbor_value_dup_text_string(&ifVal, &(llPtr->value), &len, NULL);
err = err || cbor_value_advance(&ifVal);
}
}
- err = err || cbor_value_advance(arrayVal);
+ err = err || cbor_value_advance(arrayVal);
if(err)
{
OICFree(resource->uri);
OCDiscoveryPayloadAddNewResource(out, resource);
}
- *outPayload = (OCPayload*)out;
-
- return OC_STACK_OK;
+ if(err)
+ {
+ OCDiscoveryPayloadDestroy(out);
+ return OC_STACK_MALFORMED_RESPONSE;
+ }
+ else
+ {
+ *outPayload = (OCPayload*)out;
+ return OC_STACK_OK;
+ }
}
static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal)
{
case OCREP_PROP_INT:
arr = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
- for(size_t i = 0; i < dimTotal && !err; ++i)
+ if (arr)
{
- err = err || cbor_value_get_int64(&insideArray, &(((int64_t*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
+ for(size_t i = 0; i < dimTotal && !err; ++i)
+ {
+ err = err || cbor_value_get_int64(&insideArray, &(((int64_t*)arr)[i]));
+ err = err || cbor_value_advance_fixed(&insideArray);
+ }
+ if(err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
+ {
+ OICFree(arr);
+ err = true;
+ }
}
- if(!err &&
- OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
- {}
else
{
- err = CborUnknownError;
+ err = true;
}
break;
case OCREP_PROP_DOUBLE:
arr = (double*)OICMalloc(dimTotal * sizeof(double));
- for(size_t i = 0; i < dimTotal && !err; ++i)
+ if(arr)
{
- err = err || cbor_value_get_double(&insideArray, &(((double*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
+ for(size_t i = 0; i < dimTotal && !err; ++i)
+ {
+ err = err || cbor_value_get_double(&insideArray, &(((double*)arr)[i]));
+ err = err || cbor_value_advance_fixed(&insideArray);
+ }
+ if(err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
+ {
+ OICFree(arr);
+ err = true;
+ }
}
- if(!err &&
- OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
- {}
else
{
- err = CborUnknownError;
+ err = true;
}
break;
case OCREP_PROP_BOOL:
arr = (bool*)OICMalloc(dimTotal * sizeof(bool));
- for(size_t i = 0; i < dimTotal && !err; ++i)
+ if(arr)
{
- err = err || cbor_value_get_boolean(&insideArray, &(((bool*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
+ for(size_t i = 0; i < dimTotal && !err; ++i)
+ {
+ err = err || cbor_value_get_boolean(&insideArray, &(((bool*)arr)[i]));
+ err = err || cbor_value_advance_fixed(&insideArray);
+ }
+ if(err && !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
+ {
+ OICFree(arr);
+ err = true;
+ }
}
- if(!err &&
- OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
- {}
else
{
- err = CborUnknownError;
+ err = true;
}
break;
case OCREP_PROP_STRING:
arr = (char**)OICMalloc(dimTotal * sizeof(char*));
- for(size_t i = 0; i < dimTotal && !err; ++i)
+ if(arr)
{
- err = err || cbor_value_dup_text_string(&insideArray, &tempStr, &len, NULL);
- ((char**) arr)[i] = tempStr;
- err = err || cbor_value_advance(&insideArray);
+ for(size_t i = 0; i < dimTotal && !err; ++i)
+ {
+ err = err || cbor_value_dup_text_string(&insideArray, &tempStr,
+ &len, NULL);
+ err = err || cbor_value_advance(&insideArray);
+ ((char**)arr)[i] = tempStr;
+ }
+ if(err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
+ {
+ OICFree(arr);
+ err = true;
+ }
}
- if(!err &&
- OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
- {}
else
{
- err = CborUnknownError;
+ err = true;
}
break;
case OCREP_PROP_OBJECT:
arr = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
- for(size_t i = 0; i < dimTotal && !err; ++i)
+ if(arr)
{
- pl = NULL;
- err = err || OCParseSingleRepPayload(&pl, &insideArray);
- ((OCRepPayload**)arr)[i] = pl;
- err = err || cbor_value_advance(&insideArray);
+ for(size_t i = 0; i < dimTotal && !err; ++i)
+ {
+ pl = NULL;
+ err = err || OCParseSingleRepPayload(&pl, &insideArray);
+ err = err || cbor_value_advance(&insideArray);
+ ((OCRepPayload**)arr)[i] = pl;
+ }
+ if(err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name,
+ (OCRepPayload**)arr, dimensions))
+ {
+ OICFree(arr);
+ err = true;
+ }
}
- if(!err &&
- OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
- {}
else
{
- err = CborUnknownError;
+ err = true;
}
break;
default:
OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
- err = CborUnknownError;
+ err = true;
break;
}
err = err || cbor_value_map_find_value(repParent, OC_RSRVD_PROPERTY, &curVal);
if(cbor_value_is_valid(&curVal))
{
- CborValue insidePropArray;
+ CborValue insidePropArray = {};
err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE,
&insidePropArray);
switch(cbor_value_get_type(&repMap))
{
case CborNullType:
- OCRepPayloadSetNull(curPayload, name);
+ err = !OCRepPayloadSetNull(curPayload, name);
break;
case CborIntegerType:
err = err || cbor_value_get_int64(&repMap, &intval);
- OCRepPayloadSetPropInt(curPayload, name, intval);
+ if (!err)
+ {
+ err = !OCRepPayloadSetPropInt(curPayload, name, intval);
+ }
break;
case CborDoubleType:
err = err || cbor_value_get_double(&repMap, &doubleval);
- OCRepPayloadSetPropDouble(curPayload, name, doubleval);
+ if (!err)
+ {
+ err = !OCRepPayloadSetPropDouble(curPayload, name, doubleval);
+ }
break;
case CborBooleanType:
err = err || cbor_value_get_boolean(&repMap, &boolval);
- OCRepPayloadSetPropBool(curPayload, name, boolval);
+ if (!err)
+ {
+ err = !OCRepPayloadSetPropBool(curPayload, name, boolval);
+ }
break;
case CborTextStringType:
err = err || cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
- OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
+ if (!err)
+ {
+ err = !OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
+ }
break;
case CborMapType:
err = err || OCParseSingleRepPayload(&pl, &repMap);
- OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
+ if (!err)
+ {
+ err = !OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
+ }
break;
case CborArrayType:
err = err || OCParseArray(curPayload, name, &repMap);
CborValue curVal;
// Sequence Number
- err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal);
- err = err || cbor_value_get_uint64(&curVal, &seqNum);
+ err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_NONCE, &curVal);
+ err = err || cbor_value_get_uint64(&curVal, &seqNum);
// Max Age
- err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal);
- err = err || cbor_value_get_uint64(&curVal, &maxAge);
+ err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TTL, &curVal);
+ err = err || cbor_value_get_uint64(&curVal, &maxAge);
// Trigger
- err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal);
- err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
+ err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_TRIGGER, &curVal);
+ err = err || cbor_value_dup_text_string(&curVal, &tempStr, &len, NULL);
trigger = convertTriggerStringToEnum(tempStr);
OICFree(tempStr);
tempStr = NULL;
}
result = EntityHandlerCodeToOCStackCode(ehResult);
exit:
+ OCPayloadDestroy(ehRequest.payload);
return result;
}
}
result = EntityHandlerCodeToOCStackCode(ehResult);
exit:
+ OCPayloadDestroy(ehRequest.payload);
return result;
}
request->rcvdVendorSpecificHeaderOptions,
(OCObserveAction)request->observationOption,
(OCObservationId)0);
- if(result != OC_STACK_OK)
+ if(result == OC_STACK_OK)
{
- return result;
+ result = DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest);
}
- return (DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest));
+ OCPayloadDestroy(ehRequest.payload);
+ return result;
}
OCStackResult
!= OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "Error converting payload");
+ OICFree(responseInfo.info.options);
return result;
}
{
OICFree(responseInfo.info.payload);
OC_LOG(ERROR, TAG, "Payload too long!");
+ OICFree(responseInfo.info.options);
return OC_STACK_INVALID_PARAM;
}
}
if(!serverResponse->payload)
{
- serverResponse->payload = (OCPayload*)OCRepPayloadCreate();
serverResponse->payload = ehResponse->payload;
}
else
out->adapter = (OCTransportAdapter)in->adapter;
out->flags = CAToOCTransportFlags(in->flags);
- strncpy(out->addr, in->addr, MAX_ADDR_STR_SIZE);
- out->addr[MAX_ADDR_STR_SIZE - 1] = '\0';
+ OICStrcpy(out->addr, sizeof(out->addr), in->addr);
out->port = in->port;
}
out->adapter = (CATransportAdapter_t)in->adapter;
out->flags = OCToCATransportFlags(in->flags);
- strncpy(out->addr, in->addr, MAX_ADDR_STR_SIZE);
+ OICStrcpy(out->addr, sizeof(out->addr), in->addr);
out->port = in->port;
}
ep->adapter = CA_ADAPTER_IP;
}
ep->flags = OCToCATransportFlags(devAddr->flags);
- strncpy(ep->addr, devAddr->addr, MAX_ADDR_STR_SIZE_CA);
+ OICStrcpy(ep->addr, sizeof(ep->addr), devAddr->addr);
ep->port = devAddr->port;
*endpoint = ep;
OCPresenceTrigger convertTriggerStringToEnum(const char * triggerStr)
{
- if(strcmp(triggerStr, OC_RSRVD_TRIGGER_CREATE) == 0)
+ if(!triggerStr)
+ {
+ return OC_PRESENCE_TRIGGER_CREATE;
+ }
+ else if(strcmp(triggerStr, OC_RSRVD_TRIGGER_CREATE) == 0)
{
return OC_PRESENCE_TRIGGER_CREATE;
}
VERIFY_NON_NULL(resourceUri, FATAL, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(presenceUri, FATAL, OC_STACK_INVALID_PARAM);
- const char *format;
CAEndpoint_t *ep = (CAEndpoint_t *)endpoint;
if (ep->adapter == CA_ADAPTER_IP)
}
else
{
- format = "coap://[%s]:%u%s";
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://[%s]:%u%s",
+ ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
}
}
else
OICStrcpy(ep->addr, sizeof(ep->addr), OC_MULTICAST_IP);
ep->port = OC_MULTICAST_PORT;
}
- format = "coap://%s:%u%s";
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s:%u%s",
+ ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
}
- return snprintf(presenceUri, CA_MAX_URI_LENGTH, format, ep->addr,
- ep->port, OC_RSRVD_PRESENCE_URI);
}
// might work for other adapters (untested, but better than nothing)
- format = "coap://%s%s";
- return snprintf(presenceUri, CA_MAX_URI_LENGTH, format, ep->addr,
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s%s", ep->addr,
OC_RSRVD_PRESENCE_URI);
}
OCStackApplicationResult cbResult = OC_STACK_DELETE_TRANSACTION;
ClientCB * cbNode = NULL;
char *resourceTypeName = NULL;
- OCClientResponse response;
+ OCClientResponse response = {};
OCStackResult result = OC_STACK_ERROR;
uint32_t maxAge = 0;
int uriLen;
result = OCParsePayload(&response.payload, responseInfo->info.payload,
responseInfo->info.payloadSize);
- if(result != OC_STACK_OK || response.payload->type != PAYLOAD_TYPE_PRESENCE)
+ if(result != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, PCF("Presence parse failed"));
goto exit;
}
+ if(!response.payload || response.payload->type != PAYLOAD_TYPE_PRESENCE)
+ {
+ OC_LOG(ERROR, TAG, PCF("Presence payload was wrong type"));
+ result = OC_STACK_ERROR;
+ goto exit;
+ }
response.sequenceNumber = ((OCPresencePayload*)response.payload)->sequenceNumber;
resourceTypeName = ((OCPresencePayload*)response.payload)->resourceType;
maxAge = ((OCPresencePayload*)response.payload)->maxAge;
exit:
OICFree(resourceTypeName);
+ OCPayloadDestroy(response.payload);
return result;
}
responseInfo->info.payloadSize))
{
OC_LOG(ERROR, TAG, PCF("Error converting payload"));
+ OCPayloadDestroy(response.payload);
return;
}
if(response.numRcvdVendorSpecificHeaderOptions > MAX_HEADER_OPTIONS)
{
OC_LOG(ERROR, TAG, PCF("#header options are more than MAX_HEADER_OPTIONS"));
+ OCPayloadDestroy(response.payload);
return;
}
cbNode->TTL = GetTicks(MAX_CB_TIMEOUT_SECONDS *
MILLISECONDS_PER_SECOND);
}
- OCPayloadDestroy(response.payload);
}
//Need to send ACK when the response is CON
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0);
}
+
+ OCPayloadDestroy(response.payload);
}
return;
}
responseInfo->info.messageId);
}
}
+
return;
}
requestResult = getQueryFromUri(requestInfo->info.resourceUri, &query, &uriWithoutQuery);
- if (requestResult != OC_STACK_OK)
+ if (requestResult != OC_STACK_OK || !uriWithoutQuery)
{
OC_LOG_V(ERROR, TAG, "getQueryFromUri() failed with OC error code %d\n", requestResult);
return;
FormCanonicalPresenceUri(endpoint, resourceUri, uri);
- *requestUri = (char *)OICMalloc(strlen(uri) + 1);
+ *requestUri = OICStrdup(uri);
if (!*requestUri)
{
return OC_STACK_NO_MEMORY;
}
- strcpy(*requestUri, uri);
return OC_STACK_OK;
}
if (caResult != CA_STATUS_OK)
{
OC_LOG(ERROR, TAG, PCF("CAGenerateToken error"));
+ result= OC_STACK_ERROR;
goto exit;
}
#include "oicgroup.h"
#include "cJSON.h"
#include "oic_malloc.h"
+#include "oic_string.h"
#include "occollection.h"
#include "logger.h"
#include "timer.h"
iterToken = (char *) strtok_r(NULL, ACTION_DELIMITER, &iterTokenPtr);
VARIFY_PARAM_NULL(iterToken, result, exit)
#ifndef WITH_ARDUINO
- sscanf(iterToken, "%ld %d", &(*set)->timesteps, &(*set)->type);
+ sscanf(iterToken, "%ld %u", &(*set)->timesteps, &(*set)->type);
#endif
OC_LOG_V(INFO, TAG, "ActionSet Name : %s", (*set)->actionsetName);
{
OC_LOG(INFO, TAG, PCF("Build OCAction Instance."));
+ if(action)
+ {
+ OICFree(action->resourceUri);
+ OICFree(action);
+ }
action = (OCAction*) OICMalloc(sizeof(OCAction));
VARIFY_POINTER_NULL(action, result, exit)
memset(action, 0, sizeof(OCAction));
OCStackResult SendAction(OCDoHandle *handle, const char *targetUri,
const unsigned char *action)
{
- OCCallbackData cbdata;
- cbdata.cb = &ActionSetCB;
- cbdata.cd = NULL;
- cbdata.context = (void*)DEFAULT_CONTEXT_VALUE;
-
// TODO: disabled since this is no longer compatible
return OC_STACK_NOTIMPL;
- //return OCDoResource(handle, OC_REST_PUT, targetUri,
- // NULL, (char *) action, CT_ADAPTER_IP, OC_NA_QOS, &cbdata, NULL, 0);
}
OCStackResult DoAction(OCResource* resource, OCActionSet* actionset,
#endif
AddScheduledResource(&scheduleResourceList, schedule);
}
+ else
+ {
+ OICFree(schedule);
+ }
}
}
size_t bufferLength = 0;
unsigned char buffer[MAX_RESPONSE_LENGTH] = { 0 };
- unsigned char *bufferPtr = NULL;
-
- bufferPtr = buffer;
OCResource * collResource = (OCResource *) ehRequest->resource;
jsonResponse = cJSON_Print(json);
cJSON_Delete(json);
- strcat((char *) bufferPtr, jsonResponse);
+ OICStrcat((char*)buffer, sizeof(buffer), jsonResponse);
bufferLength = strlen((const char *) buffer);
if (bufferLength > 0)
jsonResponse = cJSON_Print(json);
cJSON_Delete(json);
- strcat((char *) bufferPtr, jsonResponse);
+ OICStrcat((char*)buffer, sizeof(buffer), jsonResponse);
bufferLength = strlen((const char *) buffer);
if (bufferLength > 0)
std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
}
}
- catch(std::exception& e)
+ catch(std::exception&)
{
std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
}
std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
}
}
- catch(exception& e)
+ catch(exception&)
{
std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
}
}
catch(std::exception& e)
{
- //log(e.what());
+ std::cerr << "Exception caught in Found Resource: "<< e.what() <<std::endl;
}
}
std::cout << "Invalid connectivity type selected. Using default IP" << std::endl;
}
}
- catch(std::exception& e)
+ catch(std::exception&)
{
std::cout << "Invalid input argument. Using IP as connectivity type" << std::endl;
}
return -1;
}
}
- catch(std::exception& e)
+ catch(std::exception&)
{
std::cout << "Invalid input argument." << std::endl;
PrintUsage();
projects / platform / upstream / iotivity.git / commitdiff