1 /* ****************************************************************
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 ******************************************************************/
23 #include "routingutility.h"
24 #include "routingmanager.h"
25 #include "oic_malloc.h"
26 #include "include/logger.h"
29 * Logging tag for module name.
31 #define TAG "OIC_RM_UTIL"
34 * Tag for printing the logs of forwarding the packet.
36 #define RM_TAG "OIC_RM_RAP"
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.
45 #define DEFAULT_ROUTE_OPTION_LEN 1
48 * Minimum routing option data length is
49 * Msg Type(1 bytes) + length of src address(1byte) + length of destination address(1byte) +
52 #define MIN_ROUTE_OPTION_LEN 5
55 * Acknowledge message type is denoted as 01000000
57 #define ACK_MESSAGE_TYPE (1 << 6)
60 * Reset message type is denoted as 10000000
62 #define RST_MESSAGE_TYPE (1 << 7)
65 * Normal message type is denoted as 11000000
67 #define NORMAL_MESSAGE_TYPE (3 << 6)
72 static OCMode g_rmStackMode = OC_CLIENT;
74 void RMSetStackMode(OCMode mode)
79 // destination and source are <GatewayId><ClientId> here, where ClientId is optional.
80 OCStackResult RMAddInfo(const char *destination, void *message, bool isRequest,
83 RM_NULL_CHECK_WITH_RET(message, TAG, "options");
85 CAHeaderOption_t **options = NULL;
86 uint8_t *numOptions = NULL;
90 CARequestInfo_t *requestMsg = message;
91 options = &(requestMsg->info.options);
92 RM_NULL_CHECK_WITH_RET(options, TAG, "options");
93 numOptions = &(requestMsg->info.numOptions);
94 RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
98 CAResponseInfo_t *respMsg = message;
99 if ('\0' == destination[0] && (CA_EMPTY == respMsg->result))
101 OIC_LOG(DEBUG, TAG, "Response is for an Endpoint, No need to add the routing Option");
104 options = &(respMsg->info.options);
105 RM_NULL_CHECK_WITH_RET(options, TAG, "options");
106 numOptions = &(respMsg->info.numOptions);
107 RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
111 CAHeaderOption_t *optionPtr = NULL;
114 RMGetRouteOptionIndex(*options, *numOptions, &index);
118 OIC_LOG(INFO, TAG, "Route option is present");
119 optionPtr = *options;
123 OIC_LOG(INFO, TAG, "Route option is not present");
125 optionPtr = OICCalloc((*numOptions + 1), sizeof(CAHeaderOption_t));
128 OIC_LOG(ERROR, TAG, "OICCalloc failed");
129 return OC_STACK_NO_MEMORY;
132 memcpy(optionPtr, *options, sizeof(CAHeaderOption_t) * (*numOptions));
135 OCStackResult res = OC_STACK_OK;
136 RMRouteOption_t routeOption = {.destGw = 0};
137 if (*numOptions != index)
139 OIC_LOG(INFO, TAG, "Route option is already present");
140 res = RMParseRouteOption(&optionPtr[index], &routeOption);
141 if (OC_STACK_OK != res)
143 OIC_LOG(ERROR, TAG, "RMParseRouteOption failed");
144 return OC_STACK_ERROR;
150 CAResponseInfo_t *respMsg = message;
151 if (CA_EMPTY == respMsg->result && CA_MSG_ACKNOWLEDGE == respMsg->info.type)
153 OIC_LOG(DEBUG, TAG, "CA_EMPTY WITH ACKNOWLEDGEMENT");
154 routeOption.msgType = ACK;
155 if (OC_SERVER == g_rmStackMode)
157 OIC_LOG(DEBUG, TAG, "This is server mode");
158 // Send the Empty message in the response with adding the MSGType in Route option.
159 respMsg->info.type = CA_MSG_NONCONFIRM;
160 respMsg->result = CA_CONTENT;
164 OIC_LOG(DEBUG, TAG, "Send a POST request");
171 else if (CA_EMPTY == respMsg->result && CA_MSG_RESET == respMsg->info.type)
173 OIC_LOG(DEBUG, TAG, "CA_EMPTY WITH RESET");
174 routeOption.msgType = RST;
175 respMsg->info.type = CA_MSG_NONCONFIRM;
176 respMsg->result = CA_CONTENT;
182 memcpy(&(routeOption.destGw), destination, sizeof(routeOption.destGw));
183 memcpy(&(routeOption.destEp), destination + sizeof(routeOption.destGw),
184 sizeof(routeOption.destEp));
187 #ifdef ROUTING_GATEWAY
188 // A gateway is supposed to add its ID as source.
189 uint32_t gatewayId = RMGetGatewayId();
192 memcpy(&(routeOption.srcGw), &gatewayId, sizeof(routeOption.srcGw));
195 if(!routeOption.destGw)
197 routeOption.mSeqNum = RMGetMcastSeqNumber();
201 res = RMCreateRouteOption(&routeOption, optionPtr + index);
202 if (OC_STACK_OK != res)
204 OIC_LOG(ERROR, TAG, "Creation of routing option failed");
209 if ((*numOptions) == index )
211 (*numOptions) = (*numOptions) + 1;
213 *options = optionPtr;
219 OCStackResult RMUpdateInfo(CAHeaderOption_t **options, uint8_t *numOptions,
220 CAEndpoint_t *endpoint)
222 RM_NULL_CHECK_WITH_RET(options, TAG, "options");
223 RM_NULL_CHECK_WITH_RET(*options, TAG, "invalid option");
224 RM_NULL_CHECK_WITH_RET(numOptions, TAG, "numOptions");
225 RM_NULL_CHECK_WITH_RET(endpoint, TAG, "endpoint");
227 if (0 >= *numOptions)
229 OIC_LOG(ERROR, TAG, "Invalid arguement: numOptions");
230 return OC_STACK_ERROR;
233 int8_t routeIndex = -1;
234 RMGetRouteOptionIndex(*options, *numOptions, &routeIndex);
236 if (-1 >= routeIndex)
238 OIC_LOG(DEBUG, TAG, "Nothing to remove.");
242 // Update Endpoint with source address from RM header option.
243 if (DEFAULT_ROUTE_OPTION_LEN < (*options + routeIndex)->optionLength )
246 uint16_t count = sizeof(dLen) + DEFAULT_ROUTE_OPTION_LEN;
247 memcpy(&dLen, (*options + routeIndex)->optionData + DEFAULT_ROUTE_OPTION_LEN, sizeof(dLen));
250 memcpy(&sLen, (*options + routeIndex)->optionData + count, sizeof(sLen));
251 count += sizeof(sLen);
254 memcpy(endpoint->routeData, (*options + routeIndex)->optionData + count,
258 memcpy(&rData1, endpoint->routeData, sizeof(rData1));
259 OIC_LOG_V(DEBUG, TAG, "adding srcgid: %u in endpoint [%d]", rData1, sLen);
261 count += GATEWAY_ID_LENGTH;
263 if (GATEWAY_ID_LENGTH < sLen)
265 memcpy(endpoint->routeData + GATEWAY_ID_LENGTH,
266 (*options + routeIndex)->optionData + count, ENDPOINT_ID_LENGTH);
269 memcpy(&rData2, endpoint->routeData + GATEWAY_ID_LENGTH, sizeof(rData2));
270 OIC_LOG_V(DEBUG, TAG, "adding srceid: %u in endpoint", rData2);
275 // Remove route option from header.
276 for (uint8_t i = routeIndex; i < (*numOptions)-1; i++)
278 memcpy((*options) + i, (*options)+i+1, sizeof(**options));
280 *numOptions = (*numOptions) - 1;
282 if (0 == *numOptions)
284 // Remove route option.
291 void RMGetRouteOptionIndex(const CAHeaderOption_t *options, uint8_t numOptions, int8_t *index)
293 RM_NULL_CHECK_VOID(index, TAG, "index");
297 OIC_LOG(INFO, TAG, "No existing options");
301 for (uint32_t i = 0; i < numOptions; i++)
303 OIC_LOG_V(DEBUG, TAG, "Request- optionID: %u", options[i].optionID);
304 if (RM_OPTION_MESSAGE_SWITCHING == options[i].optionID)
306 OIC_LOG_V(INFO, TAG, "Found Option at %d", i);
313 OCStackResult RMCreateRouteOption(const RMRouteOption_t *optValue, CAHeaderOption_t *options)
315 RM_NULL_CHECK_WITH_RET(optValue, RM_TAG, "optValue");
316 RM_NULL_CHECK_WITH_RET(options, RM_TAG, "options");
318 uint8_t dLen = (optValue->destGw ? GATEWAY_ID_LENGTH:0) +
319 (optValue->destEp ? ENDPOINT_ID_LENGTH:0);
320 uint8_t sLen = (optValue->srcGw ? GATEWAY_ID_LENGTH:0) +
321 (optValue->srcEp ? ENDPOINT_ID_LENGTH:0);
323 OIC_LOG_V(DEBUG, RM_TAG, "createoption dlen %u slen [%u]", dLen, sLen);
325 unsigned int totalLength = 0;
326 uint8_t *tempData = NULL;
328 if (0 == dLen && 0 == sLen)
330 OIC_LOG(DEBUG, RM_TAG, "Source and destination is not present");
331 totalLength = DEFAULT_ROUTE_OPTION_LEN;
332 tempData = OICCalloc(totalLength, sizeof(char));
333 if (NULL == tempData)
335 OIC_LOG(ERROR, RM_TAG, "Calloc failed");
336 return OC_STACK_NO_MEMORY;
339 if (ACK == optValue->msgType)
341 OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
342 memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
344 else if (RST == optValue->msgType)
346 OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
347 memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
351 OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
352 memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
357 totalLength = MIN_ROUTE_OPTION_LEN + dLen + sLen;
358 tempData = OICCalloc(totalLength, sizeof(char));
359 if (NULL == tempData)
361 OIC_LOG(ERROR, RM_TAG, "Calloc failed");
362 return OC_STACK_NO_MEMORY;
365 if (ACK == optValue->msgType)
367 OIC_LOG(DEBUG, RM_TAG, "OptValue ACK Message Type");
368 memset(tempData, ACK_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
370 else if (RST == optValue->msgType)
372 OIC_LOG(DEBUG, RM_TAG, "OptValue RST Message Type");
373 memset(tempData, RST_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
377 OIC_LOG(DEBUG, RM_TAG, "OptValue NOR Message Type");
378 memset(tempData, NORMAL_MESSAGE_TYPE, DEFAULT_ROUTE_OPTION_LEN);
381 memcpy(tempData + DEFAULT_ROUTE_OPTION_LEN, &dLen, sizeof(dLen));
382 unsigned int count = sizeof(dLen) + DEFAULT_ROUTE_OPTION_LEN;
385 if (optValue->destGw)
387 memcpy(tempData + count, &(optValue->destGw), GATEWAY_ID_LENGTH);
388 count += GATEWAY_ID_LENGTH;
391 if (optValue->destEp)
393 memcpy(tempData + count, &(optValue->destEp), ENDPOINT_ID_LENGTH);
394 count += ENDPOINT_ID_LENGTH;
398 memcpy(tempData + count, &sLen, sizeof(sLen));
399 count += sizeof(sLen);
404 memcpy(tempData + count, &(optValue->srcGw), GATEWAY_ID_LENGTH);
405 count += GATEWAY_ID_LENGTH;
410 memcpy(tempData + count, &(optValue->srcEp), ENDPOINT_ID_LENGTH);
411 count += ENDPOINT_ID_LENGTH;
415 memcpy(tempData + count, &optValue->mSeqNum, sizeof(optValue->mSeqNum));
418 memcpy(options->optionData, tempData, totalLength);
420 options->optionID = RM_OPTION_MESSAGE_SWITCHING;
421 options->optionLength = totalLength;
423 OIC_LOG_V(INFO, RM_TAG, "Option Length is %d", options->optionLength);
429 OCStackResult RMParseRouteOption(const CAHeaderOption_t *options, RMRouteOption_t *optValue)
431 RM_NULL_CHECK_WITH_RET(options, RM_TAG, "options");
432 RM_NULL_CHECK_WITH_RET(optValue, RM_TAG, "optValue");
433 if (0 == options->optionLength)
435 OIC_LOG(ERROR, RM_TAG, "Option data is not present");
436 return OC_STACK_ERROR;
439 OIC_LOG_V(DEBUG, RM_TAG, "Option Length is %d", options->optionLength);
441 memcpy(&mType, options->optionData, sizeof(mType));
443 if (ACK_MESSAGE_TYPE == mType)
445 OIC_LOG(INFO, RM_TAG, "ACK_MESSAGE_TYPE");
446 optValue->msgType = ACK;
448 else if (RST_MESSAGE_TYPE == mType)
450 OIC_LOG(INFO, RM_TAG, "RST_MESSAGE_TYPE");
451 optValue->msgType = RST;
453 else if (NORMAL_MESSAGE_TYPE == mType)
455 OIC_LOG(INFO, RM_TAG, "NOR_MESSAGE_TYPE");
456 optValue->msgType = NOR;
459 if (DEFAULT_ROUTE_OPTION_LEN == options->optionLength)
461 OIC_LOG(INFO, RM_TAG, "No source and destination are present");
466 uint16_t count = DEFAULT_ROUTE_OPTION_LEN;
467 memcpy(&dLen, options->optionData + count, sizeof(dLen));
468 count += sizeof(dLen);
471 memcpy(&(optValue->destGw), options->optionData + count, GATEWAY_ID_LENGTH);
472 count += GATEWAY_ID_LENGTH;
474 if (GATEWAY_ID_LENGTH < dLen)
476 memcpy(&(optValue->destEp), options->optionData + count, ENDPOINT_ID_LENGTH);
477 count += ENDPOINT_ID_LENGTH;
482 memcpy(&sLen, options->optionData + count, sizeof(sLen));
483 count += sizeof(sLen);
486 memcpy(&(optValue->srcGw), options->optionData + count, GATEWAY_ID_LENGTH);
487 count += GATEWAY_ID_LENGTH;
489 if (GATEWAY_ID_LENGTH < sLen)
491 memcpy(&(optValue->srcEp), options->optionData + count, ENDPOINT_ID_LENGTH);
492 count += ENDPOINT_ID_LENGTH;
495 memcpy(&optValue->mSeqNum, options->optionData + count, sizeof(optValue->mSeqNum));
498 OIC_LOG_V(INFO, RM_TAG, "Option hopcount is %d", optValue->mSeqNum);
499 OIC_LOG_V(INFO, RM_TAG, "Option Sender Addr is [%u][%u]", optValue->srcGw, optValue->srcEp);
500 OIC_LOG_V(INFO, RM_TAG, "Option Dest Addr is [%u][%u]", optValue->destGw, optValue->destEp);
501 OIC_LOG_V(INFO, RM_TAG, "Message Type is [%u]", optValue->msgType);