#include "logger.h"
#include "ocserverrequest.h"
#include "secureresourcemanager.h"
+#include "psinterface.h"
#include "doxmresource.h"
#include "cacommon.h"
#include "cainterface.h"
#include "ocpayload.h"
#include "ocpayloadcbor.h"
+#include "platform_features.h"
#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
#include "routingutility.h"
#include "directpairing.h"
//#endif
-#ifdef WITH_ARDUINO
+#ifdef HAVE_ARDUINO_TIME_H
#include "Time.h"
-#else
+#endif
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include "coap_time.h"
#include "utlist.h"
#include "pdu.h"
-#ifndef ARDUINO
+#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
static OCResource *tailResource = NULL;
static OCResourceHandle platformResource = {0};
static OCResourceHandle deviceResource = {0};
+#ifdef MQ_BROKER
+static OCResourceHandle brokerResource = {0};
+#endif
+
#ifdef WITH_PRESENCE
static OCPresenceState presenceState = OC_PRESENCE_UNINITIALIZED;
-static PresenceResource presenceResource;
+static PresenceResource presenceResource = {0};
static uint8_t PresenceTimeOutSize = 0;
static uint32_t PresenceTimeOut[] = {50, 75, 85, 95, 100};
#endif
static const char COAP_TCP[] = "coap+tcp:";
static const char CORESPEC[] = "core";
-//#ifdef DIRECT_PAIRING
-OCDirectPairingCB gDirectpairingCallback = NULL;
-//#endif
-
//-----------------------------------------------------------------------------
// Macros
//-----------------------------------------------------------------------------
*/
static void incrementSequenceNumber(OCResource * resPtr);
-/**
- * Verify the lengths of the URI and the query separately.
- *
- * @param inputUri Input URI and query.
- * @param uriLen The length of the initial URI with query.
- * @return ::OC_STACK_OK on success, some other value upon failure.
- */
-static OCStackResult verifyUriQueryLength(const char * inputUri,
- uint16_t uriLen);
-
/*
* Attempts to initialize every network interface that the CA Layer might have compiled in.
*
out->flags = CAToOCTransportFlags(in->flags);
OICStrcpy(out->addr, sizeof(out->addr), in->addr);
out->port = in->port;
- out->interface = in->interface;
+ out->ifindex = in->ifindex;
#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
memcpy(out->routeData, in->routeData, sizeof(out->routeData));
#endif
memcpy(out->routeData, in->routeData, sizeof(out->routeData));
#endif
out->port = in->port;
- out->interface = in->interface;
+ out->ifindex = in->ifindex;
}
void FixUpClientResponse(OCClientResponse *cr)
NULL, PAYLOAD_TYPE_REPRESENTATION,
NULL, 0, 0, NULL,
OC_OBSERVE_DEREGISTER,
- observer->observeId);
+ observer->observeId,
+ 0);
if(result != OC_STACK_OK)
{
return result;
NULL, PAYLOAD_TYPE_REPRESENTATION,
NULL, 0, 0, NULL,
OC_OBSERVE_DEREGISTER,
- observer->observeId);
+ observer->observeId,
+ 0);
if(result != OC_STACK_OK)
{
return OC_STACK_ERROR;
OCStackResult CAResponseToOCStackResult(CAResponseResult_t caCode)
{
OCStackResult ret = OC_STACK_ERROR;
-
switch(caCode)
{
case CA_CREATED:
ret = OC_STACK_RESOURCE_DELETED;
break;
case CA_CHANGED:
+ ret = OC_STACK_RESOURCE_CHANGED;
+ break;
case CA_CONTENT:
case CA_VALID:
ret = OC_STACK_OK;
// This should not happen but,
// give it a value just in case but output an error
ret = CA_CONTENT;
- OIC_LOG_V(ERROR, TAG, "Unexpected OC_STACK_OK return code for method [%d].", method);
+ OIC_LOG_V(ERROR, TAG, "Unexpected OC_STACK_OK return code for method [%d].",
+ method);
}
break;
case OC_STACK_RESOURCE_CREATED:
case OC_STACK_RESOURCE_DELETED:
ret = CA_DELETED;
break;
+ case OC_STACK_RESOURCE_CHANGED:
+ ret = CA_CHANGED;
+ break;
case OC_STACK_INVALID_QUERY:
ret = CA_BAD_REQ;
break;
}
/**
+ * Encode an address string to match RFC6874.
+ *
+ * @param outputAddress a char array to be written with the encoded string.
+ *
+ * @param outputSize size of outputAddress buffer.
+ *
+ * @param inputAddress a char array of size <= CA_MAX_URI_LENGTH
+ * containing a valid IPv6 address string.
+ *
+ * @return OC_STACK_OK if encoding succeeded.
+ * Else an error occured.
+ */
+ OCStackResult encodeAddressForRFC6874(char *outputAddress,
+ size_t outputSize,
+ const char *inputAddress)
+{
+ VERIFY_NON_NULL(inputAddress, FATAL, OC_STACK_INVALID_PARAM);
+ VERIFY_NON_NULL(outputAddress, FATAL, OC_STACK_INVALID_PARAM);
+
+ /** @todo Use a max IPv6 string length instead of CA_MAX_URI_LENGTH. */
+#define ENCODE_MAX_INPUT_LENGTH CA_MAX_URI_LENGTH
+
+ size_t inputLength = strnlen(inputAddress, ENCODE_MAX_INPUT_LENGTH);
+
+ if (inputLength >= ENCODE_MAX_INPUT_LENGTH)
+ {
+ OIC_LOG(ERROR, TAG,
+ "encodeAddressForRFC6874 failed: Invalid input string: too long/unterminated!");
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ // inputSize includes the null terminator
+ size_t inputSize = inputLength + 1;
+
+ if (inputSize > outputSize)
+ {
+ OIC_LOG_V(ERROR, TAG,
+ "encodeAddressForRFC6874 failed: "
+ "outputSize (%d) < inputSize (%d)",
+ outputSize, inputSize);
+
+ return OC_STACK_ERROR;
+ }
+
+ char* percentChar = strchr(inputAddress, '%');
+
+ // If there is no '%' character, then no change is required to the string.
+ if (NULL == percentChar)
+ {
+ OICStrcpy(outputAddress, outputSize, inputAddress);
+ return OC_STACK_OK;
+ }
+
+ const char* addressPart = &inputAddress[0];
+ const char* scopeIdPart = percentChar + 1;
+
+ // Sanity check to make sure this string doesn't have more '%' characters
+ if (NULL != strchr(scopeIdPart, '%'))
+ {
+ return OC_STACK_ERROR;
+ }
+
+ // If no string follows the first '%', then the input was invalid.
+ if (scopeIdPart[0] == '\0')
+ {
+ OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: Invalid input string: no scope ID!");
+ return OC_STACK_ERROR;
+ }
+
+ // Check to see if the string is already encoded
+ if ((scopeIdPart[0] == '2') && (scopeIdPart[1] == '5'))
+ {
+ OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: Input string is already encoded");
+ return OC_STACK_ERROR;
+ }
+
+ // Fail if we don't have room for encoded string's two additional chars
+ if (outputSize < (inputSize + 2))
+ {
+ OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: Input string is already encoded");
+ return OC_STACK_ERROR;
+ }
+
+ // Restore the null terminator with an escaped '%' character, per RFC6874
+ OICStrcpy(outputAddress, scopeIdPart - addressPart, addressPart);
+ strcat(outputAddress, "%25");
+ strcat(outputAddress, scopeIdPart);
+
+ return OC_STACK_OK;
+}
+
+/**
* The cononical presence allows constructed URIs to be string compared.
*
* requestUri must be a char array of size CA_MAX_URI_LENGTH
}
else
{
+ char addressEncoded[CA_MAX_URI_LENGTH] = {0};
+
+ OCStackResult result = encodeAddressForRFC6874(addressEncoded,
+ sizeof(addressEncoded),
+ ep->addr);
+
+ if (OC_STACK_OK != result)
+ {
+ return -1;
+ }
+
return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://[%s]:%u%s",
- ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
+ addressEncoded, ep->port, OC_RSRVD_PRESENCE_URI);
}
}
else
OCClientResponse response =
{.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
- response.sequenceNumber = OC_OBSERVE_NO_OPTION;
+ response.sequenceNumber = MAX_SEQUENCE_NUMBER + 1;
CopyEndpointToDevAddr(endPoint, &response.devAddr);
FixUpClientResponse(&response);
response.resourceUri = responseInfo->info.resourceUri;
{
type = PAYLOAD_TYPE_DISCOVERY;
}
+#ifdef WITH_MQ
+ else if (strcmp(cbNode->requestUri, OC_RSRVD_WELL_KNOWN_MQ_URI) == 0)
+ {
+ type = PAYLOAD_TYPE_DISCOVERY;
+ }
+#endif
else if (strcmp(cbNode->requestUri, OC_RSRVD_DEVICE_URI) == 0)
{
type = PAYLOAD_TYPE_DEVICE;
(observationOption << 8) | optionData[i];
}
response.sequenceNumber = observationOption;
-
response.numRcvdVendorSpecificHeaderOptions = responseInfo->info.numOptions - 1;
start = 1;
}
if (cbNode->method == OC_REST_OBSERVE &&
response.sequenceNumber > OC_OFFSET_SEQUENCE_NUMBER &&
+ cbNode->sequenceNumber <= MAX_SEQUENCE_NUMBER &&
response.sequenceNumber <= cbNode->sequenceNumber)
{
OIC_LOG_V(INFO, TAG, "Received stale notification. Number :%d",
if(responseInfo->info.type == CA_MSG_CONFIRM)
{
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
- CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0, NULL);
+ CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0, NULL, CA_RESPONSE_FOR_RES);
}
OCPayloadDestroy(response.payload);
{
OIC_LOG(INFO, TAG, "Received a message without callbacks. Sending RESET");
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
- CA_MSG_RESET, 0, NULL, NULL, 0, NULL);
+ CA_MSG_RESET, 0, NULL, NULL, 0, NULL, CA_RESPONSE_FOR_RES);
}
}
OCStackResult SendDirectStackResponse(const CAEndpoint_t* endPoint, const uint16_t coapID,
const CAResponseResult_t responseResult, const CAMessageType_t type,
const uint8_t numOptions, const CAHeaderOption_t *options,
- CAToken_t token, uint8_t tokenLength, const char *resourceUri)
+ CAToken_t token, uint8_t tokenLength, const char *resourceUri,
+ CADataType_t dataType)
{
OIC_LOG(DEBUG, TAG, "Entering SendDirectStackResponse");
CAResponseInfo_t respInfo = {
respInfo.info.type = type;
respInfo.info.resourceUri = OICStrdup (resourceUri);
respInfo.info.acceptFormat = CA_FORMAT_UNDEFINED;
+ respInfo.info.dataType = dataType;
#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
// Add the destination to route option from the endpoint->routeData.
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_BAD_REQ,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
- requestInfo->info.tokenLength, requestInfo->info.resourceUri);
+ requestInfo->info.tokenLength, requestInfo->info.resourceUri,
+ CA_RESPONSE_DATA);
OICFree(serverRequest.payload);
return;
}
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_INTERNAL_SERVER_ERROR,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
- requestInfo->info.tokenLength, requestInfo->info.resourceUri);
+ requestInfo->info.tokenLength, requestInfo->info.resourceUri,
+ CA_RESPONSE_DATA);
OICFree(serverRequest.payload);
return;
}
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_BAD_OPT,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
- requestInfo->info.tokenLength, requestInfo->info.resourceUri);
+ requestInfo->info.tokenLength, requestInfo->info.resourceUri,
+ CA_RESPONSE_DATA);
OICFree(serverRequest.payload);
OICFree(serverRequest.requestToken);
return;
if (requestInfo->info.type == CA_MSG_CONFIRM)
{
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_EMPTY,
- CA_MSG_ACKNOWLEDGE,0, NULL, NULL, 0, NULL);
+ CA_MSG_ACKNOWLEDGE,0, NULL, NULL, 0, NULL,
+ CA_RESPONSE_DATA);
}
}
- else if(requestResult != OC_STACK_OK)
+ else if(!OCResultToSuccess(requestResult))
{
OIC_LOG_V(ERROR, TAG, "HandleStackRequests failed. error: %d", requestResult);
SendDirectStackResponse(endPoint, requestInfo->info.messageId, stackResponse,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
- requestInfo->info.tokenLength, requestInfo->info.resourceUri);
+ requestInfo->info.tokenLength, requestInfo->info.resourceUri,
+ CA_RESPONSE_DATA);
}
// requestToken is fed to HandleStackRequests, which then goes to AddServerRequest.
// The token is copied in there, and is thus still owned by this function.
}
}
-OCStackResult verifyUriQueryLength(const char *inputUri, uint16_t uriLen)
-{
- char *query;
-
- query = strchr (inputUri, '?');
-
- if (query != NULL)
- {
- if((query - inputUri) > MAX_URI_LENGTH)
- {
- return OC_STACK_INVALID_URI;
- }
-
- if((inputUri + uriLen - 1 - query) > MAX_QUERY_LENGTH)
- {
- return OC_STACK_INVALID_QUERY;
- }
- }
- else if(uriLen > MAX_URI_LENGTH)
- {
- return OC_STACK_INVALID_URI;
- }
- return OC_STACK_OK;
-}
-
/**
* A request uri consists of the following components in order:
* example
requestInfo.info.payloadFormat = CA_FORMAT_UNDEFINED;
}
- if (result != OC_STACK_OK)
- {
- OIC_LOG(ERROR, TAG, "CACreateEndpoint error");
- goto exit;
- }
-
// prepare for response
#ifdef WITH_PRESENCE
if (method == OC_REST_PRESENCE)
{
return OC_STACK_INVALID_PARAM;
}
- deleteResourceType(resource->rsrcType);
- resource->rsrcType = NULL;
while (type)
{
return OC_STACK_INVALID_PARAM;
}
- if(!resourceInterfaceName || strlen(resourceInterfaceName) == 0)
+ if (!resourceInterfaceName || strlen(resourceInterfaceName) == 0)
{
resourceInterfaceName = OC_RSRVD_INTERFACE_DEFAULT;
}
+#ifdef MQ_PUBLISHER
+ resourceProperties = resourceProperties | OC_MQ_PUBLISHER;
+#endif
// Make sure resourceProperties bitmask has allowed properties specified
if (resourceProperties
> (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW | OC_SECURE |
- OC_EXPLICIT_DISCOVERABLE))
+ OC_EXPLICIT_DISCOVERABLE
+#ifdef MQ_PUBLISHER
+ | OC_MQ_PUBLISHER
+#endif
+#ifdef MQ_BROKER
+ | OC_MQ_BROKER
+#endif
+ ))
{
OIC_LOG(ERROR, TAG, "Invalid property");
return OC_STACK_INVALID_PARAM;
return (const OCDPDev_t*)DPGetPairedDevices();
}
-void DirectPairingCB (OCDirectPairingDev_t * peer, OCStackResult result)
-{
- if (gDirectpairingCallback)
- {
- gDirectpairingCallback((OCDPDev_t*)peer, result);
- gDirectpairingCallback = NULL;
- }
-}
-
-OCStackResult OCDoDirectPairing(OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
+OCStackResult OCDoDirectPairing(void *ctx, OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
OCDirectPairingCB resultCallback)
{
OIC_LOG(INFO, TAG, "Start OCDoDirectPairing");
return OC_STACK_INVALID_CALLBACK;
}
- gDirectpairingCallback = resultCallback;
- return DPDirectPairing((OCDirectPairingDev_t*)peer, (OicSecPrm_t)pmSel,
- pinNumber, DirectPairingCB);
+ return DPDirectPairing(ctx, (OCDirectPairingDev_t*)peer, (OicSecPrm_t)pmSel,
+ pinNumber, (OCDirectPairingResultCB)resultCallback);
}
//#endif // DIRECT_PAIRING
if(result == OC_STACK_OK)
{
+ CreateResetProfile();
result = OCCreateResource(&deviceResource,
OC_RSRVD_RESOURCE_TYPE_DEVICE,
OC_RSRVD_INTERFACE_DEFAULT,
#endif // WITH_PRESENCE
pointer = temp;
}
+ memset(&platformResource, 0, sizeof(platformResource));
+ memset(&deviceResource, 0, sizeof(deviceResource));
+#ifdef MQ_BROKER
+ memset(&brokerResource, 0, sizeof(brokerResource));
+#endif
SRMDeInitSecureResources();
// Ensure that the last resource to be deleted is the presence resource. This allows for all
// presence notification attributed to their deletion to be processed.
deleteResource((OCResource *) presenceResource.handle);
+ memset(&presenceResource, 0, sizeof(presenceResource));
#endif // WITH_PRESENCE
}
}
else
{
- OCStackResult result = BindResourceInterfaceToResource(resource, OC_RSRVD_INTERFACE_DEFAULT);
+ OCStackResult result = BindResourceInterfaceToResource(resource,
+ OC_RSRVD_INTERFACE_DEFAULT);
if (result != OC_STACK_OK)
{
OICFree(newInterface->name);
previous = pointer;
pointer = pointer->next;
}
- previous->next = newInterface;
+
+ if (previous)
+ {
+ previous->next = newInterface;
+ }
}
}
return OC_STACK_ERROR;
}
}
+
+bool OCResultToSuccess(OCStackResult ocResult)
+{
+ switch (ocResult)
+ {
+ case OC_STACK_OK:
+ case OC_STACK_RESOURCE_CREATED:
+ case OC_STACK_RESOURCE_DELETED:
+ case OC_STACK_CONTINUE:
+ case OC_STACK_RESOURCE_CHANGED:
+ return true;
+ default:
+ return false;
+ }
+}
+
+#if defined(RD_CLIENT) || defined(RD_SERVER)
+OCStackResult OCBindResourceInsToResource(OCResourceHandle handle, uint8_t ins)
+{
+ VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
+
+ OCResource *resource = NULL;
+
+ resource = findResource((OCResource *) handle);
+ if (!resource)
+ {
+ OIC_LOG(ERROR, TAG, "Resource not found");
+ return OC_STACK_ERROR;
+ }
+
+ resource->ins = ins;
+
+ return OC_STACK_OK;
+}
+
+OCResourceHandle OCGetResourceHandleAtUri(const char *uri)
+{
+ if (!uri)
+ {
+ OIC_LOG(ERROR, TAG, "Resource uri is NULL");
+ return NULL;
+ }
+
+ OCResource *pointer = headResource;
+
+ while (pointer)
+ {
+ if (strncmp(uri, pointer->uri, MAX_URI_LENGTH) == 0)
+ {
+ OIC_LOG_V(DEBUG, TAG, "Found Resource %s", uri);
+ return pointer;
+ }
+ pointer = pointer->next;
+ }
+ return NULL;
+}
+
+OCStackResult OCGetResourceIns(OCResourceHandle handle, uint8_t *ins)
+{
+ OCResource *resource = NULL;
+
+ VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
+ VERIFY_NON_NULL(ins, ERROR, OC_STACK_INVALID_PARAM);
+
+ resource = findResource((OCResource *) handle);
+ if (resource)
+ {
+ *ins = resource->ins;
+ return OC_STACK_OK;
+ }
+ return OC_STACK_ERROR;
+}
+#endif