#include "ocrandom.h"
#include "oic_malloc.h"
#include "oic_string.h"
+#include "logger.h"
#include "ocserverrequest.h"
#include "secureresourcemanager.h"
#include "doxmresource.h"
#include "ocpayload.h"
#include "ocpayloadcbor.h"
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+#include "routingutility.h"
+#ifdef ROUTING_GATEWAY
+#include "routingmanager.h"
+#endif
+#endif
+
#ifdef WITH_ARDUINO
#include "Time.h"
#else
OCDeviceEntityHandler defaultDeviceHandler;
void* defaultDeviceHandlerCallbackParameter = NULL;
+#ifdef TCP_ADAPTER
+static const char COAP_TCP[] = "coap+tcp:";
+#endif
+
//-----------------------------------------------------------------------------
// Macros
//-----------------------------------------------------------------------------
-#define TAG PCF("OCStack")
+#define TAG "OCStack"
#define VERIFY_SUCCESS(op, successCode) { if ((op) != (successCode)) \
{OC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
#define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OC_LOG((logLevel), \
- TAG, PCF(#arg " is NULL")); return (retVal); } }
+ TAG, #arg " is NULL"); return (retVal); } }
#define VERIFY_NON_NULL_NR(arg, logLevel) { if (!(arg)) { OC_LOG((logLevel), \
- TAG, PCF(#arg " is NULL")); return; } }
+ TAG, #arg " is NULL"); return; } }
#define VERIFY_NON_NULL_V(arg) { if (!arg) {OC_LOG_V(FATAL, TAG, "%s is NULL", #arg);\
goto exit;} }
* Convert OCStackResult to CAResponseResult_t.
*
* @param caCode OCStackResult code.
- * @return ::CA_SUCCESS on success, some other value upon failure.
+ * @param method OCMethod method the return code replies to.
+ * @return ::CA_CONTENT on OK, some other value upon failure.
*/
-static CAResponseResult_t OCToCAStackResult(OCStackResult ocCode);
+static CAResponseResult_t OCToCAStackResult(OCStackResult ocCode, OCMethod method);
/**
* Convert OCTransportFlags_t to CATransportModifiers_t.
*/
static OCStackResult ResetPresenceTTL(ClientCB *cbNode, uint32_t maxAgeSeconds);
+/**
+ * Ensure the accept header option is set appropriatly before sending the requests and routing
+ * header option is updated with destination.
+ *
+ * @param object CA remote endpoint.
+ * @param requestInfo CA request info.
+ *
+ * @return ::OC_STACK_OK on success, some other value upon failure.
+ */
+static OCStackResult OCSendRequest(const CAEndpoint_t *object, CARequestInfo_t *requestInfo);
+
//-----------------------------------------------------------------------------
// Internal functions
//-----------------------------------------------------------------------------
OICStrcpy(out->addr, sizeof(out->addr), in->addr);
out->port = in->port;
out->interface = in->interface;
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ memcpy(out->routeData, in->routeData, sizeof(out->routeData));
+#endif
}
void CopyDevAddrToEndpoint(const OCDevAddr *in, CAEndpoint_t *out)
out->adapter = (CATransportAdapter_t)in->adapter;
out->flags = OCToCATransportFlags(in->flags);
OICStrcpy(out->addr, sizeof(out->addr), in->addr);
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ memcpy(out->routeData, in->routeData, sizeof(out->routeData));
+#endif
out->port = in->port;
out->interface = in->interface;
}
((cr->devAddr.adapter << CT_ADAPTER_SHIFT) | (cr->devAddr.flags & CT_MASK_FLAGS));
}
+static OCStackResult OCSendRequest(const CAEndpoint_t *object, CARequestInfo_t *requestInfo)
+{
+ VERIFY_NON_NULL(object, FATAL, OC_STACK_INVALID_PARAM);
+ VERIFY_NON_NULL(requestInfo, FATAL, OC_STACK_INVALID_PARAM);
+
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ OCStackResult rmResult = RMAddInfo(object->routeData, &(requestInfo->info.options),
+ &(requestInfo->info.numOptions));
+ if (OC_STACK_OK != rmResult)
+ {
+ OC_LOG(ERROR, TAG, "Add destination option failed");
+ return rmResult;
+ }
+#endif
+
+ // OC stack prefer CBOR encoded payloads.
+ requestInfo->info.acceptFormat = CA_FORMAT_APPLICATION_CBOR;
+ CAResult_t result = CASendRequest(object, requestInfo);
+ if(CA_STATUS_OK != result)
+ {
+ OC_LOG_V(ERROR, TAG, "CASendRequest failed with CA error %u", result);
+ return CAResultToOCResult(result);
+ }
+ return OC_STACK_OK;
+}
//-----------------------------------------------------------------------------
// Internal API function
//-----------------------------------------------------------------------------
switch(status)
{
case OC_OBSERVER_NOT_INTERESTED:
- OC_LOG(DEBUG, TAG, PCF("observer not interested in our notifications"));
+ OC_LOG(DEBUG, TAG, "observer not interested in our notifications");
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
OC_REST_NOMETHOD,
&observer->devAddr,
(OCResourceHandle)NULL,
- NULL, NULL, 0, 0, NULL,
+ NULL, PAYLOAD_TYPE_REPRESENTATION,
+ NULL, 0, 0, NULL,
OC_OBSERVE_DEREGISTER,
observer->observeId);
if(result != OC_STACK_OK)
result = DeleteObserverUsingToken (token, tokenLength);
if(result == OC_STACK_OK)
{
- OC_LOG(DEBUG, TAG, PCF("Removed observer successfully"));
+ OC_LOG(DEBUG, TAG, "Removed observer successfully");
}
else
{
result = OC_STACK_OK;
- OC_LOG(DEBUG, TAG, PCF("Observer Removal failed"));
+ OC_LOG(DEBUG, TAG, "Observer Removal failed");
}
break;
case OC_OBSERVER_STILL_INTERESTED:
- OC_LOG(DEBUG, TAG, PCF("observer still interested, reset the failedCount"));
+ OC_LOG(DEBUG, TAG, "observer still interested, reset the failedCount");
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
break;
case OC_OBSERVER_FAILED_COMM:
- OC_LOG(DEBUG, TAG, PCF("observer is unreachable"));
+ OC_LOG(DEBUG, TAG, "observer is unreachable");
observer = GetObserverUsingToken (token, tokenLength);
if(observer)
{
OC_REST_NOMETHOD,
&observer->devAddr,
(OCResourceHandle)NULL,
- NULL, NULL, 0, 0, NULL,
+ NULL, PAYLOAD_TYPE_REPRESENTATION,
+ NULL, 0, 0, NULL,
OC_OBSERVE_DEREGISTER,
observer->observeId);
if(result != OC_STACK_OK)
result = DeleteObserverUsingToken (token, tokenLength);
if(result == OC_STACK_OK)
{
- OC_LOG(DEBUG, TAG, PCF("Removed observer successfully"));
+ OC_LOG(DEBUG, TAG, "Removed observer successfully");
}
else
{
result = OC_STACK_OK;
- OC_LOG(DEBUG, TAG, PCF("Observer Removal failed"));
+ OC_LOG(DEBUG, TAG, "Observer Removal failed");
}
}
else
}
break;
default:
- OC_LOG(ERROR, TAG, PCF("Unknown status"));
+ OC_LOG(ERROR, TAG, "Unknown status");
result = OC_STACK_ERROR;
break;
}
switch(caCode)
{
- case CA_SUCCESS:
- ret = OC_STACK_OK;
- break;
case CA_CREATED:
ret = OC_STACK_RESOURCE_CREATED;
break;
case CA_DELETED:
ret = OC_STACK_RESOURCE_DELETED;
break;
+ case CA_CHANGED:
+ case CA_CONTENT:
+ ret = OC_STACK_OK;
+ break;
case CA_BAD_REQ:
ret = OC_STACK_INVALID_QUERY;
break;
return ret;
}
-CAResponseResult_t OCToCAStackResult(OCStackResult ocCode)
+CAResponseResult_t OCToCAStackResult(OCStackResult ocCode, OCMethod method)
{
CAResponseResult_t ret = CA_INTERNAL_SERVER_ERROR;
switch(ocCode)
{
case OC_STACK_OK:
- ret = CA_SUCCESS;
+ switch (method)
+ {
+ case OC_REST_PUT:
+ case OC_REST_POST:
+ // This Response Code is like HTTP 204 "No Content" but only used in
+ // response to POST and PUT requests.
+ ret = CA_CHANGED;
+ break;
+ case OC_REST_GET:
+ // This Response Code is like HTTP 200 "OK" but only used in response to
+ // GET requests.
+ ret = CA_CONTENT;
+ break;
+ default:
+ // This should not happen but,
+ // give it a value just in case but output an error
+ ret = CA_CONTENT;
+ OC_LOG_V(ERROR, TAG, "Unexpected OC_STACK_OK return code for method [d].", method);
+ }
break;
case OC_STACK_RESOURCE_CREATED:
ret = CA_CREATED;
int presenceSubscribe = 0;
int multicastPresenceSubscribe = 0;
- if (responseInfo->result != CA_SUCCESS)
+ if (responseInfo->result != CA_CONTENT)
{
OC_LOG_V(ERROR, TAG, "HandlePresenceResponse failed %d", responseInfo->result);
return OC_STACK_ERROR;
if (!presenceSubscribe && !multicastPresenceSubscribe)
{
- OC_LOG(ERROR, TAG, PCF("Received a presence notification, but no callback, ignoring"));
+ OC_LOG(ERROR, TAG, "Received a presence notification, but no callback, ignoring");
goto exit;
}
if (responseInfo->info.payload)
{
- result = OCParsePayload(&response.payload, responseInfo->info.payload,
+ result = OCParsePayload(&response.payload,
+ PAYLOAD_TYPE_PRESENCE,
+ responseInfo->info.payload,
responseInfo->info.payloadSize);
if(result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Presence parse failed"));
+ OC_LOG(ERROR, TAG, "Presence parse failed");
goto exit;
}
if(!response.payload || response.payload->type != PAYLOAD_TYPE_PRESENCE)
{
- OC_LOG(ERROR, TAG, PCF("Presence payload was wrong type"));
+ OC_LOG(ERROR, TAG, "Presence payload was wrong type");
result = OC_STACK_ERROR;
goto exit;
}
{
if(cbNode->sequenceNumber == response.sequenceNumber)
{
- OC_LOG(INFO, TAG, PCF("No presence change"));
+ OC_LOG(INFO, TAG, "No presence change");
goto exit;
}
if(maxAge == 0)
{
- OC_LOG(INFO, TAG, PCF("Stopping presence"));
+ OC_LOG(INFO, TAG, "Stopping presence");
response.result = OC_STACK_PRESENCE_STOPPED;
if(cbNode->presence)
{
if(!(cbNode->presence))
{
- OC_LOG(ERROR, TAG, PCF("Could not allocate memory for cbNode->presence"));
+ OC_LOG(ERROR, TAG, "Could not allocate memory for cbNode->presence");
result = OC_STACK_NO_MEMORY;
goto exit;
}
OICMalloc(PresenceTimeOutSize * sizeof(uint32_t));
if(!(cbNode->presence->timeOut)){
OC_LOG(ERROR, TAG,
- PCF("Could not allocate memory for cbNode->presence->timeOut"));
+ "Could not allocate memory for cbNode->presence->timeOut");
OICFree(cbNode->presence);
result = OC_STACK_NO_MEMORY;
goto exit;
{
if(mcNode->nonce == response.sequenceNumber)
{
- OC_LOG(INFO, TAG, PCF("No presence change (Multicast)"));
+ OC_LOG(INFO, TAG, "No presence change (Multicast)");
goto exit;
}
mcNode->nonce = response.sequenceNumber;
if(maxAge == 0)
{
- OC_LOG(INFO, TAG, PCF("Stopping presence"));
+ OC_LOG(INFO, TAG, "Stopping presence");
response.result = OC_STACK_PRESENCE_STOPPED;
}
}
if (!uri)
{
OC_LOG(INFO, TAG,
- PCF("No Memory for URI to store in the presence node"));
+ "No Memory for URI to store in the presence node");
result = OC_STACK_NO_MEMORY;
goto exit;
}
if(result == OC_STACK_NO_MEMORY)
{
OC_LOG(INFO, TAG,
- PCF("No Memory for Multicast Presence Node"));
+ "No Memory for Multicast Presence Node");
OICFree(uri);
goto exit;
}
VERIFY_NON_NULL_NR(endPoint, FATAL);
VERIFY_NON_NULL_NR(responseInfo, FATAL);
- OC_LOG(INFO, TAG, PCF("Enter HandleCAResponses"));
+ OC_LOG(INFO, TAG, "Enter HandleCAResponses");
+
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+#ifdef ROUTING_GATEWAY
+ bool needRIHandling = false;
+ /*
+ * Routing manager is going to update either of endpoint or response or both.
+ * This typecasting is done to avoid unnecessary duplication of Endpoint and responseInfo
+ * RM can update "routeData" option in endPoint so that future RI requests can be sent to proper
+ * destination.
+ */
+ OCStackResult ret = RMHandleResponse((CAResponseInfo_t *)responseInfo, (CAEndpoint_t *)endPoint,
+ &needRIHandling);
+ if(ret != OC_STACK_OK || !needRIHandling)
+ {
+ OC_LOG_V(INFO, TAG, "Routing status![%d]. Not forwarding to RI", ret);
+ return;
+ }
+#endif
+
+ /*
+ * Put source in sender endpoint so that the next packet from application can be routed to
+ * proper destination and remove "RM" coap header option before passing request / response to
+ * 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);
+#endif
if(responseInfo->info.resourceUri &&
strcmp(responseInfo->info.resourceUri, OC_RSRVD_PRESENCE_URI) == 0)
if(cbNode)
{
- OC_LOG(INFO, TAG, PCF("There is a cbNode associated with the response token"));
+ OC_LOG(INFO, TAG, "There is a cbNode associated with the response token");
if(responseInfo->result == CA_EMPTY)
{
- OC_LOG(INFO, TAG, PCF("Receiving A ACK/RESET for this token"));
+ OC_LOG(INFO, TAG, "Receiving A ACK/RESET for this token");
// We do not have a case for the client to receive a RESET
if(responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
{
//This is the case of receiving an ACK on a request to a slow resource!
- OC_LOG(INFO, TAG, PCF("This is a pure ACK"));
+ OC_LOG(INFO, TAG, "This is a pure ACK");
//TODO: should we inform the client
// app that at least the request was received at the server?
}
}
else if(responseInfo->result == CA_RETRANSMIT_TIMEOUT)
{
- OC_LOG(INFO, TAG, PCF("Receiving A Timeout for this token"));
- OC_LOG(INFO, TAG, PCF("Calling into application address space"));
+ OC_LOG(INFO, TAG, "Receiving A Timeout for this token");
+ OC_LOG(INFO, TAG, "Calling into application address space");
OCClientResponse response =
{.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
}
else
{
- 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"));
+ OC_LOG(INFO, TAG, "This is a regular response, A client call back is found");
+ OC_LOG(INFO, TAG, "Calling into application address space");
OCClientResponse response =
{.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
response.identity.id_length = responseInfo->info.identity.id_length;
response.result = CAToOCStackResult(responseInfo->result);
+
if(responseInfo->info.payload &&
- responseInfo->info.payloadSize &&
- OC_STACK_OK != OCParsePayload(&response.payload, responseInfo->info.payload,
- responseInfo->info.payloadSize))
+ responseInfo->info.payloadSize)
{
- OC_LOG(ERROR, TAG, PCF("Error converting payload"));
- OCPayloadDestroy(response.payload);
- return;
+ OCPayloadType type = PAYLOAD_TYPE_INVALID;
+ // check the security resource
+ if (SRMIsSecurityResourceURI(cbNode->requestUri))
+ {
+ type = PAYLOAD_TYPE_SECURITY;
+ }
+ else if (cbNode->method == OC_REST_DISCOVER)
+ {
+ if (strncmp(OC_RSRVD_WELL_KNOWN_URI,cbNode->requestUri,
+ sizeof(OC_RSRVD_WELL_KNOWN_URI) - 1) == 0)
+ {
+ type = PAYLOAD_TYPE_DISCOVERY;
+ }
+ else if (strcmp(cbNode->requestUri, OC_RSRVD_DEVICE_URI) == 0)
+ {
+ type = PAYLOAD_TYPE_DEVICE;
+ }
+ else if (strcmp(cbNode->requestUri, OC_RSRVD_PLATFORM_URI) == 0)
+ {
+ type = PAYLOAD_TYPE_PLATFORM;
+ }
+ else
+ {
+ OC_LOG_V(ERROR, TAG, "Unknown Payload type in Discovery: %d %s",
+ cbNode->method, cbNode->requestUri);
+ return;
+ }
+ }
+ else if (cbNode->method == OC_REST_GET ||
+ cbNode->method == OC_REST_PUT ||
+ cbNode->method == OC_REST_POST ||
+ cbNode->method == OC_REST_OBSERVE ||
+ cbNode->method == OC_REST_OBSERVE_ALL ||
+ cbNode->method == OC_REST_DELETE)
+ {
+ OC_LOG_V(INFO, TAG, "Assuming PAYLOAD_TYPE_REPRESENTATION: %d %s",
+ cbNode->method, cbNode->requestUri);
+ type = PAYLOAD_TYPE_REPRESENTATION;
+ }
+ else
+ {
+ OC_LOG_V(ERROR, TAG, "Unknown Payload type: %d %s",
+ cbNode->method, cbNode->requestUri);
+ return;
+ }
+
+ if(OC_STACK_OK != OCParsePayload(&response.payload,
+ type,
+ responseInfo->info.payload,
+ responseInfo->info.payloadSize))
+ {
+ OC_LOG(ERROR, TAG, "Error converting payload");
+ OCPayloadDestroy(response.payload);
+ return;
+ }
}
response.numRcvdVendorSpecificHeaderOptions = 0;
if(response.numRcvdVendorSpecificHeaderOptions > MAX_HEADER_OPTIONS)
{
- OC_LOG(ERROR, TAG, PCF("#header options are more than MAX_HEADER_OPTIONS"));
+ OC_LOG(ERROR, TAG, "#header options are more than MAX_HEADER_OPTIONS");
OCPayloadDestroy(response.payload);
return;
}
response.sequenceNumber > OC_OFFSET_SEQUENCE_NUMBER &&
response.sequenceNumber <= cbNode->sequenceNumber)
{
- OC_LOG_V(INFO, TAG, PCF("Received stale notification. Number :%d"),
+ OC_LOG_V(INFO, TAG, "Received stale notification. Number :%d",
response.sequenceNumber);
}
else
if(responseInfo->info.type == CA_MSG_CONFIRM)
{
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
- CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0);
+ CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0, NULL);
}
OCPayloadDestroy(response.payload);
if(observer)
{
- OC_LOG(INFO, TAG, PCF("There is an observer associated with the response token"));
+ OC_LOG(INFO, TAG, "There is an observer associated with the response token");
if(responseInfo->result == CA_EMPTY)
{
- OC_LOG(INFO, TAG, PCF("Receiving A ACK/RESET for this token"));
+ OC_LOG(INFO, TAG, "Receiving A ACK/RESET for this token");
if(responseInfo->info.type == CA_MSG_RESET)
{
- OC_LOG(INFO, TAG, PCF("This is a RESET"));
+ OC_LOG(INFO, TAG, "This is a RESET");
OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
OC_OBSERVER_NOT_INTERESTED);
}
else if(responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
{
- OC_LOG(INFO, TAG, PCF("This is a pure ACK"));
+ OC_LOG(INFO, TAG, "This is a pure ACK");
OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
OC_OBSERVER_STILL_INTERESTED);
}
}
else if(responseInfo->result == CA_RETRANSMIT_TIMEOUT)
{
- OC_LOG(INFO, TAG, PCF("Receiving Time Out for an observer"));
+ OC_LOG(INFO, TAG, "Receiving Time Out for an observer");
OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
OC_OBSERVER_FAILED_COMM);
}
if(!cbNode && !observer)
{
- if(myStackMode == OC_CLIENT || myStackMode == OC_CLIENT_SERVER)
+ if(myStackMode == OC_CLIENT || myStackMode == OC_CLIENT_SERVER
+ || myStackMode == OC_GATEWAY)
{
- OC_LOG(INFO, TAG, PCF("This is a client, but no cbNode was found for token"));
+ OC_LOG(INFO, TAG, "This is a client, but no cbNode was found for token");
if(responseInfo->result == CA_EMPTY)
{
- OC_LOG(INFO, TAG, PCF("Receiving CA_EMPTY in the ocstack"));
+ OC_LOG(INFO, TAG, "Receiving CA_EMPTY in the ocstack");
}
else
{
- OC_LOG(INFO, TAG, PCF("Received a message without callbacks. Sending RESET"));
+ OC_LOG(INFO, TAG, "Received a message without callbacks. Sending RESET");
SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
- CA_MSG_RESET, 0, NULL, NULL, 0);
+ CA_MSG_RESET, 0, NULL, NULL, 0, NULL);
}
}
- if(myStackMode == OC_SERVER || myStackMode == OC_CLIENT_SERVER)
+ if(myStackMode == OC_SERVER || myStackMode == OC_CLIENT_SERVER
+ || myStackMode == OC_GATEWAY)
{
- OC_LOG(INFO, TAG, PCF("This is a server, but no observer was found for token"));
+ OC_LOG(INFO, TAG, "This is a server, but no observer was found for token");
if (responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
{
- OC_LOG_V(INFO, TAG, PCF("Received ACK at server for messageId : %d"),
+ OC_LOG_V(INFO, TAG, "Received ACK at server for messageId : %d",
responseInfo->info.messageId);
}
if (responseInfo->info.type == CA_MSG_RESET)
{
- OC_LOG_V(INFO, TAG, PCF("Received RESET at server for messageId : %d"),
+ OC_LOG_V(INFO, TAG, "Received RESET at server for messageId : %d",
responseInfo->info.messageId);
}
}
return;
}
- OC_LOG(INFO, TAG, PCF("Exit HandleCAResponses"));
+ OC_LOG(INFO, TAG, "Exit HandleCAResponses");
}
/*
*/
void HandleCAErrorResponse(const CAEndpoint_t *endPoint, const CAErrorInfo_t *errrorInfo)
{
- OC_LOG(INFO, TAG, PCF("Enter HandleCAErrorResponse"));
+ OC_LOG(INFO, TAG, "Enter HandleCAErrorResponse");
if(NULL == endPoint)
{
- OC_LOG(ERROR, TAG, PCF("endPoint is NULL"));
+ OC_LOG(ERROR, TAG, "endPoint is NULL");
return;
}
if(NULL == errrorInfo)
{
- OC_LOG(ERROR, TAG, PCF("errrorInfo is NULL"));
+ OC_LOG(ERROR, TAG, "errrorInfo is NULL");
return;
}
- OC_LOG(INFO, TAG, PCF("Exit HandleCAErrorResponse"));
+ OC_LOG(INFO, TAG, "Exit HandleCAErrorResponse");
}
/*
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)
+ CAToken_t token, uint8_t tokenLength, const char *resourceUri)
{
CAResponseInfo_t respInfo = {
.result = responseResult
respInfo.info.token = token;
respInfo.info.tokenLength = tokenLength;
respInfo.info.type = type;
+ respInfo.info.resourceUri = OICStrdup (resourceUri);
+ respInfo.info.acceptFormat = CA_FORMAT_UNDEFINED;
+
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ // Add the destination to route option from the endpoint->routeData.
+ OCStackResult result = RMAddInfo(endPoint->routeData,
+ &(respInfo.info.options),
+ &(respInfo.info.numOptions));
+ if(OC_STACK_OK != result)
+ {
+ OC_LOG_V(ERROR, TAG, "Add routing option failed [%d]", result);
+ return result;
+ }
+#endif
CAResult_t caResult = CASendResponse(endPoint, &respInfo);
- if(caResult != CA_STATUS_OK)
+
+ // resourceUri in the info field is cloned in the CA layer and
+ // thus ownership is still here.
+ OICFree (respInfo.info.resourceUri);
+
+ if(CA_STATUS_OK != caResult)
{
- OC_LOG(ERROR, TAG, PCF("CASendResponse error"));
- return OC_STACK_ERROR;
+ OC_LOG(ERROR, TAG, "CASendResponse error");
+ return CAResultToOCResult(caResult);
}
return OC_STACK_OK;
}
//This function will be called back by CA layer when a request is received
void HandleCARequests(const CAEndpoint_t* endPoint, const CARequestInfo_t* requestInfo)
{
- OC_LOG(INFO, TAG, PCF("Enter HandleCARequests"));
+ OC_LOG(INFO, TAG, "Enter HandleCARequests");
if(!endPoint)
{
- OC_LOG(ERROR, TAG, PCF("endPoint is NULL"));
+ OC_LOG(ERROR, TAG, "endPoint is NULL");
return;
}
if(!requestInfo)
{
- OC_LOG(ERROR, TAG, PCF("requestInfo is NULL"));
+ OC_LOG(ERROR, TAG, "requestInfo is NULL");
return;
}
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+#ifdef ROUTING_GATEWAY
+ bool needRIHandling = false;
+ /*
+ * Routing manager is going to update either of endpoint or request or both.
+ * This typecasting is done to avoid unnecessary duplication of Endpoint and requestInfo
+ * RM can update "routeData" option in endPoint so that future RI requests can be sent to proper
+ * destination. It can also remove "RM" coap header option before passing request / response to
+ * RI as this option will make no sense to either RI or application.
+ */
+ OCStackResult ret = RMHandleRequest((CARequestInfo_t *)requestInfo, (CAEndpoint_t *)endPoint,
+ &needRIHandling);
+ if(OC_STACK_OK != ret || !needRIHandling)
+ {
+ OC_LOG_V(INFO, TAG, "Routing status![%d]. Not forwarding to RI", ret);
+ return;
+ }
+#endif
+
+ /*
+ * Put source in sender endpoint so that the next packet from application can be routed to
+ * proper destination and remove RM header option.
+ */
+ RMUpdateInfo((CAHeaderOption_t **) &(requestInfo->info.options),
+ (uint8_t *) &(requestInfo->info.numOptions),
+ (CAEndpoint_t *) endPoint);
+#endif
+
OCStackResult requestResult = OC_STACK_ERROR;
if(myStackMode == OC_CLIENT)
OCServerProtocolRequest serverRequest = {0};
- OC_LOG_V(INFO, TAG, PCF("Endpoint URI : %s"), requestInfo->info.resourceUri);
+ OC_LOG_V(INFO, TAG, "Endpoint URI : %s", requestInfo->info.resourceUri);
char * uriWithoutQuery = NULL;
char * query = NULL;
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"), uriWithoutQuery);
- OC_LOG_V(INFO, TAG, PCF("Query : %s"), query);
+ OC_LOG_V(INFO, TAG, "URI without query: %s", uriWithoutQuery);
+ OC_LOG_V(INFO, TAG, "Query : %s", query);
if(strlen(uriWithoutQuery) < MAX_URI_LENGTH)
{
}
else
{
- OC_LOG(ERROR, TAG, PCF("URI length exceeds MAX_URI_LENGTH."));
+ OC_LOG(ERROR, TAG, "URI length exceeds MAX_URI_LENGTH.");
OICFree(uriWithoutQuery);
OICFree(query);
return;
}
else
{
- OC_LOG(ERROR, TAG, PCF("Query length exceeds MAX_QUERY_LENGTH."));
+ OC_LOG(ERROR, TAG, "Query length exceeds MAX_QUERY_LENGTH.");
OICFree(query);
return;
}
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.tokenLength, requestInfo->info.resourceUri);
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.tokenLength, requestInfo->info.resourceUri);
OICFree(serverRequest.payload);
return;
}
memcpy(serverRequest.requestToken, requestInfo->info.token, requestInfo->info.tokenLength);
+ switch (requestInfo->info.acceptFormat)
+ {
+ case CA_FORMAT_APPLICATION_CBOR:
+ serverRequest.acceptFormat = OC_FORMAT_CBOR;
+ break;
+ case CA_FORMAT_UNDEFINED:
+ serverRequest.acceptFormat = OC_FORMAT_UNDEFINED;
+ break;
+ default:
+ serverRequest.acceptFormat = OC_FORMAT_UNSUPPORTED;
+ }
+
if (requestInfo->info.type == CA_MSG_CONFIRM)
{
serverRequest.qos = OC_HIGH_QOS;
if (requestInfo->info.numOptions > MAX_HEADER_OPTIONS)
{
OC_LOG(ERROR, TAG,
- PCF("The request info numOptions is greater than MAX_HEADER_OPTIONS"));
+ "The request info numOptions is greater than MAX_HEADER_OPTIONS");
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.tokenLength, requestInfo->info.resourceUri);
OICFree(serverRequest.payload);
OICFree(serverRequest.requestToken);
return;
if(requestResult == OC_STACK_SLOW_RESOURCE)
{
SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_EMPTY,
- CA_MSG_ACKNOWLEDGE,0, NULL, NULL, 0);
+ CA_MSG_ACKNOWLEDGE,0, NULL, NULL, 0, NULL);
}
else if(requestResult != OC_STACK_OK)
{
- OC_LOG_V(ERROR, TAG, PCF("HandleStackRequests failed. error: %d"), requestResult);
+ OC_LOG_V(ERROR, TAG, "HandleStackRequests failed. error: %d", requestResult);
- CAResponseResult_t stackResponse = OCToCAStackResult(requestResult);
+ CAResponseResult_t stackResponse =
+ OCToCAStackResult(requestResult, serverRequest.method);
SendDirectStackResponse(endPoint, requestInfo->info.messageId, stackResponse,
requestInfo->info.type, requestInfo->info.numOptions,
requestInfo->info.options, requestInfo->info.token,
- requestInfo->info.tokenLength);
+ requestInfo->info.tokenLength, requestInfo->info.resourceUri);
}
// 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"));
+ OC_LOG(INFO, TAG, "Exit HandleCARequests");
}
OCStackResult HandleStackRequests(OCServerProtocolRequest * protocolRequest)
{
- OC_LOG(INFO, TAG, PCF("Entering HandleStackRequests (OCStack Layer)"));
+ OC_LOG(INFO, TAG, "Entering HandleStackRequests (OCStack Layer)");
OCStackResult result = OC_STACK_ERROR;
ResourceHandling resHandling;
OCResource *resource;
if(!protocolRequest)
{
- OC_LOG(ERROR, TAG, PCF("protocolRequest is NULL"));
+ OC_LOG(ERROR, TAG, "protocolRequest is NULL");
return OC_STACK_INVALID_PARAM;
}
protocolRequest->tokenLength);
if(!request)
{
- OC_LOG(INFO, TAG, PCF("This is a new Server Request"));
+ OC_LOG(INFO, TAG, "This is a new Server Request");
result = AddServerRequest(&request, protocolRequest->coapID,
- protocolRequest->delayedResNeeded, 0,
- protocolRequest->method, protocolRequest->numRcvdVendorSpecificHeaderOptions,
+ protocolRequest->delayedResNeeded, 0, protocolRequest->method,
+ protocolRequest->numRcvdVendorSpecificHeaderOptions,
protocolRequest->observationOption, protocolRequest->qos,
protocolRequest->query, protocolRequest->rcvdVendorSpecificHeaderOptions,
protocolRequest->payload, protocolRequest->requestToken,
- protocolRequest->tokenLength,
- protocolRequest->resourceUrl, protocolRequest->reqTotalSize,
+ protocolRequest->tokenLength, protocolRequest->resourceUrl,
+ protocolRequest->reqTotalSize, protocolRequest->acceptFormat,
&protocolRequest->devAddr);
if (OC_STACK_OK != result)
{
- OC_LOG(ERROR, TAG, PCF("Error adding server request"));
+ OC_LOG(ERROR, TAG, "Error adding server request");
return result;
}
if(!request)
{
- OC_LOG(ERROR, TAG, PCF("Out of Memory"));
+ OC_LOG(ERROR, TAG, "Out of Memory");
return OC_STACK_NO_MEMORY;
}
}
else
{
- OC_LOG(INFO, TAG, PCF("This is either a repeated or blocked Server Request"));
+ OC_LOG(INFO, TAG, "This is either a repeated or blocked Server Request");
}
if(request->requestComplete)
{
- OC_LOG(INFO, TAG, PCF("This Server Request is complete"));
+ OC_LOG(INFO, TAG, "This Server Request is complete");
result = DetermineResourceHandling (request, &resHandling, &resource);
if (result == OC_STACK_OK)
{
}
else
{
- OC_LOG(INFO, TAG, PCF("This Server Request is incomplete"));
+ OC_LOG(INFO, TAG, "This Server Request is incomplete");
result = OC_STACK_CONTINUE;
}
return result;
if (!info.platformID)
{
- OC_LOG(ERROR, TAG, PCF("No platform ID found."));
+ OC_LOG(ERROR, TAG, "No platform ID found.");
return false;
}
if(lenManufacturerName == 0 || lenManufacturerName > MAX_MANUFACTURER_NAME_LENGTH)
{
- OC_LOG(ERROR, TAG, PCF("Manufacturer name fails length requirements."));
+ OC_LOG(ERROR, TAG, "Manufacturer name fails length requirements.");
return false;
}
}
else
{
- OC_LOG(ERROR, TAG, PCF("No manufacturer name present"));
+ OC_LOG(ERROR, TAG, "No manufacturer name present");
return false;
}
{
if(strlen(info.manufacturerUrl) > MAX_MANUFACTURER_URL_LENGTH)
{
- OC_LOG(ERROR, TAG, PCF("Manufacturer url fails length requirements."));
+ OC_LOG(ERROR, TAG, "Manufacturer url fails length requirements.");
return false;
}
}
{
if(stackState == OC_STACK_INITIALIZED)
{
- OC_LOG(INFO, TAG, PCF("Subsequent calls to OCInit() without calling \
- OCStop() between them are ignored."));
+ OC_LOG(INFO, TAG, "Subsequent calls to OCInit() without calling \
+ OCStop() between them are ignored.");
return OC_STACK_OK;
}
+#ifndef ROUTING_GATEWAY
+ if (OC_GATEWAY == mode)
+ {
+ OC_LOG(ERROR, TAG, "Routing Manager not supported");
+ return OC_STACK_INVALID_PARAM;
+ }
+#endif
+
#ifdef RA_ADAPTER
if(!gRASetInfo)
{
- OC_LOG(ERROR, TAG, PCF("Need to call OCSetRAInfo before calling OCInit"));
+ OC_LOG(ERROR, TAG, "Need to call OCSetRAInfo before calling OCInit");
return OC_STACK_ERROR;
}
#endif
OCStackResult result = OC_STACK_ERROR;
- OC_LOG(INFO, TAG, PCF("Entering OCInit"));
+ OC_LOG(INFO, TAG, "Entering OCInit");
// Validate mode
- if (!((mode == OC_CLIENT) || (mode == OC_SERVER) || (mode == OC_CLIENT_SERVER)))
+ if (!((mode == OC_CLIENT) || (mode == OC_SERVER) || (mode == OC_CLIENT_SERVER)
+ || (mode == OC_GATEWAY)))
{
- OC_LOG(ERROR, TAG, PCF("Invalid mode"));
+ OC_LOG(ERROR, TAG, "Invalid mode");
return OC_STACK_ERROR;
}
myStackMode = mode;
- if (mode == OC_CLIENT || mode == OC_CLIENT_SERVER)
+ if (mode == OC_CLIENT || mode == OC_CLIENT_SERVER || mode == OC_GATEWAY)
{
caglobals.client = true;
}
- if (mode == OC_SERVER || mode == OC_CLIENT_SERVER)
+ if (mode == OC_SERVER || mode == OC_CLIENT_SERVER || mode == OC_GATEWAY)
{
caglobals.server = true;
}
caglobals.clientFlags = (CATransportFlags_t)(caglobals.clientFlags|CA_IPV4|CA_IPV6);
}
+#ifdef TCP_ADAPTER
+ if (!(caglobals.serverFlags & CA_IPFAMILY_MASK))
+ {
+ caglobals.serverFlags = (CATransportFlags_t)(caglobals.serverFlags|CA_IPV4);
+ }
+ if (!(caglobals.clientFlags & CA_IPFAMILY_MASK))
+ {
+ caglobals.clientFlags = (CATransportFlags_t)(caglobals.clientFlags|CA_IPV4);
+ }
+#endif
+
defaultDeviceHandler = NULL;
defaultDeviceHandlerCallbackParameter = NULL;
OCSeedRandom();
case OC_CLIENT:
CARegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
result = CAResultToOCResult(CAStartDiscoveryServer());
- OC_LOG(INFO, TAG, PCF("Client mode: CAStartDiscoveryServer"));
+ OC_LOG(INFO, TAG, "Client mode: CAStartDiscoveryServer");
break;
case OC_SERVER:
SRMRegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
result = CAResultToOCResult(CAStartListeningServer());
- OC_LOG(INFO, TAG, PCF("Server mode: CAStartListeningServer"));
+ OC_LOG(INFO, TAG, "Server mode: CAStartListeningServer");
break;
case OC_CLIENT_SERVER:
+ case OC_GATEWAY:
SRMRegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
result = CAResultToOCResult(CAStartListeningServer());
if(result == OC_STACK_OK)
// TODO after BeachHead delivery: consolidate into single SRMInit()
}
+#ifdef ROUTING_GATEWAY
+ if (OC_GATEWAY == myStackMode)
+ {
+ result = RMInitialize();
+ }
+#endif
+
exit:
if(result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Stack initialization error"));
+ OC_LOG(ERROR, TAG, "Stack initialization error");
deleteAllResources();
CATerminate();
stackState = OC_STACK_UNINITIALIZED;
OCStackResult OCStop()
{
- OC_LOG(INFO, TAG, PCF("Entering OCStop"));
+ OC_LOG(INFO, TAG, "Entering OCStop");
if (stackState == OC_STACK_UNINIT_IN_PROGRESS)
{
- OC_LOG(DEBUG, TAG, PCF("Stack already stopping, exiting"));
+ OC_LOG(DEBUG, TAG, "Stack already stopping, exiting");
return OC_STACK_OK;
}
else if (stackState != OC_STACK_INITIALIZED)
{
- OC_LOG(ERROR, TAG, PCF("Stack not initialized"));
+ OC_LOG(ERROR, TAG, "Stack not initialized");
return OC_STACK_ERROR;
}
presenceResource.presenceTTL = 0;
#endif // WITH_PRESENCE
+#ifdef ROUTING_GATEWAY
+ if (OC_GATEWAY == myStackMode)
+ {
+ RMTerminate();
+ }
+#endif
+
// Free memory dynamically allocated for resources
deleteAllResources();
DeleteDeviceInfo();
/**
* A request uri consists of the following components in order:
* example
- * optional prefix "coap://"
+ * optionally one of
+ * CoAP over UDP prefix "coap://"
+ * CoAP over TCP prefix "coap+tcp://"
* optionally one of
* IPv6 address "[1234::5678]"
* IPv4 address "192.168.1.1"
return OC_STACK_INVALID_URI;
}
+#ifdef TCP_ADAPTER
+ // process url scheme
+ size_t prefixLen = slash2 - fullUri;
+ bool istcp = false;
+ if (prefixLen)
+ {
+ if ((prefixLen == sizeof(COAP_TCP) - 1) && (!strncmp(fullUri, COAP_TCP, prefixLen)))
+ {
+ istcp = true;
+ }
+ }
+#endif
+
+ // TODO: this logic should come in with unit tests exercising the various strings
// processs url prefix, if any
size_t urlLen = slash - start;
// port
{ // ipv4 address
colon = strchr(start, ':');
end = (colon && colon < slash) ? colon : slash;
- adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
- flags = (OCTransportFlags)(flags | OC_IP_USE_V4);
+#ifdef TCP_ADAPTER
+ if (istcp)
+ { // coap over tcp
+ adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_TCP);
+ }
+ else
+#endif
+ {
+ adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
+ flags = (OCTransportFlags)(flags | OC_IP_USE_V4);
+ }
}
else
{ // MAC address
OCHeaderOption *options,
uint8_t numOptions)
{
- OC_LOG(INFO, TAG, PCF("Entering OCDoResource"));
+ OC_LOG(INFO, TAG, "Entering OCDoResource");
// Validate input parameters
VERIFY_NON_NULL(cbData, FATAL, OC_STACK_INVALID_CALLBACK);
if (!devAddr && !destination)
{
- OC_LOG_V(DEBUG, TAG, "no devAddr and no destination");
+ OC_LOG(DEBUG, TAG, "no devAddr and no destination");
result = OC_STACK_INVALID_PARAM;
goto exit;
}
caResult = CAGenerateToken(&token, tokenLength);
if (caResult != CA_STATUS_OK)
{
- OC_LOG(ERROR, TAG, PCF("CAGenerateToken error"));
+ OC_LOG(ERROR, TAG, "CAGenerateToken error");
result= OC_STACK_ERROR;
goto exit;
}
OCConvertPayload(payload, &requestInfo.info.payload, &requestInfo.info.payloadSize))
!= OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Failed to create CBOR Payload"));
+ OC_LOG(ERROR, TAG, "Failed to create CBOR Payload");
goto exit;
}
+ requestInfo.info.payloadFormat = CA_FORMAT_APPLICATION_CBOR;
}
else
{
requestInfo.info.payload = NULL;
requestInfo.info.payloadSize = 0;
+ requestInfo.info.payloadFormat = CA_FORMAT_UNDEFINED;
}
if (result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("CACreateEndpoint error"));
+ OC_LOG(ERROR, TAG, "CACreateEndpoint error");
goto exit;
}
resourceType = NULL; // Client CB list entry now owns it
// send request
- caResult = CASendRequest(&endpoint, &requestInfo);
- if (caResult != CA_STATUS_OK)
+ result = OCSendRequest(&endpoint, &requestInfo);
+ if (OC_STACK_OK != result)
{
- OC_LOG(ERROR, TAG, PCF("CASendRequest"));
- result = OC_STACK_COMM_ERROR;
goto exit;
}
exit:
if (result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("OCDoResource error"));
+ OC_LOG(ERROR, TAG, "OCDoResource error");
FindAndDeleteClientCB(clientCB);
CADestroyToken(token);
if (handle)
*/
OCStackResult ret = OC_STACK_OK;
CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
- CAResult_t caResult;
CAInfo_t requestData = {.type = CA_MSG_CONFIRM};
CARequestInfo_t requestInfo = {.method = CA_GET};
ClientCB *clientCB = GetClientCB(NULL, 0, handle, NULL);
if (!clientCB)
{
- OC_LOG(ERROR, TAG, PCF("Client callback not found. Called OCCancel twice?"));
+ OC_LOG(ERROR, TAG, "Client callback not found. Called OCCancel twice?");
goto Error;
}
}
else
{
- OC_LOG(INFO, TAG, PCF("Cancelling observation as CONFIRMABLE"));
+ OC_LOG(INFO, TAG, "Cancelling observation as CONFIRMABLE");
}
requestData.type = qualityOfServiceToMessageType(qos);
CopyDevAddrToEndpoint(clientCB->devAddr, &endpoint);
// send request
- caResult = CASendRequest(&endpoint, &requestInfo);
- if (caResult != CA_STATUS_OK)
- {
- OC_LOG(ERROR, TAG, PCF("CASendRequest error"));
- ret = OC_STACK_ERROR;
- }
- ret = CAResultToOCResult (caResult);
+ ret = OCSendRequest(&endpoint, &requestInfo);
break;
#ifdef WITH_PRESENCE
*/
OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
{
- OC_LOG(INFO, TAG, PCF("RegisterPersistentStorageHandler !!"));
+ OC_LOG(INFO, TAG, "RegisterPersistentStorageHandler !!");
if(!persistentStorageHandler)
{
- OC_LOG(ERROR, TAG, PCF("The persistent storage handler is invalid"));
+ OC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
return OC_STACK_INVALID_PARAM;
}
else
!persistentStorageHandler->unlink ||
!persistentStorageHandler->write)
{
- OC_LOG(ERROR, TAG, PCF("The persistent storage handler is invalid"));
+ OC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
return OC_STACK_INVALID_PARAM;
}
}
// the following line floods the log with messages that are irrelevant
// to most purposes. Uncomment as needed.
- //OC_LOG(INFO, TAG, PCF("Entering RequestPresence"));
+ //OC_LOG(INFO, TAG, "Entering RequestPresence");
ClientCB* cbNode = NULL;
OCClientResponse clientResponse;
OCStackApplicationResult cbResult = OC_STACK_DELETE_TRANSACTION;
}
if (cbNode->presence->TTLlevel >= PresenceTimeOutSize)
{
- OC_LOG(DEBUG, TAG, PCF("No more timeout ticks"));
+ OC_LOG(DEBUG, TAG, "No more timeout ticks");
clientResponse.sequenceNumber = 0;
clientResponse.result = OC_STACK_PRESENCE_TIMEOUT;
continue;
}
- CAResult_t caResult = CA_STATUS_OK;
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"));
+ OC_LOG(DEBUG, TAG, "time to test server presence");
CopyDevAddrToEndpoint(cbNode->devAddr, &endpoint);
requestInfo.method = CA_GET;
requestInfo.info = requestData;
- caResult = CASendRequest(&endpoint, &requestInfo);
-
- if (caResult != CA_STATUS_OK)
+ result = OCSendRequest(&endpoint, &requestInfo);
+ if (OC_STACK_OK != result)
{
- OC_LOG(ERROR, TAG, PCF("CASendRequest error"));
goto exit;
}
exit:
if (result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("OCProcessPresence error"));
+ OC_LOG(ERROR, TAG, "OCProcessPresence error");
}
return result;
#endif
CAHandleRequestResponse();
+#ifdef ROUTING_GATEWAY
+ RMProcess();
+#endif
return OC_STACK_OK;
}
if (OC_MAX_PRESENCE_TTL_SECONDS < ttl)
{
presenceResource.presenceTTL = OC_MAX_PRESENCE_TTL_SECONDS;
- OC_LOG(INFO, TAG, PCF("Setting Presence TTL to max value"));
+ OC_LOG(INFO, TAG, "Setting Presence TTL to max value");
}
else if (0 == ttl)
{
presenceResource.presenceTTL = OC_DEFAULT_PRESENCE_TTL_SECONDS;
- OC_LOG(INFO, TAG, PCF("Setting Presence TTL to default value"));
+ OC_LOG(INFO, TAG, "Setting Presence TTL to default value");
}
else
{
CAResult_t caResult = CAGenerateToken(&caToken, tokenLength);
if (caResult != CA_STATUS_OK)
{
- OC_LOG(ERROR, TAG, PCF("CAGenerateToken error"));
+ OC_LOG(ERROR, TAG, "CAGenerateToken error");
CADestroyToken(caToken);
return OC_STACK_ERROR;
}
AddObserver(OC_RSRVD_PRESENCE_URI, NULL, 0, caToken, tokenLength,
- (OCResource *)presenceResource.handle, OC_LOW_QOS, &devAddr);
+ (OCResource *)presenceResource.handle, OC_LOW_QOS, OC_FORMAT_UNDEFINED, &devAddr);
CADestroyToken(caToken);
}
if(result != OC_STACK_OK)
{
OC_LOG(ERROR, TAG,
- PCF("Changing the presence resource properties to ACTIVE not successful"));
+ "Changing the presence resource properties to ACTIVE not successful");
return result;
}
OCStackResult OCSetPlatformInfo(OCPlatformInfo platformInfo)
{
- OC_LOG(INFO, TAG, PCF("Entering OCSetPlatformInfo"));
+ OC_LOG(INFO, TAG, "Entering OCSetPlatformInfo");
- if(myStackMode == OC_SERVER || myStackMode == OC_CLIENT_SERVER)
+ if(myStackMode == OC_SERVER || myStackMode == OC_CLIENT_SERVER || myStackMode == OC_GATEWAY)
{
if (validatePlatformInfo(platformInfo))
{
OCStackResult OCSetDeviceInfo(OCDeviceInfo deviceInfo)
{
- OC_LOG(INFO, TAG, PCF("Entering OCSetDeviceInfo"));
+ OC_LOG(INFO, TAG, "Entering OCSetDeviceInfo");
if (!deviceInfo.deviceName || deviceInfo.deviceName[0] == '\0')
{
- OC_LOG(ERROR, TAG, PCF("Null or empty device name."));
+ OC_LOG(ERROR, TAG, "Null or empty device name.");
return OC_STACK_INVALID_PARAM;
}
char *str = NULL;
OCStackResult result = OC_STACK_ERROR;
- OC_LOG(INFO, TAG, PCF("Entering OCCreateResource"));
+ OC_LOG(INFO, TAG, "Entering OCCreateResource");
if(myStackMode == OC_CLIENT)
{
// Validate parameters
if(!uri || uri[0]=='\0' || strlen(uri)>=MAX_URI_LENGTH )
{
- OC_LOG(ERROR, TAG, PCF("URI is empty or too long"));
+ OC_LOG(ERROR, TAG, "URI is empty or too long");
return OC_STACK_INVALID_URI;
}
// Is it presented during resource discovery?
if (!handle || !resourceTypeName || resourceTypeName[0] == '\0' )
{
- OC_LOG(ERROR, TAG, PCF("Input parameter is NULL"));
+ OC_LOG(ERROR, TAG, "Input parameter is NULL");
return OC_STACK_INVALID_PARAM;
}
> (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW | OC_SECURE |
OC_EXPLICIT_DISCOVERABLE))
{
- OC_LOG(ERROR, TAG, PCF("Invalid property"));
+ OC_LOG(ERROR, TAG, "Invalid property");
return OC_STACK_INVALID_PARAM;
}
result = BindResourceTypeToResource(pointer, resourceTypeName);
if (result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Error adding resourcetype"));
+ OC_LOG(ERROR, TAG, "Error adding resourcetype");
goto exit;
}
result = BindResourceInterfaceToResource(pointer, resourceInterfaceName);
if (result != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Error adding resourceinterface"));
+ OC_LOG(ERROR, TAG, "Error adding resourceinterface");
goto exit;
}
OCResource *resource = NULL;
uint8_t i = 0;
- OC_LOG(INFO, TAG, PCF("Entering OCBindResource"));
+ OC_LOG(INFO, TAG, "Entering OCBindResource");
// Validate parameters
VERIFY_NON_NULL(collectionHandle, ERROR, OC_STACK_ERROR);
// Container cannot contain itself
if (collectionHandle == resourceHandle)
{
- OC_LOG(ERROR, TAG, PCF("Added handle equals collection handle"));
+ OC_LOG(ERROR, TAG, "Added handle equals collection handle");
return OC_STACK_INVALID_PARAM;
}
resource = findResource((OCResource *) collectionHandle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Collection handle not found"));
+ OC_LOG(ERROR, TAG, "Collection handle not found");
return OC_STACK_INVALID_PARAM;
}
if (!resource->rsrcResources[i])
{
resource->rsrcResources[i] = (OCResource *) resourceHandle;
- OC_LOG(INFO, TAG, PCF("resource bound"));
+ OC_LOG(INFO, TAG, "resource bound");
#ifdef WITH_PRESENCE
if (presenceResource.handle)
OCResource *resource = NULL;
uint8_t i = 0;
- OC_LOG(INFO, TAG, PCF("Entering OCUnBindResource"));
+ OC_LOG(INFO, TAG, "Entering OCUnBindResource");
// Validate parameters
VERIFY_NON_NULL(collectionHandle, ERROR, OC_STACK_ERROR);
// Container cannot contain itself
if (collectionHandle == resourceHandle)
{
- OC_LOG(ERROR, TAG, PCF("removing handle equals collection handle"));
+ OC_LOG(ERROR, TAG, "removing handle equals collection handle");
return OC_STACK_INVALID_PARAM;
}
resource = findResource((OCResource *) collectionHandle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Collection handle not found"));
+ OC_LOG(ERROR, TAG, "Collection handle not found");
return OC_STACK_INVALID_PARAM;
}
if (resourceHandle == resource->rsrcResources[i])
{
resource->rsrcResources[i] = (OCResource *) NULL;
- OC_LOG(INFO, TAG, PCF("resource unbound"));
+ OC_LOG(INFO, TAG, "resource unbound");
// Send notification when resource is unbounded successfully.
#ifdef WITH_PRESENCE
}
}
- OC_LOG(INFO, TAG, PCF("resource not found in collection"));
+ OC_LOG(INFO, TAG, "resource not found in collection");
// Unable to add resourceHandle, so return error
return OC_STACK_ERROR;
resource = findResource((OCResource *) handle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Resource not found"));
+ OC_LOG(ERROR, TAG, "Resource not found");
return OC_STACK_ERROR;
}
resource = findResource((OCResource *) handle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Resource not found"));
+ OC_LOG(ERROR, TAG, "Resource not found");
return OC_STACK_ERROR;
}
{
if (!handle)
{
- OC_LOG(ERROR, TAG, PCF("Invalid handle for deletion"));
+ OC_LOG(ERROR, TAG, "Invalid handle for deletion");
return OC_STACK_INVALID_PARAM;
}
OCResource *resource = findResource((OCResource *) handle);
if (resource == NULL)
{
- OC_LOG(ERROR, TAG, PCF("Resource not found"));
+ OC_LOG(ERROR, TAG, "Resource not found");
return OC_STACK_NO_RESOURCE;
}
if (deleteResource((OCResource *) handle) != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, PCF("Error deleting resource"));
+ OC_LOG(ERROR, TAG, "Error deleting resource");
return OC_STACK_ERROR;
}
resource = findResource((OCResource *)handle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Resource not found"));
+ OC_LOG(ERROR, TAG, "Resource not found");
return OC_STACK_ERROR;
}
resource = findResource((OCResource *)handle);
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Resource not found"));
+ OC_LOG(ERROR, TAG, "Resource not found");
return NULL;
}
OCMethod method = OC_REST_NOMETHOD;
uint32_t maxAge = 0;
- OC_LOG(INFO, TAG, PCF("Notifying all observers"));
+ OC_LOG(INFO, TAG, "Notifying all observers");
#ifdef WITH_PRESENCE
- if (handle == presenceResource.handle)
+ if(handle == presenceResource.handle)
{
return OC_STACK_OK;
}
const OCRepPayload *payload,
OCQualityOfService qos)
{
- OC_LOG(INFO, TAG, PCF("Entering OCNotifyListOfObservers"));
+ OC_LOG(INFO, TAG, "Entering OCNotifyListOfObservers");
OCResource *resPtr = NULL;
//TODO: we should allow the server to define this
OCStackResult result = OC_STACK_ERROR;
OCServerRequest *serverRequest = NULL;
- OC_LOG(INFO, TAG, PCF("Entering OCDoResponse"));
+ OC_LOG(INFO, TAG, "Entering OCDoResponse");
// Validate input parameters
VERIFY_NON_NULL(ehResponse, ERROR, OC_STACK_INVALID_PARAM);
if (resourceProperties
> (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW))
{
- OC_LOG(ERROR, TAG, PCF("Invalid property"));
+ OC_LOG(ERROR, TAG, "Invalid property");
return OC_STACK_INVALID_PARAM;
}
if(!enable)
OCResource *temp = NULL;
if(!resource)
{
- OC_LOG_V(DEBUG,TAG,"resource is NULL");
+ OC_LOG(DEBUG,TAG,"resource is NULL");
return OC_STACK_INVALID_PARAM;
}
if (GetDoxmDeviceID(&sid) != OC_STACK_OK)
{
- OC_LOG(FATAL, TAG, PCF("Generate UUID for Server Instance failed!"));
+ OC_LOG(FATAL, TAG, "Generate UUID for Server Instance failed!");
return NULL;
}
generated = true;
if(OCConvertUuidToString(sid->id, sidStr) != RAND_UUID_OK)
{
- OC_LOG(FATAL, TAG, PCF("Generate UUID String for Server Instance failed!"));
+ OC_LOG(FATAL, TAG, "Generate UUID String for Server Instance failed!");
return NULL;
}
return OC_STACK_ERROR;
}
}
+