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     uint8_t *tempData = NULL;
 324
 325     if (0 == dLen && 0 == sLen)
 326     {
 327         OIC_LOG(DEBUG, RM_TAG, "Source and destination is not present");
 328         totalLength = DEFAULT_ROUTE_OPTION_LEN;
 329         tempData = OICCalloc(totalLength, sizeof(char));
 330         if (NULL == tempData)
 331         {
 332             OIC_LOG(ERROR, RM_TAG, "Calloc failed");
 333             return OC_STACK_NO_MEMORY;
 334         }
 335
 336         if (ACK == optValue->msgType)
 337         {
 338             OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
 339             memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 340         }
 341         else if (RST == optValue->msgType)
 342         {
 343             OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
 344             memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 345         }
 346         else
 347         {
 348             OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
 349             memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 350         }
 351     }
 352     else
 353     {
 354         totalLength = MIN_ROUTE_OPTION_LEN + dLen + sLen;
 355         tempData = OICCalloc(totalLength, sizeof(char));
 356         if (NULL == tempData)
 357         {
 358             OIC_LOG(ERROR, RM_TAG, "Calloc failed");
 359             return OC_STACK_NO_MEMORY;
 360         }
 361
 362         if (ACK == optValue->msgType)
 363         {
 364             OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
 365             memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 366         }
 367         else if (RST == optValue->msgType)
 368         {
 369             OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
 370             memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 371         }
 372         else
 373         {
 374             OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
 375             memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
 376         }
 377
 378         memcpy(tempData + DEFAULT_ROUTE_OPTION_LEN, &dLen, sizeof(dLen));
 379         unsigned int count = sizeof(dLen) + DEFAULT_ROUTE_OPTION_LEN;
 380         if (0 < dLen)
 381         {
 382             if (optValue->destGw)
 383             {
 384                 memcpy(tempData + count, &(optValue->destGw), GATEWAY_ID_LENGTH);
 385                 count += GATEWAY_ID_LENGTH;
 386             }
 387
 388             if (optValue->destEp)
 389             {
 390                 memcpy(tempData + count, &(optValue->destEp), ENDPOINT_ID_LENGTH);
 391                 count += ENDPOINT_ID_LENGTH;
 392             }
 393         }
 394
 395         memcpy(tempData + count, &sLen, sizeof(sLen));
 396         count += sizeof(sLen);
 397         if (0 < sLen)
 398         {
 399             if (optValue->srcGw)
 400             {
 401                 memcpy(tempData + count, &(optValue->srcGw), GATEWAY_ID_LENGTH);
 402                 count += GATEWAY_ID_LENGTH;
 403             }
 404
 405             if (optValue->srcEp)
 406             {
 407                 memcpy(tempData + count, &(optValue->srcEp), ENDPOINT_ID_LENGTH);
 408                 count += ENDPOINT_ID_LENGTH;
 409             }
 410         }
 411
 412         memcpy(tempData + count, &optValue->mSeqNum, sizeof(optValue->mSeqNum));
 413     }
 414
 415     memcpy(options->optionData, tempData, totalLength);
 416
 417     options->optionID = RM_OPTION_MESSAGE_SWITCHING;
 418     options->optionLength = totalLength;
 419
 420     OIC_LOG_V(INFO, RM_TAG, "Option Length is %d", options->optionLength);
 421
 422     OICFree(tempData);
 423     OIC_LOG(DEBUG, RM_TAG, "OUT");
 424     return OC_STACK_OK;
 425 }
 426
 427 OCStackResult RMParseRouteOption(const CAHeaderOption_t *options, RMRouteOption_t *optValue)
 428 {
 429     OIC_LOG(DEBUG, RM_TAG, "IN");
 430     RM_NULL_CHECK_WITH_RET(options, RM_TAG, "options");
 431     RM_NULL_CHECK_WITH_RET(optValue, RM_TAG, "optValue");
 432     if (0 == options->optionLength)
 433     {
 434         OIC_LOG(ERROR, RM_TAG, "Option data is not present");
 435         return OC_STACK_ERROR;
 436     }
 437
 438     OIC_LOG_V(DEBUG, RM_TAG, "Option Length is %d", options->optionLength);
 439     uint8_t mType = 0;
 440     memcpy(&mType, options->optionData, sizeof(mType));
 441
 442     if (ACK_MESSAGE_TYPE == mType)
 443     {
 444         OIC_LOG(INFO, RM_TAG, "ACK_MESSAGE_TYPE");
 445         optValue->msgType = ACK;
 446     }
 447     else if (RST_MESSAGE_TYPE == mType)
 448     {
 449         OIC_LOG(INFO, RM_TAG, "RST_MESSAGE_TYPE");
 450         optValue->msgType = RST;
 451     }
 452     else if (NORMAL_MESSAGE_TYPE == mType)
 453     {
 454         OIC_LOG(INFO, RM_TAG, "NOR_MESSAGE_TYPE");
 455         optValue->msgType = NOR;
 456     }
 457
 458     if (DEFAULT_ROUTE_OPTION_LEN == options->optionLength)
 459     {
 460         OIC_LOG(INFO, RM_TAG, "No source and destination are present");
 461     }
 462     else
 463     {
 464         uint8_t dLen = 0 ;
 465         uint16_t count = DEFAULT_ROUTE_OPTION_LEN;
 466         memcpy(&dLen, options->optionData + count, sizeof(dLen));
 467         count += sizeof(dLen);
 468         if (0 < dLen)
 469         {
 470             memcpy(&(optValue->destGw), options->optionData + count, GATEWAY_ID_LENGTH);
 471             count += GATEWAY_ID_LENGTH;
 472
 473             if (GATEWAY_ID_LENGTH < dLen)
 474             {
 475                 memcpy(&(optValue->destEp), options->optionData + count, ENDPOINT_ID_LENGTH);
 476                 count += ENDPOINT_ID_LENGTH;
 477             }
 478         }
 479
 480         uint8_t sLen = 0;
 481         memcpy(&sLen, options->optionData + count, sizeof(sLen));
 482         count += sizeof(sLen);
 483         if (0 < sLen)
 484         {
 485             memcpy(&(optValue->srcGw), options->optionData + count, GATEWAY_ID_LENGTH);
 486             count += GATEWAY_ID_LENGTH;
 487
 488             if (GATEWAY_ID_LENGTH < sLen)
 489             {
 490                 memcpy(&(optValue->srcEp), options->optionData + count, ENDPOINT_ID_LENGTH);
 491                 count += ENDPOINT_ID_LENGTH;
 492             }
 493         }
 494         memcpy(&optValue->mSeqNum, options->optionData + count, sizeof(optValue->mSeqNum));
 495     }
 496
 497     OIC_LOG_V(INFO, RM_TAG, "Option hopcount is %d", optValue->mSeqNum);
 498     OIC_LOG_V(INFO, RM_TAG, "Option Sender Addr is [%u][%u]", optValue->srcGw, optValue->srcEp);
 499     OIC_LOG_V(INFO, RM_TAG, "Option Dest Addr is [%u][%u]", optValue->destGw, optValue->destEp);
 500     OIC_LOG_V(INFO, RM_TAG, "Message Type is [%u]", optValue->msgType);
 501     OIC_LOG(DEBUG, RM_TAG, "OUT");
 502     return OC_STACK_OK;
 503 }