resource/csdk/stack/src/oicgroup.c

   1 //******************************************************************
   2 //
   3 // Copyright 2014 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 #define _POSIX_C_SOURCE 200112L
  22
  23 #include <string.h>
  24
  25 #include "oicgroup.h"
  26 #include "cJSON.h"
  27 #include "ocmalloc.h"
  28 #include "occollection.h"
  29 #include "logger.h"
  30 #include "timer.h"
  31
  32 #ifndef WITH_ARDUINO
  33 #include <pthread.h>
  34 #endif
  35
  36 #define TAG PCF("OICGROUP")
  37
  38 #define DESC_DELIMITER          "\""
  39 #define ACTION_DELIMITER        "*"
  40 #define ATTR_DELIMITER          "|"
  41 #define ATTR_ASSIGN             "="
  42
  43 // Definitions for operations related to actions
  44 #define DO_ACTION               "DoAction"
  45 #define GET_ACTIONSET           "GetActionSet"
  46 #define ACTIONSET               "ActionSet"
  47 #define DELETE_ACTIONSET        "DelActionSet"
  48
  49 #define OIC_ACTION_PREFIX               "{\"oc\":[{\"rep\":{"
  50 #define VARIFY_POINTER_NULL(pointer, result, toExit) \
  51     if(pointer == NULL) \
  52     {\
  53         result = OC_STACK_NO_MEMORY;\
  54         goto toExit;\
  55     }
  56 #define VARIFY_PARAM_NULL(pointer, result, toExit) \
  57     if(pointer == NULL)\
  58     {\
  59         result = OC_STACK_INVALID_PARAM;\
  60         goto exit;\
  61     }
  62
  63 #define OCFREE(pointer) \
  64     { \
  65         OCFree(pointer); \
  66         pointer = NULL; \
  67     }
  68
  69 #ifndef WITH_ARDUINO
  70 pthread_mutex_t lock;
  71 #endif
  72
  73 enum ACTION_TYPE
  74 {
  75     NONE = 0, SCHEDULED, RECURSIVE
  76 };
  77
  78 typedef struct scheduledresourceinfo
  79 {
  80     OCResource *resource;
  81     OCActionSet *actionset;
  82
  83     int timer_id;
  84
  85     OCServerRequest *ehRequest;
  86
  87     time_t time;
  88     struct scheduledresourceinfo* next;
  89 } ScheduledResourceInfo;
  90
  91 ScheduledResourceInfo *scheduleResourceList = NULL;
  92
  93 void AddScheduledResource(ScheduledResourceInfo **head,
  94         ScheduledResourceInfo* add)
  95 {
  96     OC_LOG(INFO, TAG, PCF("AddScheduledResource Entering..."));
  97
  98 #ifndef WITH_ARDUINO
  99     pthread_mutex_lock(&lock);
 100 #endif
 101     ScheduledResourceInfo *tmp = NULL;
 102
 103     if (*head != NULL)
 104     {
 105         tmp = *head;
 106
 107         while (tmp->next)
 108         {
 109             tmp = tmp->next;
 110         }
 111         tmp->next = add;
 112     }
 113     else
 114     {
 115         *head = add;
 116     }
 117 #ifndef WITH_ARDUINO
 118     pthread_mutex_unlock(&lock);
 119 #endif
 120 }
 121
 122 ScheduledResourceInfo* GetScheduledResource(ScheduledResourceInfo *head)
 123 {
 124     OC_LOG(INFO, TAG, PCF("GetScheduledResource Entering..."));
 125
 126 #ifndef WITH_ARDUINO
 127     pthread_mutex_lock(&lock);
 128 #endif
 129
 130     time_t t_now;
 131
 132     ScheduledResourceInfo *tmp = NULL;
 133     tmp = head;
 134
 135 #ifndef WITH_ARDUINO
 136     time(&t_now);
 137 #else
 138     t_now = now();
 139 #endif
 140
 141     if (tmp)
 142     {
 143         while (tmp)
 144         {
 145             time_t diffTm = 0;
 146 #ifndef WITH_ARDUINO
 147             diffTm = timespec_diff(tmp->time, t_now);
 148 #else
 149             diffTm = timespec_diff(tmp->time, t_now);
 150 #endif
 151
 152             if (diffTm <= (time_t) 0)
 153             {
 154                 OC_LOG(INFO, TAG, PCF("return Call INFO."));
 155                 goto exit;
 156             }
 157
 158             tmp = tmp->next;
 159         }
 160     }
 161
 162     exit:
 163 #ifndef WITH_ARDUINO
 164     pthread_mutex_unlock(&lock);
 165 #endif
 166     if (tmp == NULL)
 167     {
 168         OC_LOG(INFO, TAG, PCF("Cannot Find Call Info."));
 169     }
 170     return tmp;
 171 }
 172
 173 ScheduledResourceInfo* GetScheduledResourceByActionSetName(ScheduledResourceInfo *head, char *setName)
 174 {
 175     OC_LOG(INFO, TAG, PCF("GetScheduledResourceByActionSetName Entering..."));
 176
 177 #ifndef WITH_ARDUINO
 178     pthread_mutex_lock(&lock);
 179 #endif
 180     ScheduledResourceInfo *tmp = NULL;
 181     tmp = head;
 182
 183     if (tmp)
 184     {
 185         while (tmp)
 186         {
 187             if (strcmp(tmp->actionset->actionsetName, setName) == 0)
 188             {
 189                 OC_LOG(INFO, TAG, PCF("return Call INFO."));
 190                 goto exit;
 191             }
 192             tmp = tmp->next;
 193         }
 194     }
 195
 196 exit:
 197 #ifndef WITH_ARDUINO
 198     pthread_mutex_unlock(&lock);
 199 #endif
 200     if (tmp == NULL)
 201     {
 202         OC_LOG(INFO, TAG, PCF("Cannot Find Call Info."));
 203     }
 204     return tmp;
 205 }
 206
 207 void RemoveScheduledResource(ScheduledResourceInfo **head,
 208         ScheduledResourceInfo* del)
 209 {
 210 #ifndef WITH_ARDUINO
 211     pthread_mutex_lock(&lock);
 212 #endif
 213     OC_LOG(INFO, TAG, PCF("RemoveScheduledResource Entering..."));
 214     ScheduledResourceInfo *tmp = NULL;
 215
 216     if (del == NULL)
 217     {
 218         return;
 219     }
 220
 221     if (*head == del)
 222     {
 223         *head = (*head)->next;
 224     }
 225     else
 226     {
 227         tmp = *head;
 228         while (tmp->next && (tmp->next != del))
 229         {
 230             tmp = tmp->next;
 231         }
 232         if (tmp->next)
 233         {
 234             tmp->next = del->next;
 235         }
 236     }
 237
 238     OCFREE(del)
 239 #ifndef WITH_ARDUINO
 240     pthread_mutex_unlock(&lock);
 241 #endif
 242 }
 243
 244 typedef struct aggregatehandleinfo
 245 {
 246     OCServerRequest *ehRequest;
 247     OCDoHandle required;
 248     OCResource *collResource;
 249
 250     struct aggregatehandleinfo *next;
 251 } ClientRequestInfo;
 252
 253 ClientRequestInfo *clientRequstList = NULL;
 254
 255 void AddClientRequestInfo(ClientRequestInfo **head, ClientRequestInfo* add)
 256 {
 257     ClientRequestInfo *tmp = NULL;
 258
 259     if (*head != NULL)
 260     {
 261         tmp = *head;
 262
 263         while (tmp->next)
 264         {
 265             tmp = tmp->next;
 266         }
 267         tmp->next = add;
 268     }
 269     else
 270     {
 271         *head = add;
 272     }
 273 }
 274
 275 ClientRequestInfo* GetClientRequestInfo(ClientRequestInfo *head,
 276         OCDoHandle handle)
 277 {
 278     ClientRequestInfo *tmp = NULL;
 279
 280     tmp = head;
 281
 282     if (tmp)
 283     {
 284         while (tmp)
 285         {
 286             if (tmp->required == handle)
 287             {
 288                 break;
 289             }
 290
 291             tmp = tmp->next;
 292         }
 293
 294         return tmp;
 295     }
 296     return NULL;
 297 }
 298
 299 void RemoveClientRequestInfo(ClientRequestInfo **head, ClientRequestInfo* del)
 300 {
 301     ClientRequestInfo *tmp = NULL;
 302
 303     if (del == NULL)
 304         return;
 305
 306     if (*head == del)
 307     {
 308         *head = (*head)->next;
 309     }
 310     else
 311     {
 312         tmp = *head;
 313         while (tmp->next && (tmp->next != del))
 314         {
 315             tmp = tmp->next;
 316         }
 317         if (tmp->next)
 318         {
 319             tmp->next = del->next;
 320         }
 321     }
 322 }
 323
 324 void AddCapability(OCCapability** head, OCCapability* node)
 325 {
 326     OCCapability *pointer = *head;
 327     if (NULL == pointer)
 328     {
 329         *head = node;
 330     }
 331     else
 332     {
 333         while (pointer->next != NULL)
 334         {
 335             pointer = pointer->next;
 336         }
 337
 338         pointer->next = node;
 339     }
 340 }
 341
 342 void AddAction(OCAction** head, OCAction* node)
 343 {
 344     OCAction *pointer = *head;
 345     if (NULL == pointer)
 346     {
 347         *head = node;
 348     }
 349     else
 350     {
 351
 352         while (pointer->next != NULL)
 353         {
 354             pointer = pointer->next;
 355         }
 356
 357         pointer->next = node;
 358     }
 359 }
 360
 361 OCStackResult AddActionSet(OCActionSet **head, OCActionSet* node)
 362 {
 363     OCActionSet *pointer = *head;
 364     OCActionSet *prev = NULL;
 365     if(node == NULL)
 366     {
 367         return OC_STACK_ERROR;
 368     }
 369     if (NULL == pointer)
 370     {
 371         *head = node;
 372     }
 373     else
 374     {
 375         prev = pointer;
 376         while (pointer != NULL)
 377         {
 378             // check the uniqeness of actionsetname.
 379             if (strcmp(pointer->actionsetName, node->actionsetName) == 0)
 380             {
 381                 return OC_STACK_ERROR;
 382             }
 383
 384             prev = pointer;
 385             pointer = pointer->next;
 386         }
 387
 388         prev->next = node;
 389     }
 390
 391     return OC_STACK_OK;
 392 }
 393
 394 void DeleteCapability(OCCapability *del)
 395 {
 396     OCFREE(del->capability)
 397     del->capability = NULL;
 398     OCFREE(del->status)
 399     del->status = NULL;
 400     OCFREE(del)
 401 }
 402
 403 void DeleteAction(OCAction** action)
 404 {
 405     OCCapability* pointer = (*action)->head;
 406     OCCapability* pDel = NULL;
 407
 408     while (pointer)
 409     {
 410         pDel = pointer;
 411         pointer = pointer->next;
 412
 413         DeleteCapability(pDel);
 414     }
 415     OCFREE((*action)->resourceUri)
 416     (*action)->next = NULL;
 417     OCFREE(*action)
 418 }
 419
 420 void DeleteActionSet(OCActionSet** actionset)
 421 {
 422     if(*actionset == NULL)
 423         return;
 424
 425     OCAction* pointer = (*actionset)->head;
 426     OCAction* pDel = NULL;
 427
 428     while (pointer)
 429     {
 430         pDel = pointer;
 431         pointer = pointer->next;
 432
 433         DeleteAction(&pDel);
 434     }
 435     //    (*actionset)->head = NULL;
 436     OCFREE((*actionset)->actionsetName)
 437     OCFREE(*actionset)
 438 }
 439
 440 OCStackResult FindAndDeleteActionSet(OCResource **resource,
 441         const char * actionsetName)
 442 {
 443     if (*resource != NULL)
 444     {
 445         OCActionSet *pointer = NULL;
 446         OCActionSet *pDel = NULL;
 447
 448         pointer = (*resource)->actionsetHead;
 449
 450         if (pointer == NULL)
 451         {
 452             return OC_STACK_ERROR;
 453         }
 454         else
 455         {
 456             if (strcmp(pointer->actionsetName, actionsetName) == 0)
 457             {
 458                 if (pointer->next != NULL)
 459                     (*resource)->actionsetHead = pointer->next;
 460                 else
 461                     (*resource)->actionsetHead = NULL;
 462
 463                 DeleteActionSet(&pointer);
 464             }
 465             else if (pointer->next != NULL)
 466             {
 467                 while (pointer)
 468                 {
 469                     if (pointer->next != NULL)
 470                     {
 471                         if (strcmp(pointer->next->actionsetName, actionsetName)
 472                                 == 0)
 473                         {
 474                             pDel = pointer->next;
 475                             pointer->next = pointer->next->next;
 476
 477                             DeleteActionSet(&pDel);
 478                         }
 479                     }
 480                     pointer = pointer->next;
 481                 }
 482             }
 483
 484             return OC_STACK_OK;
 485         }
 486
 487     }
 488     return OC_STACK_ERROR;
 489 }
 490
 491 OCStackResult DeleteActionSets(OCResource** resource)
 492 {
 493     OCActionSet *pointer = (*resource)->actionsetHead;
 494     OCActionSet *pDel = pointer;
 495
 496     while (pointer)
 497     {
 498         pDel = pointer;
 499         pointer = pointer->next;
 500
 501         DeleteActionSet(&pDel);
 502         pDel->next = NULL;
 503     }
 504
 505     (*resource)->actionsetHead = NULL;
 506     return OC_STACK_OK;
 507 }
 508
 509 OCStackResult GetActionSet(const char *actionName, OCActionSet *head,
 510         OCActionSet** actionset)
 511 {
 512     OCActionSet *pointer = head;
 513
 514     while (pointer)
 515     {
 516         if (strcmp(pointer->actionsetName, actionName) == 0)
 517         {
 518             *actionset = pointer;
 519             return OC_STACK_OK;
 520         }
 521
 522         pointer = pointer->next;
 523     }
 524
 525     return OC_STACK_ERROR;
 526
 527 }
 528
 529 OCStackResult ExtractKeyValueFromRequest(char *request, char **key,
 530         char **value)
 531 {
 532     OCStackResult result = OC_STACK_OK;
 533     size_t length = 0;
 534
 535     char* pRequest = (char *) request + strlen(OIC_ACTION_PREFIX);
 536     char* iterToken, *iterTokenPtr;
 537
 538     iterToken = (char *) strtok_r(pRequest, ":", &iterTokenPtr);
 539     VARIFY_POINTER_NULL(iterToken, result, exit);
 540     length = strlen(iterToken) + 1;
 541
 542     *key = (char *) OCMalloc(length);
 543     VARIFY_POINTER_NULL(*key, result, exit)
 544
 545     strncpy(*key, iterToken + 1, length);
 546     ((*key)[((length - 1) - 2)]) = '\0';
 547
 548     iterToken = (char *) strtok_r(NULL, "}", &iterTokenPtr);
 549     VARIFY_POINTER_NULL(iterToken, result, exit);
 550     length = strlen(iterToken) + 1;
 551
 552     *value = (char *) OCMalloc(length);
 553     VARIFY_POINTER_NULL(*value, result, exit)
 554
 555     strncpy(*value, iterToken + 1, length);
 556     ((*value)[((length - 1) - 2)]) = '\0';
 557
 558 exit:
 559     if (result != OC_STACK_OK)
 560     {
 561         OCFREE(*key)
 562         OCFREE(*value)
 563     }
 564
 565     return result;
 566 }
 567
 568 OCStackResult ExtractActionSetNameAndDelaytime(char *pChar, char **setName,
 569         long int *pa)
 570 {
 571     char *token, *tokenPtr;
 572     OCStackResult result = OC_STACK_OK;
 573
 574     token = (char*) strtok_r(pChar, ACTION_DELIMITER, &tokenPtr);
 575     *setName = (char *) OCMalloc(strlen(token) + 1);
 576     VARIFY_POINTER_NULL(*setName, result, exit)
 577     VARIFY_PARAM_NULL(token, result, exit)
 578     strncpy(*setName, token, strlen(token) + 1);
 579
 580     token = strtok_r(NULL, ACTION_DELIMITER, &tokenPtr);
 581     VARIFY_POINTER_NULL(pa, result, exit)
 582     VARIFY_PARAM_NULL(token, result, exit)
 583     *pa = atoi(token);
 584
 585     return OC_STACK_OK;
 586
 587 exit:
 588     OCFREE(*setName);
 589     return result;
 590 }
 591
 592 OCStackResult BuildActionSetFromString(OCActionSet **set, char* actiondesc)
 593 {
 594     OCStackResult result = OC_STACK_OK;
 595
 596     char *iterToken = NULL, *iterTokenPtr = NULL;
 597     char *descIterToken = NULL, *descIterTokenPtr = NULL;
 598     char *attrIterToken = NULL, *attrIterTokenPtr = NULL;
 599     char *desc = NULL, *attr = NULL;
 600     char *key = NULL, *value = NULL;
 601
 602     OCAction *action = NULL;
 603     OCCapability *capa = NULL;
 604
 605     OC_LOG(INFO, TAG, PCF("Build ActionSet Instance."));
 606
 607     *set = (OCActionSet*) OCMalloc(sizeof(OCActionSet));
 608     VARIFY_POINTER_NULL(*set, result, exit)
 609
 610     iterToken = (char *) strtok_r(actiondesc, ACTION_DELIMITER, &iterTokenPtr);
 611
 612     // ActionSet Name
 613     memset(*set, 0, sizeof(OCActionSet));
 614     (*set)->actionsetName = (char *) OCMalloc(strlen(iterToken) + 1);
 615     VARIFY_POINTER_NULL((*set)->actionsetName, result, exit)
 616     VARIFY_PARAM_NULL(iterToken, result, exit)
 617     strncpy((*set)->actionsetName, iterToken, strlen(iterToken) + 1);
 618
 619     // Time info. for Scheduled/Recursive Group action.
 620     // d is meant Day of the week.
 621     // T is meant ActionType.
 622     // yyyy-mm-dd hh:mm:ss d
 623     iterToken = (char *) strtok_r(NULL, ACTION_DELIMITER, &iterTokenPtr);
 624     VARIFY_PARAM_NULL(iterToken, result, exit)
 625 #ifndef WITH_ARDUINO
 626     sscanf(iterToken, "%ld %d", &(*set)->timesteps, &(*set)->type);
 627 #endif
 628
 629     OC_LOG_V(INFO, TAG, "ActionSet Name : %s", (*set)->actionsetName);
 630
 631     iterToken = (char *) strtok_r(NULL, ACTION_DELIMITER, &iterTokenPtr);
 632     while (iterToken)
 633     {
 634         desc = (char *) OCMalloc(strlen(iterToken) + 1);
 635         VARIFY_POINTER_NULL(desc, result, exit)
 636         VARIFY_PARAM_NULL(desc, result, exit)
 637         strncpy(desc, iterToken, strlen(iterToken) + 1);
 638         descIterToken = (char *) strtok_r(desc, ATTR_DELIMITER,
 639                 &descIterTokenPtr);
 640         while (descIterToken)
 641         {
 642             attr = (char *) OCMalloc(strlen(descIterToken) + 1);
 643             VARIFY_POINTER_NULL(attr, result, exit)
 644             VARIFY_PARAM_NULL(descIterToken, result, exit)
 645             strncpy(attr, descIterToken, strlen(descIterToken) + 1);
 646
 647             attrIterToken = (char *) strtok_r(attr, ATTR_ASSIGN,
 648                     &attrIterTokenPtr);
 649             key = (char *) OCMalloc(strlen(attrIterToken) + 1);
 650             VARIFY_POINTER_NULL(key, result, exit)
 651             VARIFY_PARAM_NULL(attrIterToken, result, exit)
 652             strncpy(key, attrIterToken, strlen(attrIterToken) + 1);
 653
 654             attrIterToken = (char *) strtok_r(NULL, ATTR_ASSIGN,
 655                     &attrIterTokenPtr);
 656             value = (char *) OCMalloc(strlen(attrIterToken) + 1);
 657             VARIFY_POINTER_NULL(value, result, exit)
 658             VARIFY_PARAM_NULL(attrIterToken, result, exit)
 659             strncpy(value, attrIterToken, strlen(attrIterToken) + 1);
 660
 661             if (strcmp(key, "uri") == 0)
 662             {
 663                 OC_LOG(INFO, TAG, PCF("Build OCAction Instance."));
 664
 665                 action = (OCAction*) OCMalloc(sizeof(OCAction));
 666                 VARIFY_POINTER_NULL(action, result, exit)
 667                 memset(action, 0, sizeof(OCAction));
 668                 action->resourceUri = (char *) OCMalloc(strlen(value) + 1);
 669                 VARIFY_POINTER_NULL(action->resourceUri, result, exit)
 670                 VARIFY_PARAM_NULL(value, result, exit)
 671                 strncpy(action->resourceUri, value, strlen(value) + 1);
 672             }
 673             else
 674             {
 675                 if ((key != NULL) && (value != NULL))
 676                 {
 677                     OC_LOG(INFO, TAG, PCF("Build OCCapability Instance."));
 678
 679                     capa = (OCCapability*) OCMalloc(sizeof(OCCapability));
 680                     VARIFY_POINTER_NULL(capa, result, exit)
 681                     memset(capa, 0, sizeof(OCCapability));
 682
 683                     capa->capability = (char *) OCMalloc(strlen(key) + 1);
 684                     VARIFY_POINTER_NULL(capa->capability, result, exit)
 685                     VARIFY_PARAM_NULL(key, result, exit)
 686                     strncpy(capa->capability, key, strlen(key) + 1);
 687
 688                     capa->status = (char *) OCMalloc(strlen(value) + 1);
 689                     VARIFY_POINTER_NULL(capa->status, result, exit)
 690                     VARIFY_PARAM_NULL(value, result, exit)
 691                     strncpy(capa->status, value, strlen(value) + 1);
 692
 693                     VARIFY_POINTER_NULL(action, result, exit)
 694
 695                     AddCapability(&action->head, capa);
 696                 }
 697             }
 698
 699             OCFREE(key)
 700             OCFREE(value)
 701             OCFREE(attr)
 702
 703             descIterToken = (char *) strtok_r(NULL, ATTR_DELIMITER,
 704                     &descIterTokenPtr);
 705         }
 706
 707         AddAction(&(*set)->head, action);
 708         iterToken = (char *) strtok_r(NULL, ACTION_DELIMITER, &iterTokenPtr);
 709         OCFREE(desc);
 710     }
 711
 712     return OC_STACK_OK;
 713 exit:
 714     OCFREE(attr)
 715     OCFREE(desc)
 716     OCFREE(capa)
 717     OCFREE(action)
 718     OCFREE(*set)
 719     OCFREE(key)
 720     OCFREE(value)
 721     OCFREE(attr)
 722
 723     return result;
 724 }
 725
 726 OCStackResult BuildStringFromActionSet(OCActionSet* actionset, char** desc)
 727 {
 728     char temp[1024] = { 0 };
 729     int remaining = 1023;
 730     OCStackResult res = OC_STACK_ERROR;
 731
 732     OCAction *action = actionset->head;
 733
 734     if (remaining >= strlen(actionset->actionsetName) + 1)
 735     {
 736         strcat(temp, actionset->actionsetName);
 737         remaining -= strlen(actionset->actionsetName);
 738         strcat(temp, ACTION_DELIMITER);
 739         remaining--;
 740     }
 741     else
 742     {
 743         res = OC_STACK_ERROR;
 744         goto exit;
 745     }
 746
 747     while (action != NULL)
 748     {
 749         strcat(temp, "uri=");
 750         remaining -= strlen("uri=");
 751         strcat(temp, action->resourceUri);
 752         remaining -= strlen(action->resourceUri);
 753         strcat(temp, "|");
 754         remaining--;
 755
 756         OCCapability *capas = action->head;
 757         while (capas != NULL)
 758         {
 759             strcat(temp, capas->capability);
 760             remaining -= strlen(capas->capability);
 761             strcat(temp, "=");
 762             remaining--;
 763             strcat(temp, capas->status);
 764             remaining -= strlen(capas->capability);
 765
 766             capas = capas->next;
 767             if (capas != NULL)
 768             {
 769                 strcat(temp, "|");
 770             }
 771         }
 772
 773         action = action->next;
 774         if (action != NULL)
 775         {
 776             strcat(temp, ACTION_DELIMITER);
 777             remaining--;
 778         }
 779     }
 780
 781     *desc = (char *) OCMalloc(1024 - remaining);
 782     VARIFY_POINTER_NULL(*desc, res, exit);
 783     strcpy(*desc, temp);
 784
 785     return OC_STACK_OK;
 786
 787 exit:
 788     OCFREE(*desc);
 789     return res;
 790
 791 }
 792
 793 OCStackApplicationResult ActionSetCB(void* context, OCDoHandle handle,
 794         OCClientResponse* clientResponse)
 795 {
 796     OC_LOG(INFO, TAG, PCF("Entering BuildActionJSON"));
 797
 798     ClientRequestInfo *info = GetClientRequestInfo(clientRequstList, handle);
 799
 800     if (info)
 801     {
 802         int idx;
 803
 804         unsigned char *responseJson;
 805         responseJson = (unsigned char *) OCMalloc(
 806                 (unsigned int) (strlen((char *) clientResponse->resJSONPayload)
 807                         + 1));
 808
 809         if( responseJson == NULL )
 810             return OC_STACK_DELETE_TRANSACTION;
 811
 812         // We need the body of response.
 813         // Copy the body from the response
 814         strcpy((char *) responseJson,
 815                 ((char *) clientResponse->resJSONPayload + OC_JSON_PREFIX_LEN));
 816         idx = strlen((char *) responseJson) - OC_JSON_SUFFIX_LEN;
 817         // And insert NULL at the end of body.
 818         (responseJson[idx]) = 0;
 819
 820         OCEntityHandlerResponse response = { 0 };
 821         response.ehResult = OC_EH_OK;
 822         response.payload = (char*)responseJson;
 823         response.payloadSize = (unsigned int) strlen((char *) responseJson) + 1;
 824         response.persistentBufferFlag = 0;
 825         response.requestHandle = (OCRequestHandle) info->ehRequest;
 826         response.resourceHandle = (OCResourceHandle) info->collResource;
 827
 828         OCDoResponse(&response);
 829
 830         RemoveClientRequestInfo(&clientRequstList, info);
 831         OCFREE(info)
 832         OCFREE(responseJson)
 833     }
 834
 835     return OC_STACK_KEEP_TRANSACTION;
 836 }
 837
 838 void ActionSetCD(void *context)
 839 {
 840 }
 841
 842 OCStackResult BuildActionJSON(OCAction* action, unsigned char* bufferPtr,
 843         uint16_t *remaining)
 844 {
 845     OCStackResult ret = OC_STACK_ERROR;
 846     cJSON *json;
 847     cJSON *body;
 848
 849     char *jsonStr;
 850     uint16_t jsonLen;
 851
 852     OC_LOG(INFO, TAG, PCF("Entering BuildActionJSON"));
 853     json = cJSON_CreateObject();
 854
 855     cJSON_AddItemToObject(json, "rep", body = cJSON_CreateObject());
 856
 857     OCCapability* pointerCapa = action->head;
 858     while (pointerCapa)
 859     {
 860         cJSON_AddStringToObject(body, pointerCapa->capability,
 861                 pointerCapa->status);
 862         pointerCapa = pointerCapa->next;
 863     }
 864
 865     jsonStr = cJSON_PrintUnformatted(json);
 866
 867     jsonLen = strlen(jsonStr);
 868     if (jsonLen < *remaining)
 869     {
 870         strcat((char*) bufferPtr, jsonStr);
 871         *remaining -= jsonLen;
 872         bufferPtr += jsonLen;
 873         ret = OC_STACK_OK;
 874     }
 875
 876     cJSON_Delete(json);
 877     free(jsonStr);
 878
 879     return ret;
 880 }
 881
 882 unsigned int GetNumOfTargetResource(OCAction *actionset)
 883 {
 884     int numOfResource = 0;
 885
 886     OCAction *pointerAction = actionset;
 887
 888     while (pointerAction != NULL)
 889     {
 890         numOfResource++;
 891         pointerAction = pointerAction->next;
 892     }
 893
 894     return numOfResource;
 895 }
 896
 897
 898 #define DEFAULT_CONTEXT_VALUE 0x99
 899
 900 OCStackResult SendAction(OCDoHandle *handle, const char *targetUri,
 901         const unsigned char *action)
 902 {
 903     OCCallbackData cbdata = { 0 };
 904     cbdata.cb = &ActionSetCB;
 905     cbdata.cd = NULL;
 906     cbdata.context = (void*)DEFAULT_CONTEXT_VALUE;
 907
 908 // TODO: Selecting OC_WIFI for android, tizen and OC_ETHERNET for linux platform.
 909 // It is temporary change as OC_ALL is not working currently. Remove this code and use OC_ALL
 910 // once it is functioning.
 911 #if defined(__ANDROID__) || defined(__TIZEN__)
 912     return OCDoResource(handle, OC_REST_PUT, targetUri,
 913     NULL, (char *) action, OC_WIFI, OC_NA_QOS, &cbdata, NULL, 0);
 914 #else
 915     return OCDoResource(handle, OC_REST_PUT, targetUri,
 916     NULL, (char *) action, OC_ETHERNET, OC_NA_QOS, &cbdata, NULL, 0);
 917 #endif
 918 }
 919
 920 OCStackResult DoAction(OCResource* resource, OCActionSet* actionset,
 921         OCServerRequest* requestHandle)
 922 {
 923     OCStackResult result = OC_STACK_ERROR;
 924     OCAction *pointerAction = actionset->head;
 925
 926     while (pointerAction != NULL)
 927     {
 928         unsigned char actionDesc[MAX_RESPONSE_LENGTH] = { 0 };
 929         unsigned char* actionDescPtr = actionDesc;
 930         uint16_t remaining = MAX_RESPONSE_LENGTH;
 931
 932         strncpy((char *) actionDescPtr, (const char *) OC_JSON_PREFIX,
 933                 strlen((const char *) OC_JSON_PREFIX) + 1);
 934         BuildActionJSON(pointerAction, actionDescPtr, &remaining);
 935         strncat((char *) actionDescPtr, (const char *) OC_JSON_SUFFIX,
 936                 strlen((const char *) OC_JSON_SUFFIX));
 937
 938         ClientRequestInfo *info = (ClientRequestInfo *) OCMalloc(
 939                 sizeof(ClientRequestInfo));
 940
 941         if( info == NULL )
 942             return OC_STACK_NO_MEMORY;
 943
 944         memset(info, 0, sizeof(ClientRequestInfo));
 945
 946         info->collResource = resource;
 947         info->ehRequest = requestHandle;
 948
 949         result = SendAction(&info->required, pointerAction->resourceUri,
 950                 actionDescPtr);
 951         if (result != OC_STACK_OK)
 952         {
 953             return result;
 954         }
 955
 956         AddClientRequestInfo(&clientRequstList, info);
 957
 958         pointerAction = pointerAction->next;
 959     }
 960
 961     return result;
 962 }
 963
 964 void DoScheduledGroupAction()
 965 {
 966     OC_LOG(INFO, TAG, PCF("DoScheduledGroupAction Entering..."));
 967     ScheduledResourceInfo* info = GetScheduledResource(scheduleResourceList);
 968
 969     if (info == NULL)
 970     {
 971         OC_LOG(INFO, TAG, PCF("Target resource is NULL"));
 972         goto exit;
 973     }
 974     else if (info->resource == NULL)
 975     {
 976         OC_LOG(INFO, TAG, PCF("Target resource is NULL"));
 977         goto exit;
 978     }
 979     else if (info->actionset == NULL)
 980     {
 981         OC_LOG(INFO, TAG, PCF("Target ActionSet is NULL"));
 982         goto exit;
 983     }
 984     else if (info->ehRequest == NULL)
 985     {
 986         OC_LOG(INFO, TAG, PCF("Target ActionSet is NULL"));
 987         goto exit;
 988     }
 989 #ifndef WITH_ARDUINO
 990     pthread_mutex_lock(&lock);
 991 #endif
 992     DoAction(info->resource, info->actionset, info->ehRequest);
 993 #ifndef WITH_ARDUINO
 994     pthread_mutex_unlock(&lock);
 995 #endif
 996
 997     if (info->actionset->type == RECURSIVE)
 998     {
 999         ScheduledResourceInfo *schedule;
1000         schedule = (ScheduledResourceInfo *) OCMalloc(
1001                 sizeof(ScheduledResourceInfo));
1002
1003         if (schedule)
1004         {
1005             OC_LOG(INFO, TAG, PCF("Building New Call Info."));
1006             memset(schedule, 0, sizeof(ScheduledResourceInfo));
1007
1008             if (info->actionset->timesteps > 0)
1009             {
1010 #ifndef WITH_ARDUINO
1011                 pthread_mutex_lock(&lock);
1012 #endif
1013                 schedule->resource = info->resource;
1014                 schedule->actionset = info->actionset;
1015                 schedule->ehRequest = info->ehRequest;
1016
1017                 schedule->time = registerTimer(info->actionset->timesteps,
1018                         &schedule->timer_id,
1019                         &DoScheduledGroupAction);
1020
1021                 OC_LOG(INFO, TAG, PCF("Reregisteration."));
1022 #ifndef WITH_ARDUINO
1023                 pthread_mutex_unlock(&lock);
1024 #endif
1025                 AddScheduledResource(&scheduleResourceList, schedule);
1026             }
1027         }
1028     }
1029
1030     RemoveScheduledResource(&scheduleResourceList, info);
1031
1032     exit:
1033
1034     return;
1035 }
1036
1037 OCStackResult BuildCollectionGroupActionJSONResponse(
1038         OCMethod method/*OCEntityHandlerFlag flag*/, OCResource *resource,
1039         OCEntityHandlerRequest *ehRequest)
1040 {
1041     OCStackResult stackRet = OC_STACK_ERROR;
1042
1043     OC_LOG(INFO, TAG, PCF("Group Action is requested."));
1044     // if (stackRet == OC_STACK_OK)
1045     {
1046         char *doWhat = NULL;
1047         char *details = NULL;
1048
1049         size_t bufferLength = 0;
1050         unsigned char buffer[MAX_RESPONSE_LENGTH] = { 0 };
1051         unsigned char *bufferPtr = NULL;
1052
1053         bufferPtr = buffer;
1054
1055         OCResource * collResource = (OCResource *) ehRequest->resource;
1056
1057         char *jsonResponse;
1058
1059         stackRet = ExtractKeyValueFromRequest((char *) ehRequest->reqJSONPayload,
1060                 &doWhat, &details);
1061
1062         if(stackRet != OC_STACK_OK)
1063         {
1064             OC_LOG_V(ERROR, TAG, "ExtractKeyValueFromRequest failed: %d", stackRet);
1065             return stackRet;
1066         }
1067
1068         stackRet = OC_STACK_ERROR;
1069
1070         cJSON *json;
1071         cJSON *format;
1072
1073         if (method == OC_REST_PUT)
1074         {
1075             json = cJSON_CreateObject();
1076             cJSON_AddStringToObject(json, "href", resource->uri);
1077             cJSON_AddItemToObject(json, "rep", format = cJSON_CreateObject());
1078
1079             OC_LOG(INFO, TAG, PCF("Group Action[PUT]."));
1080
1081             if (strcmp(doWhat, ACTIONSET) == 0)
1082             {
1083                 OCActionSet *actionSet = NULL;
1084                 stackRet = BuildActionSetFromString(&actionSet, details);
1085
1086                 if(stackRet == OC_STACK_OK)
1087                 {
1088                     if (actionSet != NULL)
1089                     {
1090                         stackRet = AddActionSet(&resource->actionsetHead,
1091                                 actionSet);
1092                         if (stackRet == OC_STACK_ERROR)
1093                         {
1094                             if(actionSet != NULL)
1095                             {
1096                                 DeleteActionSet( &actionSet );
1097                             }
1098                             OC_LOG(INFO, TAG, PCF("Duplicated ActionSet "));
1099                         }
1100                     }
1101                 }
1102                 else
1103                 {
1104                     stackRet = OC_STACK_ERROR;
1105                 }
1106
1107             }
1108             else if (strcmp(doWhat, DELETE_ACTIONSET) == 0)
1109             {
1110                 if (FindAndDeleteActionSet(&resource, details) == OC_STACK_OK)
1111                 {
1112                     stackRet = OC_STACK_OK;
1113                 }
1114                 else
1115                 {
1116                     stackRet = OC_STACK_ERROR;
1117                 }
1118             }
1119
1120             jsonResponse = cJSON_Print(json);
1121             cJSON_Delete(json);
1122
1123             strcat((char *) bufferPtr, jsonResponse);
1124
1125             bufferLength = strlen((const char *) buffer);
1126             if (bufferLength > 0)
1127             {
1128                 OCEntityHandlerResponse response = { 0 };
1129                 if(stackRet == OC_STACK_OK)
1130                     response.ehResult = OC_EH_OK;
1131                 else
1132                     response.ehResult = OC_EH_ERROR;
1133                 response.payload = (char*)buffer;
1134                 response.payloadSize = bufferLength + 1;
1135                 response.persistentBufferFlag = 0;
1136                 response.requestHandle =
1137                         (OCRequestHandle) ehRequest->requestHandle;
1138                 response.resourceHandle = (OCResourceHandle) collResource;
1139                 stackRet = OCDoResponse(&response);
1140             }
1141         }
1142
1143         if (method == OC_REST_POST)
1144         {
1145             OCActionSet *actionset = NULL;
1146
1147             json = cJSON_CreateObject();
1148             cJSON_AddStringToObject(json, "href", resource->uri);
1149
1150             if ((strcmp(doWhat, DO_ACTION) == 0)
1151                     || (strcmp(doWhat, "DoScheduledAction") == 0))
1152             {
1153                 char *pActionsetName = NULL;
1154                 long int delay = -1;
1155
1156                 if (strcmp(doWhat, "DoScheduledAction") == 0)
1157                 {
1158                     stackRet = ExtractActionSetNameAndDelaytime(details,
1159                             &pActionsetName, &delay);
1160
1161                     OCFREE(details)
1162                     details = pActionsetName;
1163                 }
1164                 else
1165                 {
1166                     stackRet = OC_STACK_OK;
1167                 }
1168
1169                 if (stackRet == OC_STACK_OK)
1170                 {
1171                     if (GetActionSet(details, resource->actionsetHead,
1172                             &actionset) != OC_STACK_OK)
1173                     {
1174                         OC_LOG(INFO, TAG, PCF("ERROR"));
1175                         stackRet = OC_STACK_ERROR;
1176                     }
1177
1178                     if (actionset == NULL)
1179                     {
1180                         OC_LOG(INFO, TAG, PCF("Cannot Find ActionSet"));
1181                         stackRet = OC_STACK_ERROR;
1182                     }
1183                     else
1184                     {
1185                         OC_LOG(INFO, TAG, PCF("Group Action[POST]."));
1186                         if (actionset->type == NONE)
1187                         {
1188                             OC_LOG_V(INFO, TAG, "Execute ActionSet : %s",
1189                                     actionset->actionsetName);
1190                             unsigned int num = GetNumOfTargetResource(
1191                                     actionset->head);
1192
1193                             ((OCServerRequest *) ehRequest->requestHandle)->ehResponseHandler =
1194                                     HandleAggregateResponse;
1195                             ((OCServerRequest *) ehRequest->requestHandle)->numResponses =
1196                                     num + 1;
1197
1198                             DoAction(resource, actionset,
1199                                     (OCServerRequest*) ehRequest->requestHandle);
1200                             stackRet = OC_STACK_OK;
1201                         }
1202                         else
1203                         {
1204                             OC_LOG_V(INFO, TAG, "Execute Scheduled ActionSet : %s",
1205                                     actionset->actionsetName);
1206
1207                             delay =
1208                                     (delay == -1 ? actionset->timesteps : delay);
1209
1210                             ScheduledResourceInfo *schedule;
1211                             schedule = (ScheduledResourceInfo *) OCMalloc(
1212                                     sizeof(ScheduledResourceInfo));
1213
1214                             if (schedule)
1215                             {
1216                                 OC_LOG(INFO, TAG, PCF("Building New Call Info."));
1217                                 memset(schedule, 0,
1218                                         sizeof(ScheduledResourceInfo));
1219
1220                                 schedule->resource = resource;
1221                                 schedule->actionset = actionset;
1222                                 schedule->ehRequest =
1223                                         (OCServerRequest*) ehRequest->requestHandle;
1224
1225                                 if (delay > 0)
1226                                 {
1227                                     OC_LOG_V(INFO, TAG, "delay_time is %lf seconds.",
1228                                             actionset->timesteps);
1229
1230                                     schedule->time = registerTimer(delay,
1231                                             &schedule->timer_id,
1232                                             &DoScheduledGroupAction);
1233
1234                                     AddScheduledResource(&scheduleResourceList,
1235                                             schedule);
1236                                     stackRet = OC_STACK_OK;
1237                                 }
1238                                 else
1239                                 {
1240                                     stackRet = OC_STACK_ERROR;
1241                                 }
1242                             }
1243                         }
1244                     }
1245                 }
1246             }
1247             else if (strcmp(doWhat, "CancelAction") == 0)
1248             {
1249                 ScheduledResourceInfo *info =
1250                         GetScheduledResourceByActionSetName(scheduleResourceList, details);
1251
1252                 if(info != NULL)
1253                 {
1254                     unregisterTimer(info->timer_id);
1255
1256                     RemoveScheduledResource(&scheduleResourceList, info);
1257                     stackRet = OC_STACK_OK;
1258                 }
1259                 else
1260                 {
1261                     stackRet = OC_STACK_ERROR;
1262                 }
1263             }
1264
1265             else if (strcmp(doWhat, GET_ACTIONSET) == 0)
1266             {
1267                 char *plainText = NULL;
1268                 OCActionSet *actionset = NULL;
1269
1270                 cJSON_AddItemToObject(json, "rep", format =
1271                         cJSON_CreateObject());
1272                 GetActionSet(details, resource->actionsetHead, &actionset);
1273                 if (actionset != NULL)
1274                 {
1275                     BuildStringFromActionSet(actionset, &plainText);
1276
1277                     if (plainText != NULL)
1278                     {
1279                         cJSON_AddStringToObject(format, ACTIONSET, plainText);
1280                     }
1281                     OCFree(plainText);
1282                     stackRet = OC_STACK_OK;
1283                 }
1284             }
1285
1286
1287             jsonResponse = cJSON_Print(json);
1288             cJSON_Delete(json);
1289
1290             strcat((char *) bufferPtr, jsonResponse);
1291
1292             bufferLength = strlen((const char *) buffer);
1293             if (bufferLength > 0)
1294             {
1295                 OCEntityHandlerResponse response = { 0 };
1296                 if(stackRet == OC_STACK_OK)
1297                     response.ehResult = OC_EH_OK;
1298                 else
1299                     response.ehResult = OC_EH_ERROR;
1300                 response.payload = (char *)buffer;
1301                 response.payloadSize = bufferLength + 1;
1302                 response.persistentBufferFlag = 0;
1303                 response.requestHandle =
1304                         (OCRequestHandle) ehRequest->requestHandle;
1305                 response.resourceHandle = (OCResourceHandle) collResource;
1306                 stackRet = OCDoResponse(&response);
1307             }
1308         }
1309
1310         OCFREE(doWhat)
1311         OCFREE(details)
1312     }
1313
1314     return stackRet;
1315 }