#include "ocstack.h"
#include "ocserverrequest.h"
#include "ocresourcehandler.h"
+#include "ocobserve.h"
#include "oic_malloc.h"
#include "oic_string.h"
#include "ocpayload.h"
#include "ocpayloadcbor.h"
+#include "logger.h"
+
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+#include "routingutility.h"
+#endif
#include "cacommon.h"
#include "cainterface.h"
-#include "utlist.h"
-#include "pdu.h"
+#include <coap/utlist.h>
+#include <coap/pdu.h>
// Module Name
-#define VERIFY_NON_NULL(arg) { if (!arg) {OC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
+#define VERIFY_NON_NULL(arg) { if (!arg) {OIC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
-#define TAG "ocserverrequest"
+#define TAG "OIC_RI_SERVERREQUEST"
static struct OCServerRequest * serverRequestList = NULL;
static struct OCServerResponse * serverResponseList = NULL;
*/
static OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
{
+ if (!response)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
OCServerResponse * serverResponse = NULL;
serverResponse = (OCServerResponse *) OICCalloc(1, sizeof(OCServerResponse));
serverResponse->requestHandle = requestHandle;
*response = serverResponse;
- OC_LOG(INFO, TAG, "Server Response Added!!");
+ OIC_LOG(INFO, TAG, "Server Response Added!!");
LL_APPEND (serverResponseList, serverResponse);
return OC_STACK_OK;
{
LL_DELETE(serverRequestList, serverRequest);
OICFree(serverRequest->requestToken);
+ OICFree(serverRequest->rcvdVendorSpecificHeaderOptions);
OICFree(serverRequest);
serverRequest = NULL;
- OC_LOG(INFO, TAG, "Server Request Removed!!");
+ OIC_LOG(INFO, TAG, "Server Request Removed!!");
}
}
if(serverResponse)
{
LL_DELETE(serverResponseList, serverResponse);
- OICFree(serverResponse->payload);
+ OCPayloadDestroy(serverResponse->payload);
OICFree(serverResponse);
- OC_LOG(INFO, TAG, "Server Response Removed!!");
+ OIC_LOG(INFO, TAG, "Server Response Removed!!");
}
}
}
/**
- * Ensure no accept header option is included when sending responses
+ * Ensure no accept header option is included when sending responses and add routing info to
+ * outgoing response.
*
* @param object CA remote endpoint.
* @param requestInfo CA request info.
*/
static OCStackResult OCSendResponse(const CAEndpoint_t *object, CAResponseInfo_t *responseInfo)
{
+#if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ // Add route info in RM option.
+ OCStackResult rmResult = RMAddInfo(object->routeData, responseInfo, false, NULL);
+ if(OC_STACK_OK != rmResult)
+ {
+ OIC_LOG(ERROR, TAG, "Add option failed");
+ return rmResult;
+ }
+#endif
+
// Do not include the accept header option
responseInfo->info.acceptFormat = CA_FORMAT_UNDEFINED;
CAResult_t result = CASendResponse(object, responseInfo);
if(CA_STATUS_OK != result)
{
- OC_LOG_V(ERROR, TAG, "CASendResponse failed with CA error %u", result);
+ OIC_LOG_V(ERROR, TAG, "CASendResponse failed with CA error %u", result);
return CAResultToOCResult(result);
}
return OC_STACK_OK;
{
if(!token)
{
- OC_LOG(ERROR, TAG, "Invalid Parameter Token");
+ OIC_LOG(ERROR, TAG, "Invalid Parameter Token");
return NULL;
}
OCServerRequest * out = NULL;
- OC_LOG(INFO, TAG,"Get server request with token");
- OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
+ OIC_LOG(INFO, TAG,"Get server request with token");
+ OIC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
- OC_LOG(INFO, TAG,"Found token");
+ OIC_LOG(INFO, TAG, "Found token");
LL_FOREACH (serverRequestList, out)
{
- OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, tokenLength);
- if(memcmp(out->requestToken, token, tokenLength) == 0)
+ if(out)
{
- return out;
+ OIC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, out->tokenLength);
+ if((tokenLength == out->tokenLength) &&
+ memcmp(out->requestToken, token, tokenLength) == 0)
+ {
+ return out;
+ }
}
}
- OC_LOG(ERROR, TAG, "Server Request not found!!");
+ OIC_LOG(INFO, TAG, "Server Request not found!!");
return NULL;
}
* @return
* OCServerRequest*
*/
-OCServerRequest * GetServerRequestUsingHandle (const OCServerRequest * handle)
+OCServerRequest * GetServerRequestUsingHandle (const OCRequestHandle handle)
{
OCServerRequest * out = NULL;
LL_FOREACH (serverRequestList, out)
{
- if(out == handle)
+ if(out->requestId == handle)
{
return out;
}
}
- OC_LOG(ERROR, TAG, "Server Request not found!!");
+ OIC_LOG(ERROR, TAG, "Server Request not found!!");
return NULL;
}
* @return
* OCServerResponse*
*/
-OCServerResponse * GetServerResponseUsingHandle (const OCServerRequest * handle)
+OCServerResponse * GetServerResponseUsingHandle (const OCRequestHandle handle)
{
OCServerResponse * out = NULL;
LL_FOREACH (serverResponseList, out)
return out;
}
}
- OC_LOG(ERROR, TAG, "Server Response not found!!");
+ OIC_LOG(INFO, TAG, "Server Response not found!!");
return NULL;
}
char * resourceUrl, size_t reqTotalSize, OCPayloadFormat acceptFormat,
const OCDevAddr *devAddr)
{
+ if (!request)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
OCServerRequest * serverRequest = NULL;
+ OIC_LOG_V(INFO, TAG, "addserverrequest entry!! [%s:%u]", devAddr->addr, devAddr->port);
+
serverRequest = (OCServerRequest *) OICCalloc(1, sizeof(OCServerRequest) +
(reqTotalSize ? reqTotalSize : 1) - 1);
VERIFY_NON_NULL(devAddr);
serverRequest->acceptFormat = acceptFormat;
serverRequest->ehResponseHandler = HandleSingleResponse;
serverRequest->numResponses = 1;
+ serverRequest->requestId = OCGetRandom();
if(query)
{
if(rcvdVendorSpecificHeaderOptions)
{
+ serverRequest->rcvdVendorSpecificHeaderOptions =
+ (OCHeaderOption *) OICCalloc(numRcvdVendorSpecificHeaderOptions, sizeof(OCHeaderOption));
+ VERIFY_NON_NULL(serverRequest->rcvdVendorSpecificHeaderOptions);
+
memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
- MAX_HEADER_OPTIONS * sizeof(OCHeaderOption));
+ numRcvdVendorSpecificHeaderOptions * sizeof(OCHeaderOption));
}
if(payload && reqTotalSize)
{
- // destination is at least 1 greater than the source, so a NULL always exists in the
+ // destination is at least 1 greater than the source, so a NULL always exists in the
// last character
memcpy(serverRequest->payload, payload, reqTotalSize);
serverRequest->payloadSize = reqTotalSize;
serverRequest->requestComplete = 0;
if(requestToken)
{
- // If tokenLength is zero, the return value depends on the
- // particular library implementation (it may or may not be a null pointer).
+ // If tokenLength is zero, the return value depends on the
+ // particular library implementation (it may or may not be a null pointer).
if (tokenLength)
{
serverRequest->requestToken = (CAToken_t) OICMalloc(tokenLength);
VERIFY_NON_NULL(serverRequest->requestToken);
memcpy(serverRequest->requestToken, requestToken, tokenLength);
}
-
}
serverRequest->tokenLength = tokenLength;
serverRequest->devAddr = *devAddr;
*request = serverRequest;
- OC_LOG(INFO, TAG, "Server Request Added!!");
+ OIC_LOG(INFO, TAG, "Server Request Added!!");
LL_APPEND (serverRequestList, serverRequest);
return OC_STACK_OK;
exit:
if (serverRequest)
{
+ OICFree(serverRequest->requestToken);
+ OICFree(serverRequest->rcvdVendorSpecificHeaderOptions);
OICFree(serverRequest);
serverRequest = NULL;
}
OCDevAddr *endpoint,
OCResourceHandle resource,
char * queryBuf,
+ OCPayloadType payloadType,
uint8_t * payload,
size_t payloadSize,
uint8_t numVendorOptions,
OCHeaderOption * vendorOptions,
OCObserveAction observeAction,
- OCObservationId observeID)
+ OCObservationId observeID,
+ uint16_t messageID)
{
if (entityHandlerRequest)
{
entityHandlerRequest->query = queryBuf;
entityHandlerRequest->obsInfo.action = observeAction;
entityHandlerRequest->obsInfo.obsId = observeID;
+ entityHandlerRequest->messageID = messageID;
if(payload && payloadSize)
{
- if(OCParsePayload(&entityHandlerRequest->payload, payload, payloadSize) != OC_STACK_OK)
+ if(OCParsePayload(&entityHandlerRequest->payload, payloadType,
+ payload, payloadSize) != OC_STACK_OK)
{
return OC_STACK_ERROR;
}
switch (result)
{
- case OC_EH_OK:
- 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.
- caResult = CA_CHANGED;
- break;
- case OC_REST_GET:
- // This Response Code is like HTTP 200 "OK" but only used in response to
- // GET requests.
- caResult = CA_CONTENT;
- break;
- default:
- // This should not happen but,
- // give it a value just in case but output an error
- caResult = CA_CONTENT;
- OC_LOG_V(ERROR, TAG, "Unexpected OC_EH_OK return code for method [d].", method);
- }
+ // Successful Client Request
+ case OC_EH_RESOURCE_CREATED: // 2.01
+ if (method == OC_REST_POST || method == OC_REST_PUT)
+ {
+ caResult = CA_CREATED;
+ }
break;
- case OC_EH_ERROR:
- caResult = CA_BAD_REQ;
+ case OC_EH_RESOURCE_DELETED: // 2.02
+ if (method == OC_REST_POST || method == OC_REST_DELETE)
+ {
+ caResult = CA_DELETED;
+ }
break;
- case OC_EH_RESOURCE_CREATED:
- caResult = CA_CREATED;
+ case OC_EH_SLOW: // 2.05
+ caResult = CA_CONTENT;
break;
- case OC_EH_RESOURCE_DELETED:
- caResult = CA_DELETED;
+ case OC_EH_OK:
+ case OC_EH_CHANGED: // 2.04
+ case OC_EH_CONTENT: // 2.05
+ if (method == OC_REST_POST || method == OC_REST_PUT)
+ {
+ caResult = CA_CHANGED;
+ }
+ else if (method == OC_REST_GET)
+ {
+ caResult = CA_CONTENT;
+ }
break;
- case OC_EH_SLOW:
- caResult = CA_CONTENT;
+ case OC_EH_VALID: // 2.03
+ caResult = CA_VALID;
break;
- case OC_EH_FORBIDDEN:
+ // Unsuccessful Client Request
+ case OC_EH_UNAUTHORIZED_REQ: // 4.01
caResult = CA_UNAUTHORIZED_REQ;
break;
- case OC_EH_RESOURCE_NOT_FOUND:
+ case OC_EH_BAD_OPT: // 4.02
+ caResult = CA_BAD_OPT;
+ break;
+ case OC_EH_FORBIDDEN: // 4.03
+ caResult = CA_FORBIDDEN_REQ;
+ break;
+ case OC_EH_RESOURCE_NOT_FOUND: // 4.04
caResult = CA_NOT_FOUND;
break;
+ case OC_EH_METHOD_NOT_ALLOWED: // 4.05
+ caResult = CA_METHOD_NOT_ALLOWED;
+ break;
+ case OC_EH_NOT_ACCEPTABLE: // 4.06
+ caResult = CA_NOT_ACCEPTABLE;
+ break;
+ case OC_EH_INTERNAL_SERVER_ERROR: // 5.00
+ caResult = CA_INTERNAL_SERVER_ERROR;
+ break;
+ case OC_EH_NOT_IMPLEMENTED: // 5.01
+ caResult = CA_NOT_IMPLEMENTED;
+ break;
+ case OC_EH_BAD_GATEWAY: // 5.02
+ caResult = CA_BAD_GATEWAY;
+ break;
+ case OC_EH_SERVICE_UNAVAILABLE: // 5.03
+ caResult = CA_SERVICE_UNAVAILABLE;
+ break;
+ case OC_EH_RETRANSMIT_TIMEOUT: // 5.04
+ caResult = CA_RETRANSMIT_TIMEOUT;
+ break;
+ case OC_EH_PROXY_NOT_SUPPORTED: // 5.05
+ caResult = CA_PROXY_NOT_SUPPORTED;
+ break;
default:
caResult = CA_BAD_REQ;
break;
* @return
* OCStackResult
*/
-
OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
{
OCStackResult result = OC_STACK_ERROR;
if(!ehResponse || !ehResponse->requestHandle)
{
+ OIC_LOG(ERROR, TAG, "ehResponse/requestHandle is NULL");
return OC_STACK_ERROR;
}
- OCServerRequest *serverRequest = (OCServerRequest *)ehResponse->requestHandle;
+ OCServerRequest *serverRequest = GetServerRequestUsingHandle(ehResponse->requestHandle);
+ if (NULL == serverRequest)
+ {
+ OIC_LOG(ERROR, TAG, "No serverRequest matching with ehResponse");
+ return OC_STACK_ERROR;
+ }
CopyDevAddrToEndpoint(&serverRequest->devAddr, &responseEndpoint);
+ responseInfo.info.messageId = serverRequest->coapID;
responseInfo.info.resourceUri = serverRequest->resourceUrl;
responseInfo.result = ConvertEHResultToCAResult(ehResponse->ehResult, serverRequest->method);
+ responseInfo.info.dataType = CA_RESPONSE_DATA;
if(serverRequest->notificationFlag && serverRequest->qos == OC_HIGH_QOS)
{
else if(!serverRequest->notificationFlag && serverRequest->slowFlag &&
serverRequest->qos == OC_HIGH_QOS)
{
+ // To assign new messageId in CA.
+ responseInfo.info.messageId = 0;
responseInfo.info.type = CA_MSG_CONFIRM;
}
else if(!serverRequest->notificationFlag)
{
responseInfo.info.type = CA_MSG_NONCONFIRM;
}
+ else
+ {
+ OIC_LOG(ERROR, TAG, "default responseInfo type is NON");
+ responseInfo.info.type = CA_MSG_NONCONFIRM;
+ }
- char rspToken[CA_MAX_TOKEN_LEN + 1] = {};
+ char rspToken[CA_MAX_TOKEN_LEN + 1] = {0};
responseInfo.info.messageId = serverRequest->coapID;
responseInfo.info.token = (CAToken_t)rspToken;
memcpy(responseInfo.info.token, serverRequest->requestToken, serverRequest->tokenLength);
responseInfo.info.tokenLength = serverRequest->tokenLength;
- if(serverRequest->observeResult == OC_STACK_OK)
+ if((serverRequest->observeResult == OC_STACK_OK)&&
+ (serverRequest->observationOption != MAX_SEQUENCE_NUMBER + 1))
{
responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
}
if(!responseInfo.info.options)
{
- OC_LOG(FATAL, TAG, "Memory alloc for options failed");
+ OIC_LOG(FATAL, TAG, "Memory alloc for options failed");
return OC_STACK_NO_MEMORY;
}
responseInfo.info.options[0].optionLength = sizeof(uint32_t);
uint8_t* observationData = (uint8_t*)responseInfo.info.options[0].optionData;
uint32_t observationOption= serverRequest->observationOption;
- size_t i;
- for (i=sizeof(uint32_t); i; --i)
+
+ for (size_t i=sizeof(uint32_t); i; --i)
{
observationData[i-1] = observationOption & 0xFF;
observationOption >>=8;
// Put the JSON prefix and suffix around the payload
if(ehResponse->payload)
{
+#ifdef WITH_PRESENCE
if (ehResponse->payload->type == PAYLOAD_TYPE_PRESENCE)
{
responseInfo.isMulticast = true;
}
else
+#endif
{
responseInfo.isMulticast = false;
}
&responseInfo.info.payloadSize))
!= OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "Error converting payload");
+ OIC_LOG(ERROR, TAG, "Error converting payload");
OICFree(responseInfo.info.options);
return result;
}
- responseInfo.info.payloadFormat = CA_FORMAT_APPLICATION_CBOR;
+ // Add CONTENT_FORMAT OPT if payload exist
+ if (responseInfo.info.payloadSize > 0)
+ {
+ responseInfo.info.payloadFormat = CA_FORMAT_APPLICATION_CBOR;
+ }
break;
default:
responseInfo.result = CA_NOT_ACCEPTABLE;
CATransportAdapter_t CAConnTypes[] = {
CA_ADAPTER_IP,
CA_ADAPTER_GATT_BTLE,
- CA_ADAPTER_RFCOMM_BTEDR
-
+ CA_ADAPTER_RFCOMM_BTEDR,
+ CA_ADAPTER_NFC
#ifdef RA_ADAPTER
, CA_ADAPTER_REMOTE_ACCESS
#endif
-
-#ifdef TCP_ADAPTER
, CA_ADAPTER_TCP
-#endif
};
- int size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
+ size_t size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
CATransportAdapter_t adapter = responseEndpoint.adapter;
// Default adapter, try to send response out on all adapters.
(CATransportAdapter_t)(
CA_ADAPTER_IP |
CA_ADAPTER_GATT_BTLE |
- CA_ADAPTER_RFCOMM_BTEDR
-
+ CA_ADAPTER_RFCOMM_BTEDR |
+ CA_ADAPTER_NFC
#ifdef RA_ADAP
| CA_ADAPTER_REMOTE_ACCESS
#endif
-
-#ifdef TCP_ADAPTER
| CA_ADAPTER_TCP
-#endif
);
}
result = OC_STACK_OK;
OCStackResult tempResult = OC_STACK_OK;
- for(int i = 0; i < size; i++ )
+ for(size_t i = 0; i < size; i++ )
{
responseEndpoint.adapter = (CATransportAdapter_t)(adapter & CAConnTypes[i]);
if(responseEndpoint.adapter)
}
#else
- OC_LOG(INFO, TAG, "Calling OCSendResponse with:");
- OC_LOG_V(INFO, TAG, "\tEndpoint address: %s", responseEndpoint.addr);
- OC_LOG_V(INFO, TAG, "\tEndpoint adapter: %s", responseEndpoint.adapter);
- OC_LOG_V(INFO, TAG, "\tResponse result : %s", responseInfo.result);
- OC_LOG_V(INFO, TAG, "\tResponse for uri: %s", responseInfo.info.resourceUri);
+ OIC_LOG(INFO, TAG, "Calling OCSendResponse with:");
+ OIC_LOG_V(INFO, TAG, "\tEndpoint address: %s", responseEndpoint.addr);
+ OIC_LOG_V(INFO, TAG, "\tEndpoint adapter: %s", responseEndpoint.adapter);
+ OIC_LOG_V(INFO, TAG, "\tResponse result : %s", responseInfo.result);
+ OIC_LOG_V(INFO, TAG, "\tResponse for uri: %s", responseInfo.info.resourceUri);
result = OCSendResponse(&responseEndpoint, &responseInfo);
#endif
*/
OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
{
- OCStackResult stackRet = OC_STACK_ERROR;
- OCServerRequest * serverRequest = NULL;
- OCServerResponse * serverResponse = NULL;
-
if(!ehResponse || !ehResponse->payload)
{
- OC_LOG(ERROR, TAG, "HandleAggregateResponse invalid parameters");
+ OIC_LOG(ERROR, TAG, "HandleAggregateResponse invalid parameters");
return OC_STACK_INVALID_PARAM;
}
- OC_LOG(INFO, TAG, "Inside HandleAggregateResponse");
+ OIC_LOG(INFO, TAG, "Inside HandleAggregateResponse");
- serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
- serverResponse = GetServerResponseUsingHandle((OCServerRequest *)ehResponse->requestHandle);
+ OCServerRequest *serverRequest = GetServerRequestUsingHandle(ehResponse->requestHandle);
+ OCServerResponse *serverResponse = GetServerResponseUsingHandle(ehResponse->requestHandle);
+ OCStackResult stackRet = OC_STACK_ERROR;
if(serverRequest)
{
if(!serverResponse)
{
- OC_LOG(INFO, TAG, "This is the first response fragment");
+ OIC_LOG(INFO, TAG, "This is the first response fragment");
stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
if (OC_STACK_OK != stackRet)
{
- OC_LOG(ERROR, TAG, "Error adding server response");
+ OIC_LOG(ERROR, TAG, "Error adding server response");
return stackRet;
}
VERIFY_NON_NULL(serverResponse);
if(ehResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION)
{
stackRet = OC_STACK_ERROR;
- OC_LOG(ERROR, TAG, "Error adding payload, as it was the incorrect type");
+ OIC_LOG(ERROR, TAG, "Error adding payload, as it was the incorrect type");
goto exit;
}
+ OCRepPayload *newPayload = OCRepPayloadBatchClone((OCRepPayload *)ehResponse->payload);
+
if(!serverResponse->payload)
{
- serverResponse->payload = ehResponse->payload;
+ serverResponse->payload = (OCPayload *)newPayload;
}
else
{
OCRepPayloadAppend((OCRepPayload*)serverResponse->payload,
- (OCRepPayload*)ehResponse->payload);
+ (OCRepPayload*)newPayload);
}
-
(serverRequest->numResponses)--;
if(serverRequest->numResponses == 0)
{
- OC_LOG(INFO, TAG, "This is the last response fragment");
+ OIC_LOG(INFO, TAG, "This is the last response fragment");
ehResponse->payload = serverResponse->payload;
+ ehResponse->ehResult = OC_EH_OK;
stackRet = HandleSingleResponse(ehResponse);
//Delete the request and response
FindAndDeleteServerRequest(serverRequest);
}
else
{
- OC_LOG(INFO, TAG, "More response fragments to come");
+ OIC_LOG(INFO, TAG, "More response fragments to come");
stackRet = OC_STACK_OK;
}
}
exit:
+
return stackRet;
}
-
projects / platform / upstream / iotivity.git / blobdiff