#include "secureresourcemanager.h"
#include "cacommon.h"
#include "cainterface.h"
+#include "ocpayload.h"
+#include "ocpayloadcbor.h"
#ifdef WITH_ARDUINO
#include "Time.h"
#include "coap_time.h"
#include "utlist.h"
#include "pdu.h"
-#include "cJSON.h"
#ifndef ARDUINO
#include <arpa/inet.h>
#endif
static OCMode myStackMode;
+#ifdef RA_ADAPTER
+//TODO: revisit this design
+static bool gRASetInfo = false;
+#endif
OCDeviceEntityHandler defaultDeviceHandler;
void* defaultDeviceHandlerCallbackParameter = NULL;
#define MAX_OBSERVE_AGE (0x2FFFFUL)
#define MILLISECONDS_PER_SECOND (1000)
-/**
- * Parse the presence payload and extract various parameters.
- * Note: Caller should invoke OICFree after done with resType pointer.
- *
- * @param payload Presence payload.
- * @param seqNum Sequence number.
- * @param maxAge Time To Live (in seconds).
- * @param resType Resource type.
- */
-void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge,
- OCPresenceTrigger *presenceTrigger, char** resType);
//-----------------------------------------------------------------------------
// Private internal function prototypes
static OCStackResult verifyUriQueryLength(const char * inputUri,
uint16_t uriLen);
-/**
- * Determine if a request/response must be sent in a block transfer because it is too large to be
- * sent in a single PDU. This function can be used for either a request or a response.
- * Note: Either the request or response parameter should be non-NULL (i.e. only one, not both).
- *
- * @param request NULL or pointer to request.
- * @param response NULL or pointer to response.
- * @param size 0 or size of the request/response. If 0, strlen is used for determining
- * the length of the request/response.
- *
- * @return
- * false - packet transfer NOT required (i.e. normal request/response).
- * true - packet transfer required (i.e. block transfer needed).
- */
-static bool OCIsPacketTransferRequired(const char *request, const char *response, size_t size);
-
/*
* Attempts to initialize every network interface that the CA Layer might have compiled in.
*
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->interface = in->interface;
}
void CopyDevAddrToEndpoint(const OCDevAddr *in, CAEndpoint_t *out)
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;
-}
-
-static OCStackResult OCCreateEndpoint(OCDevAddr *devAddr, CAEndpoint_t **endpoint)
-{
- VERIFY_NON_NULL(devAddr, FATAL, OC_STACK_INVALID_PARAM);
- VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
-
- CAEndpoint_t *ep = (CAEndpoint_t *)OICMalloc(sizeof (CAEndpoint_t));
- if (!ep)
- {
- return OC_STACK_NO_MEMORY;
- }
-
- ep->adapter = (CATransportAdapter_t)devAddr->adapter;
- ep->flags = OCToCATransportFlags(devAddr->flags);
- strncpy(ep->addr, devAddr->addr, MAX_ADDR_STR_SIZE_CA);
- ep->port = devAddr->port;
-
- *endpoint = ep;
-
- return OC_STACK_OK;
-}
-
-static void OCDestroyEndpoint(CAEndpoint_t *endpoint)
-{
- free(endpoint);
+ out->interface = in->interface;
}
void FixUpClientResponse(OCClientResponse *cr)
{
OCStackResult result = OC_STACK_ERROR;
ResourceObserver * observer = NULL;
- OCEntityHandlerRequest ehRequest = {};
+ OCEntityHandlerRequest ehRequest = {0};
switch(status)
{
case OC_OBSERVER_NOT_INTERESTED:
- OC_LOG(DEBUG, TAG, PCF("observer is not interested in our notifications anymore"));
+ OC_LOG(DEBUG, TAG, PCF("observer not interested in our notifications"));
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
- result = FormOCEntityHandlerRequest(&ehRequest, (OCRequestHandle) NULL,
- OC_REST_NOMETHOD, (OCResourceHandle) NULL, NULL, NULL, 0,
- NULL, OC_OBSERVE_DEREGISTER, observer->observeId);
+ result = FormOCEntityHandlerRequest(&ehRequest,
+ (OCRequestHandle)NULL,
+ OC_REST_NOMETHOD,
+ &observer->devAddr,
+ (OCResourceHandle)NULL,
+ NULL, NULL, 0, 0, NULL,
+ OC_OBSERVE_DEREGISTER,
+ observer->observeId);
if(result != OC_STACK_OK)
{
return result;
observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
observer->resource->entityHandlerCallbackParam);
}
- //observer is not observing anymore
+
result = DeleteObserverUsingToken (token, tokenLength);
if(result == OC_STACK_OK)
{
OC_LOG(DEBUG, TAG, PCF("Observer Removal failed"));
}
break;
+
case OC_OBSERVER_STILL_INTERESTED:
- //observer is still interested
- OC_LOG(DEBUG, TAG, PCF("observer is interested in our \
- notifications, reset the failedCount"));
+ OC_LOG(DEBUG, TAG, PCF("observer still interested, reset the failedCount"));
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
result = OC_STACK_OBSERVER_NOT_FOUND;
}
break;
+
case OC_OBSERVER_FAILED_COMM:
- //observer is not reachable
OC_LOG(DEBUG, TAG, PCF("observer is unreachable"));
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
if(observer->failedCommCount >= MAX_OBSERVER_FAILED_COMM)
{
- result = FormOCEntityHandlerRequest(&ehRequest, (OCRequestHandle) NULL,
- OC_REST_NOMETHOD, (OCResourceHandle) NULL, NULL, NULL, 0,
- NULL, OC_OBSERVE_DEREGISTER, observer->observeId);
+ result = FormOCEntityHandlerRequest(&ehRequest,
+ (OCRequestHandle)NULL,
+ OC_REST_NOMETHOD,
+ &observer->devAddr,
+ (OCResourceHandle)NULL,
+ NULL, NULL, 0, 0, NULL,
+ OC_OBSERVE_DEREGISTER,
+ observer->observeId);
if(result != OC_STACK_OK)
{
return OC_STACK_ERROR;
}
observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
observer->resource->entityHandlerCallbackParam);
- //observer is unreachable
+
result = DeleteObserverUsingToken (token, tokenLength);
if(result == OC_STACK_OK)
{
case CA_BAD_REQ:
ret = OC_STACK_INVALID_QUERY;
break;
+ case CA_UNAUTHORIZED_REQ:
+ ret = OC_STACK_UNAUTHORIZED_REQ;
+ break;
case CA_BAD_OPT:
ret = OC_STACK_INVALID_OPTION;
break;
case OC_STACK_COMM_ERROR:
ret = CA_RETRANSMIT_TIMEOUT;
break;
+ case OC_STACK_UNAUTHORIZED_REQ:
+ ret = CA_UNAUTHORIZED_REQ;
+ break;
default:
break;
}
{
CATransportFlags_t caFlags = (CATransportFlags_t)ocFlags;
- // supply default behavior
+ // supply default behavior.
if ((caFlags & (CA_IPV6|CA_IPV4)) == 0)
{
caFlags = (CATransportFlags_t)(caFlags|CA_IPV6|CA_IPV4);
cbNode->presence->TTL = maxAgeSeconds;
- for(int index = 0; index < PresenceTimeOutSize; index++)
+ for (int index = 0; index < PresenceTimeOutSize; index++)
{
// Guard against overflow
if (cbNode->presence->TTL < (UINT32_MAX/(MILLISECONDS_PER_SECOND*PresenceTimeOut[index]))
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;
}
*
* requestUri must be a char array of size CA_MAX_URI_LENGTH
*/
-static int FormCanonicalPresenceUri(const CAEndpoint_t *endpoint, char *resourceUri, char *presenceUri)
+static int FormCanonicalPresenceUri(const CAEndpoint_t *endpoint, char *resourceUri,
+ char *presenceUri)
{
- VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
+ VERIFY_NON_NULL(endpoint , FATAL, OC_STACK_INVALID_PARAM);
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 (endpoint->flags & CA_IPV6)
- {
- format = "coap://[%s]:%u%s";
- }
- else
- {
- format = "coap://%s:%u%s";
- }
-
- return snprintf(presenceUri, CA_MAX_URI_LENGTH, format, endpoint->addr,
- endpoint->port, OC_PRESENCE_URI);
-}
-
-void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge,
- OCPresenceTrigger *presenceTrigger, char** resType)
-{
- if(!payload || !seqNum || !maxAge || !presenceTrigger || !resType)
+ if (ep->adapter == CA_ADAPTER_IP)
{
- return;
- }
-
- cJSON *repObj = cJSON_Parse(payload);
- cJSON *ocObj = NULL;
- cJSON *presenceObj = NULL;
- cJSON *seqNumObj = NULL;
- cJSON *maxAgeObj = NULL;
- cJSON *triggerObj = NULL;
- cJSON *resObj = NULL;
- if(repObj)
- {
- ocObj = cJSON_GetObjectItem(repObj, OC_RSRVD_OC);
- if(ocObj)
+ if ((ep->flags & CA_IPV6) && !(ep->flags & CA_IPV4))
{
- //Presence payloads should only carry one JSON payload. The first
- // & only array item is retrieved.
- presenceObj = cJSON_GetArrayItem(ocObj, 0);
- if(presenceObj)
+ if ('\0' == ep->addr[0]) // multicast
{
- seqNumObj = cJSON_GetObjectItem(presenceObj, OC_RSRVD_NONCE);
- if(seqNumObj)
- {
- *seqNum = (uint32_t)seqNumObj->valuedouble;
- }
- else
- {
- OC_LOG(ERROR, TAG, PCF("Nonce (AKA SeqNum) not found in"
- " JSON Presence Payload."));
- goto exit;
- }
- maxAgeObj = cJSON_GetObjectItem(presenceObj, OC_RSRVD_TTL);
- if(maxAgeObj)
- {
- *maxAge = maxAgeObj->valueint;
- }
- else
- {
- OC_LOG(ERROR, TAG, PCF("TTL (AKA MaxAge) not found in"
- " JSON Presence Payload."));
- goto exit;
- }
- triggerObj = cJSON_GetObjectItem(presenceObj,
- OC_RSRVD_TRIGGER);
- if(triggerObj)
- {
- char * triggerStr = triggerObj->valuestring;
- *presenceTrigger = convertTriggerStringToEnum(triggerStr);
- }
- else
- {
- OC_LOG(ERROR, TAG, PCF("Trigger Reason not found in"
- " JSON Presence Payload."));
- goto exit;
- }
- resObj = cJSON_GetObjectItem(presenceObj,
- OC_RSRVD_RESOURCE_TYPE);
- if(resObj)
- {
- *resType = OICStrdup(resObj->valuestring);
- if(!*resType)
- {
- goto exit;
- }
- }
- else
- {
- OC_LOG(ERROR, TAG, PCF("Resource Type not found in"
- " JSON Presence Payload."));
- goto exit;
- }
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, OC_RSRVD_PRESENCE_URI);
}
else
{
- OC_LOG(ERROR, TAG, PCF("JSON Presence Object not found in"
- " Presence Payload."));
- OICFree(*resType);
- goto exit;
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://[%s]:%u%s",
+ ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
}
}
else
{
- OC_LOG(ERROR, TAG, PCF("JSON Presence Payload does not contain a"
- " valid \"oic\" JSON representation."));
- OICFree(*resType);
- goto exit;
+ if ('\0' == ep->addr[0]) // multicast
+ {
+ OICStrcpy(ep->addr, sizeof(ep->addr), OC_MULTICAST_IP);
+ ep->port = OC_MULTICAST_PORT;
+ }
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s:%u%s",
+ ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
}
}
- else
- {
- OC_LOG(ERROR, TAG, PCF("JSON Presence Payload does map to a valid JSON"
- " representation."));
- OICFree(*resType);
- goto exit;
- }
-exit:
- cJSON_Delete(repObj);
+ // might work for other adapters (untested, but better than nothing)
+ return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s%s", ep->addr,
+ OC_RSRVD_PRESENCE_URI);
}
+
OCStackResult HandlePresenceResponse(const CAEndpoint_t *endpoint,
const CAResponseInfo_t *responseInfo)
{
OCStackApplicationResult cbResult = OC_STACK_DELETE_TRANSACTION;
ClientCB * cbNode = NULL;
char *resourceTypeName = NULL;
- OCClientResponse response;
+ OCClientResponse response = {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
OCStackResult result = OC_STACK_ERROR;
uint32_t maxAge = 0;
- OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
int uriLen;
char presenceUri[CA_MAX_URI_LENGTH];
return OC_STACK_ERROR;
}
- uriLen = FormCanonicalPresenceUri(endpoint, OC_PRESENCE_URI, presenceUri);
- if (uriLen < 0 || uriLen >= sizeof (presenceUri))
+ // check for unicast presence
+ uriLen = FormCanonicalPresenceUri(endpoint, OC_RSRVD_PRESENCE_URI, presenceUri);
+ if (uriLen < 0 || (size_t)uriLen >= sizeof (presenceUri))
{
return OC_STACK_INVALID_URI;
}
}
else
{
- strncpy(presenceUri, responseInfo->info.resourceUri, CA_MAX_URI_LENGTH);
+ // check for multiicast presence
+ CAEndpoint_t ep = { .adapter = endpoint->adapter,
+ .flags = endpoint->flags };
+
+ uriLen = FormCanonicalPresenceUri(&ep, OC_RSRVD_PRESENCE_URI, presenceUri);
+
cbNode = GetClientCB(NULL, 0, NULL, presenceUri);
if (cbNode)
{
if (!presenceSubscribe && !multicastPresenceSubscribe)
{
- OC_LOG(ERROR, TAG, PCF("Received a presence notification, but no callback, ignoring"));
+ OC_LOG(ERROR, TAG, PCF("Received a presence notification, but no callback, ignoring"));
goto exit;
}
- response.resJSONPayload = responseInfo->info.payload;
+ response.payload = NULL;
response.result = OC_STACK_OK;
CopyEndpointToDevAddr(endpoint, &response.devAddr);
if (responseInfo->info.payload)
{
- parsePresencePayload(responseInfo->info.payload,
- &(response.sequenceNumber),
- &maxAge,
- &presenceTrigger,
- &resourceTypeName);
+ result = OCParsePayload(&response.payload, responseInfo->info.payload,
+ responseInfo->info.payloadSize);
+
+ 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;
}
if (presenceSubscribe)
cbNode->sequenceNumber = response.sequenceNumber;
// Ensure that a filter is actually applied.
- if(resourceTypeName && cbNode->filterResourceType)
+ if( resourceTypeName && cbNode->filterResourceType)
{
if(!findResourceType(cbNode->filterResourceType, resourceTypeName))
{
}
exit:
- OICFree(resourceTypeName);
+ OCPayloadDestroy(response.payload);
return result;
}
{
VERIFY_NON_NULL_NR(endPoint, FATAL);
VERIFY_NON_NULL_NR(responseInfo, FATAL);
- VERIFY_NON_NULL_NR(responseInfo->info.resourceUri, FATAL);
- if(strcmp(responseInfo->info.resourceUri, OC_PRESENCE_URI) == 0)
+ OC_LOG(INFO, TAG, PCF("Enter HandleCAResponses"));
+
+ if(responseInfo->info.resourceUri &&
+ strcmp(responseInfo->info.resourceUri, OC_RSRVD_PRESENCE_URI) == 0)
{
HandlePresenceResponse(endPoint, responseInfo);
return;
ClientCB *cbNode = GetClientCB(responseInfo->info.token,
responseInfo->info.tokenLength, NULL, NULL);
- OC_LOG_V(DEBUG, TAG, "Response has the token %s", responseInfo->info.token);
+
ResourceObserver * observer = GetObserverUsingToken (responseInfo->info.token,
responseInfo->info.tokenLength);
OC_LOG(INFO, TAG, PCF("Receiving A Timeout for this token"));
OC_LOG(INFO, TAG, PCF("Calling into application address space"));
- OCClientResponse response = {};
+ OCClientResponse response =
+ {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
CopyEndpointToDevAddr(endPoint, &response.devAddr);
FixUpClientResponse(&response);
response.resourceUri = responseInfo->info.resourceUri;
+ memcpy(response.identity.id, responseInfo->info.identity.id,
+ sizeof (response.identity.id));
+ response.identity.id_length = responseInfo->info.identity.id_length;
response.result = CAToOCStackResult(responseInfo->result);
cbNode->callBack(cbNode->context,
OC_LOG(INFO, TAG, PCF("This is a regular response, A client call back is found"));
OC_LOG(INFO, TAG, PCF("Calling into application address space"));
- OCClientResponse response = {};
+ OCClientResponse response =
+ {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
+ response.sequenceNumber = OC_OBSERVE_NO_OPTION;
CopyEndpointToDevAddr(endPoint, &response.devAddr);
FixUpClientResponse(&response);
response.resourceUri = responseInfo->info.resourceUri;
+ memcpy(response.identity.id, responseInfo->info.identity.id,
+ sizeof (response.identity.id));
+ response.identity.id_length = responseInfo->info.identity.id_length;
response.result = CAToOCStackResult(responseInfo->result);
- response.resJSONPayload = (const char*)responseInfo->info.payload;
+ if(responseInfo->info.payload &&
+ responseInfo->info.payloadSize &&
+ OC_STACK_OK != OCParsePayload(&response.payload, responseInfo->info.payload,
+ responseInfo->info.payloadSize))
+ {
+ OC_LOG(ERROR, TAG, PCF("Error converting payload"));
+ OCPayloadDestroy(response.payload);
+ return;
+ }
+
response.numRcvdVendorSpecificHeaderOptions = 0;
if(responseInfo->info.numOptions > 0)
{
if(response.numRcvdVendorSpecificHeaderOptions > MAX_HEADER_OPTIONS)
{
OC_LOG(ERROR, TAG, PCF("#header options are more than MAX_HEADER_OPTIONS"));
+ OCPayloadDestroy(response.payload);
return;
}
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0);
}
+
+ OCPayloadDestroy(response.payload);
}
return;
}
}
else
{
- OC_LOG(INFO, TAG, PCF("Received a response or notification,\
- but I do not have callback. Sending RESET"));
+ OC_LOG(INFO, TAG, PCF("Received a message without callbacks. Sending RESET"));
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
CA_MSG_RESET, 0, NULL, NULL, 0);
}
responseInfo->info.messageId);
}
}
+
return;
}
- OC_LOG_V(INFO, TAG, PCF("Received payload: %s\n"), (char*)responseInfo->info.payload);
OC_LOG(INFO, TAG, PCF("Exit HandleCAResponses"));
}
const uint8_t numOptions, const CAHeaderOption_t *options,
CAToken_t token, uint8_t tokenLength)
{
- CAResponseInfo_t respInfo = {};
- respInfo.result = responseResult;
+ CAResponseInfo_t respInfo = {
+ .result = responseResult
+ };
respInfo.info.messageId = coapID;
respInfo.info.numOptions = numOptions;
respInfo.info.options = (CAHeaderOption_t*)options;
return;
}
- OCServerProtocolRequest serverRequest = {};
+ OCServerProtocolRequest serverRequest = {0};
- OC_LOG_V(INFO, TAG, PCF("Endpoint URI : %s\n"), requestInfo->info.resourceUri);
+ OC_LOG_V(INFO, TAG, PCF("Endpoint URI : %s"), requestInfo->info.resourceUri);
- char * newUri = NULL;
+ char * uriWithoutQuery = NULL;
char * query = NULL;
- requestResult = getQueryFromUri(requestInfo->info.resourceUri, &query, &newUri);
+ 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;
}
- OC_LOG_V(INFO, TAG, PCF("URI without query: %s\n"), newUri);
- OC_LOG_V(INFO, TAG, PCF("Query : %s\n"), query);
+ OC_LOG_V(INFO, TAG, PCF("URI without query: %s"), uriWithoutQuery);
+ OC_LOG_V(INFO, TAG, PCF("Query : %s"), query);
- if(strlen(newUri) < MAX_URI_LENGTH)
+ if(strlen(uriWithoutQuery) < MAX_URI_LENGTH)
{
- //copy URI
- OICStrcpy(serverRequest.resourceUrl, sizeof(serverRequest.resourceUrl),
- newUri);
- OICFree(newUri);
+ OICStrcpy(serverRequest.resourceUrl, sizeof(serverRequest.resourceUrl), uriWithoutQuery);
+ OICFree(uriWithoutQuery);
}
else
{
OC_LOG(ERROR, TAG, PCF("URI length exceeds MAX_URI_LENGTH."));
- OICFree(newUri);
+ OICFree(uriWithoutQuery);
OICFree(query);
return;
}
- //copy query
+
if(query)
{
if(strlen(query) < MAX_QUERY_LENGTH)
return;
}
}
- //copy request payload
- if (requestInfo->info.payload)
+
+ if ((requestInfo->info.payload) && (0 < requestInfo->info.payloadSize))
{
- size_t payloadLen = strlen(requestInfo->info.payload);
- serverRequest.reqTotalSize = payloadLen + 1;
- OICStrcpy(serverRequest.reqJSONPayload, sizeof(serverRequest.reqJSONPayload),
- requestInfo->info.payload);
+ serverRequest.reqTotalSize = requestInfo->info.payloadSize;
+ serverRequest.payload = (uint8_t *) OICMalloc(requestInfo->info.payloadSize);
+ memcpy (serverRequest.payload, requestInfo->info.payload,
+ requestInfo->info.payloadSize);
}
else
{
- serverRequest.reqTotalSize = 1;
- serverRequest.reqJSONPayload[0] = '\0';
+ serverRequest.reqTotalSize = 0;
}
switch (requestInfo->method)
serverRequest.method = OC_REST_DELETE;
break;
default:
- OC_LOG(ERROR, TAG, PCF("Received CA method %d not supported"));
+ OC_LOG_V(ERROR, TAG, "Received CA method %d not supported", requestInfo->method);
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_BAD_REQ,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
requestInfo->info.tokenLength);
+ OICFree(serverRequest.payload);
return;
}
- OC_LOG_V(INFO, TAG, "HandleCARequests: CA token length = %d",
- requestInfo->info.tokenLength);
OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)requestInfo->info.token,
requestInfo->info.tokenLength);
serverRequest.requestToken = (CAToken_t)OICMalloc(requestInfo->info.tokenLength);
serverRequest.tokenLength = requestInfo->info.tokenLength;
- // Module Name
+
if (!serverRequest.requestToken)
{
- OC_LOG(FATAL, TAG, "Server Request Token is NULL");
+ OC_LOG(FATAL, TAG, "Allocation for token failed.");
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_INTERNAL_SERVER_ERROR,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
requestInfo->info.tokenLength);
+ OICFree(serverRequest.payload);
return;
}
memcpy(serverRequest.requestToken, requestInfo->info.token, requestInfo->info.tokenLength);
serverRequest.coapID = requestInfo->info.messageId;
- // copy the address
CopyEndpointToDevAddr(endPoint, &serverRequest.devAddr);
// copy vendor specific header options
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
requestInfo->info.tokenLength);
+ OICFree(serverRequest.payload);
OICFree(serverRequest.requestToken);
return;
}
}
// requestToken is fed to HandleStackRequests, which then goes to AddServerRequest.
// The token is copied in there, and is thus still owned by this function.
+ OICFree(serverRequest.payload);
OICFree(serverRequest.requestToken);
OC_LOG(INFO, TAG, PCF("Exit HandleCARequests"));
}
protocolRequest->method, protocolRequest->numRcvdVendorSpecificHeaderOptions,
protocolRequest->observationOption, protocolRequest->qos,
protocolRequest->query, protocolRequest->rcvdVendorSpecificHeaderOptions,
- protocolRequest->reqJSONPayload, protocolRequest->requestToken,
+ protocolRequest->payload, protocolRequest->requestToken,
protocolRequest->tokenLength,
protocolRequest->resourceUrl, protocolRequest->reqTotalSize,
&protocolRequest->devAddr);
}
else
{
- OC_LOG(INFO, TAG,
- PCF("This is either a repeated or blocked Server Request"));
+ OC_LOG(INFO, TAG, PCF("This is either a repeated or blocked Server Request"));
}
if(request->requestComplete)
//-----------------------------------------------------------------------------
// Public APIs
//-----------------------------------------------------------------------------
+#ifdef RA_ADAPTER
+OCStackResult OCSetRAInfo(const OCRAInfo_t *raInfo)
+{
+ if (!raInfo ||
+ !raInfo->username ||
+ !raInfo->hostname ||
+ !raInfo->xmpp_domain)
+ {
+
+ return OC_STACK_INVALID_PARAM;
+ }
+ OCStackResult result = CAResultToOCResult(CASetRAInfo((const CARAInfo_t *) raInfo));
+ gRASetInfo = (result == OC_STACK_OK)? true : false;
+
+ return result;
+}
+#endif
OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
{
(void) ipAddr;
(void) port;
-
return OCInit1(mode, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS);
}
return OC_STACK_OK;
}
+#ifdef RA_ADAPTER
+ if(!gRASetInfo)
+ {
+ OC_LOG(ERROR, TAG, PCF("Need to call OCSetRAInfo before calling OCInit"));
+ return OC_STACK_ERROR;
+ }
+#endif
+
OCStackResult result = OC_STACK_ERROR;
OC_LOG(INFO, TAG, PCF("Entering OCInit"));
}
myStackMode = mode;
+ if (mode == OC_CLIENT || mode == OC_CLIENT_SERVER)
+ {
+ caglobals.client = true;
+ }
+ if (mode == OC_SERVER || mode == OC_CLIENT_SERVER)
+ {
+ caglobals.server = true;
+ }
+
caglobals.serverFlags = (CATransportFlags_t)serverFlags;
+ if (!(caglobals.serverFlags & CA_IPFAMILY_MASK))
+ {
+ caglobals.serverFlags = (CATransportFlags_t)(caglobals.serverFlags|CA_IPV4|CA_IPV6);
+ }
caglobals.clientFlags = (CATransportFlags_t)clientFlags;
+ if (!(caglobals.clientFlags & CA_IPFAMILY_MASK))
+ {
+ caglobals.clientFlags = (CATransportFlags_t)(caglobals.clientFlags|CA_IPV4|CA_IPV6);
+ }
defaultDeviceHandler = NULL;
defaultDeviceHandlerCallbackParameter = NULL;
VERIFY_SUCCESS(result, OC_STACK_OK);
#ifdef WITH_PRESENCE
- PresenceTimeOutSize = sizeof(PresenceTimeOut)/sizeof(PresenceTimeOut[0]) - 1;
+ PresenceTimeOutSize = sizeof (PresenceTimeOut) / sizeof (PresenceTimeOut[0]) - 1;
#endif // WITH_PRESENCE
//Update Stack state to initialized
// Free memory dynamically allocated for resources
deleteAllResources();
DeleteDeviceInfo();
+ DeletePlatformInfo();
CATerminate();
// Remove all observers
DeleteObserverList();
// TODO after BeachHead delivery: consolidate into single SRMDeInit()
SRMDeInitPolicyEngine();
+
stackState = OC_STACK_UNINITIALIZED;
return OC_STACK_OK;
}
// processs url prefix, if any
size_t urlLen = slash - start;
+ // port
+ uint16_t port = 0;
+ size_t len = 0;
if (urlLen && devAddr)
{ // construct OCDevAddr
if (start[0] == '[')
{
colon = close + 1;
}
+ adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
+ flags = (OCTransportFlags)(flags | OC_IP_USE_V6);
}
else
- { // ipv4 address
- end = slash;
- colon = strchr(start, ':');
- end = (colon && colon < slash) ? colon : slash;
+ {
+ char *dot = strchr(start, '.');
+ if (dot && dot < slash)
+ { // ipv4 address
+ colon = strchr(start, ':');
+ end = (colon && colon < slash) ? colon : slash;
+ adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
+ flags = (OCTransportFlags)(flags | OC_IP_USE_V4);
+ }
+ else
+ { // MAC address
+ end = slash;
+ }
}
- size_t len = end - start;
- if (len > MAX_ADDR_STR_SIZE)
+ len = end - start;
+ if (len >= sizeof(da->addr))
{
return OC_STACK_INVALID_URI;
}
-
- // port
- uint16_t port = 0; // use standard multicast port
+ // collect port, if any
if (colon && colon < slash)
{
for (colon++; colon < slash; colon++)
}
da = (OCDevAddr *)OICCalloc(1, sizeof (OCDevAddr));
+
+ len = end - start;
+ if (len >= sizeof(da->addr))
+ {
+ return OC_STACK_INVALID_URI;
+ }
+
+ da = (OCDevAddr *)OICCalloc(sizeof (OCDevAddr), 1);
+
if (!da)
{
return OC_STACK_NO_MEMORY;
}
- strncpy(da->addr, start, len);
+ OICStrcpyPartial(da->addr, sizeof(da->addr), start, len);
da->port = port;
da->adapter = adapter;
da->flags = flags;
size_t tlen = 0; // resource type length
char *type = NULL;
- static const char *strPresence = "/oc/presence?rt=";
- static const size_t lenPresence = 15; // = strlen(presence);
+ static const char strPresence[] = "/oic/ad?rt=";
+ static const size_t lenPresence = sizeof(strPresence) - 1;
if (!strncmp(slash, strPresence, lenPresence))
{
type = slash + lenPresence;
result = OC_STACK_NO_MEMORY;
goto error;
}
- strncpy(*resourceType, type, tlen);
+
+ OICStrcpy(*resourceType, (tlen+1), type);
}
}
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;
}
OCMethod method,
const char *requestUri,
const OCDevAddr *destination,
- const char *request,
+ OCPayload* payload,
OCConnectivityType connectivityType,
OCQualityOfService qos,
OCCallbackData *cbData,
uint8_t tokenLength = CA_MAX_TOKEN_LEN;
ClientCB *clientCB = NULL;
OCDoHandle resHandle = NULL;
- CAEndpoint_t *endpoint = NULL;
+ CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
OCDevAddr tmpDevAddr = { OC_DEFAULT_ADAPTER };
uint32_t ttl = 0;
OCTransportAdapter adapter;
OCTransportFlags flags;
// the request contents are put here
- CARequestInfo_t requestInfo = { CA_GET };
+ CARequestInfo_t requestInfo = {.method = CA_GET};
// requestUri will be parsed into the following three variables
OCDevAddr *devAddr = NULL;
char *resourceUri = NULL;
goto exit;
}
- if ((request) && (strlen(request) > MAX_REQUEST_LENGTH))
- {
- result = OC_STACK_INVALID_PARAM;
- goto exit;
- }
-
/*
* Support original behavior with address on resourceUri argument.
*/
flags = (OCTransportFlags)(connectivityType & CT_MASK_FLAGS);
result = ParseRequestUri(requestUri, adapter, flags, &devAddr, &resourceUri, &resourceType);
+
if (result != OC_STACK_OK)
{
OC_LOG_V(DEBUG, TAG, "Unable to parse uri: %s", requestUri);
break;
case OC_REST_DISCOVER:
qos = OC_LOW_QOS;
- if (!destination && !devAddr)
+ if (destination || devAddr)
+ {
+ requestInfo.isMulticast = false;
+ }
+ else
{
+ tmpDevAddr.adapter = adapter;
+ tmpDevAddr.flags = flags;
destination = &tmpDevAddr;
+ requestInfo.isMulticast = true;
}
// CA_DISCOVER will become GET and isMulticast
requestInfo.method = CA_GET;
- requestInfo.isMulticast = true;
break;
#ifdef WITH_PRESENCE
case OC_REST_PRESENCE:
if (caResult != CA_STATUS_OK)
{
OC_LOG(ERROR, TAG, PCF("CAGenerateToken error"));
+ result= OC_STACK_ERROR;
goto exit;
}
requestInfo.info.token = token;
requestInfo.info.tokenLength = tokenLength;
requestInfo.info.resourceUri = resourceUri;
- requestInfo.info.payload = (char *)request;
+
if ((method == OC_REST_OBSERVE) || (method == OC_REST_OBSERVE_ALL))
{
result = CreateObserveHeaderOption (&(requestInfo.info.options),
requestInfo.info.numOptions = numOptions;
}
- // create remote endpoint
- result = OCCreateEndpoint(devAddr, &endpoint);
+ CopyDevAddrToEndpoint(devAddr, &endpoint);
+
+ if(payload)
+ {
+ if((result =
+ OCConvertPayload(payload, &requestInfo.info.payload, &requestInfo.info.payloadSize))
+ != OC_STACK_OK)
+ {
+ OC_LOG(ERROR, TAG, PCF("Failed to create CBOR Payload"));
+ goto exit;
+ }
+ }
+ else
+ {
+ requestInfo.info.payload = NULL;
+ requestInfo.info.payloadSize = 0;
+ }
+
if (result != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, PCF("CACreateEndpoint error"));
if (method == OC_REST_PRESENCE)
{
char *presenceUri = NULL;
- result = OCPreparePresence(endpoint, resourceUri, &presenceUri);
+ result = OCPreparePresence(&endpoint, resourceUri, &presenceUri);
if (OC_STACK_OK != result)
{
goto exit;
}
- OICFree(resourceUri);
+
+ // Assign full presence uri as coap://ip:port/oic/ad to add to callback list.
+ // Presence notification will form a canonical uri to
+ // look for callbacks into the application.
resourceUri = presenceUri;
}
#endif
resourceType = NULL; // Client CB list entry now owns it
// send request
- caResult = CASendRequest(endpoint, &requestInfo);
+ caResult = CASendRequest(&endpoint, &requestInfo);
if (caResult != CA_STATUS_OK)
{
OC_LOG(ERROR, TAG, PCF("CASendRequest"));
}
OICFree(resHandle);
}
+
+ // This is the owner of the payload object, so we free it
+ OCPayloadDestroy(payload);
+ OICFree(requestInfo.info.payload);
OICFree(devAddr);
OICFree(resourceUri);
OICFree(resourceType);
- OICFree(endpoint);
if (hdrOptionMemAlloc)
{
OICFree(requestInfo.info.options);
* Remove the callback associated on client side.
*/
OCStackResult ret = OC_STACK_OK;
- CAEndpoint_t* endpoint = NULL;
+ CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
CAResult_t caResult;
- CAInfo_t requestData = {};
- CARequestInfo_t requestInfo = {};
+ CAInfo_t requestData = {.type = CA_MSG_CONFIRM};
+ CARequestInfo_t requestInfo = {.method = CA_GET};
if(!handle)
{
return OC_STACK_INVALID_PARAM;
}
- OC_LOG(INFO, TAG, PCF("Entering OCCancel"));
-
ClientCB *clientCB = GetClientCB(NULL, 0, handle, NULL);
if (!clientCB)
{
{
case OC_REST_OBSERVE:
case OC_REST_OBSERVE_ALL:
- OC_LOG(INFO, TAG, PCF("Canceling observation"));
+ OC_LOG_V(INFO, TAG, "Canceling observation for resource %s",
+ clientCB->requestUri);
if (qos != OC_HIGH_QOS)
{
FindAndDeleteClientCB(clientCB);
break;
}
+ else
+ {
+ OC_LOG(INFO, TAG, PCF("Cancelling observation as CONFIRMABLE"));
+ }
requestData.type = qualityOfServiceToMessageType(qos);
requestData.token = clientCB->token;
return OC_STACK_ERROR;
}
requestData.numOptions = numOptions + 1;
+ requestData.resourceUri = OICStrdup (clientCB->requestUri);
+
requestInfo.method = CA_GET;
requestInfo.info = requestData;
- ret = OCCreateEndpoint(clientCB->devAddr, &endpoint);
- if (ret != OC_STACK_OK)
- {
- OC_LOG(ERROR, TAG, PCF("CACreateEndpoint error"));
- goto Error;
- }
+ CopyDevAddrToEndpoint(clientCB->devAddr, &endpoint);
// send request
- caResult = CASendRequest(endpoint, &requestInfo);
+ caResult = CASendRequest(&endpoint, &requestInfo);
if (caResult != CA_STATUS_OK)
{
OC_LOG(ERROR, TAG, PCF("CASendRequest error"));
}
Error:
- OCDestroyEndpoint(endpoint);
if (requestData.numOptions > 0)
{
OICFree(requestData.options);
}
-
+ if (requestData.resourceUri)
+ {
+ OICFree (requestData.resourceUri);
+ }
return ret;
}
cbNode->presence->TTLlevel);
OC_LOG_V(DEBUG, TAG, "current ticks %d", now);
- if(cbNode->presence->TTLlevel >= (PresenceTimeOutSize + 1))
+ if (cbNode->presence->TTLlevel > PresenceTimeOutSize)
{
goto exit;
}
OC_LOG_V(DEBUG, TAG, "timeout ticks %d",
cbNode->presence->timeOut[cbNode->presence->TTLlevel]);
}
-
if (cbNode->presence->TTLlevel >= PresenceTimeOutSize)
{
OC_LOG(DEBUG, TAG, PCF("No more timeout ticks"));
clientResponse.result = OC_STACK_PRESENCE_TIMEOUT;
clientResponse.devAddr = *cbNode->devAddr;
FixUpClientResponse(&clientResponse);
- clientResponse.resJSONPayload = NULL;
+ clientResponse.payload = NULL;
// Increment the TTLLevel (going to a next state), so we don't keep
// sending presence notification to client.
}
CAResult_t caResult = CA_STATUS_OK;
- CAEndpoint_t* endpoint = NULL;
- CAInfo_t requestData ={};
- CARequestInfo_t requestInfo = {};
+ CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
+ CAInfo_t requestData = {.type = CA_MSG_CONFIRM};
+ CARequestInfo_t requestInfo = {.method = CA_GET};
OC_LOG(DEBUG, TAG, PCF("time to test server presence"));
- result = OCCreateEndpoint(cbNode->devAddr, &endpoint);
- if (result != OC_STACK_OK)
- {
- OC_LOG(ERROR, TAG, PCF("CACreateEndpoint error"));
- goto exit;
- }
+ CopyDevAddrToEndpoint(cbNode->devAddr, &endpoint);
requestData.type = CA_MSG_NONCONFIRM;
requestData.token = cbNode->token;
requestData.tokenLength = cbNode->tokenLength;
+ requestData.resourceUri = OC_RSRVD_PRESENCE_URI;
requestInfo.method = CA_GET;
requestInfo.info = requestData;
- caResult = CASendRequest(endpoint, &requestInfo);
- OCDestroyEndpoint(endpoint);
+ caResult = CASendRequest(&endpoint, &requestInfo);
if (caResult != CA_STATUS_OK)
{
{
OC_LOG(ERROR, TAG, PCF("OCProcessPresence error"));
}
+
return result;
}
#endif // WITH_PRESENCE
presenceState = OC_PRESENCE_INITIALIZED;
OCDevAddr devAddr = { OC_DEFAULT_ADAPTER };
- OICStrcpy(devAddr.addr, sizeof(devAddr.addr), OC_MULTICAST_IP);
- devAddr.port = OC_MULTICAST_PORT;
CAToken_t caToken = NULL;
CAResult_t caResult = CAGenerateToken(&caToken, tokenLength);
return OC_STACK_ERROR;
}
- AddObserver(OC_PRESENCE_URI, NULL, 0, caToken, tokenLength,
+ AddObserver(OC_RSRVD_PRESENCE_URI, NULL, 0, caToken, tokenLength,
(OCResource *)presenceResource.handle, OC_LOW_QOS, &devAddr);
CADestroyToken(caToken);
}
if(presenceResource.handle)
{
((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
- }
// make resource inactive
result = OCChangeResourceProperty(
&(((OCResource *) presenceResource.handle)->resourceProperties),
OC_ACTIVE, 0);
+ }
if(result != OC_STACK_OK)
{
// Validate parameters
if(!uri || uri[0]=='\0' || strlen(uri)>=MAX_URI_LENGTH )
{
- OC_LOG(ERROR, TAG, PCF("URI is invalid"));
+ OC_LOG(ERROR, TAG, PCF("URI is empty or too long"));
return OC_STACK_INVALID_URI;
}
// Is it presented during resource discovery?
- if (!handle || !resourceTypeName)
+ if (!handle || !resourceTypeName || resourceTypeName[0] == '\0' )
{
OC_LOG(ERROR, TAG, PCF("Input parameter is NULL"));
return OC_STACK_INVALID_PARAM;
// Make sure resourceProperties bitmask has allowed properties specified
if (resourceProperties
- > (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW | OC_SECURE))
+ > (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW | OC_SECURE |
+ OC_EXPLICIT_DISCOVERABLE))
{
OC_LOG(ERROR, TAG, PCF("Invalid property"));
return OC_STACK_INVALID_PARAM;
{
if (strncmp(uri, pointer->uri, MAX_URI_LENGTH) == 0)
{
- OC_LOG(ERROR, TAG, PCF("URI already in use"));
+ OC_LOG_V(ERROR, TAG, "Resource %s already exists", uri);
return OC_STACK_INVALID_PARAM;
}
pointer = pointer->next;
char *str = NULL;
OCStackResult result = OC_STACK_ERROR;
- OC_LOG(INFO, TAG, PCF("Entering BindResourceTypeToResource"));
-
- // Validate parameters
VERIFY_NON_NULL(resourceTypeName, ERROR, OC_STACK_INVALID_PARAM);
- // TODO: Does resource attribute representation really have to be maintained in stack?
- // Is it presented during resource discovery?
- // Create the resourcetype and insert it into the resource list
pointer = (OCResourceType *) OICCalloc(1, sizeof(OCResourceType));
if (!pointer)
{
goto exit;
}
- // Set the resourceTypeName
str = OICStrdup(resourceTypeName);
if (!str)
{
char *str = NULL;
OCStackResult result = OC_STACK_ERROR;
- OC_LOG(INFO, TAG, PCF("Entering BindResourceInterfaceToResource"));
-
- // Validate parameters
VERIFY_NON_NULL(resourceInterfaceName, ERROR, OC_STACK_INVALID_PARAM);
- //TODO ("Make sure that the resourceinterface name doesn't already exist in the resource");
+ OC_LOG_V(INFO, TAG, "Binding %s interface to %s", resourceInterfaceName, resource->uri);
- // Create the resourceinterface and insert it into the resource list
pointer = (OCResourceInterface *) OICCalloc(1, sizeof(OCResourceInterface));
if (!pointer)
{
goto exit;
}
- // Set the resourceinterface name
str = OICStrdup(resourceInterfaceName);
if (!str)
{
OCStackResult result = OC_STACK_ERROR;
OCResource *resource = NULL;
- // Make sure resource exists
resource = findResource((OCResource *) handle);
if (!resource)
{
return OC_STACK_ERROR;
}
- // call internal function
result = BindResourceTypeToResource(resource, resourceTypeName);
#ifdef WITH_PRESENCE
OCStackResult result = OC_STACK_ERROR;
OCResource *resource = NULL;
- // Make sure resource exists
resource = findResource((OCResource *) handle);
if (!resource)
{
return OC_STACK_ERROR;
}
- // call internal function
result = BindResourceInterfaceToResource(resource, resourceInterfaceName);
#ifdef WITH_PRESENCE
{
OCResource *pointer = headResource;
- OC_LOG(INFO, TAG, PCF("Entering OCGetNumberOfResources"));
VERIFY_NON_NULL(numResources, ERROR, OC_STACK_INVALID_PARAM);
*numResources = 0;
while (pointer)
{
OCResource *pointer = headResource;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceHandle"));
-
- // Iterate through the list
for( uint8_t i = 0; i < index && pointer; ++i)
{
pointer = pointer->next;
OCStackResult OCDeleteResource(OCResourceHandle handle)
{
- OC_LOG(INFO, TAG, PCF("Entering OCDeleteResource"));
-
if (!handle)
{
- OC_LOG(ERROR, TAG, PCF("Invalid param"));
+ OC_LOG(ERROR, TAG, PCF("Invalid handle for deletion"));
return OC_STACK_INVALID_PARAM;
}
const char *OCGetResourceUri(OCResourceHandle handle)
{
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceUri"));
resource = findResource((OCResource *) handle);
if (resource)
OCResourceProperty OCGetResourceProperties(OCResourceHandle handle)
{
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceProperties"));
resource = findResource((OCResource *) handle);
if (resource)
OCResource *resource = NULL;
OCResourceType *pointer = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetNumberOfResourceTypes"));
VERIFY_NON_NULL(numResourceTypes, ERROR, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
{
OCResourceType *resourceType = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceTypeName"));
-
resourceType = findResourceTypeAtIndex(handle, index);
if (resourceType)
{
OCResourceInterface *pointer = NULL;
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetNumberOfResourceInterfaces"));
-
VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(numResourceInterfaces, ERROR, OC_STACK_INVALID_PARAM);
{
OCResourceInterface *resourceInterface = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceInterfaceName"));
-
resourceInterface = findResourceInterfaceAtIndex(handle, index);
if (resourceInterface)
{
{
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetContainedResource"));
-
if (index >= MAX_CONTAINED_RESOURCES)
{
return NULL;
{
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCBindResourceHandler"));
-
// Validate parameters
VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
{
OCResource *resource = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCGetResourceHandler"));
-
- // Use the handle to find the resource in the resource linked list
resource = findResource((OCResource *)handle);
if (!resource)
{
#endif // WITH_PRESENCE
OCStackResult OCNotifyAllObservers(OCResourceHandle handle, OCQualityOfService qos)
{
-
- OC_LOG(INFO, TAG, PCF("Entering OCNotifyAllObservers"));
-
OCResource *resPtr = NULL;
OCStackResult result = OC_STACK_ERROR;
OCMethod method = OC_REST_NOMETHOD;
uint32_t maxAge = 0;
- OC_LOG(INFO, TAG, PCF("Entering OCNotifyAllObservers"));
+ OC_LOG(INFO, TAG, PCF("Notifying all observers"));
#ifdef WITH_PRESENCE
if(handle == presenceResource.handle)
{
OCNotifyListOfObservers (OCResourceHandle handle,
OCObservationId *obsIdList,
uint8_t numberOfIds,
- const char *notificationJSONPayload,
+ const OCRepPayload *payload,
OCQualityOfService qos)
{
OC_LOG(INFO, TAG, PCF("Entering OCNotifyListOfObservers"));
VERIFY_NON_NULL(handle, ERROR, OC_STACK_ERROR);
VERIFY_NON_NULL(obsIdList, ERROR, OC_STACK_ERROR);
- VERIFY_NON_NULL(notificationJSONPayload, ERROR, OC_STACK_ERROR);
+ VERIFY_NON_NULL(payload, ERROR, OC_STACK_ERROR);
- // Verify that the resource exists
resPtr = findResource ((OCResource *) handle);
if (NULL == resPtr || myStackMode == OC_CLIENT)
{
incrementSequenceNumber(resPtr);
}
return (SendListObserverNotification(resPtr, obsIdList, numberOfIds,
- notificationJSONPayload, maxAge, qos));
+ payload, maxAge, qos));
}
OCStackResult OCDoResponse(OCEntityHandlerResponse *ehResponse)
VERIFY_NON_NULL(ehResponse, ERROR, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(ehResponse->requestHandle, ERROR, OC_STACK_INVALID_PARAM);
- // TODO: Placeholder for creating a response entry when implementing
- // block transfer feature
-
- // If a response payload is present, check if block transfer is required
- if (ehResponse->payload && OCIsPacketTransferRequired(NULL,
- (const char *)ehResponse->payload, ehResponse->payloadSize))
- {
- OC_LOG(INFO, TAG, PCF("Block transfer required"));
-
- // Persistent response buffer is needed for block transfer
- if (!ehResponse->persistentBufferFlag)
- {
- OC_LOG(WARNING, TAG, PCF("Persistent response buffer required"));
- return OC_STACK_PERSISTENT_BUFFER_REQUIRED;
- }
- // TODO: Placeholder for block transfer handling
- // TODO: Placeholder for setting the the response handle in the OCServerResponse struct
- // when implementing the block transfer feature
- }
- else
+ // Normal response
+ // Get pointer to request info
+ serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
+ if(serverRequest)
{
- // Normal response
- // Get pointer to request info
- serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
- if(serverRequest)
- {
- result = serverRequest->ehResponseHandler(ehResponse);
- }
+ // response handler in ocserverrequest.c. Usually HandleSingleResponse.
+ result = serverRequest->ehResponseHandler(ehResponse);
}
+
return result;
}
OCStackResult initResources()
{
OCStackResult result = OC_STACK_OK;
- // Init application resource vars
+
headResource = NULL;
tailResource = NULL;
// Init Virtual Resources
#ifdef WITH_PRESENCE
presenceResource.presenceTTL = OC_DEFAULT_PRESENCE_TTL_SECONDS;
- //presenceResource.token = OCGenerateCoAPToken();
+
result = OCCreateResource(&presenceResource.handle,
OC_RSRVD_RESOURCE_TYPE_PRESENCE,
"core.r",
- OC_PRESENCE_URI,
+ OC_RSRVD_PRESENCE_URI,
NULL,
NULL,
OC_OBSERVABLE);
{
OCResource *prev = NULL;
OCResource *temp = NULL;
+ if(!resource)
+ {
+ OC_LOG_V(DEBUG,TAG,"resource is NULL");
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ OC_LOG_V (INFO, TAG, "Deleting resource %s", resource->uri);
temp = headResource;
while (temp)
return;
}
- // remove URI
OICFree(resource->uri);
-
- // Delete resourcetype linked list
deleteResourceType(resource->rsrcType);
-
- // Delete resourceinterface linked list
deleteResourceInterface(resource->rsrcInterface);
}
while (pointer)
{
- // resource type already exists. Free 2nd arg and return.
if (!strcmp(resourceType->resourcetypename, pointer->resourcetypename))
{
+ OC_LOG_V(INFO, TAG, "Type %s already exists", resourceType->resourcetypename);
OICFree(resourceType->resourcetypename);
OICFree(resourceType);
return;
previous->next = resourceType;
}
resourceType->next = NULL;
+
+ OC_LOG_V(INFO, TAG, "Added type %s to %s", resourceType->resourcetypename, resource->uri);
}
OCResourceType *findResourceTypeAtIndex(OCResourceHandle handle, uint8_t index)
return pointer;
}
-bool OCIsPacketTransferRequired(const char *request, const char *response, size_t size)
-{
- bool result = false;
-
- // Determine if we are checking a request or a response
- if (request)
- {
- // If size is greater than 0, use it for the request size value, otherwise
- // assume request is null terminated and use strlen for size value
- if ((size > MAX_REQUEST_LENGTH) || (strlen(request) > MAX_REQUEST_LENGTH))
- {
- result = true;
- }
- }
- else if (response)
- {
- // If size is greater than 0, use it for the response size value, otherwise
- // assume response is null terminated and use strlen for size value
- if ((size > MAX_RESPONSE_LENGTH) || (strlen(response) > MAX_RESPONSE_LENGTH))
- {
- result = true;
- }
- }
- return result;
-}
-
/*
* This function splits the uri using the '?' delimiter.
* "uriWithoutQuery" is the block of characters between the beginning
char *pointerToDelimiter = strstr(uri, "?");
- uriWithoutQueryLen = pointerToDelimiter == NULL ? uriLen : pointerToDelimiter - uri;
+ uriWithoutQueryLen = pointerToDelimiter == NULL ? uriLen : (size_t)(pointerToDelimiter - uri);
queryLen = pointerToDelimiter == NULL ? 0 : uriLen - uriWithoutQueryLen - 1;
if (uriWithoutQueryLen)
CATransportAdapter_t connTypes[] = {
CA_ADAPTER_IP,
CA_ADAPTER_RFCOMM_BTEDR,
- CA_ADAPTER_GATT_BTLE};
+ CA_ADAPTER_GATT_BTLE
+
+ #ifdef RA_ADAPTER
+ ,CA_ADAPTER_REMOTE_ACCESS
+ #endif
+ };
int numConnTypes = sizeof(connTypes)/sizeof(connTypes[0]);
for(int i = 0; i<numConnTypes; i++)
projects / platform / upstream / iotivity.git / blobdiff