RM fix for JIRA issue [1342]
[platform/upstream/iotivity.git] / resource / csdk / routing / src / routingmanager.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 "routingmanager.h"
24 #include "routingmanagerinterface.h"
25 #include "routingtablemanager.h"
26 #include "routingmessageparser.h"
27 #include "oic_malloc.h"
28 #include "oic_string.h"
29 #include "ocrandom.h"
30 #include "ulinklist.h"
31 #include "uarraylist.h"
32 #include "ocstackinternal.h"
33 #include "include/logger.h"
34
35 /**
36  * Logging tag for module name.
37  */
38 #define TAG "OIC_RM"
39
40 /**
41  * Tag for printing the logs of forwarding the packet.
42  */
43 #define RM_TAG "OIC_RM_RAP"
44
45
46 /**
47  * Unique gateway ID generated before hosting a gateway resource.
48  */
49 static uint32_t g_GatewayID = 0;
50
51 /**
52  * Used for assigning unique ID.to endpoint's connected to this gateway
53  */
54 static uint16_t g_EndpointCount = 0;
55
56 /**
57  * Routing table which holds hop entries of Gateways with routeCost.
58  */
59 static u_linklist_t *g_routingGatewayTable = NULL;
60
61 /**
62  * List which holds hop entries with Endpoint information.
63  */
64 static u_linklist_t *g_routingEndpointTable = NULL;
65
66 /**
67  * Current time in microseconds.
68  */
69 static uint64_t g_aliveTime = 0;
70
71 /**
72  * Time to refresh the table entries.
73  */
74 static uint64_t g_refreshTableTime = 0;
75
76 /**
77  * Sequence number for the notification.
78  */
79 static uint32_t g_sequenceNumber = 1;
80
81 /**
82  * To check if the routing table is validated on 25th seconds.
83  */
84 static bool g_isValidated = false;
85
86 /**
87  * Multi cast Sequence number.
88  */
89 static uint16_t g_mcastsequenceNumber = 1;
90
91 /**
92  * To check if RM is initialized.
93  */
94 static bool g_isRMInitialized = false;
95
96 /**
97  * API to handle the GET request received for a Gateway Resource.
98  * @param[in]   request     Request Received.
99  * @param[in]   resource    Resource handle used for sending the response.
100  * @return  ::OC_STACK_OK or Appropriate error code.
101  */
102 OCStackResult RMHandleGETRequest(const OCServerRequest *request, const OCResource *resource);
103
104 /**
105  * API to handle the OBSERVE request received for a Gateway Resource.
106  * @param[in,out]   request    Request Received.
107  * @param[in]       resource   Resource handle used for sending the response.
108  * @return  ::OC_STACK_OK or Appropriate error code.
109  */
110 OCStackResult RMHandleOBSERVERequest(OCServerRequest *request, const OCResource *resource);
111
112 /**
113  * API to handle the OBSERVE request received for a Gateway Resource.
114  * @param[in,out]   request    Request Received.
115  * @param[in]       resource   Resource handle used for sending the response.
116  * @return  ::OC_STACK_OK or Appropriate error code.
117  */
118 OCStackResult RMHandleDELETERequest(const OCServerRequest *request, const OCResource *resource);
119
120 /**
121  * Adds a observer after generating observer ID whenever observe
122  * request is received.
123  * @param[in,out]   request     Request handle of the Observe request.
124  *                              Sets the value of observeResult as OC_STACK_OK
125  *                              if observer is added successfully.
126  * @param[out]      obsID       Observer ID generated for the observer.
127  * @return  ::OC_STACK_OK or Appropriate error code.
128  */
129 OCStackResult RMAddObserver(OCServerRequest *request, OCObservationId *obsID);
130
131 /**
132  * Send Notification to all the observers.
133  * @param[in]   payload                 Payload to be sent in notification.
134  * @return  ::OC_STACK_OK or Appropriate error code.
135  */
136 OCStackResult RMSendNotificationToAll(const OCRepPayload *payload);
137
138 /**
139  * Send Delete request to all the neighbour nodes.
140  * @return  NONE.
141  */
142 void RMSendDeleteToNeighbourNodes();
143
144 void RMGenerateGatewayID(uint8_t *id, size_t idLen)
145 {
146     OIC_LOG(DEBUG, TAG, "RMGenerateGatewayID IN");
147     OCFillRandomMem(id, idLen);
148     OIC_LOG(DEBUG, TAG, "RMGenerateGatewayID OUT");
149 }
150 OCStackResult RMInitialize()
151 {
152     OIC_LOG(DEBUG, TAG, "RMInitialize IN");
153     if (g_isRMInitialized)
154     {
155         OIC_LOG(DEBUG, TAG, "RM already initialized");
156         return OC_STACK_OK;
157     }
158
159     // Initialize the GatewayResource[/oic/gateway].
160     OCStackResult result = RMInitGatewayResource();
161     if (OC_STACK_OK != result)
162     {
163         OIC_LOG_V(ERROR, TAG, "RMInitGatewayResource failed[%d]", result);
164         return result;
165     }
166
167     // Generates a 4 byte Gateway ID.
168     RMGenerateGatewayID((uint8_t *)&g_GatewayID, sizeof(g_GatewayID));
169
170     OIC_LOG_V(INFO, RM_TAG, "Gateway ID: %u", g_GatewayID);
171
172     // Initialize the Routing table manager.
173     result = RTMInitialize(&g_routingGatewayTable, &g_routingEndpointTable);
174     if (OC_STACK_OK != result)
175     {
176         OIC_LOG_V(ERROR, TAG, "RTMInitialize failed[%d]", result);
177         return result;
178     }
179
180     g_isRMInitialized = true;
181
182     // Send a DISCOVER request for the gateway resource.
183     result = RMDiscoverGatewayResource();
184     if (OC_STACK_OK != result)
185     {
186         OIC_LOG_V(ERROR, TAG, "RMDiscoverGatewayResource failed[%d]", result);
187         RTMTerminate(&g_routingGatewayTable, &g_routingEndpointTable);
188         return result;
189     }
190
191     // Initialize the timer with the current time.
192     g_aliveTime = RTMGetCurrentTime();
193     g_refreshTableTime = g_aliveTime;
194
195     OIC_LOG(DEBUG, TAG, "RMInitialize OUT");
196     return result;
197 }
198
199 OCStackResult RMTerminate()
200 {
201     OIC_LOG(DEBUG, TAG, "RMTerminate IN");
202     if (!g_isRMInitialized)
203     {
204         OIC_LOG(ERROR, TAG, "RM not initialized");
205         return OC_STACK_ERROR;
206     }
207     // Send DELETE request to neighbour nodes
208     RMSendDeleteToNeighbourNodes();
209
210     OCStackResult result = RTMTerminate(&g_routingGatewayTable, &g_routingEndpointTable);
211     if (OC_STACK_OK != result)
212     {
213         OIC_LOG_V(ERROR, TAG, "CARegisterRoutingMessageHandler failed[%d]", result);
214         return result;
215     }
216     g_isRMInitialized = false;
217     OIC_LOG(DEBUG, TAG, "RMTerminate OUT");
218     return result;
219 }
220
221 OCStackResult RMHandleGatewayRequest(OCServerRequest *request, const OCResource *resource)
222 {
223     OIC_LOG(DEBUG, TAG, "RMHandleGatewayRequest IN");
224
225     if (!g_isRMInitialized)
226     {
227         OIC_LOG(ERROR, TAG, "RM not initialized");
228         return OC_STACK_ERROR;
229     }
230
231     RM_NULL_CHECK_WITH_RET(request, TAG, "request");
232     RM_NULL_CHECK_WITH_RET(resource, TAG, "resource");
233
234     OIC_LOG_V(DEBUG, TAG, "Received request of method: %d", request->method);
235
236     if (OC_REST_GET == request->method)
237     {
238         switch((OCObserveAction)request->observationOption)
239         {
240             case OC_OBSERVE_REGISTER:
241                 OIC_LOG(DEBUG, TAG, "Received OBSERVE request");
242                 RMHandleOBSERVERequest(request, resource);
243                 break;
244             case OC_OBSERVE_DEREGISTER:
245                 //TODO: Handle this case
246                 OIC_LOG(DEBUG, TAG, "Received OBSERVE deregister");
247                 break;
248             case OC_OBSERVE_NO_OPTION:
249                 OIC_LOG(DEBUG, TAG, "Received GET request");
250                 RMHandleGETRequest(request, resource);
251                 break;
252             default:
253                 OIC_LOG(DEBUG, TAG, "Not Supported by Routing Manager");
254         }
255     }
256     else if (OC_REST_DELETE == request->method)
257     {
258         OIC_LOG(DEBUG, TAG, "Received a Delete request");
259         RMHandleDELETERequest(request, resource);
260     }
261     OIC_LOG(DEBUG, TAG, "RMHandleGatewayRequest OUT");
262     return OC_STACK_OK;
263 }
264
265 OCStackResult RMHandleRequestPayload(OCDevAddr devAddr, const uint8_t *reqPayload,
266                                      size_t payloadSize)
267 {
268     OIC_LOG(DEBUG, TAG, "RMHandleRequestPayload IN");
269     RM_NULL_CHECK_WITH_RET(reqPayload, TAG, "reqPayload");
270
271     uint32_t gatewayId = 0;
272
273     OCStackResult result = RMPParseRequestPayload(reqPayload, payloadSize, &gatewayId);
274     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
275     OIC_LOG(INFO, TAG, "RMPParseRequestPayload is success");
276     // Check if the entry is its own.
277     if (gatewayId == g_GatewayID)
278     {
279         OIC_LOG(INFO, TAG, "Own Request Received!!");
280         return OC_STACK_CONTINUE;
281     }
282
283     CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
284     CopyDevAddrToEndpoint(&devAddr, &endpoint);
285
286     OIC_LOG_V(INFO, TAG, "Add the gateway ID: %u", gatewayId);
287     RTMDestIntfInfo_t destInterfaces = {.observerId = 0};
288     destInterfaces.destIntfAddr = endpoint;
289     result = RTMAddGatewayEntry(gatewayId, 0, 1, &destInterfaces, &g_routingGatewayTable);
290
291     if (OC_STACK_OK != result)
292     {
293         OIC_LOG(DEBUG, TAG, "Gateway was not added to the routing table");
294         return result;
295     }
296
297     OIC_LOG(INFO, TAG, "Gateway was added");
298     // Create a list to add the updated entries and notify the observers
299     u_linklist_t *updatedTableList = u_linklist_create();
300     if(!updatedTableList)
301     {
302         OIC_LOG(DEBUG, TAG, "Failure to notify");
303         return OC_STACK_NO_MEMORY;
304     }
305
306     RTMGatewayId_t gwId = {.gatewayId = gatewayId};
307     RTMGatewayEntry_t newNode;
308     newNode.destination = &gwId;
309     newNode.routeCost = 1;
310     u_linklist_add(updatedTableList, (void *)&newNode);
311     RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
312
313     OCRepPayload *updatedPayload = NULL;
314
315     g_sequenceNumber++;
316     result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber,
317                                            updatedTableList, false,
318                                            &updatedPayload);
319     if (OC_STACK_OK != result)
320     {
321         OIC_LOG_V(ERROR, TAG, "RMPConstructObserveResPayload failed[%d]", result);
322         RMPFreePayload(updatedPayload);
323         goto exit;
324     }
325
326     result = RMSendNotificationToAll(updatedPayload);
327     RMPFreePayload(updatedPayload);
328     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
329
330 exit:
331     u_linklist_free(&updatedTableList);
332     OIC_LOG(DEBUG, TAG, "RMHandleRequestPayload OUT");
333     return result;
334 }
335
336 OCStackResult RMHandleResponsePayload(const OCDevAddr *devAddr, const OCRepPayload *respPayload)
337 {
338     OIC_LOG(DEBUG, TAG, "RMHandleResponsePayload IN");
339     RM_NULL_CHECK_WITH_RET(respPayload, TAG, "respPayload");
340
341     // Parse the Payload to get the Gateway ID of neighbouring node.
342     uint32_t gatewayId = 0;
343     uint32_t seqNum = 0;
344     u_linklist_t *gatewayTableList = NULL;
345     bool isUpdateSeqNum = false;
346
347     OCStackResult result = RMPParseResponsePayload(respPayload, &gatewayId, &seqNum,
348                                                    &gatewayTableList,  &isUpdateSeqNum);
349     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
350     // Check if the entry is its own.
351     if (gatewayId == g_GatewayID)
352     {
353         OIC_LOG(INFO, TAG, "-------------->Own entry, continue!!");
354         RTMFreeGatewayRouteTable(&gatewayTableList);
355         return OC_STACK_ERROR;
356     }
357     // Convert OCDevAddr to endpoint address
358     CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_FLAGS};
359     CopyDevAddrToEndpoint(devAddr, &endpoint);
360     RTMDestIntfInfo_t destInterfaces = {.observerId = 0};
361     destInterfaces.destIntfAddr = endpoint;
362     if (0 < seqNum)
363     {
364         OIC_LOG_V(DEBUG, TAG, "Sequence Number of Resp payload is %d, Forceupdate: %d",
365                  seqNum, isUpdateSeqNum);
366         result = RTMUpdateEntryParameters(gatewayId, seqNum, &destInterfaces,
367                                           &g_routingGatewayTable, isUpdateSeqNum);
368         if (OC_STACK_COMM_ERROR == result)
369         {
370             OIC_LOG(ERROR, TAG, "Few packet drops are found, sequence number is not matching");
371             // Send a observe request to the gateway.
372             RMSendObserveRequest(devAddr, NULL);
373             RTMFreeGatewayRouteTable(&gatewayTableList);
374             return result;
375         }
376         else if (OC_STACK_DUPLICATE_REQUEST == result)
377         {
378             OIC_LOG(ERROR, TAG, "Same sequence number is received");
379             RTMFreeGatewayRouteTable(&gatewayTableList);
380             return result;
381         }
382     }
383
384     // Check if the payload is for Removal
385     bool doRemoveEntry = false;
386
387     if (NULL != gatewayTableList && NULL != gatewayTableList->list)
388     {
389         RTMGatewayEntry_t *headPtr = u_linklist_get_data(gatewayTableList->list);
390         if (headPtr && 0 == headPtr->routeCost)
391         {
392             OIC_LOG(INFO, TAG, "Remove entry is called");
393             doRemoveEntry = true;
394         }
395     }
396
397     // Create a list to add the updated entries and notify the observers
398     u_linklist_t *updatedTableList = u_linklist_create();
399     if(!updatedTableList)
400     {
401         OIC_LOG(DEBUG, TAG, "Failed to allocate memory");
402         return OC_STACK_NO_MEMORY;
403     }
404
405     u_linklist_t *alternativeRouteList = u_linklist_create();
406     if(!alternativeRouteList)
407     {
408         OIC_LOG(DEBUG, TAG, "Failed to allocate memory");
409         return OC_STACK_NO_MEMORY;
410     }
411
412     OCRepPayload *updatedPayload = NULL;
413     if (false == doRemoveEntry)
414     {
415         OIC_LOG_V(INFO, TAG, "Add the gateway ID: %u", gatewayId);
416         result = RTMAddGatewayEntry(gatewayId, 0, 1, &destInterfaces, &g_routingGatewayTable);
417         if (OC_STACK_OK == result)
418         {
419             OIC_LOG(INFO, TAG, "Node was added");
420             RTMGatewayId_t gwId = {.gatewayId = gatewayId};
421             RTMGatewayEntry_t newNode;
422             newNode.destination = &gwId;
423             newNode.routeCost = 1;
424             u_linklist_add(updatedTableList, (void *)&newNode);
425             RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
426
427             if (NULL == gatewayTableList)
428             {
429                 OIC_LOG(INFO, TAG, "Received a Discover Payload");
430                 g_sequenceNumber++;
431                 result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber,
432                                                        updatedTableList, false,
433                                                        &updatedPayload);
434                 RM_VERIFY_SUCCESS(result, OC_STACK_OK);
435                 goto sendNotification;
436             }
437         }
438     }
439
440     // Iterate the Table and get each entry
441     u_linklist_iterator_t *iterTable = NULL;
442     u_linklist_init_iterator(gatewayTableList, &iterTable);
443
444     while (NULL != iterTable)
445     {
446         RTMGatewayEntry_t *entry = u_linklist_get_data(iterTable);
447         // Check if the entry is its own.
448         if (!entry || entry->destination->gatewayId == g_GatewayID)
449         {
450             OIC_LOG(INFO, TAG, "Ignore entry, continue!!");
451             u_linklist_get_next(&iterTable);
452             continue;
453         }
454
455         OIC_LOG_V(INFO, TAG, "Gateway ID: %u", entry->destination->gatewayId);
456         if (true == doRemoveEntry)
457         {
458             // Remove the entry from RTM.
459             RTMGatewayEntry_t *existEntry = NULL;
460             result = RTMRemoveGatewayDestEntry(entry->destination->gatewayId, gatewayId,
461                                                &destInterfaces, &existEntry,
462                                                &g_routingGatewayTable);
463             if (OC_STACK_OK != result && NULL != existEntry)
464             {
465                 u_linklist_add(alternativeRouteList, (void *)existEntry);
466             }
467         }
468         else
469         {
470             // Add the entry to RTM.
471             entry->routeCost = entry->routeCost + 1;
472             result = RTMAddGatewayEntry(entry->destination->gatewayId, gatewayId,
473                                         entry->routeCost, NULL, &g_routingGatewayTable);
474         }
475
476         if (OC_STACK_OK == result)
477         {
478             OIC_LOG(INFO, TAG, "Gateway was added/removed");
479             u_linklist_add(updatedTableList, (void *)entry);
480             RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
481         }
482         u_linklist_get_next(&iterTable);
483     }
484
485     if ( 0 < u_linklist_length(alternativeRouteList))
486     {
487         OIC_LOG(DEBUG, TAG, "Alternative routing found");
488         // Send the notification.
489         OCRepPayload *removeTablePayload = NULL;
490         g_sequenceNumber++;
491         result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber,
492                                                alternativeRouteList, false,
493                                                &removeTablePayload);
494         if (OC_STACK_OK != result)
495         {
496             OIC_LOG_V(ERROR, TAG, "RMPConstructObserveResPayload failed[%d]", result);
497             RMPFreePayload(removeTablePayload);
498             goto exit;
499         }
500         result = RMSendNotificationToAll(removeTablePayload);
501         RMPFreePayload(removeTablePayload);
502         RM_VERIFY_SUCCESS(result, OC_STACK_OK);
503     }
504
505     if ( 0 >= u_linklist_length(updatedTableList))
506     {
507         OIC_LOG_V(DEBUG, TAG, "No updation is needed, Length is %d",
508                  u_linklist_length(updatedTableList));
509         goto exit;
510     }
511
512     g_sequenceNumber++;
513     if (true == doRemoveEntry)
514     {
515         result = RMPConstructRemovalPayload(g_GatewayID, g_sequenceNumber, updatedTableList,
516                                             false, &updatedPayload);
517     }
518     else
519     {
520         result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber,
521                                                updatedTableList, false,
522                                                &updatedPayload);
523     }
524     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
525
526 sendNotification:
527     result = RMSendNotificationToAll(updatedPayload);
528     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
529
530 exit:
531     RMPFreePayload(updatedPayload);
532     RTMFreeGatewayRouteTable(&gatewayTableList);
533     u_linklist_free(&updatedTableList);
534     u_linklist_free(&alternativeRouteList);
535     OIC_LOG(DEBUG, TAG, "RMHandleResponsePayload OUT");
536     return OC_STACK_OK;
537 }
538
539 OCStackResult RMHandleGETRequest(const OCServerRequest *request, const OCResource *resource)
540 {
541     OIC_LOG(DEBUG, TAG, "RMHandleGETRequest IN");
542     RM_NULL_CHECK_WITH_RET(request, TAG, "request");
543     RM_NULL_CHECK_WITH_RET(resource, TAG, "resource");
544
545     OCRepPayload *payload = NULL;
546     OCStackResult result = RMPConstructGatewayPayload(g_GatewayID, &payload);
547     if (OC_STACK_OK != result)
548     {
549         OIC_LOG_V(DEBUG, TAG, "RMPConstructDiscoverPayload failed[%d]", result);
550         return result;
551     }
552
553     // Send a response for GET request
554     result = RMSendResponse(request, resource, payload);
555     if (OC_STACK_OK != result)
556     {
557         OIC_LOG_V(DEBUG, TAG, "Send response failed[%d]", result);
558         RMPFreePayload(payload);
559         return result;
560     }
561
562     RMPFreePayload(payload);
563     // Send a observe request
564     result = RMSendObserveRequest(&(request->devAddr), NULL);
565     if (OC_STACK_OK != result)
566     {
567         OIC_LOG_V(DEBUG, TAG, "Send response failed[%d]", result);
568     }
569     OIC_LOG(DEBUG, TAG, "RMHandleGETRequest OUT");
570     return result;
571 }
572
573 OCStackResult RMHandleOBSERVERequest(OCServerRequest *request, const OCResource *resource)
574 {
575     OIC_LOG(DEBUG, TAG, "RMHandleOBSERVERequest IN");
576     RM_NULL_CHECK_WITH_RET(request, TAG, "request");
577     RM_NULL_CHECK_WITH_RET(resource, TAG, "resource");
578
579     // Parse payload and add the gateway entry.
580     if (0 < request->payloadSize)
581     {
582         RMHandleRequestPayload(request->devAddr, request->payload, request->payloadSize);
583     }
584
585     // Generate and add observer.
586     OCObservationId obsID = 0;
587     OCStackResult result = RMAddObserver(request, &obsID);
588     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
589     OIC_LOG_V(DEBUG, TAG, "Observer ID is %d", obsID);
590
591
592     // Get the Routing table from RTM
593     OCRepPayload *payload = NULL;
594     RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
595     OIC_LOG(DEBUG, TAG, "Construct Routing table payload");
596     result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber,
597                                            g_routingGatewayTable, true,
598                                            &payload);
599     if (OC_STACK_OK != result)
600     {
601         OIC_LOG_V(ERROR, TAG, "RMPConstructObserveResPayload failed[%d]", result);
602         RMPFreePayload(payload);
603         goto exit;
604     }
605
606     result = RMSendResponse(request, resource, payload);
607     RMPFreePayload(payload);
608     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
609 exit:
610     OIC_LOG(DEBUG, TAG, "RMHandleOBSERVERequest OUT");
611     return result;
612 }
613
614 OCStackResult RMHandleDELETERequest(const OCServerRequest *request, const OCResource *resource)
615 {
616     OIC_LOG(DEBUG, TAG, "RMHandleDELETERequest IN");
617     RM_NULL_CHECK_WITH_RET(request, TAG, "request");
618     RM_NULL_CHECK_WITH_RET(resource, TAG, "resource");
619
620     uint32_t gatewayId = 0;
621     OCStackResult result = RMPParseRequestPayload(request->payload, request->payloadSize,
622                                                   &gatewayId);
623     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
624     OIC_LOG(INFO, TAG, "RMPParseRequestPayload is success");
625
626     OIC_LOG_V(INFO, TAG, "Remove the gateway ID: %u", gatewayId);
627
628     u_linklist_t *removedGatewayNodes = NULL;
629     result = RTMRemoveGatewayEntry(gatewayId, &removedGatewayNodes, &g_routingGatewayTable);
630     RM_VERIFY_SUCCESS(result, OC_STACK_OK);
631
632     if (0 < u_linklist_length(removedGatewayNodes))
633     {
634         OCRepPayload *resPayloads = NULL;
635         g_sequenceNumber++;
636         result = RMPConstructRemovalPayload(g_GatewayID, g_sequenceNumber, removedGatewayNodes,
637                                             false, &resPayloads);
638         if (OC_STACK_OK != result)
639         {
640             OIC_LOG_V(ERROR, TAG, "RMPConstructRemovalPayload failed[%d]", result);
641             RMPFreePayload(resPayloads);
642             goto exit;
643         }
644         result = RMSendNotificationToAll(resPayloads);
645         RMPFreePayload(resPayloads);
646         RM_VERIFY_SUCCESS(result, OC_STACK_OK);
647         RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
648     }
649
650 exit:
651     RTMFreeGatewayRouteTable(&removedGatewayNodes);
652     OIC_LOG(DEBUG, TAG, "RMHandleDELETERequest OUT");
653     return result;
654 }
655
656 OCStackResult RMAddObserver(OCServerRequest *request, OCObservationId *obsID)
657 {
658     OIC_LOG(DEBUG, TAG, "RMAddObserverForGateway OUT");
659     RM_NULL_CHECK_WITH_RET(request, TAG, "request");
660     RM_NULL_CHECK_WITH_RET(obsID, TAG, "obsID");
661
662     // Generate the ObserverID
663     CAEndpoint_t endpoint = {.adapter = 0};
664     CopyDevAddrToEndpoint(&(request->devAddr), &endpoint);
665
666     // Check if observer is already added.
667     if (true == RTMIsObserverPresent(endpoint, obsID, g_routingGatewayTable))
668     {
669         OIC_LOG(DEBUG, TAG, "Observer is present");
670         request->observeResult = OC_STACK_OK;
671         return OC_STACK_OK;
672     }
673
674     OCStackResult result = RMAddObserverToStack(request, obsID);
675     request->observeResult = result;
676     if (OC_STACK_OK == result)
677     {
678         OIC_LOG(DEBUG, TAG, "Added observer successfully");
679
680         // Add the observer to the list.
681         result = RTMAddObserver(*obsID, endpoint, &g_routingGatewayTable);
682         if (OC_STACK_OK != result)
683         {
684             OIC_LOG_V(DEBUG, TAG, "RMAddObserver failed[%d]", result);
685         }
686     }
687     OIC_LOG(DEBUG, TAG, "RMAddObserverForGateway OUT");
688     return result;
689 }
690
691 OCStackResult RMSendNotificationToAll(const OCRepPayload *payload)
692 {
693     OIC_LOG(DEBUG, TAG, "RMSendNotificationToAll IN");
694     RM_NULL_CHECK_WITH_RET(payload, TAG, "payload");
695
696     OCObservationId *obsList = NULL;
697     uint8_t obsLen = 0;
698     // Get the complete observer list.
699     RTMGetObserverList(&obsList, &obsLen, g_routingGatewayTable);
700     OCStackResult result = OC_STACK_OK;
701     OIC_LOG_V(DEBUG, TAG, "Number of observers is %d", obsLen);
702     if (0 < obsLen)
703     {
704         // Send notification to the list of observers.
705         OIC_LOG_V(DEBUG, TAG, "Sending notification with Sequence Number: %d", g_sequenceNumber);
706         result = RMSendNotificationForListofObservers(obsList, obsLen, payload);
707         RM_VERIFY_SUCCESS(result, OC_STACK_OK);
708         g_aliveTime = RTMGetCurrentTime();
709     }
710
711 exit:
712     OICFree(obsList);
713     OIC_LOG(DEBUG, TAG, "RMSendNotificationToAll OUT");
714     return result;
715 }
716
717 void RMProcess()
718 {
719     if (!g_isRMInitialized)
720     {
721         return;
722     }
723
724     OCStackResult result = OC_STACK_OK;
725     uint64_t currentTime = RTMGetCurrentTime();
726     if (GATEWAY_ALIVE_TIMEOUT <= currentTime - g_aliveTime)
727     {
728         g_aliveTime = currentTime;
729         // Construct a payload with only the current sequence number.
730         OCRepPayload *payload = NULL;
731         result = RMPConstructObserveResPayload(g_GatewayID, g_sequenceNumber, NULL,
732                                                false, &payload);
733         if (OC_STACK_OK != result)
734         {
735             OIC_LOG_V(ERROR, TAG, "RMPConstructObserveResPayload failed[%d]", result);
736             RMPFreePayload(payload);
737             goto exit;
738         }
739         OIC_LOG(DEBUG, TAG, "Sending the alive notification to all");
740         // Send notification for every 15s to all the neighbours.
741         result = RMSendNotificationToAll(payload);
742         RMPFreePayload(payload);
743         RM_VERIFY_SUCCESS(result, OC_STACK_OK);
744     }
745
746     if (ROUTINGTABLE_VALIDATION_TIMEOUT <= currentTime - g_refreshTableTime)
747     {
748         OIC_LOG(DEBUG, TAG, "Validating the routing table");
749         u_linklist_t *removedEntries = NULL;
750         // Remove the invalid gateway entries.
751         RTMRemoveInvalidGateways(&removedEntries, &g_routingGatewayTable);
752         if (0 < u_linklist_length(removedEntries))
753         {
754             OCRepPayload *resPayloads = NULL;
755             g_sequenceNumber++;
756             result = RMPConstructRemovalPayload(g_GatewayID, g_sequenceNumber, removedEntries,
757                                                 false, &resPayloads);
758             RTMFreeGatewayRouteTable(&removedEntries);
759             if (OC_STACK_OK != result)
760             {
761                 OIC_LOG_V(ERROR, TAG, "RMPConstructRemovalPayload failed[%d]", result);
762                 RMPFreePayload(resPayloads);
763                 goto exit;
764             }
765             result = RMSendNotificationToAll(resPayloads);
766             RMPFreePayload(resPayloads);
767             RM_VERIFY_SUCCESS(result, OC_STACK_OK);
768             RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
769         }
770         g_refreshTableTime = currentTime;
771         g_isValidated = false;
772         u_linklist_free(&removedEntries);
773         goto exit;
774     }
775
776     if (!g_isValidated && ROUTINGTABLE_REFRESH_TIMEOUT <= (currentTime - g_refreshTableTime))
777     {
778         OIC_LOG_V(DEBUG, TAG, "Refreshing the routing table: %llu", currentTime);
779         u_linklist_t* invalidInterfaces = NULL;
780         RTMUpdateDestAddrValidity(&invalidInterfaces, &g_routingGatewayTable);
781         if (0 < u_linklist_length(invalidInterfaces))
782         {
783             u_linklist_iterator_t *iterTable = NULL;
784             u_linklist_init_iterator(invalidInterfaces, &iterTable);
785             while (NULL != iterTable)
786             {
787                 RTMDestIntfInfo_t *entry = (RTMDestIntfInfo_t *) u_linklist_get_data(iterTable);
788                 if(!entry)
789                 {
790                     u_linklist_get_next(&iterTable);
791                     continue;
792                 }
793                 OCDevAddr devAddr = {.adapter = OC_DEFAULT_ADAPTER};
794                 CopyEndpointToDevAddr(&(entry->destIntfAddr), &devAddr);
795                 RMSendObserveRequest(&devAddr, NULL);
796                 u_linklist_get_next(&iterTable);
797             }
798         }
799         g_isValidated = true;
800         RTMPrintTable(g_routingGatewayTable, g_routingEndpointTable);
801         u_linklist_free(&invalidInterfaces);
802     }
803
804 exit:
805     return;
806 }
807
808 OCStackResult RMGetGatewayPayload(OCRepPayload **payload)
809 {
810     OIC_LOG(DEBUG, TAG, "RMGetGatewayPayload IN");
811     OCStackResult result = RMPConstructGatewayPayload(g_GatewayID, payload);
812     OIC_LOG_V(DEBUG, TAG, "RMPConstructDiscoverPayload result is %d", result);
813     OIC_LOG(DEBUG, TAG, "RMGetGatewayPayload OUT");
814     return result;
815 }
816
817 void RMSendDeleteToNeighbourNodes()
818 {
819     OIC_LOG(DEBUG, TAG, "RMSendDeleteToNeighbourNodes IN");
820     u_linklist_t *neighbourNodes = NULL;
821     RTMGetNeighbours(&neighbourNodes, g_routingGatewayTable);
822
823     if (0 >= u_linklist_length(neighbourNodes))
824     {
825         OIC_LOG(DEBUG, TAG, "No neighbour nodes present");
826         return;
827     }
828
829     u_linklist_iterator_t *iterTable = NULL;
830     u_linklist_init_iterator(neighbourNodes, &iterTable);
831     while (NULL != iterTable)
832     {
833
834         OCRepPayload *payload = NULL;
835         // Created payload is freed in the OCDoResource() api.
836         OCStackResult result = RMPConstructGatewayPayload(g_GatewayID, &payload);
837         if (OC_STACK_OK != result)
838         {
839             OIC_LOG_V(DEBUG, TAG, "RMPConstructGatewayPayload failed[%d]", result);
840             RMPFreePayload(payload);
841             u_linklist_free(&neighbourNodes);
842             return;
843         }
844
845         RTMGatewayEntry_t *entry = (RTMGatewayEntry_t *) u_linklist_get_data(iterTable);
846         if (entry)
847         {
848             for (uint32_t i = 0; i < u_arraylist_length(entry->destination->destIntfAddr); i++)
849             {
850                 RTMDestIntfInfo_t *dest = u_arraylist_get(entry->destination->destIntfAddr, i);
851                 if (!dest)
852                 {
853                     OIC_LOG(ERROR, RM_TAG, "Failed to get dest address");
854                     continue;
855                 }
856                 OCDevAddr devAddr = {.adapter = OC_DEFAULT_ADAPTER};
857                 CopyEndpointToDevAddr(&(dest->destIntfAddr), &devAddr);
858                 OIC_LOG_V(DEBUG, TAG, "\nDestination interface addresses: %s[%d], OCDevAddr: %s[%d]",
859                          dest->destIntfAddr.addr, dest->destIntfAddr.port, devAddr.addr, devAddr.port);
860                 RMSendDeleteRequest(&devAddr, payload);
861             }
862         }
863
864         u_linklist_get_next(&iterTable);
865     }
866
867     u_linklist_free(&neighbourNodes);
868     OIC_LOG(DEBUG, TAG, "RMSendDeleteToNeighbourNodes OUT");
869 }
870
871 uint32_t RMGetGatewayId()
872 {
873     if (!g_isRMInitialized)
874     {
875         OIC_LOG(ERROR, TAG, "RM not initialized");
876         return 0;
877     }
878     return g_GatewayID;
879 }
880
881 uint16_t RMGetMcastSeqNumber()
882 {
883     if (!g_isRMInitialized)
884     {
885         OIC_LOG(DEBUG, TAG, "RM not initialized");
886         return 0;
887     }
888     return ++g_mcastsequenceNumber;
889 }
890
891 /*
892  * This function is lifeline of packet forwarding module, hence we are going to do some serious
893  * handling here. Following are the expectations from this function:
894  * 1) If routing option is not available, forward packet to RI only. else:
895  * 2) If source is empty in routing option, packet is from end device, add an end device entry and
896  *    add "GatewayId:ClientId" as source.
897  * 3) If destination is empty in routing option, its multicast packet, increase hopcount and
898  *    multicast on other interfaces. Also remove routing Option and forward to RI. (Before
899  *    forwarding, check last mCastSeqNumber for the source gateway otherwise we might be looping
900  *     the packet.)
901  * 4) If destination is present in routing option, its unicast packet,
902  *    a) If self gatewayId is present in destination and no clientId, remove routing option
903  *       and forward to RI.
904  *    b) If self gatewayId and a clientId is present in destination, forward to end device.
905  * 5) Drop a packet if its hop count reaches NUMBER_OF_GATEWAYS.
906  */
907
908 OCStackResult RMHandlePacket(bool isRequest, void *message, const CAEndpoint_t *sender,
909                              bool *selfDestination, bool *isEmptyMsg)
910 {
911     RM_NULL_CHECK_WITH_RET(message, RM_TAG, "message");
912     RM_NULL_CHECK_WITH_RET(sender, RM_TAG, "sender");
913     RM_NULL_CHECK_WITH_RET(selfDestination, RM_TAG, "selfDestination");
914
915     bool forward = false;
916     bool isEMPTYPacket = false;
917     CAEndpoint_t nextHop = {.adapter = CA_DEFAULT_ADAPTER};
918     CAInfo_t *info = NULL;
919     if (isRequest)
920     {
921         CARequestInfo_t *msg = message;
922         info = &(msg->info);
923         RM_NULL_CHECK_WITH_RET(info, RM_TAG, "info");
924     }
925     else
926     {
927         CAResponseInfo_t *msg = message;
928         info = &(msg->info);
929         RM_NULL_CHECK_WITH_RET(info, RM_TAG, "info");
930     }
931
932     // 1.  If routing option is not available, forward packet to RI only.
933     int8_t routeIndex = -1;
934     RMGetRouteOptionIndex(info->options, info->numOptions, &routeIndex);
935     if (-1 >= routeIndex)
936     {
937         OIC_LOG(ERROR, RM_TAG, "No route option present. Let RI Handle");
938         // Let RI handle this packet.
939         *selfDestination = true;
940         return OC_STACK_OK;
941     }
942
943     // Get existing values in packet route option.
944     RMRouteOption_t routeOption = {.srcGw = 0};
945     OCStackResult res = RMParseRouteOption(&info->options[routeIndex], &routeOption);
946     if (OC_STACK_OK != res)
947     {
948         OIC_LOG_V(ERROR, RM_TAG, "RMParseRouteOption failed");
949         return OC_STACK_ERROR;
950     }
951
952     /*
953      * 2) If source is empty in routing option, packet is from end device, add an end device entry
954      *  and add "GatewayId:ClientId" as source.
955      */
956     if (g_GatewayID == routeOption.srcGw)
957     {
958         OIC_LOG_V(ERROR, RM_TAG, "Packet is of its own");
959         if (0 == routeOption.destGw && g_mcastsequenceNumber < routeOption.mSeqNum)
960         {
961             g_mcastsequenceNumber = routeOption.mSeqNum;
962         }
963
964         return OC_STACK_ERROR;
965     }
966     else if (0 == routeOption.srcGw)
967     {
968         OIC_LOG(INFO, RM_TAG, "Source missing in option");
969         // Packet from end device as Gateway will add source in option.
970         uint16_t endpointId = g_EndpointCount + 1;
971         OCStackResult res = RTMAddEndpointEntry(&endpointId, sender, &g_routingEndpointTable);
972         if (OC_STACK_OK == res)
973         {
974             g_EndpointCount = endpointId;
975             OIC_LOG_V(INFO, RM_TAG, "New endpoint added [%d]:[%s]", g_EndpointCount, sender->addr);
976         }
977         else if (OC_STACK_DUPLICATE_REQUEST == res)
978         {
979             OIC_LOG_V(INFO, RM_TAG, "Endpoint exist [%d]", endpointId);
980         }
981         else
982         {
983             OIC_LOG(ERROR, RM_TAG, "Add Endpoint failed");
984             return OC_STACK_ERROR;
985         }
986
987         // add source option.
988         routeOption.srcGw = g_GatewayID;
989         routeOption.srcEp = endpointId;
990         OIC_LOG_V(INFO, RM_TAG, "Added source: [%u:%u]", g_GatewayID, endpointId);
991     }
992
993     /*
994      * 3) If destination is empty in routing option, its a multicast packet, increase hopcount and
995      *    multicast on other interfaces. Also remove routing Option and forward to RI (taken care by
996      *    caller of this function).
997      */
998     if (0 == routeOption.destGw)
999     {
1000         OIC_LOG(INFO, RM_TAG, "Destination missing in option");
1001         // This is a multicast packet.
1002         if (g_GatewayID == routeOption.srcGw)
1003         {
1004             routeOption.mSeqNum = ++g_mcastsequenceNumber;
1005         }
1006         else
1007         {
1008             OCStackResult update = RTMUpdateMcastSeqNumber(routeOption.srcGw, routeOption.mSeqNum,
1009                                                            &g_routingGatewayTable);
1010             if (OC_STACK_OK != update)
1011             {
1012                 // this shouldnt have been forwarded. ignore.
1013                 OIC_LOG_V(ERROR, RM_TAG, "Multicast Sequence number not proper: %d",
1014                          routeOption.mSeqNum);
1015                 return OC_STACK_ERROR;
1016             }
1017         }
1018
1019         // forward
1020         *selfDestination = true;
1021         forward = true;
1022
1023         // Send multicast on every adapter except the one from which packet was received
1024         // TODO::: support to be added for IP hop.
1025         if (sender->adapter != CA_ADAPTER_IP)
1026         {
1027             nextHop.adapter |= CA_ADAPTER_IP;
1028             nextHop.flags |= CA_IPV4 | CA_IPV6;
1029         }
1030
1031         if(sender->adapter != CA_ADAPTER_GATT_BTLE)
1032         {
1033             nextHop.adapter |= CA_ADAPTER_GATT_BTLE;
1034         }
1035
1036         if(sender->adapter != CA_ADAPTER_RFCOMM_BTEDR)
1037         {
1038             nextHop.adapter |= CA_ADAPTER_RFCOMM_BTEDR;
1039         }
1040
1041         // Only requests are sent as multicast.
1042         if(isRequest)
1043         {
1044             CARequestInfo_t *msg = message;
1045             msg->isMulticast = true;
1046         }
1047         goto  rewriteandexit;
1048     }
1049     else if (g_GatewayID == routeOption.destGw)
1050     {
1051         OIC_LOG(INFO, RM_TAG, "GatewayId found in destination");
1052
1053         // Check the MSGType of RouteOption to find if the packet is EMPTY packet.
1054         if (ACK == routeOption.msgType || RST == routeOption.msgType)
1055         {
1056             isEMPTYPacket = true;
1057         }
1058
1059         /*
1060          * This unicast packet either belongs to us or any of our connected end devices
1061          * check if packet belongs to end device.
1062          */
1063         if (0 != routeOption.destEp)
1064         {
1065             // forward packet to the client.
1066             OIC_LOG_V(INFO, RM_TAG, "Forwarding packet to client id [%u]", routeOption.destEp);
1067             CAEndpoint_t *clientInfo = RTMGetEndpointEntry(routeOption.destEp,
1068                                                            g_routingEndpointTable);
1069             if(!clientInfo)
1070             {
1071                 OIC_LOG(ERROR, RM_TAG, "Failed to get Client info");
1072                 return OC_STACK_ERROR;
1073             }
1074
1075             nextHop = *clientInfo;
1076             forward = true;
1077             *selfDestination = false;
1078             goto rewriteandexit;
1079         }
1080         else
1081         {
1082             // packet is for us.
1083             OIC_LOG(INFO, RM_TAG, "Received packet for self");
1084             forward = false;
1085             *selfDestination = true;
1086             goto rewriteandexit;
1087         }
1088     }
1089     else
1090     {
1091         /*
1092          * This unicast packet belongs to other gateway.
1093          * we only want to print first 4 bytes of packet as readable GatewayId.
1094          */
1095         OIC_LOG_V(INFO, RM_TAG, "Forwarding packet to Gateway: %u", routeOption.destGw);
1096         RTMGatewayId_t *nextHopGw = RTMGetNextHop(routeOption.destGw, g_routingGatewayTable);
1097         if(!nextHopGw)
1098         {
1099             OIC_LOG(ERROR, RM_TAG, "Failed to get next hop");
1100             return OC_STACK_ERROR;
1101         }
1102
1103         // TODO:: check preferences among multiple interface addresses, for now sending on first one
1104         RTMDestIntfInfo_t *address = u_arraylist_get(nextHopGw->destIntfAddr, 0);
1105         if (!address)
1106         {
1107             OIC_LOG(ERROR, RM_TAG, "Failed to get address for next hop");
1108             return OC_STACK_ERROR;
1109         }
1110
1111         nextHop = address->destIntfAddr;
1112         forward = true;
1113         *selfDestination = false;
1114         goto rewriteandexit;
1115     }
1116
1117 rewriteandexit:
1118
1119     if (forward)
1120     {
1121         // Don't forward any packet meant for gateway resource.
1122         if (info->resourceUri && (0 == strcmp(info->resourceUri, OC_RSRVD_GATEWAY_URI)) &&
1123             (ACK != routeOption.msgType))
1124         {
1125             OIC_LOG(ERROR, RM_TAG, "Not forwarding gateway resource packet");
1126         }
1127         else if (sender->flags & CA_SECURE)
1128         {
1129             OIC_LOG(ERROR, RM_TAG, "This is secured request. Not supported by routing manager");
1130             return OC_STACK_ERROR;
1131         }
1132         else if (isEMPTYPacket)
1133         {
1134             OIC_LOG(DEBUG, TAG, "The message to be Forwarded is a EMPTY message");
1135             CAResponseInfo_t responseMessage = {.result = CA_EMPTY};
1136             if (ACK == routeOption.msgType)
1137             {
1138                 responseMessage.info.type = CA_MSG_ACKNOWLEDGE;
1139             }
1140             else
1141             {
1142                 responseMessage.info.type = CA_MSG_RESET;
1143             }
1144
1145             responseMessage.info.messageId = info->messageId;
1146             responseMessage.info.dataType = CA_RESPONSE_DATA;
1147
1148             CAResult_t caRes = CASendResponse(&nextHop, &responseMessage);
1149             if (CA_STATUS_OK != caRes)
1150             {
1151                 OIC_LOG_V(ERROR, RM_TAG, "Failed to forward response to next hop [%d][%s]",
1152                          caRes, nextHop.addr);
1153                 // Since a response is always unicast, return error here.
1154                 return OC_STACK_ERROR;
1155             }
1156         }
1157         else
1158         {
1159             // rewrite any changes in routing option.
1160             res = RMCreateRouteOption(&routeOption, &info->options[routeIndex]);
1161             if (OC_STACK_OK != res)
1162             {
1163                 OIC_LOG_V(ERROR, RM_TAG, "Rewriting RM option failed");
1164                 return res;
1165             }
1166             /*
1167              * When forwarding a packet, do not attempt retransmission as its the responsibility of
1168              * packet originator node.
1169              */
1170             info->skipRetransmission = true;
1171             if(isRequest)
1172             {
1173                 CARequestInfo_t *msg = message;
1174                 msg->info.dataType = CA_REQUEST_DATA;
1175                 CAResult_t caRes = CASendRequest(&nextHop, msg);
1176                 if (CA_STATUS_OK != caRes)
1177                 {
1178                     OIC_LOG_V(ERROR, RM_TAG, "Failed to forward request to next hop [%d][%s]", caRes,
1179                              nextHop.addr);
1180                     if(0 == routeOption.destGw)
1181                     {
1182                         /*
1183                          * No point going forward as unicast packet could not be forwarded
1184                          * not returning error for multicast as we may still let RI process
1185                          * this packet.
1186                          */
1187                         return OC_STACK_ERROR;
1188                     }
1189                 }
1190             }
1191             else
1192             {
1193                 CAResponseInfo_t *msg = message;
1194                 msg->info.dataType = CA_RESPONSE_DATA;
1195                 CAResult_t caRes = CASendResponse(&nextHop, msg);
1196                 if (CA_STATUS_OK != caRes)
1197                 {
1198                     OIC_LOG_V(ERROR, RM_TAG, "Failed to forward response to next hop [%d][%s]",
1199                              caRes, nextHop.addr);
1200                     // Since a response is always unicast, return error here.
1201                     return OC_STACK_ERROR;
1202                 }
1203             }
1204         }
1205     }
1206     else
1207     {
1208         if (isEMPTYPacket)
1209         {
1210             if (isRequest)
1211             {
1212                 OIC_LOG(DEBUG, TAG, "POST message with type ACK in Route Option");
1213                 if (NULL != isEmptyMsg)
1214                 {
1215                     *isEmptyMsg = true;
1216                 }
1217             }
1218             else
1219             {
1220                 OIC_LOG(DEBUG, TAG, "Response for EMPTY message is received");
1221                 CAResponseInfo_t *msg = message;
1222                 if (ACK == (MSGType)routeOption.msgType)
1223                 {
1224                     msg->info.type = CA_MSG_ACKNOWLEDGE;
1225                 }
1226                 else
1227                 {
1228                     msg->info.type = CA_MSG_RESET;
1229                 }
1230                 msg->result = CA_EMPTY;
1231                 OICFree(msg->info.token);
1232                 msg->info.token = NULL;
1233                 msg->info.tokenLength = 0;
1234             }
1235         }
1236     }
1237
1238     OIC_LOG_V(INFO, RM_TAG, "Sender: [%u] Destination: [%u]", routeOption.srcGw, routeOption.destGw);
1239     return OC_STACK_OK;
1240 }
1241
1242 OCStackResult RMHandleRequest(CARequestInfo_t *message, const CAEndpoint_t *sender,
1243                               bool *selfDestination, bool *isEmptyMsg)
1244 {
1245     if (!g_isRMInitialized)
1246     {
1247         OIC_LOG(ERROR, TAG, "RM not initialized");
1248         *selfDestination = true;
1249         return OC_STACK_OK;
1250     }
1251     OCStackResult res = RMHandlePacket(true, message, sender, selfDestination, isEmptyMsg);
1252     return res;
1253 }
1254
1255 OCStackResult RMHandleResponse(CAResponseInfo_t *message, const CAEndpoint_t *sender,
1256                                bool *selfDestination)
1257 {
1258     if (!g_isRMInitialized)
1259     {
1260         OIC_LOG(ERROR, TAG, "RM not initialized");
1261         *selfDestination = true;
1262         return OC_STACK_OK;
1263     }
1264     OCStackResult res = RMHandlePacket(false, message, sender, selfDestination, NULL);
1265     return res;
1266 }