resource/csdk/stack/src/ocserverrequest.c

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   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
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  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.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20 #include <string.h>
  21
  22 #include "ocstack.h"
  23 #include "ocserverrequest.h"
  24 #include "ocresourcehandler.h"
  25 #include "ocmalloc.h"
  26
  27 #include "cacommon.h"
  28 #include "cainterface.h"
  29
  30 #include "utlist.h"
  31 #include "pdu.h"
  32
  33 // Module Name
  34 #define VERIFY_NON_NULL(arg) { if (!arg) {OC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
  35
  36 #define TAG  PCF("ocserverrequest")
  37
  38 static struct OCServerRequest * serverRequestList = NULL;
  39 static struct OCServerResponse * serverResponseList = NULL;
  40
  41 OCServerRequest * GetServerRequestUsingToken (const CAToken_t token)
  42 {
  43     OCServerRequest * out = NULL;
  44     LL_FOREACH (serverRequestList, out)
  45     {
  46         OC_LOG(INFO, TAG,PCF("comparing tokens"));
  47         OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, CA_MAX_TOKEN_LEN);
  48         OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, CA_MAX_TOKEN_LEN);
  49         if(memcmp(out->requestToken, token, CA_MAX_TOKEN_LEN) == 0)
  50         {
  51             return out;
  52         }
  53     }
  54     OC_LOG(INFO, TAG, PCF("Server Request not found!!"));
  55     return NULL;
  56 }
  57
  58 OCServerRequest * GetServerRequestUsingHandle (const OCServerRequest * handle)
  59 {
  60     OCServerRequest * out = NULL;
  61     LL_FOREACH (serverRequestList, out)
  62     {
  63         if(out == handle)
  64         {
  65             return out;
  66         }
  67     }
  68     OC_LOG(INFO, TAG, PCF("Server Request not found!!"));
  69     return NULL;
  70 }
  71
  72 OCServerResponse * GetServerResponseUsingHandle (const OCServerRequest * handle)
  73 {
  74     OCServerResponse * out = NULL;
  75     LL_FOREACH (serverResponseList, out)
  76     {
  77         if(out->requestHandle == handle)
  78         {
  79             return out;
  80         }
  81     }
  82     OC_LOG(INFO, TAG, PCF("Server Response not found!!"));
  83     return NULL;
  84 }
  85
  86 OCStackResult AddServerRequest (OCServerRequest ** request, uint16_t coapID,
  87         uint8_t delayedResNeeded, uint8_t secured, uint8_t notificationFlag, OCMethod method,
  88         uint8_t numRcvdVendorSpecificHeaderOptions, uint32_t observationOption,
  89         OCQualityOfService qos, unsigned char * query,
  90         OCHeaderOption * rcvdVendorSpecificHeaderOptions,
  91         unsigned char * reqJSONPayload, CAToken_t * requestToken,
  92         OCDevAddr * requesterAddr, unsigned char * resourceUrl, size_t reqTotalSize,
  93         CAAddress_t *addressInfo, CAConnectivityType_t connectivityType)
  94 {
  95     OCServerRequest * serverRequest = NULL;
  96
  97     //Note: OCServerRequest includes 1 byte for the JSON Payload.  payloadSize is calculated
  98     //as the required length of the string, so this will result in enough room for the
  99     //null terminator as well.
 100     serverRequest = (OCServerRequest *) OCCalloc(1, sizeof(OCServerRequest) + reqTotalSize - 1);
 101     VERIFY_NON_NULL(serverRequest);
 102
 103     serverRequest->coapID = coapID;
 104     serverRequest->delayedResNeeded = delayedResNeeded;
 105     serverRequest->secured = secured;
 106     serverRequest->notificationFlag = notificationFlag;
 107
 108     serverRequest->method = method;
 109     serverRequest->numRcvdVendorSpecificHeaderOptions = numRcvdVendorSpecificHeaderOptions;
 110     serverRequest->observationOption = observationOption;
 111     serverRequest->observeResult = OC_STACK_ERROR;
 112     serverRequest->qos = qos;
 113     serverRequest->ehResponseHandler = HandleSingleResponse;
 114     serverRequest->numResponses = 1;
 115     if(query)
 116     {
 117         memcpy(serverRequest->query, query, strlen((const char *)query) + 1);
 118     }
 119     if(rcvdVendorSpecificHeaderOptions)
 120     {
 121         memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
 122             MAX_HEADER_OPTIONS * sizeof(OCHeaderOption));
 123     }
 124     if(reqJSONPayload)
 125     {
 126         // destination is at least 1 greater than the source, so a NULL always exists in the
 127         // last character
 128         strncpy((char*)serverRequest->reqJSONPayload,
 129                 (const char*)reqJSONPayload, reqTotalSize - 1);
 130     }
 131     serverRequest->requestComplete = 0;
 132     if(requestToken)
 133     {
 134         serverRequest->requestToken = (CAToken_t)OCMalloc(CA_MAX_TOKEN_LEN+1);
 135         VERIFY_NON_NULL (serverRequest->requestToken);
 136         memset(serverRequest->requestToken, 0, CA_MAX_TOKEN_LEN + 1);
 137         memcpy(serverRequest->requestToken, *requestToken, CA_MAX_TOKEN_LEN);
 138     }
 139     if(requesterAddr)
 140     {
 141         memcpy(&serverRequest->requesterAddr, requesterAddr, sizeof(OCDevAddr));
 142     }
 143     if(resourceUrl)
 144     {
 145         memcpy(serverRequest->resourceUrl, resourceUrl, strlen((const char *)resourceUrl) + 1);
 146     }
 147     if (addressInfo)
 148     {
 149         serverRequest->addressInfo = *addressInfo;
 150     }
 151     serverRequest->connectivityType = connectivityType;
 152
 153     *request = serverRequest;
 154     OC_LOG(INFO, TAG, PCF("Server Request Added!!"));
 155     LL_APPEND (serverRequestList, serverRequest);
 156     return OC_STACK_OK;
 157
 158 exit:
 159     if (serverRequest)
 160     {
 161         OCFree(serverRequest);
 162         serverRequest = NULL;
 163     }
 164     *request = NULL;
 165     return OC_STACK_NO_MEMORY;
 166 }
 167
 168 OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
 169 {
 170     OCServerResponse * serverResponse = NULL;
 171
 172     serverResponse = (OCServerResponse *) OCCalloc(1, sizeof(OCServerResponse));
 173     VERIFY_NON_NULL(serverResponse);
 174
 175     serverResponse->payload = (unsigned char *) OCMalloc(MAX_RESPONSE_LENGTH);
 176     VERIFY_NON_NULL(serverResponse->payload);
 177     memset(serverResponse->payload, 0, MAX_RESPONSE_LENGTH);
 178
 179     serverResponse->remainingPayloadSize = MAX_RESPONSE_LENGTH;
 180     serverResponse->requestHandle = requestHandle;
 181
 182     *response = serverResponse;
 183     OC_LOG(INFO, TAG, PCF("Server Response Added!!"));
 184     LL_APPEND (serverResponseList, serverResponse);
 185     return OC_STACK_OK;
 186
 187 exit:
 188     if (serverResponse)
 189     {
 190         OCFree(serverResponse);
 191         serverResponse = NULL;
 192     }
 193     *response = NULL;
 194     return OC_STACK_NO_MEMORY;
 195 }
 196
 197 // Form the OCEntityHandlerRequest struct
 198 OCStackResult FormOCEntityHandlerRequest(
 199         OCEntityHandlerRequest * entityHandlerRequest,
 200         OCRequestHandle request,
 201         OCMethod method,
 202         OCResourceHandle resource,
 203         unsigned char * queryBuf,
 204         unsigned char * bufReqPayload,
 205         uint8_t numVendorOptions,
 206         OCHeaderOption * vendorOptions,
 207         OCObserveAction observeAction,
 208         OCObservationId observeID)
 209 {
 210     if (entityHandlerRequest)
 211     {
 212         memset(entityHandlerRequest, 0, sizeof(OCEntityHandlerRequest));
 213         entityHandlerRequest->requestHandle = request;
 214         entityHandlerRequest->method = method;
 215         entityHandlerRequest->resource = (OCResourceHandle) resource;
 216         entityHandlerRequest->query = queryBuf;
 217         entityHandlerRequest->reqJSONPayload = bufReqPayload;
 218         entityHandlerRequest->numRcvdVendorSpecificHeaderOptions = numVendorOptions;
 219         entityHandlerRequest->rcvdVendorSpecificHeaderOptions = vendorOptions;
 220
 221         entityHandlerRequest->obsInfo.action = observeAction;
 222         entityHandlerRequest->obsInfo.obsId = observeID;
 223         return OC_STACK_OK;
 224     }
 225
 226     return OC_STACK_INVALID_PARAM;
 227 }
 228
 229 void FindAndDeleteServerResponse(OCServerResponse * serverResponse)
 230 {
 231     OCServerResponse* tmp;
 232     if(serverResponse)
 233     {
 234         LL_FOREACH(serverResponseList, tmp)
 235         {
 236             if (serverResponse == tmp)
 237             {
 238                 DeleteServerResponse(tmp);
 239                 return;
 240             }
 241         }
 242     }
 243 }
 244
 245 void DeleteServerResponse(OCServerResponse * serverResponse)
 246 {
 247     if(serverResponse) {
 248         LL_DELETE(serverResponseList, serverResponse);
 249         OCFree(serverResponse->payload);
 250         OCFree(serverResponse);
 251         OC_LOG(INFO, TAG, PCF("Server Response Removed!!"));
 252     }
 253 }
 254
 255 void FindAndDeleteServerRequest(OCServerRequest * serverRequest)
 256 {
 257     OCServerRequest* tmp;
 258     if(serverRequest)
 259     {
 260         LL_FOREACH(serverRequestList, tmp)
 261         {
 262             if (serverRequest == tmp)
 263             {
 264                 DeleteServerRequest(tmp);
 265                 return;
 266             }
 267         }
 268     }
 269 }
 270
 271 void DeleteServerRequest(OCServerRequest * serverRequest)
 272 {
 273     if(serverRequest) {
 274         LL_DELETE(serverRequestList, serverRequest);
 275         OCFree(serverRequest);
 276         serverRequest = NULL;
 277         OC_LOG(INFO, TAG, PCF("Server Request Removed!!"));
 278     }
 279 }
 280
 281 OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
 282 {
 283     OCStackResult result = OC_STACK_ERROR;
 284     CARemoteEndpoint_t responseEndpoint = {};
 285     CAResponseInfo_t responseInfo = {};
 286     CAHeaderOption_t* optionsPointer;
 287
 288     OC_LOG_V(INFO, TAG, "Inside HandleSingleResponse: %s", ehResponse->payload);
 289
 290     OCServerRequest *serverRequest = (OCServerRequest *)ehResponse->requestHandle;
 291
 292     // Copy the address
 293     responseEndpoint.resourceUri      = (CAURI_t) serverRequest->resourceUrl;
 294     responseEndpoint.addressInfo      = serverRequest->addressInfo;
 295     responseEndpoint.connectivityType = serverRequest->connectivityType;
 296     responseEndpoint.isSecured        = (CABool_t) serverRequest->secured;
 297
 298     // Copy the info
 299     switch (ehResponse->ehResult)
 300     {
 301         case OC_EH_OK:
 302             responseInfo.result = CA_SUCCESS;
 303             break;
 304         case OC_EH_ERROR:
 305             responseInfo.result = CA_BAD_REQ;
 306             break;
 307         case OC_EH_RESOURCE_CREATED:
 308             responseInfo.result = CA_CREATED;
 309             break;
 310         case OC_EH_RESOURCE_DELETED:
 311             responseInfo.result = CA_DELETED;
 312             break;
 313         case OC_EH_SLOW:
 314             responseInfo.result = CA_SUCCESS;
 315             break;
 316         case OC_EH_FORBIDDEN:
 317             responseInfo.result = CA_BAD_REQ;
 318             break;
 319         default:
 320             responseInfo.result = CA_BAD_REQ;
 321             break;
 322     }
 323
 324     switch (serverRequest->qos)
 325     {
 326         case OC_LOW_QOS:
 327             responseInfo.info.type = CA_MSG_NONCONFIRM;
 328             break;
 329         case OC_MEDIUM_QOS:
 330             responseInfo.info.type = CA_MSG_NONCONFIRM;
 331             break;
 332         case OC_HIGH_QOS:
 333             responseInfo.info.type = CA_MSG_CONFIRM;
 334             break;
 335         case OC_NA_QOS:
 336             responseInfo.info.type = CA_MSG_NONCONFIRM;
 337             break;
 338         default:
 339             responseInfo.info.type = CA_MSG_NONCONFIRM;
 340             break;
 341     }
 342
 343     responseInfo.info.token = (CAToken_t)OCMalloc(CA_MAX_TOKEN_LEN+1);
 344     if (!responseInfo.info.token)
 345     {
 346         OC_LOG(FATAL, TAG, "Response Info Token is NULL");
 347         return result;
 348     }
 349     memset(responseInfo.info.token, 0, CA_MAX_TOKEN_LEN + 1);
 350     memcpy(responseInfo.info.token, serverRequest->requestToken, CA_MAX_TOKEN_LEN);
 351
 352     if(serverRequest->observeResult == OC_STACK_OK)
 353     {
 354         responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
 355     }
 356     else
 357     {
 358         responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions;
 359     }
 360
 361     responseInfo.info.options = (CAHeaderOption_t *)
 362                                     malloc(sizeof(CAHeaderOption_t) * responseInfo.info.numOptions);
 363
 364     optionsPointer = responseInfo.info.options;
 365
 366     if(serverRequest->observeResult == OC_STACK_OK)
 367     {
 368         responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
 369     }
 370
 371     // TODO: This exposes CoAP specific details.  At some point, this should be
 372     // re-factored and handled in the CA layer.
 373     if(serverRequest->observeResult == OC_STACK_OK)
 374     {
 375         responseInfo.info.options[0].protocolID = CA_COAP_ID;
 376         responseInfo.info.options[0].optionID = COAP_OPTION_OBSERVE;
 377         responseInfo.info.options[0].optionLength = sizeof(uint32_t);
 378         memcpy(responseInfo.info.options[0].optionData,
 379                 &(serverRequest->observationOption), sizeof(uint32_t));
 380
 381         // Point to the next header option before copying vender specific header options
 382         optionsPointer += 1;
 383     }
 384
 385     if (ehResponse->numSendVendorSpecificHeaderOptions)
 386     {
 387         memcpy(optionsPointer, ehResponse->sendVendorSpecificHeaderOptions,
 388                         sizeof(OCHeaderOption) * ehResponse->numSendVendorSpecificHeaderOptions);
 389     }
 390
 391     // Allocate memory for the payload.
 392     char *payload = (char *)OCCalloc(1, MAX_RESPONSE_LENGTH);
 393     if(!payload)
 394     {
 395         return OC_STACK_NO_MEMORY;
 396     }
 397
 398     // Put the JSON prefix and suffix around the payload
 399     strcpy(payload, (const char *)OC_JSON_PREFIX);
 400     strcat(payload, (const char *)ehResponse->payload);
 401     strcat(payload, (const char *)OC_JSON_SUFFIX);
 402     responseInfo.info.payload = (CAPayload_t)payload;
 403
 404     CAResult_t caResult = CASendResponse(&responseEndpoint, &responseInfo);
 405     if(caResult != CA_STATUS_OK)
 406     {
 407         OC_LOG(ERROR, TAG, PCF("CASendResponse error"));
 408     }
 409     else
 410     {
 411         result = OC_STACK_OK;
 412     }
 413
 414     OCFree(payload);
 415     //Delete the request
 416     FindAndDeleteServerRequest(serverRequest);
 417     return result;
 418 }
 419
 420 OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
 421 {
 422     OCStackResult stackRet = OC_STACK_ERROR;
 423     OCServerRequest * serverRequest = NULL;
 424     OCServerResponse * serverResponse = NULL;
 425     uint16_t bufferNeeded = 0;
 426
 427     OC_LOG_V(INFO, TAG, "Inside HandleAggregateResponse: %s", ehResponse->payload);
 428
 429     serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
 430     serverResponse = GetServerResponseUsingHandle((OCServerRequest *)ehResponse->requestHandle);
 431
 432     if(serverRequest)
 433     {
 434         if(!serverResponse)
 435         {
 436             OC_LOG(INFO, TAG, PCF("This is the first response fragment"));
 437             stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
 438             if (OC_STACK_OK != stackRet)
 439             {
 440                 OC_LOG(ERROR, TAG, PCF("Error adding server response"));
 441                 return stackRet;
 442             }
 443             VERIFY_NON_NULL(serverResponse);
 444             VERIFY_NON_NULL(serverResponse->payload);
 445         }
 446
 447         // If there is more than 1 response, then we need to allow for a null-termination
 448         // in the server response payload buffer AND the JSON response separator
 449         bufferNeeded = ehResponse->payloadSize + 1;
 450         if (serverRequest->numResponses > 1)
 451         {
 452             bufferNeeded += strlen(OC_JSON_SEPARATOR_STR);
 453         }
 454         if(serverResponse->remainingPayloadSize >= bufferNeeded)
 455         {
 456             OC_LOG(INFO, TAG, PCF("There is room in response buffer"));
 457             // append
 458             strncat((char *)serverResponse->payload,
 459                     (char *)ehResponse->payload,
 460                     serverResponse->remainingPayloadSize);
 461             OC_LOG_V(INFO, TAG, "Current aggregated response  ...%s", serverResponse->payload);
 462             serverResponse->remainingPayloadSize -= strlen((char *)ehResponse->payload);
 463             (serverRequest->numResponses)--;
 464             if(serverRequest->numResponses == 0)
 465             {
 466                 OC_LOG(INFO, TAG, PCF("This is the last response fragment"));
 467                 ehResponse->payload = serverResponse->payload;
 468                 ehResponse->payloadSize = strlen((char *) serverResponse->payload) + 1;
 469                 stackRet = HandleSingleResponse(ehResponse);
 470                 //Delete the request and response
 471                 FindAndDeleteServerRequest(serverRequest);
 472                 FindAndDeleteServerResponse(serverResponse);
 473             }
 474             else
 475             {
 476                 OC_LOG(INFO, TAG, PCF("More response fragments to come"));
 477                 strncat((char *)serverResponse->payload,
 478                         OC_JSON_SEPARATOR_STR,
 479                         serverResponse->remainingPayloadSize);
 480                 OC_LOG_V(INFO, TAG, "Current aggregated response  ...%s", serverResponse->payload);
 481                 serverResponse->remainingPayloadSize -= strlen(OC_JSON_SEPARATOR_STR);
 482                 stackRet = OC_STACK_OK;
 483             }
 484         }
 485         else
 486         {
 487             OC_LOG(INFO, TAG, PCF("No room in response buffer"));
 488             //Delete the request and response
 489             FindAndDeleteServerRequest(serverRequest);
 490             FindAndDeleteServerResponse(serverResponse);
 491             stackRet = OC_STACK_NO_MEMORY;
 492         }
 493     }
 494 exit:
 495     return stackRet;
 496 }