resource/csdk/stack/src/oickeepalive.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 "oickeepalive.h"
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include "oic_malloc.h"
  26 #include "oic_string.h"
  27 #include "oic_time.h"
  28 #include "ocrandom.h"
  29 #include "uarraylist.h"
  30 #include "ocstackinternal.h"
  31 #include "ocpayloadcbor.h"
  32 #include "ocpayload.h"
  33 #include "ocresourcehandler.h"
  34 #include "logger.h"
  35
  36 /**
  37  * Logging tag for module name.
  38  */
  39 #define TAG "OIC_RI_KEEPALIVE"
  40
  41 static const uint64_t USECS_PER_SEC = 1000000;
  42
  43 //-----------------------------------------------------------------------------
  44 // Macros
  45 //-----------------------------------------------------------------------------
  46 #define VERIFY_SUCCESS(op, successCode) { if ((op) != (successCode)) \
  47             {OIC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
  48
  49 #define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OIC_LOG((logLevel), \
  50              TAG, #arg " is NULL"); return (retVal); } }
  51
  52 #define VERIFY_NON_NULL_NR(arg, logLevel) { if (!(arg)) { OIC_LOG((logLevel), \
  53              TAG, #arg " is NULL"); return; } }
  54
  55 #define VERIFY_NON_NULL_V(arg) { if (!arg) {OIC_LOG_V(FATAL, TAG, "%s is NULL", #arg);\
  56     goto exit;} }
  57
  58 /**
  59  * The KeepAlive table entries are removed
  60  * if it can't receive response message within 60 seconds.
  61  */
  62 #define KEEPALIVE_RESPONSE_TIMEOUT_SEC 60
  63
  64 /**
  65  * The Min time interval value. (2 minutes)
  66  * start from 2 minutes and increases in multiples of 2 up to a maximum of 64minutes.
  67  */
  68 #define KEEPALIVE_MIN_INTERVAL 2
  69
  70 /**
  71  * The Max time interval value. (64 minutes)
  72  */
  73 #define KEEPALIVE_MAX_INTERVAL 64
  74
  75 /**
  76  * Default counts of interval value.
  77  */
  78 #define DEFAULT_INTERVAL_COUNT  6
  79
  80 /**
  81  * KeepAlive key to parser Payload Table.
  82  */
  83 static const char INTERVAL[] = "in";
  84
  85 /**
  86  * KeepAlive key to get interval values from Payload Table.
  87  */
  88 static const char INTERVAL_ARRAY[] = "inarray";
  89
  90 /**
  91  * To check if KeepAlive is initialized.
  92  */
  93 static bool g_isKeepAliveInitialized = false;
  94
  95 /**
  96  * Pointer to handle of the newly created KeepAlive resource.
  97  */
  98 static OCResourceHandle g_keepAliveHandle = NULL;
  99
 100 /**
 101  * KeepAlive table which holds connection interval.
 102  */
 103 static u_arraylist_t *g_keepAliveConnectionTable = NULL;
 104
 105 /**
 106  * KeepAlive table entries.
 107  */
 108 typedef struct
 109 {
 110     OCMode mode;                    /**< host Mode of Operation. */
 111     CAEndpoint_t remoteAddr;        /**< destination Address. */
 112     uint32_t interval;              /**< time interval for KeepAlive. in seconds.*/
 113     int32_t currIndex;              /**< current interval value index. */
 114     size_t intervalSize;            /**< total interval counts. */
 115     int64_t *intervalInfo;          /**< interval values for KeepAlive. */
 116     bool sentPingMsg;               /**< if oic client already sent ping message. */
 117     uint64_t timeStamp;             /**< last sent or received ping message. in microseconds. */
 118 } KeepAliveEntry_t;
 119
 120 /**
 121  * Send disconnect message to remove connection.
 122  */
 123 static OCStackResult SendDisconnectMessage(const KeepAliveEntry_t *entry);
 124
 125 /**
 126  * Send ping message to remote endpoint.
 127  */
 128 static OCStackResult SendPingMessage(KeepAliveEntry_t *entry);
 129
 130 /**
 131  * Increase interval value to send next ping message.
 132  */
 133 static void IncreaseInterval(KeepAliveEntry_t *entry);
 134
 135 /**
 136  * Ping Message callback registered with RI for KeepAlive Request.
 137  */
 138 static OCStackApplicationResult PingRequestCallback(void* ctx, OCDoHandle handle,
 139                                              OCClientResponse * clientResponse);
 140
 141 /**
 142  * This function creates KeepAlive resource.
 143  * @return  ::OC_STACK_OK or Appropriate error code.
 144  */
 145 static OCStackResult CreateKeepAliveResource();
 146
 147 /**
 148  * This function deletes KeepAlive resource.
 149  * @return  ::OC_STACK_OK or Appropriate error code.
 150  */
 151 static OCStackResult DeleteKeepAliveResource();
 152
 153 /**
 154  * API to handle the GET request received for a KeepAlive resource.
 155  * @param[in]   endPoint        RemoteEndpoint which sent the packet.
 156  * @param[in]   requestInfo     Received coap packet.
 157  * @return  ::OC_STACK_OK or Appropriate error code.
 158  */
 159 static OCStackResult HandleKeepAliveGETRequest(const CAEndpoint_t* endPoint,
 160                                         const CARequestInfo_t* requestInfo);
 161
 162 /**
 163  * API to handle the PUT request received for a KeepAlive resource.
 164  * @param[in]   endPoint        RemoteEndpoint which sent the packet.
 165  * @param[in]   requestInfo     Received coap packet.
 166  * @return  ::OC_STACK_OK or Appropriate error code.
 167  */
 168 static OCStackResult HandleKeepAlivePUTRequest(const CAEndpoint_t* endPoint,
 169                                         const CARequestInfo_t* requestInfo);
 170
 171 /**
 172  * API to handle the Response payload.
 173  * @param[in]   endpoint        RemoteEndpoint which sent the packet.
 174  * @param[in]   responseCode    Received reseponse code.
 175  * @param[in]   respPayload     Response payload.
 176  * @return  ::OC_STACK_OK or Appropriate error code.
 177  */
 178 OCStackResult HandleKeepAliveResponse(const CAEndpoint_t *endPoint,
 179                                       OCStackResult responseCode,
 180                                       const OCRepPayload *respPayload);
 181 /**
 182  * Gets keepalive entry.
 183  * @param[in]   endpoint    Remote Endpoint information (like ipaddress,
 184  *                          port, reference uri and transport type) to
 185  *                          which the ping message has to be sent.
 186  * @param[out]  index       index of array list.
 187  * @return  KeepAlive entry to send ping message.
 188  */
 189 static KeepAliveEntry_t *GetEntryFromEndpoint(const CAEndpoint_t *endpoint, uint32_t *index);
 190
 191 /**
 192  * Add keepalive entry.
 193  * @param[in]   endpoint    Remote Endpoint information (like ipaddress,
 194  *                          port, reference uri and transport type).
 195  * @param[in]   mode        Whether it is OIC Server or OIC Client.
 196  * @param[in]   intervalArray   Received interval values from cloud server.
 197  * @return  The KeepAlive entry added in KeepAlive Table.
 198  */
 199 KeepAliveEntry_t *AddKeepAliveEntry(const CAEndpoint_t *endpoint, OCMode mode,
 200                                     int64_t *intervalArray);
 201
 202 /**
 203  * Remove keepalive entry.
 204  * @param[in]   endpoint    Remote Endpoint information (like ipaddress,
 205  *                          port, reference uri and transport type).
 206  * @return  The KeepAlive entry removed in KeepAlive Table.
 207  */
 208 static OCStackResult RemoveKeepAliveEntry(const CAEndpoint_t *endpoint);
 209
 210 OCStackResult InitializeKeepAlive(OCMode mode)
 211 {
 212     OIC_LOG(DEBUG, TAG, "InitializeKeepAlive IN");
 213     if (g_isKeepAliveInitialized)
 214     {
 215         OIC_LOG(DEBUG, TAG, "KeepAlive already initialized");
 216         return OC_STACK_OK;
 217     }
 218
 219     if (OC_CLIENT != mode)
 220     {
 221         // Create the KeepAlive Resource[/oic/ping].
 222         OCStackResult result = CreateKeepAliveResource();
 223         if (OC_STACK_OK != result)
 224         {
 225             OIC_LOG_V(ERROR, TAG, "CreateKeepAliveResource failed[%d]", result);
 226             return result;
 227         }
 228     }
 229
 230     if (!g_keepAliveConnectionTable)
 231     {
 232         g_keepAliveConnectionTable = u_arraylist_create();
 233         if (NULL == g_keepAliveConnectionTable)
 234         {
 235             OIC_LOG(ERROR, TAG, "Creating KeepAlive Table failed");
 236             TerminateKeepAlive(mode);
 237             return OC_STACK_ERROR;
 238         }
 239     }
 240
 241     g_isKeepAliveInitialized = true;
 242
 243     OIC_LOG(DEBUG, TAG, "InitializeKeepAlive OUT");
 244     return OC_STACK_OK;
 245 }
 246
 247 OCStackResult TerminateKeepAlive(OCMode mode)
 248 {
 249     OIC_LOG(DEBUG, TAG, "TerminateKeepAlive IN");
 250     if (!g_isKeepAliveInitialized)
 251     {
 252         OIC_LOG(ERROR, TAG, "KeepAlive not initialized");
 253         return OC_STACK_ERROR;
 254     }
 255
 256     if (OC_CLIENT != mode)
 257     {
 258         // Delete the KeepAlive Resource[/oic/ping].
 259         OCStackResult result = DeleteKeepAliveResource();
 260         if (OC_STACK_OK != result)
 261         {
 262             OIC_LOG_V(ERROR, TAG, "DeleteKeepAliveResource failed[%d]", result);
 263             return result;
 264         }
 265     }
 266
 267     if (NULL != g_keepAliveConnectionTable)
 268     {
 269         u_arraylist_destroy(g_keepAliveConnectionTable);
 270         g_keepAliveConnectionTable = NULL;
 271     }
 272
 273     g_isKeepAliveInitialized = false;
 274
 275     OIC_LOG(DEBUG, TAG, "TerminateKeepAlive OUT");
 276     return OC_STACK_OK;
 277 }
 278
 279 OCStackResult CreateKeepAliveResource()
 280 {
 281     OIC_LOG(DEBUG, TAG, "InitKeepAliveResource IN");
 282
 283     // Create a KeepAlive resource
 284     OCStackResult result = OCCreateResource(&g_keepAliveHandle,
 285                                             KEEPALIVE_RESOURCE_TYPE_NAME,
 286                                             KEEPALIVE_RESOURCE_INTF_NAME,
 287                                             KEEPALIVE_RESOURCE_URI,
 288                                             NULL,
 289                                             NULL,
 290                                             OC_DISCOVERABLE);
 291
 292     if (OC_STACK_OK != result)
 293     {
 294         OIC_LOG_V(ERROR, TAG, "Create resource for KeepAlive failed[%d]", result);
 295     }
 296
 297     OIC_LOG(DEBUG, TAG, "InitKeepAliveResource OUT");
 298     return result;
 299 }
 300
 301 OCStackResult DeleteKeepAliveResource()
 302 {
 303     OIC_LOG(DEBUG, TAG, "DeleteKeepAliveResource IN");
 304
 305     // Create a KeepAlive resource
 306     OCStackResult result = OCDeleteResource(g_keepAliveHandle);
 307
 308     if (OC_STACK_OK != result)
 309     {
 310         OIC_LOG_V(ERROR, TAG, "Delete resource for KeepAlive failed[%d]", result);
 311     }
 312
 313     OIC_LOG(DEBUG, TAG, "DeleteKeepAliveResource OUT");
 314     return result;
 315 }
 316
 317 OCStackResult HandleKeepAliveRequest(const CAEndpoint_t* endPoint,
 318                                      const CARequestInfo_t* requestInfo)
 319 {
 320     VERIFY_NON_NULL(endPoint, FATAL, OC_STACK_INVALID_PARAM);
 321     VERIFY_NON_NULL(requestInfo, FATAL, OC_STACK_INVALID_PARAM);
 322
 323     OIC_LOG(DEBUG, TAG, "HandleKeepAliveRequest IN");
 324
 325     OCStackResult result = OC_STACK_OK;
 326     if (CA_PUT == requestInfo->method)
 327     {
 328         result = HandleKeepAlivePUTRequest(endPoint, requestInfo);
 329     }
 330     else if (CA_GET == requestInfo->method)
 331     {
 332         result = HandleKeepAliveGETRequest(endPoint, requestInfo);
 333     }
 334
 335     OIC_LOG(DEBUG, TAG, "HandleKeepAliveRequest OUT");
 336     return result;
 337 }
 338
 339 OCStackResult HandleKeepAliveGETRequest(const CAEndpoint_t* endPoint,
 340                                         const CARequestInfo_t* requestInfo)
 341 {
 342     VERIFY_NON_NULL(endPoint, FATAL, OC_STACK_INVALID_PARAM);
 343     VERIFY_NON_NULL(requestInfo, FATAL, OC_STACK_INVALID_PARAM);
 344
 345     OIC_LOG_V(DEBUG, TAG, "Find Ping resource [%s]", requestInfo->info.resourceUri);
 346
 347     CAResponseResult_t result = CA_CONTENT;
 348     OCResource *resourcePtr = FindResourceByUri(requestInfo->info.resourceUri);
 349     if (!resourcePtr)
 350     {
 351         // Resource URL not specified
 352         OIC_LOG_V(DEBUG, TAG, "There is no Ping resource [%s]", requestInfo->info.resourceUri);
 353         result = CA_NOT_FOUND;
 354     }
 355
 356     SendDirectStackResponse(endPoint, requestInfo->info.messageId, result, requestInfo->info.type,
 357                             requestInfo->info.numOptions, requestInfo->info.options,
 358                             requestInfo->info.token, requestInfo->info.tokenLength,
 359                             requestInfo->info.resourceUri);
 360
 361     return OC_STACK_OK;
 362 }
 363
 364 OCStackResult HandleKeepAlivePUTRequest(const CAEndpoint_t* endPoint,
 365                                         const CARequestInfo_t* requestInfo)
 366 {
 367     VERIFY_NON_NULL(endPoint, FATAL, OC_STACK_INVALID_PARAM);
 368     VERIFY_NON_NULL(requestInfo, FATAL, OC_STACK_INVALID_PARAM);
 369
 370     // Get entry from KeepAlive table.
 371     uint32_t index = 0;
 372     KeepAliveEntry_t *entry = GetEntryFromEndpoint(endPoint, &index);
 373     if (!entry)
 374     {
 375         OIC_LOG(ERROR, TAG, "Received the first keepalive message from client");
 376         entry = AddKeepAliveEntry(endPoint, OC_SERVER, NULL);
 377         if (!entry)
 378         {
 379             OIC_LOG(ERROR, TAG, "Failed to add new keepalive entry");
 380             return OC_STACK_ERROR;
 381         }
 382     }
 383
 384     OCPayload *ocPayload = NULL;
 385     OCParsePayload(&ocPayload, PAYLOAD_TYPE_REPRESENTATION,
 386                    requestInfo->info.payload, requestInfo->info.payloadSize);
 387     OCRepPayload *repPayload = (OCRepPayload *)ocPayload;
 388
 389     uint32_t interval = 0;
 390     OCRepPayloadGetPropInt(repPayload, INTERVAL, &interval);
 391     entry->interval = interval;
 392     OIC_LOG_V(DEBUG, TAG, "Received interval is [%d]", entry->interval);
 393     entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
 394
 395     // Send response message.
 396     SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_VALID, requestInfo->info.type,
 397                             requestInfo->info.numOptions, requestInfo->info.options,
 398                             requestInfo->info.token, requestInfo->info.tokenLength,
 399                             requestInfo->info.resourceUri);
 400
 401     return OC_STACK_OK;
 402 }
 403
 404 OCStackResult HandleKeepAliveResponse(const CAEndpoint_t *endPoint,
 405                                       OCStackResult responseCode,
 406                                       const OCRepPayload *respPayload)
 407 {
 408     VERIFY_NON_NULL(endPoint, FATAL, OC_STACK_INVALID_PARAM);
 409
 410     OIC_LOG(DEBUG, TAG, "HandleKeepAliveResponse IN");
 411
 412     // Get entry from KeepAlive table.
 413     uint32_t index = 0;
 414     KeepAliveEntry_t *entry = GetEntryFromEndpoint(endPoint, &index);
 415     if (!entry)
 416     {
 417         // Receive response message about find /oic/ping request.
 418         OIC_LOG(ERROR, TAG, "There is no connection info in KeepAlive table");
 419
 420         if (OC_STACK_NO_RESOURCE == responseCode)
 421         {
 422             OIC_LOG(ERROR, TAG, "Server doesn't have a ping resource");
 423             return OC_STACK_ERROR;
 424         }
 425         else if (OC_STACK_OK == responseCode)
 426         {
 427             int64_t *recvInterval = NULL;
 428             size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
 429             OCRepPayloadGetIntArray(respPayload, INTERVAL_ARRAY, &recvInterval, dimensions);
 430             size_t serverIntervalSize = calcDimTotal(dimensions);
 431
 432             entry = AddKeepAliveEntry(endPoint, OC_CLIENT, recvInterval);
 433             if (!entry)
 434             {
 435                 OIC_LOG(ERROR, TAG, "Failed to add new KeepAlive entry");
 436                 return OC_STACK_ERROR;
 437             }
 438
 439             if (serverIntervalSize)
 440             {
 441                 // update interval size with received size of server.
 442                 entry->intervalSize = serverIntervalSize;
 443             }
 444
 445             // Send first ping message
 446             return SendPingMessage(entry);
 447         }
 448     }
 449
 450     // Set sentPingMsg values with false.
 451     entry->sentPingMsg = false;
 452
 453     OIC_LOG(DEBUG, TAG, "HandleKeepAliveResponse OUT");
 454     return OC_STACK_OK;
 455 }
 456
 457 void ProcessKeepAlive()
 458 {
 459     if (!g_isKeepAliveInitialized)
 460     {
 461         OIC_LOG(ERROR, TAG, "KeepAlive not initialized");
 462         return;
 463     }
 464
 465     uint32_t len = u_arraylist_length(g_keepAliveConnectionTable);
 466
 467     for (uint32_t i = 0; i < len; i++)
 468     {
 469         KeepAliveEntry_t *entry = u_arraylist_get(g_keepAliveConnectionTable, i);
 470         if (NULL == entry)
 471         {
 472             continue;
 473         }
 474
 475         uint64_t currentTime = OICGetCurrentTime(TIME_IN_US);
 476         if (OC_CLIENT == entry->mode)
 477         {
 478             if (entry->sentPingMsg)
 479             {
 480                 /*
 481                  * If an OIC Client does not receive the response within 1 minutes,
 482                  * terminate the connection.
 483                  * In this case the timeStamp means last time sent ping message.
 484                  */
 485                 if ((KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC) <= currentTime - entry->timeStamp)
 486                 {
 487                     OIC_LOG(DEBUG, TAG, "Client does not receive the response within 1 minutes.");
 488
 489                     // Send message to disconnect session.
 490                     SendDisconnectMessage(entry);
 491                 }
 492             }
 493             else
 494             {
 495                 if ((entry->interval * KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC)
 496                         <= currentTime - entry->timeStamp)
 497                 {
 498                     // Increase interval value.
 499                     IncreaseInterval(entry);
 500
 501                     OCStackResult result = SendPingMessage(entry);
 502                     if (OC_STACK_OK != result)
 503                     {
 504                         OIC_LOG(ERROR, TAG, "Failed to send ping request");
 505                         continue;
 506                     }
 507                 }
 508             }
 509         }
 510         else if (OC_SERVER == entry->mode)
 511         {
 512             /*
 513              * If an OIC Server does not receive a PUT request to ping resource
 514              * within the specified interval time, terminate the connection.
 515              * In this case the timeStamp means last time received ping message.
 516              */
 517             if ((entry->interval * KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC)
 518                     <= currentTime - entry->timeStamp)
 519             {
 520                 OIC_LOG(DEBUG, TAG, "Server does not receive a PUT request.");
 521                 SendDisconnectMessage(entry);
 522             }
 523         }
 524     }
 525 }
 526
 527 void IncreaseInterval(KeepAliveEntry_t *entry)
 528 {
 529     VERIFY_NON_NULL_NR(entry, FATAL);
 530
 531     OIC_LOG_V(DEBUG, TAG, "Total interval counts: %d", entry->intervalSize);
 532     if (entry->intervalSize > entry->currIndex + 1)
 533     {
 534         entry->currIndex++;
 535         entry->interval = entry->intervalInfo[entry->currIndex];
 536         OIC_LOG_V(DEBUG, TAG, "increase interval value [%d]", entry->interval);
 537     }
 538 }
 539
 540 OCStackResult SendDisconnectMessage(const KeepAliveEntry_t *entry)
 541 {
 542     VERIFY_NON_NULL(entry, FATAL, OC_STACK_INVALID_PARAM);
 543
 544     /*
 545      * Send empty message to disconnect a connection.
 546      * If CA get the empty message from RI, CA will disconnect a connection.
 547      */
 548     CARequestInfo_t requestInfo = { .method = CA_PUT };
 549     return CASendRequest(&entry->remoteAddr, &requestInfo);
 550 }
 551
 552 OCStackResult SendPingMessage(KeepAliveEntry_t *entry)
 553 {
 554     VERIFY_NON_NULL(entry, FATAL, OC_STACK_INVALID_PARAM);
 555
 556     // Send ping message.
 557     OCCallbackData pingData = { .cb = PingRequestCallback };
 558     OCDevAddr devAddr = { .adapter = OC_ADAPTER_TCP };
 559     CopyEndpointToDevAddr(&(entry->remoteAddr), &devAddr);
 560
 561     OCRepPayload *payload = OCRepPayloadCreate();
 562     if (!payload)
 563     {
 564         OIC_LOG(ERROR, TAG, "Failed to allocate Payload");
 565         return OC_STACK_ERROR;
 566     }
 567     payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
 568     OCRepPayloadSetPropInt(payload, INTERVAL, entry->interval);
 569
 570     OCDoResource(NULL, OC_REST_PUT, KEEPALIVE_RESOURCE_URI, &devAddr,
 571                  (OCPayload *) payload, CT_ADAPTER_TCP, OC_LOW_QOS, &pingData, NULL, 0);
 572
 573     // Update timeStamp with time sent ping message for next ping message.
 574     entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
 575     entry->sentPingMsg = true;
 576
 577     OIC_LOG_V(DEBUG, TAG, "Client sent ping message, interval [%d]", entry->interval);
 578
 579     return OC_STACK_OK;
 580 }
 581
 582 OCStackApplicationResult PingRequestCallback(void* ctx, OCDoHandle handle,
 583                                              OCClientResponse *clientResponse)
 584 {
 585     OIC_LOG(DEBUG, TAG, "PingRequestCallback IN");
 586     (void) ctx;
 587     (void) handle;
 588     if (NULL == clientResponse)
 589     {
 590         OIC_LOG(ERROR, TAG, "clientResponse is NULL");
 591         return OC_STACK_KEEP_TRANSACTION;
 592     }
 593
 594     CAEndpoint_t endpoint = { .adapter = CA_ADAPTER_TCP };
 595     CopyDevAddrToEndpoint(&(clientResponse->devAddr), &endpoint);
 596
 597     HandleKeepAliveResponse(&endpoint, clientResponse->result,
 598                             (OCRepPayload *)clientResponse->payload);
 599
 600     OIC_LOG(DEBUG, TAG, "PingRequestCallback OUT");
 601     return OC_STACK_KEEP_TRANSACTION;
 602 }
 603
 604 KeepAliveEntry_t *GetEntryFromEndpoint(const CAEndpoint_t *endpoint, uint32_t *index)
 605 {
 606     if (!g_keepAliveConnectionTable)
 607     {
 608         OIC_LOG(ERROR, TAG, "KeepAlive Table was not Created.");
 609         return NULL;
 610     }
 611
 612     uint32_t len = u_arraylist_length(g_keepAliveConnectionTable);
 613
 614     for (uint32_t i = 0; i < len; i++)
 615     {
 616         KeepAliveEntry_t *entry = u_arraylist_get(g_keepAliveConnectionTable, i);
 617         if (NULL == entry)
 618         {
 619             continue;
 620         }
 621
 622         if (!strncmp(entry->remoteAddr.addr, endpoint->addr, sizeof(entry->remoteAddr.addr))
 623                 && (entry->remoteAddr.port == endpoint->port))
 624         {
 625             OIC_LOG(DEBUG, TAG, "Connection Info found in KeepAlive table");
 626             *index = i;
 627             return entry;
 628         }
 629     }
 630
 631     return NULL;
 632 }
 633
 634 KeepAliveEntry_t *AddKeepAliveEntry(const CAEndpoint_t *endpoint, OCMode mode,
 635                                     int64_t *intervalInfo)
 636 {
 637     if (!endpoint)
 638     {
 639         OIC_LOG(ERROR, TAG, "endpoint is NULL");
 640         return NULL;
 641     }
 642
 643     if (!g_keepAliveConnectionTable)
 644     {
 645         OIC_LOG(ERROR, TAG, "KeepAlive Table was not Created.");
 646         return NULL;
 647     }
 648
 649     KeepAliveEntry_t *entry = (KeepAliveEntry_t *) OICCalloc(1, sizeof(KeepAliveEntry_t));
 650     if (NULL == entry)
 651     {
 652         OIC_LOG(ERROR, TAG, "Failed to Calloc KeepAlive Entry");
 653         return NULL;
 654     }
 655
 656     entry->mode = mode;
 657     entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
 658     entry->remoteAddr.adapter = endpoint->adapter;
 659     entry->remoteAddr.flags = endpoint->flags;
 660     entry->remoteAddr.interface = endpoint->interface;
 661     entry->remoteAddr.port = endpoint->port;
 662     strncpy(entry->remoteAddr.addr, endpoint->addr, sizeof(entry->remoteAddr.addr));
 663
 664     entry->intervalSize = DEFAULT_INTERVAL_COUNT;
 665     entry->intervalInfo = intervalInfo;
 666     if (!entry->intervalInfo)
 667     {
 668         entry->intervalInfo = (int64_t*) OICMalloc(entry->intervalSize * sizeof(int64_t));
 669         for (size_t i = 0; i < entry->intervalSize; i++)
 670         {
 671             entry->intervalInfo[i] = KEEPALIVE_MIN_INTERVAL << i;
 672         }
 673     }
 674     entry->interval = entry->intervalInfo[0];
 675
 676     bool result = u_arraylist_add(g_keepAliveConnectionTable, (void *)entry);
 677     if (!result)
 678     {
 679         OIC_LOG(ERROR, TAG, "Adding node to head failed");
 680         OICFree(entry->intervalInfo);
 681         OICFree(entry);
 682         return NULL;
 683     }
 684
 685     return entry;
 686 }
 687
 688 OCStackResult RemoveKeepAliveEntry(const CAEndpoint_t *endpoint)
 689 {
 690     VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
 691
 692     uint32_t index = 0;
 693     KeepAliveEntry_t *entry = GetEntryFromEndpoint(endpoint, &index);
 694     if (!entry)
 695     {
 696         OIC_LOG(ERROR, TAG, "There is no entry in keepalive table.");
 697         return OC_STACK_ERROR;
 698     }
 699
 700     KeepAliveEntry_t *removedEntry = u_arraylist_remove(g_keepAliveConnectionTable, index);
 701     if (NULL == removedEntry)
 702     {
 703         OIC_LOG(ERROR, TAG, "Removed Entry is NULL");
 704         return OC_STACK_ERROR;
 705     }
 706
 707     OIC_LOG_V(DEBUG, TAG, "Remove Connection Info from KeepAlive table, "
 708              "remote addr=%s port:%d", removedEntry->remoteAddr.addr,
 709              removedEntry->remoteAddr.port);
 710
 711     OICFree(entry->intervalInfo);
 712     OICFree(removedEntry);
 713
 714     return OC_STACK_OK;
 715 }
 716
 717 void HandleKeepAliveConnCB(const CAEndpoint_t *endpoint)
 718 {
 719     VERIFY_NON_NULL_NR(endpoint, FATAL);
 720
 721     OIC_LOG(DEBUG, TAG, "Received the connected device information from CA");
 722
 723     // Send discover message to find ping resource
 724     OCCallbackData pingData = { .cb = PingRequestCallback };
 725     OCDevAddr devAddr = { .adapter = OC_ADAPTER_TCP };
 726     CopyEndpointToDevAddr(endpoint, &devAddr);
 727
 728     OCDoResource(NULL, OC_REST_DISCOVER, KEEPALIVE_RESOURCE_URI, &devAddr, NULL,
 729                  OC_ADAPTER_TCP, OC_HIGH_QOS, &pingData, NULL, 0);
 730 }
 731
 732 void HandleKeepAliveDisconnCB(const CAEndpoint_t *endpoint)
 733 {
 734     VERIFY_NON_NULL_NR(endpoint, FATAL);
 735
 736     OIC_LOG(DEBUG, TAG, "Received the disconnected device information from CA");
 737
 738     OCStackResult result = RemoveKeepAliveEntry(endpoint);
 739     if(result != OC_STACK_OK)
 740     {
 741         OIC_LOG(ERROR, TAG, "Failed to remove entry");
 742         return;
 743     }
 744 }