resource/csdk/routing/src/routingutility.c

   1 /* ****************************************************************
   2  *
   3  * Copyright 2015 Samsung Electronics 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
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include "routingutility.h"
  24 #include "routingmanager.h"
  25 #include "oic_malloc.h"
  26 #include "include/logger.h"
  27
  28 /**
  29  * Logging tag for module name.
  30  */
  31 #define TAG "OIC_RM_UTIL"
  32
  33 /**
  34  * Tag for printing the logs of forwarding the packet.
  35  */
  36 #define RM_TAG "OIC_RM_RAP"
  37
  38 /**
  39  * Default routing option data length is 1 byte with any of the following values.
  40  * 00 - source and destination address is not present.
  41  * 01 - source and destination address is present with message type as ACK.
  42  * 10 - source and destination address is present with message type as RESET.
  43  * 11 - source and destination address is present with message type as NORMAL.
  44  */
  45 #define DEFAULT_ROUTE_OPTION_LEN 1
  46
  47 /**
  48  * Minimum routing option data length is
  49  * Msg Type(1 bytes) + length of src address(1byte) + length of destination address(1byte) +
  50  * Seq Num(2bytes)
  51  */
  52 #define MIN_ROUTE_OPTION_LEN 5
  53
  54 /**
  55  * Acknowledge message type is denoted as 01000000
  56  */
  57 #define ACK_MESSAGE_TYPE (1 << 6)
  58
  59 /**
  60  * Reset message type is denoted as 10000000
  61  */
  62 #define RST_MESSAGE_TYPE (1 << 7)
  63
  64 /**
  65  * Normal message type is denoted as 11000000
  66  */
  67 #define NORMAL_MESSAGE_TYPE (3 << 6)
  68
  69 /**
  70  * Stack mode.
  71  */
  72 static OCMode g_rmStackMode = OC_CLIENT;
  73
  74 void RMSetStackMode(OCMode mode)
  75 {
  76     g_rmStackMode = mode;
  77 }
  78
  79 // destination and source are <GatewayId><ClientId> here, where ClientId is optional.
  80 OCStackResult RMAddInfo(const char *destination, void *message, bool isRequest,
  81                         bool *doPost)
  82 {
  83     OIC_LOG(DEBUG, TAG, "IN");
  84     RM_NULL_CHECK_WITH_RET(message, TAG, "options");
  85
  86     CAHeaderOption_t **options = NULL;
  87     uint8_t *numOptions = NULL;
  88
  89     if (isRequest)
  90     {
  91         CARequestInfo_t *requestMsg = message;
  92         options = &(requestMsg->info.options);
  93         RM_NULL_CHECK_WITH_RET(options, TAG, "options");
  94         numOptions = &(requestMsg->info.numOptions);
  95         RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
  96     }
  97     else
  98     {
  99         CAResponseInfo_t *respMsg = message;
 100         if ('\0' == destination[0] && (CA_EMPTY == respMsg->result))
 101         {
 102             OIC_LOG(DEBUG, TAG, "Response is for an Endpoint, No need to add the routing Option");
 103             return OC_STACK_OK;
 104         }
 105         options = &(respMsg->info.options);
 106         RM_NULL_CHECK_WITH_RET(options, TAG, "options");
 107         numOptions = &(respMsg->info.numOptions);
 108         RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
 109     }
 110
 111
 112     CAHeaderOption_t *optionPtr = NULL;
 113     int8_t index = -1;
 114
 115     RMGetRouteOptionIndex(*options, *numOptions, &index);
 116
 117     if (-1 < index)
 118     {
 119         OIC_LOG(INFO, TAG, "Route option is present");
 120         optionPtr = *options;
 121     }
 122     else
 123     {
 124         OIC_LOG(INFO, TAG, "Route option is not present");
 125         index = *numOptions;
 126         optionPtr = OICCalloc((*numOptions + 1), sizeof(CAHeaderOption_t));
 127         if (!optionPtr)
 128         {
 129             OIC_LOG(ERROR, TAG, "OICCalloc failed");
 130             return OC_STACK_NO_MEMORY;
 131         }
 132
 133         memcpy(optionPtr, *options, sizeof(CAHeaderOption_t) * (*numOptions));
 134     }
 135
 136     OCStackResult res = OC_STACK_OK;
 137     RMRouteOption_t routeOption = {.destGw = 0};
 138     if (*numOptions != index)
 139     {
 140         OIC_LOG(INFO, TAG, "Route option is already present");
 141         res = RMParseRouteOption(&optionPtr[index], &routeOption);
 142         if (OC_STACK_OK != res)
 143         {
 144             OIC_LOG(ERROR, TAG, "RMParseRouteOption failed");
 145             return OC_STACK_ERROR;
 146         }
 147     }
 148
 149     if (!isRequest)
 150     {
 151         CAResponseInfo_t *respMsg = message;
 152         if (CA_EMPTY == respMsg->result && CA_MSG_ACKNOWLEDGE == respMsg->info.type)
 153         {
 154             OIC_LOG(DEBUG, TAG, "CA_EMPTY WITH ACKNOWLEDGEMENT");
 155             routeOption.msgType = ACK;
 156             if (OC_SERVER == g_rmStackMode)
 157             {
 158                 OIC_LOG(DEBUG, TAG, "This is server mode");
 159                 // Send the Empty message in the response with adding the MSGType in Route option.
 160                 respMsg->info.type = CA_MSG_NONCONFIRM;
 161                 respMsg->result = CA_CONTENT;
 162             }
 163             else
 164             {
 165                 OIC_LOG(DEBUG, TAG, "Send a POST request");
 166                 if (NULL != doPost)
 167                 {
 168                     *doPost = true;
 169                 }
 170             }
 171         }
 172         else if (CA_EMPTY == respMsg->result && CA_MSG_RESET == respMsg->info.type)
 173         {
 174             OIC_LOG(DEBUG, TAG, "CA_EMPTY WITH RESET");
 175             routeOption.msgType = RST;
 176             respMsg->info.type = CA_MSG_NONCONFIRM;
 177             respMsg->result = CA_CONTENT;
 178         }
 179     }
 180
 181     if(destination)
 182     {
 183         memcpy(&(routeOption.destGw), destination, sizeof(routeOption.destGw));
 184         memcpy(&(routeOption.destEp), destination + sizeof(routeOption.destGw),
 185                sizeof(routeOption.destEp));
 186     }
 187
 188 #ifdef ROUTING_GATEWAY
 189     // A gateway is supposed to add its ID as source.
 190     uint32_t gatewayId = RMGetGatewayId();
 191     if (gatewayId)
 192     {
 193         memcpy(&(routeOption.srcGw), &gatewayId, sizeof(routeOption.srcGw));
 194     }
 195
 196     if(!routeOption.destGw)
 197     {
 198         routeOption.mSeqNum = RMGetMcastSeqNumber();
 199     }
 200 #endif
 201
 202     res = RMCreateRouteOption(&routeOption, optionPtr + index);
 203     if (OC_STACK_OK != res)
 204     {
 205         OIC_LOG(ERROR, TAG, "Creation of routing option failed");
 206         OICFree(optionPtr);
 207         return res;
 208     }
 209
 210     if ((*numOptions) == index )
 211     {
 212         (*numOptions) = (*numOptions) + 1;
 213         OICFree(*options);
 214         *options = optionPtr;
 215     }
 216
 217     OIC_LOG(DEBUG, TAG, "OUT");
 218     return OC_STACK_OK;
 219 }
 220
 221 OCStackResult RMUpdateInfo(CAHeaderOption_t **options, uint8_t *numOptions,
 222                            CAEndpoint_t *endpoint)
 223 {
 224     OIC_LOG(DEBUG, TAG, "IN");
 225     RM_NULL_CHECK_WITH_RET(options, TAG, "options");
 226     RM_NULL_CHECK_WITH_RET(*options, TAG, "invalid option");
 227     RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
 228     RM_NULL_CHECK_WITH_RET(endpoint, TAG, "endpoint");
 229
 230     if (0 >= *numOptions)
 231     {
 232         OIC_LOG(ERROR, TAG, "Invalid arguement: numOptions");
 233         return OC_STACK_ERROR;
 234     }
 235
 236     int8_t routeIndex = -1;
 237     RMGetRouteOptionIndex(*options, *numOptions, &routeIndex);
 238
 239     if (-1 >= routeIndex)
 240     {
 241         OIC_LOG(DEBUG, TAG, "Nothing to remove.");
 242         return OC_STACK_OK;
 243     }
 244
 245     // Update Endpoint with source address from RM header option.
 246     if (DEFAULT_ROUTE_OPTION_LEN < (*options + routeIndex)->optionLength )
 247     {
 248         uint8_t dLen = 0;
 249         uint16_t count = sizeof(dLen) + DEFAULT_ROUTE_OPTION_LEN;
 250         memcpy(&dLen, (*options + routeIndex)->optionData + DEFAULT_ROUTE_OPTION_LEN, sizeof(dLen));
 251         count += dLen;
 252         uint8_t sLen = 0;
 253         memcpy(&sLen, (*options + routeIndex)->optionData + count, sizeof(sLen));
 254         count += sizeof(sLen);
 255         if (0 < sLen)
 256         {
 257             memcpy(endpoint->routeData, (*options + routeIndex)->optionData + count,
 258                    GATEWAY_ID_LENGTH);
 259             OIC_LOG_V(DEBUG, TAG, "adding srcgid: %u in endpoint [%d]",
 260                      *((uint32_t *)endpoint->routeData), sLen);
 261
 262             count += GATEWAY_ID_LENGTH;
 263
 264             if (GATEWAY_ID_LENGTH < sLen)
 265             {
 266                 memcpy(endpoint->routeData + GATEWAY_ID_LENGTH,
 267                        (*options + routeIndex)->optionData + count, ENDPOINT_ID_LENGTH);
 268                 OIC_LOG_V(DEBUG, TAG, "adding srceid: %u in endpoint",
 269                          *((uint16_t *)(endpoint->routeData + GATEWAY_ID_LENGTH)));
 270             }
 271         }
 272     }
 273
 274     // Remove route option from header.
 275     for (uint8_t i = routeIndex; i < (*numOptions)-1; i++)
 276     {
 277         memcpy((*options) + i, (*options)+i+1, sizeof(**options));
 278     }
 279     *numOptions = (*numOptions) - 1;
 280
 281     if (0 == *numOptions)
 282     {
 283         // Remove route option.
 284         OICFree(*options);
 285         *options = NULL;
 286     }
 287     OIC_LOG(DEBUG, TAG, "OUT");
 288     return OC_STACK_OK;
 289 }
 290
 291 void RMGetRouteOptionIndex(const CAHeaderOption_t *options, uint8_t numOptions, int8_t *index)
 292 {
 293     OIC_LOG(DEBUG, TAG, "IN");
 294     RM_NULL_CHECK_VOID(options, TAG, "options");
 295     RM_NULL_CHECK_VOID(index, TAG, "index");
 296     for (uint32_t i = 0; i < numOptions; i++)
 297     {
 298         OIC_LOG_V(DEBUG, TAG, "Request- optionID: %u", options[i].optionID);
 299         if (RM_OPTION_MESSAGE_SWITCHING == options[i].optionID)
 300         {
 301             OIC_LOG_V(INFO, TAG, "Found Option at %d", i);
 302             *index = i;
 303             break;
 304         }
 305     }
 306     OIC_LOG(DEBUG, TAG, "OUT");
 307 }
 308
 309 OCStackResult RMCreateRouteOption(const RMRouteOption_t *optValue, CAHeaderOption_t *options)
 310 {
 311     OIC_LOG(DEBUG, RM_TAG, "IN");
 312     RM_NULL_CHECK_WITH_RET(optValue, RM_TAG, "optValue");
 313     RM_NULL_CHECK_WITH_RET(options, RM_TAG, "options");
 314
 315     uint8_t dLen = (optValue->destGw ? GATEWAY_ID_LENGTH:0) +
 316                         (optValue->destEp ? ENDPOINT_ID_LENGTH:0);
 317     uint8_t sLen = (optValue->srcGw ? GATEWAY_ID_LENGTH:0) +
 318                         (optValue->srcEp ? ENDPOINT_ID_LENGTH:0);
 319
 320     OIC_LOG_V(DEBUG, RM_TAG, "createoption dlen %u slen [%u]", dLen, sLen);
 321
 322     unsigned int totalLength = 0;
 323     void *tempData = NULL;
 324     if (0 == dLen && 0 == sLen)
 325     {
 326         OIC_LOG(DEBUG, RM_TAG, "Source and destination is not present");
 327         totalLength = DEFAULT_ROUTE_OPTION_LEN;
 328         tempData = OICCalloc(totalLength, sizeof(char));
 329         if (NULL == tempData)
 330         {
 331             OIC_LOG(ERROR, RM_TAG, "Calloc failed");
 332             return OC_STACK_NO_MEMORY;
 333         }
 334
 335         if (ACK == optValue->msgType)
 336         {
 337             OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
 338             memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 339         }
 340         else if (RST == optValue->msgType)
 341         {
 342             OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
 343             memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 344         }
 345         else
 346         {
 347             OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
 348             memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 349         }
 350     }
 351     else
 352     {
 353         totalLength = MIN_ROUTE_OPTION_LEN + dLen + sLen;
 354         tempData = OICCalloc(totalLength, sizeof(char));
 355         if (NULL == tempData)
 356         {
 357             OIC_LOG(ERROR, RM_TAG, "Calloc failed");
 358             return OC_STACK_NO_MEMORY;
 359         }
 360
 361         if (ACK == optValue->msgType)
 362         {
 363             OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
 364             memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 365         }
 366         else if (RST == optValue->msgType)
 367         {
 368             OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
 369             memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 370         }
 371         else
 372         {
 373             OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
 374             memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 375         }
 376
 377         memcpy(tempData + DEFAULT_ROUTE_OPTION_LEN, &dLen, sizeof(dLen));
 378         unsigned int count = sizeof(dLen) + DEFAULT_ROUTE_OPTION_LEN;
 379         if (0 < dLen)
 380         {
 381             if (optValue->destGw)
 382             {
 383                 memcpy(tempData + count, &(optValue->destGw), GATEWAY_ID_LENGTH);
 384                 count += GATEWAY_ID_LENGTH;
 385             }
 386
 387             if (optValue->destEp)
 388             {
 389                 memcpy(tempData + count, &(optValue->destEp), ENDPOINT_ID_LENGTH);
 390                 count += ENDPOINT_ID_LENGTH;
 391             }
 392         }
 393
 394         memcpy(tempData + count, &sLen, sizeof(sLen));
 395         count += sizeof(sLen);
 396         if (0 < sLen)
 397         {
 398             if (optValue->srcGw)
 399             {
 400                 memcpy(tempData + count, &(optValue->srcGw), GATEWAY_ID_LENGTH);
 401                 count += GATEWAY_ID_LENGTH;
 402             }
 403
 404             if (optValue->srcEp)
 405             {
 406                 memcpy(tempData + count, &(optValue->srcEp), ENDPOINT_ID_LENGTH);
 407                 count += ENDPOINT_ID_LENGTH;
 408             }
 409         }
 410
 411         memcpy(tempData + count, &optValue->mSeqNum, sizeof(optValue->mSeqNum));
 412     }
 413
 414     memcpy(options->optionData, tempData, totalLength);
 415
 416     options->optionID = RM_OPTION_MESSAGE_SWITCHING;
 417     options->optionLength = totalLength;
 418
 419     OIC_LOG_V(INFO, RM_TAG, "Option Length is %d", options->optionLength);
 420
 421     OICFree(tempData);
 422     OIC_LOG(DEBUG, RM_TAG, "OUT");
 423     return OC_STACK_OK;
 424 }
 425
 426 OCStackResult RMParseRouteOption(const CAHeaderOption_t *options, RMRouteOption_t *optValue)
 427 {
 428     OIC_LOG(DEBUG, RM_TAG, "IN");
 429     RM_NULL_CHECK_WITH_RET(options, RM_TAG, "options");
 430     RM_NULL_CHECK_WITH_RET(optValue, RM_TAG, "optValue");
 431     if (0 == options->optionLength)
 432     {
 433         OIC_LOG(ERROR, RM_TAG, "Option data is not present");
 434         return OC_STACK_ERROR;
 435     }
 436
 437     OIC_LOG_V(DEBUG, RM_TAG, "Option Length is %d", options->optionLength);
 438     uint8_t mType = 0;
 439     memcpy(&mType, options->optionData, sizeof(mType));
 440
 441     if (ACK_MESSAGE_TYPE == mType)
 442     {
 443         OIC_LOG(INFO, RM_TAG, "ACK_MESSAGE_TYPE");
 444         optValue->msgType = ACK;
 445     }
 446     else if (RST_MESSAGE_TYPE == mType)
 447     {
 448         OIC_LOG(INFO, RM_TAG, "RST_MESSAGE_TYPE");
 449         optValue->msgType = RST;
 450     }
 451     else if (NORMAL_MESSAGE_TYPE == mType)
 452     {
 453         OIC_LOG(INFO, RM_TAG, "NOR_MESSAGE_TYPE");
 454         optValue->msgType = NOR;
 455     }
 456
 457     if (DEFAULT_ROUTE_OPTION_LEN == options->optionLength)
 458     {
 459         OIC_LOG(INFO, RM_TAG, "No source and destination are present");
 460     }
 461     else
 462     {
 463         uint8_t dLen = 0 ;
 464         uint16_t count = DEFAULT_ROUTE_OPTION_LEN;
 465         memcpy(&dLen, options->optionData + count, sizeof(dLen));
 466         count += sizeof(dLen);
 467         if (0 < dLen)
 468         {
 469             memcpy(&(optValue->destGw), options->optionData + count, GATEWAY_ID_LENGTH);
 470             count += GATEWAY_ID_LENGTH;
 471
 472             if (GATEWAY_ID_LENGTH < dLen)
 473             {
 474                 memcpy(&(optValue->destEp), options->optionData + count, ENDPOINT_ID_LENGTH);
 475                 count += ENDPOINT_ID_LENGTH;
 476             }
 477         }
 478
 479         uint8_t sLen = 0;
 480         memcpy(&sLen, options->optionData + count, sizeof(sLen));
 481         count += sizeof(sLen);
 482         if (0 < sLen)
 483         {
 484             memcpy(&(optValue->srcGw), options->optionData + count, GATEWAY_ID_LENGTH);
 485             count += GATEWAY_ID_LENGTH;
 486
 487             if (GATEWAY_ID_LENGTH < sLen)
 488             {
 489                 memcpy(&(optValue->srcEp), options->optionData + count, ENDPOINT_ID_LENGTH);
 490                 count += ENDPOINT_ID_LENGTH;
 491             }
 492         }
 493         memcpy(&optValue->mSeqNum, options->optionData + count, sizeof(optValue->mSeqNum));
 494     }
 495
 496     OIC_LOG_V(INFO, RM_TAG, "Option hopcount is %d", optValue->mSeqNum);
 497     OIC_LOG_V(INFO, RM_TAG, "Option Sender Addr is [%u][%u]", optValue->srcGw, optValue->srcEp);
 498     OIC_LOG_V(INFO, RM_TAG, "Option Dest Addr is [%u][%u]", optValue->destGw, optValue->destEp);
 499     OIC_LOG_V(INFO, RM_TAG, "Message Type is [%u]", optValue->msgType);
 500     OIC_LOG(DEBUG, RM_TAG, "OUT");
 501     return OC_STACK_OK;
 502 }