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