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