1 //******************************************************************
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
23 #include "ocserverrequest.h"
24 #include "ocresourcehandler.h"
25 #include "oic_malloc.h"
26 #include "oic_string.h"
29 #include "cainterface.h"
35 #define VERIFY_NON_NULL(arg) { if (!arg) {OC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
37 #define TAG PCF("ocserverrequest")
39 static struct OCServerRequest * serverRequestList = NULL;
40 static struct OCServerResponse * serverResponseList = NULL;
42 //-------------------------------------------------------------------------------------------------
44 //-------------------------------------------------------------------------------------------------
47 * Add a server response to the server response list
49 * @param response initialized server response that is created by this function
50 * @param requestHandle - handle of the response
55 static OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
57 OCServerResponse * serverResponse = NULL;
59 serverResponse = (OCServerResponse *) OICCalloc(1, sizeof(OCServerResponse));
60 VERIFY_NON_NULL(serverResponse);
62 serverResponse->payload = (char *) OICCalloc(1, MAX_RESPONSE_LENGTH);
63 VERIFY_NON_NULL(serverResponse->payload);
65 serverResponse->remainingPayloadSize = MAX_RESPONSE_LENGTH;
66 serverResponse->requestHandle = requestHandle;
68 *response = serverResponse;
69 OC_LOG(INFO, TAG, PCF("Server Response Added!!"));
70 LL_APPEND (serverResponseList, serverResponse);
76 OICFree(serverResponse);
77 serverResponse = NULL;
80 return OC_STACK_NO_MEMORY;
84 * Delete a server request from the server request list
86 * @param serverRequest - server request to delete
88 static void DeleteServerRequest(OCServerRequest * serverRequest)
92 LL_DELETE(serverRequestList, serverRequest);
93 OICFree(serverRequest->requestToken);
94 OICFree(serverRequest);
96 OC_LOG(INFO, TAG, PCF("Server Request Removed!!"));
101 * Delete a server response from the server response list
103 * @param serverResponse - server response to delete
105 static void DeleteServerResponse(OCServerResponse * serverResponse)
109 LL_DELETE(serverResponseList, serverResponse);
110 OICFree(serverResponse->payload);
111 OICFree(serverResponse);
112 OC_LOG(INFO, TAG, PCF("Server Response Removed!!"));
117 * Find a server response and delete it from the server response list
119 * @param serverResponse - server response to find and delete
121 static void FindAndDeleteServerResponse(OCServerResponse * serverResponse)
123 OCServerResponse* tmp;
126 LL_FOREACH(serverResponseList, tmp)
128 if (serverResponse == tmp)
130 DeleteServerResponse(tmp);
137 //-------------------------------------------------------------------------------------------------
139 //-------------------------------------------------------------------------------------------------
142 * Get a server request from the server request list using the specified token.
144 * @param token - token of server request
145 * @param tokenLength - length of token
150 OCServerRequest * GetServerRequestUsingToken (const CAToken_t token, uint8_t tokenLength)
154 OC_LOG(ERROR, TAG, PCF("Invalid Parameter Token"));
158 OCServerRequest * out = NULL;
159 LL_FOREACH (serverRequestList, out)
161 OC_LOG(INFO, TAG,PCF("comparing tokens"));
162 OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
163 OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, tokenLength);
164 if(memcmp(out->requestToken, token, tokenLength) == 0)
169 OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
174 * Get a server request from the server request list using the specified handle
176 * @param handle - handle of server request
180 OCServerRequest * GetServerRequestUsingHandle (const OCServerRequest * handle)
182 OCServerRequest * out = NULL;
183 LL_FOREACH (serverRequestList, out)
190 OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
195 * Get a server response from the server response list using the specified handle
197 * @param handle - handle of server response
202 OCServerResponse * GetServerResponseUsingHandle (const OCServerRequest * handle)
204 OCServerResponse * out = NULL;
205 LL_FOREACH (serverResponseList, out)
207 if(out->requestHandle == handle)
212 OC_LOG(ERROR, TAG, PCF("Server Response not found!!"));
217 * Add a server request to the server request list
219 * @param request - initialized server request that is created by this function
220 * @param coapID - ID of CoAP pdu
221 * @param delayedResNeeded - delayed response required 0=no 1=yes
222 * @param secured - secure endpoint 0=no 1=yes
223 * @param notificationFlag - //TODO: remove - does not appear to be used any longer
224 * @param method - RESTful method
225 * @param numRcvdVendorSpecificHeaderOptions - number of received vendor specific header options
226 * @param observationOption - value of observation option
227 * @param qos - request QOS
228 * @param query - request query
229 * @param rcvdVendorSpecificHeaderOptions - received vendor specific header options
230 * @param reqJSONPayload - request JSON payload
231 * @param requestToken - request token
232 * @param tokenLength - request token length
233 * @param resourceUrl - URL of resource
234 * @param reqTotalSize - total size of the request
235 * @param addressInfo - CA Address
236 * @param connectivityType - connection type
241 OCStackResult AddServerRequest (OCServerRequest ** request, uint16_t coapID,
242 uint8_t delayedResNeeded, uint8_t notificationFlag, OCMethod method,
243 uint8_t numRcvdVendorSpecificHeaderOptions, uint32_t observationOption,
244 OCQualityOfService qos, char * query,
245 OCHeaderOption * rcvdVendorSpecificHeaderOptions,
246 char * reqJSONPayload, CAToken_t requestToken, uint8_t tokenLength,
247 char * resourceUrl, size_t reqTotalSize, const OCDevAddr *devAddr)
249 OCServerRequest * serverRequest = NULL;
251 //Note: OCServerRequest includes 1 byte for the JSON Payload. payloadSize is calculated
252 //as the required length of the string, so this will result in enough room for the
253 //null terminator as well.
254 serverRequest = (OCServerRequest *) OICCalloc(1, sizeof(OCServerRequest) +
255 (reqTotalSize ? reqTotalSize : 1) - 1);
256 VERIFY_NON_NULL(devAddr);
257 VERIFY_NON_NULL(serverRequest);
259 serverRequest->coapID = coapID;
260 serverRequest->delayedResNeeded = delayedResNeeded;
261 serverRequest->notificationFlag = notificationFlag;
263 serverRequest->method = method;
264 serverRequest->numRcvdVendorSpecificHeaderOptions = numRcvdVendorSpecificHeaderOptions;
265 serverRequest->observationOption = observationOption;
266 serverRequest->observeResult = OC_STACK_ERROR;
267 serverRequest->qos = qos;
268 serverRequest->ehResponseHandler = HandleSingleResponse;
269 serverRequest->numResponses = 1;
273 OICStrcpy(serverRequest->query, sizeof(serverRequest->query), query);
276 if(rcvdVendorSpecificHeaderOptions)
278 memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
279 MAX_HEADER_OPTIONS * sizeof(OCHeaderOption));
281 if(reqJSONPayload && reqTotalSize)
283 OICStrcpy(serverRequest->reqJSONPayload, reqTotalSize, reqJSONPayload);
285 serverRequest->requestComplete = 0;
288 // If tokenLength is zero, the return value depends on the
289 // particular library implementation (it may or may not be a null pointer).
292 serverRequest->requestToken = (CAToken_t) OICMalloc(tokenLength);
293 VERIFY_NON_NULL(serverRequest->requestToken);
294 memcpy(serverRequest->requestToken, requestToken, tokenLength);
298 serverRequest->tokenLength = tokenLength;
302 OICStrcpy(serverRequest->resourceUrl, sizeof(serverRequest->resourceUrl),
306 serverRequest->devAddr = *devAddr;
308 *request = serverRequest;
309 OC_LOG(INFO, TAG, PCF("Server Request Added!!"));
310 LL_APPEND (serverRequestList, serverRequest);
316 OICFree(serverRequest);
317 serverRequest = NULL;
320 return OC_STACK_NO_MEMORY;
324 * Form the OCEntityHandlerRequest struct that is passed to a resource's entity handler
326 * @param entityHandlerRequest - pointer to the OCEntityHandlerRequest struct that is created.
327 * Required to be zero-initialized before calling this function.
328 * @param request - request handle
329 * @param method - RESTful method
330 * @param resource - resource handle
331 * @param queryBuf - resource query of request
332 * @param bufReqPayload - JSON payload of request
333 * @param numVendorOptions - number of vendor options
334 * @param vendorOptions - vendor options
335 * @param observeAction - observe action flag
336 * @param observeID - observe ID
341 OCStackResult FormOCEntityHandlerRequest(
342 OCEntityHandlerRequest * entityHandlerRequest,
343 OCRequestHandle request,
345 OCResourceHandle resource,
347 char * bufReqPayload,
348 uint8_t numVendorOptions,
349 OCHeaderOption * vendorOptions,
350 OCObserveAction observeAction,
351 OCObservationId observeID)
353 if (entityHandlerRequest)
355 entityHandlerRequest->resource = (OCResourceHandle) resource;
356 entityHandlerRequest->requestHandle = request;
357 entityHandlerRequest->method = method;
358 entityHandlerRequest->query = queryBuf;
359 entityHandlerRequest->obsInfo.action = observeAction;
360 entityHandlerRequest->obsInfo.obsId = observeID;
361 entityHandlerRequest->numRcvdVendorSpecificHeaderOptions = numVendorOptions;
362 entityHandlerRequest->rcvdVendorSpecificHeaderOptions = vendorOptions;
363 entityHandlerRequest->reqJSONPayload = bufReqPayload;
368 return OC_STACK_INVALID_PARAM;
372 * Find a server request in the server request list and delete
374 * @param serverRequest - server request to find and delete
376 void FindAndDeleteServerRequest(OCServerRequest * serverRequest)
378 OCServerRequest* tmp;
381 LL_FOREACH(serverRequestList, tmp)
383 if (serverRequest == tmp)
385 DeleteServerRequest(tmp);
392 CAResponseResult_t ConvertEHResultToCAResult (OCEntityHandlerResult result)
394 CAResponseResult_t caResult = CA_BAD_REQ;
399 caResult = CA_SUCCESS;
402 caResult = CA_BAD_REQ;
404 case OC_EH_RESOURCE_CREATED:
405 caResult = CA_CREATED;
407 case OC_EH_RESOURCE_DELETED:
408 caResult = CA_DELETED;
411 caResult = CA_SUCCESS;
413 case OC_EH_FORBIDDEN:
414 caResult = CA_UNAUTHORIZED_REQ;
416 case OC_EH_RESOURCE_NOT_FOUND:
417 caResult = CA_NOT_FOUND;
420 caResult = CA_BAD_REQ;
428 * Handler function for sending a response from a single resource
430 * @param ehResponse - pointer to the response from the resource
436 OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
438 OCStackResult result = OC_STACK_ERROR;
439 CAEndpoint_t responseEndpoint = {};
440 CAResponseInfo_t responseInfo = {};
441 CAHeaderOption_t* optionsPointer = NULL;
443 if(!ehResponse || !ehResponse->requestHandle)
445 return OC_STACK_ERROR;
448 OC_LOG_V(INFO, TAG, "Inside HandleSingleResponse: %s", ehResponse->payload);
450 if(ehResponse->payloadSize >= (MAX_RESPONSE_LENGTH))// - OC_JSON_PREFIX_LEN - OC_JSON_SUFFIX_LEN))
452 OC_LOG_V(ERROR, TAG, "Response payload size was too large. Max is %hu, payload size was %hu",
453 (MAX_RESPONSE_LENGTH - OC_JSON_PREFIX_LEN - OC_JSON_SUFFIX_LEN), ehResponse->payloadSize);
454 return OC_STACK_INVALID_PARAM;
457 OCServerRequest *serverRequest = (OCServerRequest *)ehResponse->requestHandle;
459 CopyDevAddrToEndpoint(&serverRequest->devAddr, &responseEndpoint);
461 responseInfo.info.resourceUri = serverRequest->resourceUrl;
462 responseInfo.result = ConvertEHResultToCAResult(ehResponse->ehResult);
464 if(serverRequest->notificationFlag && serverRequest->qos == OC_HIGH_QOS)
466 responseInfo.info.type = CA_MSG_CONFIRM;
468 else if(serverRequest->notificationFlag && serverRequest->qos != OC_HIGH_QOS)
470 responseInfo.info.type = CA_MSG_NONCONFIRM;
472 else if(!serverRequest->notificationFlag && !serverRequest->slowFlag &&
473 serverRequest->qos == OC_HIGH_QOS)
475 responseInfo.info.type = CA_MSG_ACKNOWLEDGE;
477 else if(!serverRequest->notificationFlag && serverRequest->slowFlag &&
478 serverRequest->qos == OC_HIGH_QOS)
480 responseInfo.info.type = CA_MSG_CONFIRM;
482 else if(!serverRequest->notificationFlag)
484 responseInfo.info.type = CA_MSG_NONCONFIRM;
487 responseInfo.info.messageId = serverRequest->coapID;
488 responseInfo.info.token = (CAToken_t)OICMalloc(CA_MAX_TOKEN_LEN+1);
489 if (!responseInfo.info.token)
491 OC_LOG(FATAL, TAG, "Response Info Token is NULL");
495 memcpy(responseInfo.info.token, serverRequest->requestToken, serverRequest->tokenLength);
496 responseInfo.info.tokenLength = serverRequest->tokenLength;
498 if(serverRequest->observeResult == OC_STACK_OK)
500 responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
504 responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions;
507 if(responseInfo.info.numOptions > 0)
509 responseInfo.info.options = (CAHeaderOption_t *)
510 OICCalloc(responseInfo.info.numOptions,
511 sizeof(CAHeaderOption_t));
513 if(!responseInfo.info.options)
515 OC_LOG(FATAL, TAG, PCF("options is NULL"));
516 OICFree(responseInfo.info.token);
517 return OC_STACK_NO_MEMORY;
520 optionsPointer = responseInfo.info.options;
522 // TODO: This exposes CoAP specific details. At some point, this should be
523 // re-factored and handled in the CA layer.
524 if(serverRequest->observeResult == OC_STACK_OK)
526 responseInfo.info.options[0].protocolID = CA_COAP_ID;
527 responseInfo.info.options[0].optionID = COAP_OPTION_OBSERVE;
528 responseInfo.info.options[0].optionLength = sizeof(uint32_t);
529 memcpy(responseInfo.info.options[0].optionData,
530 &(serverRequest->observationOption), sizeof(uint32_t));
532 // Point to the next header option before copying vender specific header options
536 if (ehResponse->numSendVendorSpecificHeaderOptions)
538 memcpy(optionsPointer, ehResponse->sendVendorSpecificHeaderOptions,
539 sizeof(OCHeaderOption) *
540 ehResponse->numSendVendorSpecificHeaderOptions);
545 responseInfo.info.options = NULL;
548 char payload[MAX_RESPONSE_LENGTH + OC_JSON_PREFIX_LEN + OC_JSON_SUFFIX_LEN + 1] = {};
550 // Put the JSON prefix and suffix around the payload
551 OICStrcpy(payload, sizeof(payload), OC_JSON_PREFIX);
552 if(ehResponse->payloadSize)
554 OICStrcatPartial(payload, sizeof(payload),
556 ehResponse->payloadSize < MAX_RESPONSE_LENGTH ?
557 ehResponse->payloadSize : MAX_RESPONSE_LENGTH);
559 OICStrcat(payload, sizeof(payload), OC_JSON_SUFFIX);
560 responseInfo.info.payload = (CAPayload_t)payload;
563 //TODO: Add other connectivity types to CAConnTypes[] when enabled
564 CATransportAdapter_t CAConnTypes[] = {CA_ADAPTER_IP};
565 const char * connTypes[] = {"IP"};
566 int size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
567 CATransportAdapter_t adapter = responseEndpoint.adapter;
568 CAResult_t caResult = CA_STATUS_FAILED;
569 result = OC_STACK_OK;
571 // Default adapter, try to send response out on all adapters.
572 if (adapter == CA_DEFAULT_ADAPTER)
575 (CATransportAdapter_t)(CA_ADAPTER_IP | CA_ADAPTER_GATT_BTLE | CA_ADAPTER_RFCOMM_BTEDR);
578 for(int i = 0; i < size; i++ )
580 responseEndpoint.adapter = (CATransportAdapter_t)(adapter & CAConnTypes[i]);
581 if(responseEndpoint.adapter)
583 //The result is set to OC_STACK_OK only if CASendResponse succeeds in sending the
584 //response on all the n/w interfaces else it is set to OC_STACK_ERROR
585 caResult = CASendResponse(&responseEndpoint, &responseInfo);
586 if(caResult != CA_STATUS_OK)
588 OC_LOG_V(ERROR, TAG, "CASendResponse failed on %s", connTypes[i]);
589 result = CAResultToOCResult(caResult);
593 OC_LOG_V(INFO, TAG, "CASendResponse succeeded on %s", connTypes[i]);
598 CAResult_t caResult = CASendResponse(&responseEndpoint, &responseInfo);
599 if(caResult != CA_STATUS_OK)
601 OC_LOG(ERROR, TAG, PCF("CASendResponse failed"));
602 result = CAResultToOCResult(caResult);
606 result = OC_STACK_OK;
610 OICFree(responseInfo.info.token);
611 OICFree(responseInfo.info.options);
613 FindAndDeleteServerRequest(serverRequest);
618 * Handler function for sending a response from multiple resources, such as a collection.
619 * Aggregates responses from multiple resource until all responses are received then sends the
620 * concatenated response
622 * TODO: Need to add a timeout in case a (remote?) resource does not respond
624 * @param ehResponse - pointer to the response from the resource
629 OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
631 OCStackResult stackRet = OC_STACK_ERROR;
632 OCServerRequest * serverRequest = NULL;
633 OCServerResponse * serverResponse = NULL;
634 uint16_t bufferNeeded = 0;
636 if(!ehResponse || !ehResponse->payload)
638 OC_LOG(ERROR, TAG, PCF("HandleAggregateResponse invalid parameters"));
639 return OC_STACK_INVALID_PARAM;
642 OC_LOG_V(INFO, TAG, "Inside HandleAggregateResponse: %s", ehResponse->payload);
644 serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
645 serverResponse = GetServerResponseUsingHandle((OCServerRequest *)ehResponse->requestHandle);
651 OC_LOG(INFO, TAG, PCF("This is the first response fragment"));
652 stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
653 if (OC_STACK_OK != stackRet)
655 OC_LOG(ERROR, TAG, PCF("Error adding server response"));
658 VERIFY_NON_NULL(serverResponse);
659 VERIFY_NON_NULL(serverResponse->payload);
662 // If there is more than 1 response, then we need to allow for a null-termination
663 // in the server response payload buffer AND the JSON response separator
664 bufferNeeded = ehResponse->payloadSize + 1;
665 if (serverRequest->numResponses > 1)
667 bufferNeeded += strlen(OC_JSON_SEPARATOR_STR);
669 if(serverResponse->remainingPayloadSize >= bufferNeeded)
671 OC_LOG(ERROR, TAG, PCF("There is room in response buffer"));
673 // allocated size of the payload is assumed, since a search of the code
674 // shows that it is OICCalloc'ed to this size in AddServerResponse above
675 OICStrcatPartial(serverResponse->payload,
678 serverResponse->remainingPayloadSize);
679 OC_LOG_V(INFO, TAG, "Current aggregated response ...%s", serverResponse->payload);
680 serverResponse->remainingPayloadSize -= strlen((char *)ehResponse->payload);
681 (serverRequest->numResponses)--;
682 if(serverRequest->numResponses == 0)
684 OC_LOG(INFO, TAG, PCF("This is the last response fragment"));
685 ehResponse->payload = serverResponse->payload;
686 ehResponse->payloadSize = strlen((char *) serverResponse->payload) + 1;
687 stackRet = HandleSingleResponse(ehResponse);
688 //Delete the request and response
689 FindAndDeleteServerRequest(serverRequest);
690 FindAndDeleteServerResponse(serverResponse);
694 OC_LOG(INFO, TAG, PCF("More response fragments to come"));
695 OICStrcatPartial(serverResponse->payload,
697 OC_JSON_SEPARATOR_STR,
698 serverResponse->remainingPayloadSize);
699 OC_LOG_V(INFO, TAG, "Current aggregated response ...%s", serverResponse->payload);
700 serverResponse->remainingPayloadSize -= strlen(OC_JSON_SEPARATOR_STR);
701 stackRet = OC_STACK_OK;
706 OC_LOG(ERROR, TAG, PCF("No room in response buffer"));
707 //Delete the request and response
708 FindAndDeleteServerRequest(serverRequest);
709 FindAndDeleteServerResponse(serverResponse);
710 stackRet = OC_STACK_NO_MEMORY;