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