# endif
# define OC_STATIC_ASSERT(condition, msg) static_assert(condition, msg)
#else
-# define OC_STATIC_ASSERT(condition, msg) ((void)sizeof(char[2*!!(condition) - 1]))
+# define OC_CAT_(a, b) a ## b
+# define OC_CAT(a, b) OC_CAT_(a, b)
+# define OC_STATIC_ASSERT(condition, msg) \
+ typedef int OC_CAT(StaticAssertTemp, __LINE__)[2 * !!(condition) - 1]
#endif
#ifndef INLINE_API
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+// Warning disabled globally but VS2013 ignores the /wd4200 option in C++ files.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#pragma warning(disable : 4200)
+#endif
+
#include "iotivity_config.h"
#include <stdio.h>
#include <stdlib.h>
* @param responseInfo CA response info.
*/
static void HandleCAResponses(const CAEndpoint_t* endPoint,
- const CAResponseInfo_t* responseInfo);
+ const CAResponseInfo_t* responseInfo);
/**
* This function will be called back by CA layer when a request is received.
* @param requestInfo CA request info.
*/
static void HandleCARequests(const CAEndpoint_t* endPoint,
- const CARequestInfo_t* requestInfo);
+ const CARequestInfo_t* requestInfo);
/**
* Extract query from a URI.
// check obs header option
bool obsHeaderOpt = false;
CAHeaderOption_t *options = responseInfo->info.options;
- for (uint8_t i = 0; i< responseInfo->info.numOptions; i++)
+ for (uint8_t i = 0; i < responseInfo->info.numOptions; i++)
{
if (options && (options[i].optionID == COAP_OPTION_OBSERVE))
{
response->numRcvdVendorSpecificHeaderOptions = 0;
if((responseInfo->info.numOptions > 0) && (responseInfo->info.options != NULL))
{
- int start = 0;
+ uint8_t start = 0;
//First option always with option ID is COAP_OPTION_OBSERVE if it is available.
if(responseInfo->info.options[0].optionID == COAP_OPTION_OBSERVE)
{
return;
}
- for (int i = start; i < responseInfo->info.numOptions; i++)
+ for (uint8_t i = start; i < responseInfo->info.numOptions; i++)
{
- memcpy (&(response->rcvdVendorSpecificHeaderOptions[i-start]),
+ memcpy (&(response->rcvdVendorSpecificHeaderOptions[i - start]),
&(responseInfo->info.options[i]), sizeof(OCHeaderOption));
}
}
* RI as this option will make no sense to either RI or application.
*/
RMUpdateInfo((CAHeaderOption_t **) &(responseInfo->info.options),
- (uint8_t *) &(responseInfo->info.numOptions),
- (CAEndpoint_t *) endPoint);
+ (uint8_t *) &(responseInfo->info.numOptions),
+ (CAEndpoint_t *)endPoint);
#endif
OCHandleResponse(endPoint, responseInfo);
* proper destination and remove RM header option.
*/
RMUpdateInfo((CAHeaderOption_t **) &(requestInfo->info.options),
- (uint8_t *) &(requestInfo->info.numOptions),
- (CAEndpoint_t *) endPoint);
+ (uint8_t *) &(requestInfo->info.numOptions),
+ (CAEndpoint_t *)endPoint);
#ifdef ROUTING_GATEWAY
if (isEmptyMsg)
return OC_STACK_INVALID_PARAM;
}
- for (uint8_t i = 0; i < numOptions; i++)
+ for (size_t i = 0; i < numOptions; i++)
{
if (ocHdrOpt[i].optionID == optionID)
{
optionData,
optionDataSize,
&actualDataSize));
- EXPECT_EQ(optionData[0], 1);
- EXPECT_EQ(actualDataSize, 8);
+ EXPECT_EQ(1, optionData[0]);
+ EXPECT_EQ(8, actualDataSize);
}
TEST(StackEndpoints, OCGetSupportedEndpointTpsFlags)
OCStackResult result;
auto cLock = m_csdkLock.lock();
+ if (headerOptions.size() > MAX_HEADER_OPTIONS)
+ {
+ OIC_LOG_V(ERROR, TAG, "%s: passed number of header options"
+ " (%" PRIuPTR ") exceeds the maximum of %d.",
+ __func__, headerOptions.size(), MAX_HEADER_OPTIONS);
+ return OC_STACK_ERROR;
+ }
+
if (cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
result = OCCancel(handle,
static_cast<OCQualityOfService>(QoS),
assembleHeaderOptions(options, headerOptions),
- headerOptions.size());
+ (uint8_t)headerOptions.size());
}
else
{
for (auto it=headerOptions.begin(); it != headerOptions.end(); ++it)
{
+ size_t headerOptionLength = it->getOptionData().length() + 1;
+ if (headerOptionLength > MAX_HEADER_OPTION_DATA_LENGTH)
+ {
+ OIC_LOG_V(ERROR, TAG, "%s: passed header option's data length"
+ " (%" PRIuPTR ") exceeds the maximum of %d.",
+ __func__, headerOptionLength, MAX_HEADER_OPTION_DATA_LENGTH);
+ return nullptr;
+ }
+
options[i] = OCHeaderOption();
options[i].protocolID = OC_COAP_ID;
options[i].optionID = it->getOptionID();
- options[i].optionLength = it->getOptionData().length() + 1;
+ options[i].optionLength = (uint16_t)headerOptionLength;
strncpy((char*)options[i].optionData, it->getOptionData().c_str(),
sizeof(options[i].optionLength) -1 );
options[i].optionData[sizeof(options[i].optionLength) - 1] = 0;
auto cLock = m_csdkLock.lock();
OCStackResult result = OC_STACK_ERROR;
+ if (pResponse->getHeaderOptions().size() > MAX_HEADER_OPTIONS)
+ {
+ oclog() << "Error passed too many server header options.\n";
+ return OC_STACK_ERROR;
+ }
+
if(!pResponse)
{
result = OC_STACK_MALFORMED_RESPONSE;
response.persistentBufferFlag = 0;
- response.numSendVendorSpecificHeaderOptions = serverHeaderOptions.size();
+ OC_STATIC_ASSERT(MAX_HEADER_OPTIONS <= UINT8_MAX,
+ "Maximum number of headers too large.");
+
+ response.numSendVendorSpecificHeaderOptions = (uint8_t)serverHeaderOptions.size();
int i = 0;
for (auto it=serverHeaderOptions.begin(); it != serverHeaderOptions.end(); ++it)
{
+ size_t optionDataLength = (it->getOptionData()).length() + 1;
+
+ if (optionDataLength > MAX_HEADER_OPTION_DATA_LENGTH)
+ {
+ oclog() << "Error header " << i << " option data length too large.\n";
+ return OC_STACK_ERROR;
+ }
+
+ OC_STATIC_ASSERT(MAX_HEADER_OPTION_DATA_LENGTH <= UINT16_MAX,
+ "Max header options lenght too large.");
+
response.sendVendorSpecificHeaderOptions[i].protocolID = OC_COAP_ID;
response.sendVendorSpecificHeaderOptions[i].optionID =
static_cast<uint16_t>(it->getOptionID());
response.sendVendorSpecificHeaderOptions[i].optionLength =
- (it->getOptionData()).length() + 1;
+ (uint16_t)optionDataLength;
std::string optionData = it->getOptionData();
std::copy(optionData.begin(),
optionData.end(),
const std::shared_ptr<OCResourceResponse> pResponse,
QualityOfService QoS)
{
- if(!pResponse)
+ if(!pResponse || (observationIds.size() > UINT8_MAX))
{
return result_guard(OC_STACK_ERROR);
}
OCRepPayload* pl = pResponse->getResourceRepresentation().getPayload();
OCStackResult result =
OCNotifyListOfObservers(resourceHandle,
- &observationIds[0], observationIds.size(),
+ &observationIds[0], (uint8_t)observationIds.size(),
pl,
static_cast<OCQualityOfService>(QoS));
OCRepPayloadDestroy(pl);