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"
28 #include "cainterface.h"
34 #define VERIFY_NON_NULL(arg) { if (!arg) {OC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
36 #define TAG PCF("ocserverrequest")
38 static struct OCServerRequest * serverRequestList = NULL;
39 static struct OCServerResponse * serverResponseList = NULL;
41 //-------------------------------------------------------------------------------------------------
43 //-------------------------------------------------------------------------------------------------
46 * Add a server response to the server response list
48 * @param response initialized server response that is created by this function
49 * @param requestHandle - handle of the response
54 static OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
56 OCServerResponse * serverResponse = NULL;
58 serverResponse = (OCServerResponse *) OCCalloc(1, sizeof(OCServerResponse));
59 VERIFY_NON_NULL(serverResponse);
61 serverResponse->payload = (char *) OCCalloc(1, MAX_RESPONSE_LENGTH);
62 VERIFY_NON_NULL(serverResponse->payload);
64 serverResponse->remainingPayloadSize = MAX_RESPONSE_LENGTH;
65 serverResponse->requestHandle = requestHandle;
67 *response = serverResponse;
68 OC_LOG(INFO, TAG, PCF("Server Response Added!!"));
69 LL_APPEND (serverResponseList, serverResponse);
75 OCFree(serverResponse);
76 serverResponse = NULL;
79 return OC_STACK_NO_MEMORY;
83 * Delete a server request from the server request list
85 * @param serverRequest - server request to delete
87 static void DeleteServerRequest(OCServerRequest * serverRequest)
91 LL_DELETE(serverRequestList, serverRequest);
92 OCFree(serverRequest);
94 OC_LOG(INFO, TAG, PCF("Server Request Removed!!"));
99 * Delete a server response from the server response list
101 * @param serverResponse - server response to delete
103 static void DeleteServerResponse(OCServerResponse * serverResponse)
107 LL_DELETE(serverResponseList, serverResponse);
108 OCFree(serverResponse->payload);
109 OCFree(serverResponse);
110 OC_LOG(INFO, TAG, PCF("Server Response Removed!!"));
115 * Find a server response and delete it from the server response list
117 * @param serverResponse - server response to find and delete
119 static void FindAndDeleteServerResponse(OCServerResponse * serverResponse)
121 OCServerResponse* tmp;
124 LL_FOREACH(serverResponseList, tmp)
126 if (serverResponse == tmp)
128 DeleteServerResponse(tmp);
135 //-------------------------------------------------------------------------------------------------
137 //-------------------------------------------------------------------------------------------------
140 * Get a server request from the server request list using the specified token.
142 * @param token - token of server request
143 * @param tokenLength - length of token
148 OCServerRequest * GetServerRequestUsingToken (const CAToken_t token, uint8_t tokenLength)
152 OC_LOG(ERROR, TAG, PCF("Invalid Parameter Token"));
156 OCServerRequest * out = NULL;
157 LL_FOREACH (serverRequestList, out)
159 OC_LOG(INFO, TAG,PCF("comparing tokens"));
160 OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
161 OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, tokenLength);
162 if(memcmp(out->requestToken, token, tokenLength) == 0)
167 OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
172 * Get a server request from the server request list using the specified handle
174 * @param handle - handle of server request
178 OCServerRequest * GetServerRequestUsingHandle (const OCServerRequest * handle)
180 OCServerRequest * out = NULL;
181 LL_FOREACH (serverRequestList, out)
188 OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
193 * Get a server response from the server response list using the specified handle
195 * @param handle - handle of server response
200 OCServerResponse * GetServerResponseUsingHandle (const OCServerRequest * handle)
202 OCServerResponse * out = NULL;
203 LL_FOREACH (serverResponseList, out)
205 if(out->requestHandle == handle)
210 OC_LOG(ERROR, TAG, PCF("Server Response not found!!"));
215 * Add a server request to the server request list
217 * @param request - initialized server request that is created by this function
218 * @param coapID - ID of CoAP pdu
219 * @param delayedResNeeded - delayed response required 0=no 1=yes
220 * @param secured - secure endpoint 0=no 1=yes
221 * @param notificationFlag - //TODO: remove - does not appear to be used any longer
222 * @param method - RESTful method
223 * @param numRcvdVendorSpecificHeaderOptions - number of received vendor specific header options
224 * @param observationOption - value of observation option
225 * @param qos - request QOS
226 * @param query - request query
227 * @param rcvdVendorSpecificHeaderOptions - received vendor specific header options
228 * @param reqJSONPayload - request JSON payload
229 * @param requestToken - request token
230 * @param tokenLength - request token length
231 * @param resourceUrl - URL of resource
232 * @param reqTotalSize - total size of the request
233 * @param addressInfo - CA Address
234 * @param connectivityType - connection type
239 OCStackResult AddServerRequest (OCServerRequest ** request, uint16_t coapID,
240 uint8_t delayedResNeeded, uint8_t secured, uint8_t notificationFlag, OCMethod method,
241 uint8_t numRcvdVendorSpecificHeaderOptions, uint32_t observationOption,
242 OCQualityOfService qos, char * query,
243 OCHeaderOption * rcvdVendorSpecificHeaderOptions,
244 char * reqJSONPayload, CAToken_t * requestToken,
246 char * resourceUrl, size_t reqTotalSize,
247 CAAddress_t *addressInfo, CAConnectivityType_t connectivityType)
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 *) OCCalloc(1, sizeof(OCServerRequest) +
255 (reqTotalSize ? reqTotalSize : 1) - 1);
256 VERIFY_NON_NULL(serverRequest);
258 serverRequest->coapID = coapID;
259 serverRequest->delayedResNeeded = delayedResNeeded;
260 serverRequest->secured = secured;
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 strncpy((char*)serverRequest->query,
274 (const char*)query, sizeof(serverRequest->query) - 1);
277 if(rcvdVendorSpecificHeaderOptions)
279 memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
280 MAX_HEADER_OPTIONS * sizeof(OCHeaderOption));
282 if(reqJSONPayload && reqTotalSize)
284 // destination is at least 1 greater than the source, so a NULL always exists in the
286 strncpy((char*)serverRequest->reqJSONPayload,
287 (const char*)reqJSONPayload, reqTotalSize - 1);
289 serverRequest->requestComplete = 0;
292 // If tokenLength is zero, the return value depends on the
293 // particular library implementation (it may or may not be a null pointer).
296 serverRequest->requestToken = (CAToken_t) OCMalloc(tokenLength);
297 VERIFY_NON_NULL(serverRequest->requestToken);
298 memcpy(serverRequest->requestToken, *requestToken, tokenLength);
302 serverRequest->tokenLength = tokenLength;
306 strncpy((char*)serverRequest->resourceUrl,
307 (const char*)resourceUrl, sizeof(serverRequest->resourceUrl) - 1);
312 serverRequest->addressInfo = *addressInfo;
314 serverRequest->connectivityType = connectivityType;
316 *request = serverRequest;
317 OC_LOG(INFO, TAG, PCF("Server Request Added!!"));
318 LL_APPEND (serverRequestList, serverRequest);
324 OCFree(serverRequest);
325 serverRequest = NULL;
328 return OC_STACK_NO_MEMORY;
332 * Form the OCEntityHandlerRequest struct that is passed to a resource's entity handler
334 * @param entityHandlerRequest - pointer to the OCEntityHandlerRequest struct that is created
335 * @param request - request handle
336 * @param method - RESTful method
337 * @param resource - resource handle
338 * @param queryBuf - resource query of request
339 * @param bufReqPayload - JSON payload of request
340 * @param numVendorOptions - number of vendor options
341 * @param vendorOptions - vendor options
342 * @param observeAction - observe action flag
343 * @param observeID - observe ID
348 OCStackResult FormOCEntityHandlerRequest(
349 OCEntityHandlerRequest * entityHandlerRequest,
350 OCRequestHandle request,
352 OCResourceHandle resource,
354 char * bufReqPayload,
355 uint8_t numVendorOptions,
356 OCHeaderOption * vendorOptions,
357 OCObserveAction observeAction,
358 OCObservationId observeID)
360 if (entityHandlerRequest)
362 memset(entityHandlerRequest, 0, sizeof(OCEntityHandlerRequest));
363 entityHandlerRequest->requestHandle = request;
364 entityHandlerRequest->method = method;
365 entityHandlerRequest->resource = (OCResourceHandle) resource;
366 entityHandlerRequest->query = queryBuf;
367 entityHandlerRequest->reqJSONPayload = bufReqPayload;
368 entityHandlerRequest->numRcvdVendorSpecificHeaderOptions = numVendorOptions;
369 entityHandlerRequest->rcvdVendorSpecificHeaderOptions = vendorOptions;
371 entityHandlerRequest->obsInfo.action = observeAction;
372 entityHandlerRequest->obsInfo.obsId = observeID;
376 return OC_STACK_INVALID_PARAM;
380 * Find a server request in the server request list and delete
382 * @param serverRequest - server request to find and delete
384 void FindAndDeleteServerRequest(OCServerRequest * serverRequest)
386 OCServerRequest* tmp;
389 LL_FOREACH(serverRequestList, tmp)
391 if (serverRequest == tmp)
393 DeleteServerRequest(tmp);
401 * Handler function for sending a response from a single resource
403 * @param ehResponse - pointer to the response from the resource
408 OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
410 OCStackResult result = OC_STACK_ERROR;
411 CARemoteEndpoint_t responseEndpoint = {};
412 CAResponseInfo_t responseInfo = {};
413 CAHeaderOption_t* optionsPointer = NULL;
417 OC_LOG(ERROR, TAG, PCF("HandleSingleResponse invalid parameters"));
418 return OC_STACK_INVALID_PARAM;
421 OC_LOG_V(INFO, TAG, "Inside HandleSingleResponse: %s", ehResponse->payload);
423 OCServerRequest *serverRequest = (OCServerRequest *)ehResponse->requestHandle;
426 responseEndpoint.resourceUri = (CAURI_t) serverRequest->resourceUrl;
427 responseEndpoint.addressInfo = serverRequest->addressInfo;
428 responseEndpoint.connectivityType = serverRequest->connectivityType;
429 responseEndpoint.isSecured = serverRequest->secured;
431 switch (ehResponse->ehResult)
434 responseInfo.result = CA_SUCCESS;
437 responseInfo.result = CA_BAD_REQ;
439 case OC_EH_RESOURCE_CREATED:
440 responseInfo.result = CA_CREATED;
442 case OC_EH_RESOURCE_DELETED:
443 responseInfo.result = CA_DELETED;
446 responseInfo.result = CA_SUCCESS;
448 case OC_EH_FORBIDDEN:
449 responseInfo.result = CA_BAD_REQ;
452 responseInfo.result = CA_BAD_REQ;
455 responseInfo.info.type = qualityOfServiceToMessageType(serverRequest->qos);
456 char token[CA_MAX_TOKEN_LEN] = {};
457 responseInfo.info.token = token;
458 memcpy(responseInfo.info.token, serverRequest->requestToken, serverRequest->tokenLength);
459 responseInfo.info.tokenLength = serverRequest->tokenLength;
461 if(serverRequest->observeResult == OC_STACK_OK)
463 responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
467 responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions;
470 if(responseInfo.info.numOptions > 0)
472 responseInfo.info.options = (CAHeaderOption_t *)
473 OCCalloc(responseInfo.info.numOptions,
474 sizeof(CAHeaderOption_t));
476 if(!responseInfo.info.options)
478 OC_LOG(FATAL, TAG, PCF("options is NULL"));
479 return OC_STACK_NO_MEMORY;
482 optionsPointer = responseInfo.info.options;
484 // TODO: This exposes CoAP specific details. At some point, this should be
485 // re-factored and handled in the CA layer.
486 if(serverRequest->observeResult == OC_STACK_OK)
488 responseInfo.info.options[0].protocolID = CA_COAP_ID;
489 responseInfo.info.options[0].optionID = COAP_OPTION_OBSERVE;
490 responseInfo.info.options[0].optionLength = sizeof(uint32_t);
491 memcpy(responseInfo.info.options[0].optionData,
492 &(serverRequest->observationOption), sizeof(uint32_t));
494 // Point to the next header option before copying vender specific header options
498 if (ehResponse->numSendVendorSpecificHeaderOptions)
500 memcpy(optionsPointer, ehResponse->sendVendorSpecificHeaderOptions,
501 sizeof(OCHeaderOption) *
502 ehResponse->numSendVendorSpecificHeaderOptions);
507 responseInfo.info.options = NULL;
510 char payload[MAX_RESPONSE_LENGTH] = {};
512 // Put the JSON prefix and suffix around the payload
513 strcpy(payload, (const char *)OC_JSON_PREFIX);
514 strncat(payload, (const char *)ehResponse->payload, ehResponse->payloadSize);
515 strcat(payload, (const char *)OC_JSON_SUFFIX);
516 responseInfo.info.payload = (CAPayload_t)payload;
519 //TODO: Add other connectivity types to CAConnTypes[] when enabled
520 CAConnectivityType_t CAConnTypes[] = {CA_ETHERNET, CA_WIFI};
521 const char * connTypes[] = {"ethernet", "wifi"};
522 int size = sizeof(CAConnTypes)/ sizeof(CAConnectivityType_t);
523 CAConnectivityType_t connType = responseEndpoint.connectivityType;
524 CAResult_t caResult = CA_STATUS_FAILED;
525 result = OC_STACK_OK;
527 //Sending response on all n/w interfaces
528 for(int i = 0; i < size; i++ )
530 responseEndpoint.connectivityType = (CAConnectivityType_t)(connType & CAConnTypes[i]);
531 if(responseEndpoint.connectivityType)
533 //The result is set to OC_STACK_OK only if CASendResponse succeeds in sending the
534 //response on all the n/w interfaces else it is set to OC_STACK_ERROR
535 caResult = CASendResponse(&responseEndpoint, &responseInfo);
536 if(caResult != CA_STATUS_OK)
538 OC_LOG_V(ERROR, TAG, "CASendResponse failed on %s", connTypes[i]);
539 result = CAResultToOCResult(caResult);
543 OC_LOG_V(INFO, TAG, "CASendResponse succeeded on %s", connTypes[i]);
548 CAResult_t caResult = CASendResponse(&responseEndpoint, &responseInfo);
549 if(caResult != CA_STATUS_OK)
551 OC_LOG(ERROR, TAG, PCF("CASendResponse failed"));
552 result = CAResultToOCResult(caResult);
556 result = OC_STACK_OK;
560 OCFree(responseInfo.info.options);
562 FindAndDeleteServerRequest(serverRequest);
567 * Handler function for sending a response from multiple resources, such as a collection.
568 * Aggregates responses from multiple resource until all responses are received then sends the
569 * concatenated response
571 * TODO: Need to add a timeout in case a (remote?) resource does not respond
573 * @param ehResponse - pointer to the response from the resource
578 OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
580 OCStackResult stackRet = OC_STACK_ERROR;
581 OCServerRequest * serverRequest = NULL;
582 OCServerResponse * serverResponse = NULL;
583 uint16_t bufferNeeded = 0;
585 if(!ehResponse || !ehResponse->payload)
587 OC_LOG(ERROR, TAG, PCF("HandleAggregateResponse invalid parameters"));
588 return OC_STACK_INVALID_PARAM;
591 OC_LOG_V(INFO, TAG, "Inside HandleAggregateResponse: %s", ehResponse->payload);
593 serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
594 serverResponse = GetServerResponseUsingHandle((OCServerRequest *)ehResponse->requestHandle);
600 OC_LOG(INFO, TAG, PCF("This is the first response fragment"));
601 stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
602 if (OC_STACK_OK != stackRet)
604 OC_LOG(ERROR, TAG, PCF("Error adding server response"));
607 VERIFY_NON_NULL(serverResponse);
608 VERIFY_NON_NULL(serverResponse->payload);
611 // If there is more than 1 response, then we need to allow for a null-termination
612 // in the server response payload buffer AND the JSON response separator
613 bufferNeeded = ehResponse->payloadSize + 1;
614 if (serverRequest->numResponses > 1)
616 bufferNeeded += strlen(OC_JSON_SEPARATOR_STR);
618 if(serverResponse->remainingPayloadSize >= bufferNeeded)
620 OC_LOG(ERROR, TAG, PCF("There is room in response buffer"));
622 strncat((char *)serverResponse->payload,
623 (char *)ehResponse->payload,
624 serverResponse->remainingPayloadSize);
625 OC_LOG_V(INFO, TAG, "Current aggregated response ...%s", serverResponse->payload);
626 serverResponse->remainingPayloadSize -= strlen((char *)ehResponse->payload);
627 (serverRequest->numResponses)--;
628 if(serverRequest->numResponses == 0)
630 OC_LOG(INFO, TAG, PCF("This is the last response fragment"));
631 ehResponse->payload = serverResponse->payload;
632 ehResponse->payloadSize = strlen((char *) serverResponse->payload) + 1;
633 stackRet = HandleSingleResponse(ehResponse);
634 //Delete the request and response
635 FindAndDeleteServerRequest(serverRequest);
636 FindAndDeleteServerResponse(serverResponse);
640 OC_LOG(INFO, TAG, PCF("More response fragments to come"));
641 strncat((char *)serverResponse->payload,
642 OC_JSON_SEPARATOR_STR,
643 serverResponse->remainingPayloadSize);
644 OC_LOG_V(INFO, TAG, "Current aggregated response ...%s", serverResponse->payload);
645 serverResponse->remainingPayloadSize -= strlen(OC_JSON_SEPARATOR_STR);
646 stackRet = OC_STACK_OK;
651 OC_LOG(ERROR, TAG, PCF("No room in response buffer"));
652 //Delete the request and response
653 FindAndDeleteServerRequest(serverRequest);
654 FindAndDeleteServerResponse(serverResponse);
655 stackRet = OC_STACK_NO_MEMORY;