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, CA_RESPONSE_DATA);
 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     int64_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     OCPayloadDestroy(ocPayload);
 396
 397     // Send response message.
 398     return SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_CHANGED,
 399                                    requestInfo->info.type, requestInfo->info.numOptions,
 400                                    requestInfo->info.options, requestInfo->info.token,
 401                                    requestInfo->info.tokenLength, requestInfo->info.resourceUri,
 402                                    CA_RESPONSE_DATA);
 403 }
 404
 405 OCStackResult HandleKeepAliveResponse(const CAEndpoint_t *endPoint,
 406                                       OCStackResult responseCode,
 407                                       const OCRepPayload *respPayload)
 408 {
 409     VERIFY_NON_NULL(endPoint, FATAL, OC_STACK_INVALID_PARAM);
 410
 411     OIC_LOG(DEBUG, TAG, "HandleKeepAliveResponse IN");
 412
 413     // Get entry from KeepAlive table.
 414     uint32_t index = 0;
 415     KeepAliveEntry_t *entry = GetEntryFromEndpoint(endPoint, &index);
 416     if (!entry)
 417     {
 418         // Receive response message about find /oic/ping request.
 419         OIC_LOG(ERROR, TAG, "There is no connection info in KeepAlive table");
 420
 421         if (OC_STACK_NO_RESOURCE == responseCode)
 422         {
 423             OIC_LOG(ERROR, TAG, "Server doesn't have a ping resource");
 424             return OC_STACK_ERROR;
 425         }
 426         else if (OC_STACK_OK == responseCode)
 427         {
 428             int64_t *recvInterval = NULL;
 429             size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
 430             OCRepPayloadGetIntArray(respPayload, INTERVAL_ARRAY, &recvInterval, dimensions);
 431             size_t serverIntervalSize = calcDimTotal(dimensions);
 432
 433             entry = AddKeepAliveEntry(endPoint, OC_CLIENT, recvInterval);
 434             if (!entry)
 435             {
 436                 OIC_LOG(ERROR, TAG, "Failed to add new KeepAlive entry");
 437                 return OC_STACK_ERROR;
 438             }
 439
 440             if (serverIntervalSize)
 441             {
 442                 // update interval size with received size of server.
 443                 entry->intervalSize = serverIntervalSize;
 444             }
 445
 446             // Send first ping message
 447             return SendPingMessage(entry);
 448         }
 449     }
 450     else
 451     {
 452         // Set sentPingMsg values with false.
 453         entry->sentPingMsg = false;
 454     }
 455
 456     OIC_LOG(DEBUG, TAG, "HandleKeepAliveResponse OUT");
 457     return OC_STACK_OK;
 458 }
 459
 460 void ProcessKeepAlive()
 461 {
 462     if (!g_isKeepAliveInitialized)
 463     {
 464         OIC_LOG(ERROR, TAG, "KeepAlive not initialized");
 465         return;
 466     }
 467
 468     uint32_t len = u_arraylist_length(g_keepAliveConnectionTable);
 469
 470     for (uint32_t i = 0; i < len; i++)
 471     {
 472         KeepAliveEntry_t *entry = (KeepAliveEntry_t *)u_arraylist_get(g_keepAliveConnectionTable,
 473                                                                       i);
 474         if (NULL == entry)
 475         {
 476             continue;
 477         }
 478
 479         uint64_t currentTime = OICGetCurrentTime(TIME_IN_US);
 480         if (OC_CLIENT == entry->mode)
 481         {
 482             if (entry->sentPingMsg)
 483             {
 484                 /*
 485                  * If an OIC Client does not receive the response within 1 minutes,
 486                  * terminate the connection.
 487                  * In this case the timeStamp means last time sent ping message.
 488                  */
 489                 if ((KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC) <= currentTime - entry->timeStamp)
 490                 {
 491                     OIC_LOG(DEBUG, TAG, "Client does not receive the response within 1 minutes.");
 492
 493                     // Send message to disconnect session.
 494                     SendDisconnectMessage(entry);
 495                 }
 496             }
 497             else
 498             {
 499                 if ((entry->interval * KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC)
 500                         <= currentTime - entry->timeStamp)
 501                 {
 502                     // Increase interval value.
 503                     IncreaseInterval(entry);
 504
 505                     OCStackResult result = SendPingMessage(entry);
 506                     if (OC_STACK_OK != result)
 507                     {
 508                         OIC_LOG(ERROR, TAG, "Failed to send ping request");
 509                         continue;
 510                     }
 511                 }
 512             }
 513         }
 514         else if (OC_SERVER == entry->mode)
 515         {
 516             /*
 517              * If an OIC Server does not receive a PUT request to ping resource
 518              * within the specified interval time, terminate the connection.
 519              * In this case the timeStamp means last time received ping message.
 520              */
 521             if ((entry->interval * KEEPALIVE_RESPONSE_TIMEOUT_SEC * USECS_PER_SEC)
 522                     <= currentTime - entry->timeStamp)
 523             {
 524                 OIC_LOG(DEBUG, TAG, "Server does not receive a PUT request.");
 525                 SendDisconnectMessage(entry);
 526             }
 527         }
 528     }
 529 }
 530
 531 void IncreaseInterval(KeepAliveEntry_t *entry)
 532 {
 533     VERIFY_NON_NULL_NR(entry, FATAL);
 534
 535     OIC_LOG_V(DEBUG, TAG, "Total interval counts: %zu", entry->intervalSize);
 536     if (entry->intervalSize > (size_t)entry->currIndex + 1)
 537     {
 538         entry->currIndex++;
 539         entry->interval = entry->intervalInfo[entry->currIndex];
 540         OIC_LOG_V(DEBUG, TAG, "increase interval value [%d]", entry->interval);
 541     }
 542 }
 543
 544 OCStackResult SendDisconnectMessage(const KeepAliveEntry_t *entry)
 545 {
 546     VERIFY_NON_NULL(entry, FATAL, OC_STACK_INVALID_PARAM);
 547
 548     /*
 549      * Send empty message to disconnect a connection.
 550      * If CA get the empty message from RI, CA will disconnect a connection.
 551      */
 552
 553     OCStackResult result = RemoveKeepAliveEntry(&entry->remoteAddr);
 554     if (result != OC_STACK_OK)
 555     {
 556         return result;
 557     }
 558
 559     CARequestInfo_t requestInfo = { .method = CA_PUT };
 560     result = CASendRequest(&entry->remoteAddr, &requestInfo);
 561     return CAResultToOCResult(result);
 562 }
 563
 564 OCStackResult SendPingMessage(KeepAliveEntry_t *entry)
 565 {
 566     VERIFY_NON_NULL(entry, FATAL, OC_STACK_INVALID_PARAM);
 567
 568     // Send ping message.
 569     OCCallbackData pingData = { .context = NULL, .cb = PingRequestCallback };
 570     OCDevAddr devAddr = { .adapter = OC_ADAPTER_TCP };
 571     CopyEndpointToDevAddr(&(entry->remoteAddr), &devAddr);
 572
 573     OCRepPayload *payload = OCRepPayloadCreate();
 574     if (!payload)
 575     {
 576         OIC_LOG(ERROR, TAG, "Failed to allocate Payload");
 577         return OC_STACK_ERROR;
 578     }
 579     payload->base.type = PAYLOAD_TYPE_REPRESENTATION;
 580     OCRepPayloadSetPropInt(payload, INTERVAL, entry->interval);
 581
 582     OCDoResource(NULL, OC_REST_PUT, KEEPALIVE_RESOURCE_URI, &devAddr,
 583                  (OCPayload *) payload, CT_ADAPTER_TCP, OC_LOW_QOS, &pingData, NULL, 0);
 584
 585     // Update timeStamp with time sent ping message for next ping message.
 586     entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
 587     entry->sentPingMsg = true;
 588
 589     OIC_LOG_V(DEBUG, TAG, "Client sent ping message, interval [%d]", entry->interval);
 590
 591     return OC_STACK_OK;
 592 }
 593
 594 OCStackApplicationResult PingRequestCallback(void* ctx, OCDoHandle handle,
 595                                              OCClientResponse *clientResponse)
 596 {
 597     OIC_LOG(DEBUG, TAG, "PingRequestCallback IN");
 598     (void) ctx;
 599     (void) handle;
 600     if (NULL == clientResponse)
 601     {
 602         OIC_LOG(ERROR, TAG, "clientResponse is NULL");
 603         return OC_STACK_KEEP_TRANSACTION;
 604     }
 605
 606     CAEndpoint_t endpoint = { .adapter = CA_ADAPTER_TCP };
 607     CopyDevAddrToEndpoint(&(clientResponse->devAddr), &endpoint);
 608
 609     HandleKeepAliveResponse(&endpoint, clientResponse->result,
 610                             (OCRepPayload *)clientResponse->payload);
 611
 612     OIC_LOG(DEBUG, TAG, "PingRequestCallback OUT");
 613     return OC_STACK_KEEP_TRANSACTION;
 614 }
 615
 616 KeepAliveEntry_t *GetEntryFromEndpoint(const CAEndpoint_t *endpoint, uint32_t *index)
 617 {
 618     if (!g_keepAliveConnectionTable)
 619     {
 620         OIC_LOG(ERROR, TAG, "KeepAlive Table was not Created.");
 621         return NULL;
 622     }
 623
 624     uint32_t len = u_arraylist_length(g_keepAliveConnectionTable);
 625
 626     for (uint32_t i = 0; i < len; i++)
 627     {
 628         KeepAliveEntry_t *entry = (KeepAliveEntry_t *)u_arraylist_get(g_keepAliveConnectionTable,
 629                                                                       i);
 630         if (NULL == entry)
 631         {
 632             continue;
 633         }
 634
 635         if (!strncmp(entry->remoteAddr.addr, endpoint->addr, sizeof(entry->remoteAddr.addr))
 636                 && (entry->remoteAddr.port == endpoint->port))
 637         {
 638             OIC_LOG(DEBUG, TAG, "Connection Info found in KeepAlive table");
 639             *index = i;
 640             return entry;
 641         }
 642     }
 643
 644     return NULL;
 645 }
 646
 647 KeepAliveEntry_t *AddKeepAliveEntry(const CAEndpoint_t *endpoint, OCMode mode,
 648                                     int64_t *intervalInfo)
 649 {
 650     if (!endpoint)
 651     {
 652         OIC_LOG(ERROR, TAG, "endpoint is NULL");
 653         return NULL;
 654     }
 655
 656     if (!g_keepAliveConnectionTable)
 657     {
 658         OIC_LOG(ERROR, TAG, "KeepAlive Table was not Created.");
 659         return NULL;
 660     }
 661
 662     KeepAliveEntry_t *entry = (KeepAliveEntry_t *) OICCalloc(1, sizeof(KeepAliveEntry_t));
 663     if (NULL == entry)
 664     {
 665         OIC_LOG(ERROR, TAG, "Failed to Calloc KeepAlive Entry");
 666         return NULL;
 667     }
 668
 669     entry->mode = mode;
 670     entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
 671     entry->remoteAddr.adapter = endpoint->adapter;
 672     entry->remoteAddr.flags = endpoint->flags;
 673     entry->remoteAddr.ifindex = endpoint->ifindex;
 674     entry->remoteAddr.port = endpoint->port;
 675     strncpy(entry->remoteAddr.addr, endpoint->addr, sizeof(entry->remoteAddr.addr));
 676
 677     entry->intervalSize = DEFAULT_INTERVAL_COUNT;
 678     entry->intervalInfo = intervalInfo;
 679     if (!entry->intervalInfo)
 680     {
 681         entry->intervalInfo = (int64_t*) OICMalloc(entry->intervalSize * sizeof(int64_t));
 682         for (size_t i = 0; i < entry->intervalSize; i++)
 683         {
 684             entry->intervalInfo[i] = KEEPALIVE_MIN_INTERVAL << i;
 685         }
 686     }
 687     entry->interval = entry->intervalInfo[0];
 688
 689     bool result = u_arraylist_add(g_keepAliveConnectionTable, (void *)entry);
 690     if (!result)
 691     {
 692         OIC_LOG(ERROR, TAG, "Adding node to head failed");
 693         OICFree(entry->intervalInfo);
 694         OICFree(entry);
 695         return NULL;
 696     }
 697
 698     return entry;
 699 }
 700
 701 OCStackResult RemoveKeepAliveEntry(const CAEndpoint_t *endpoint)
 702 {
 703     VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
 704
 705     uint32_t index = 0;
 706     KeepAliveEntry_t *entry = GetEntryFromEndpoint(endpoint, &index);
 707     if (!entry)
 708     {
 709         OIC_LOG(ERROR, TAG, "There is no entry in keepalive table.");
 710         return OC_STACK_ERROR;
 711     }
 712
 713     KeepAliveEntry_t *removedEntry = (KeepAliveEntry_t *)
 714                                         u_arraylist_remove(g_keepAliveConnectionTable, index);
 715     if (NULL == removedEntry)
 716     {
 717         OIC_LOG(ERROR, TAG, "Removed Entry is NULL");
 718         return OC_STACK_ERROR;
 719     }
 720
 721     OIC_LOG_V(DEBUG, TAG, "Remove Connection Info from KeepAlive table, "
 722              "remote addr=%s port:%d", removedEntry->remoteAddr.addr,
 723              removedEntry->remoteAddr.port);
 724
 725     OICFree(entry->intervalInfo);
 726     OICFree(removedEntry);
 727
 728     return OC_STACK_OK;
 729 }
 730
 731 void HandleKeepAliveConnCB(const CAEndpoint_t *endpoint, bool isConnected)
 732 {
 733     VERIFY_NON_NULL_NR(endpoint, FATAL);
 734
 735     if (isConnected)
 736     {
 737         OIC_LOG(DEBUG, TAG, "Received the connected device information from CA");
 738
 739         // Send discover message to find ping resource
 740         OCCallbackData pingData = {.context = NULL, .cb = PingRequestCallback };
 741         OCDevAddr devAddr = { .adapter = OC_ADAPTER_TCP };
 742         CopyEndpointToDevAddr(endpoint, &devAddr);
 743
 744         OCDoResource(NULL, OC_REST_DISCOVER, KEEPALIVE_RESOURCE_URI, &devAddr, NULL,
 745                      CT_ADAPTER_TCP, OC_HIGH_QOS, &pingData, NULL, 0);
 746     }
 747     else
 748     {
 749         OIC_LOG(DEBUG, TAG, "Received the disconnected device information from CA");
 750
 751         OCStackResult result = RemoveKeepAliveEntry(endpoint);
 752         if(result != OC_STACK_OK)
 753         {
 754             return;
 755         }
 756     }
 757 }