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 "oic_malloc.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         OICFree(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 *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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*) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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*) OICMalloc(sizeof(OCAction));
 666                 VARIFY_POINTER_NULL(action, result, exit)
 667                 memset(action, 0, sizeof(OCAction));
 668                 action->resourceUri = (char *) OICMalloc(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*) OICMalloc(sizeof(OCCapability));
 680                     VARIFY_POINTER_NULL(capa, result, exit)
 681                     memset(capa, 0, sizeof(OCCapability));
 682
 683                     capa->capability = (char *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(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 *) OICMalloc(
 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;
 904     cbdata.cb = &ActionSetCB;
 905     cbdata.cd = NULL;
 906     cbdata.context = (void*)DEFAULT_CONTEXT_VALUE;
 907
 908     return OCDoResource(handle, OC_REST_PUT, targetUri,
 909             NULL, (char *) action, CT_ADAPTER_IP, OC_NA_QOS, &cbdata, NULL, 0);
 910 }
 911
 912 OCStackResult DoAction(OCResource* resource, OCActionSet* actionset,
 913         OCServerRequest* requestHandle)
 914 {
 915     OCStackResult result = OC_STACK_ERROR;
 916     OCAction *pointerAction = actionset->head;
 917
 918     while (pointerAction != NULL)
 919     {
 920         unsigned char actionDesc[MAX_RESPONSE_LENGTH] = { 0 };
 921         unsigned char* actionDescPtr = actionDesc;
 922         uint16_t remaining = MAX_RESPONSE_LENGTH;
 923
 924         strncpy((char *) actionDescPtr, (const char *) OC_JSON_PREFIX,
 925                 strlen((const char *) OC_JSON_PREFIX) + 1);
 926         BuildActionJSON(pointerAction, actionDescPtr, &remaining);
 927         strncat((char *) actionDescPtr, (const char *) OC_JSON_SUFFIX,
 928                 strlen((const char *) OC_JSON_SUFFIX));
 929
 930         ClientRequestInfo *info = (ClientRequestInfo *) OICMalloc(
 931                 sizeof(ClientRequestInfo));
 932
 933         if( info == NULL )
 934             return OC_STACK_NO_MEMORY;
 935
 936         memset(info, 0, sizeof(ClientRequestInfo));
 937
 938         info->collResource = resource;
 939         info->ehRequest = requestHandle;
 940
 941         result = SendAction(&info->required, pointerAction->resourceUri,
 942                 actionDescPtr);
 943         if (result != OC_STACK_OK)
 944         {
 945             return result;
 946         }
 947
 948         AddClientRequestInfo(&clientRequstList, info);
 949
 950         pointerAction = pointerAction->next;
 951     }
 952
 953     return result;
 954 }
 955
 956 void DoScheduledGroupAction()
 957 {
 958     OC_LOG(INFO, TAG, PCF("DoScheduledGroupAction Entering..."));
 959     ScheduledResourceInfo* info = GetScheduledResource(scheduleResourceList);
 960
 961     if (info == NULL)
 962     {
 963         OC_LOG(INFO, TAG, PCF("Target resource is NULL"));
 964         goto exit;
 965     }
 966     else if (info->resource == NULL)
 967     {
 968         OC_LOG(INFO, TAG, PCF("Target resource is NULL"));
 969         goto exit;
 970     }
 971     else if (info->actionset == NULL)
 972     {
 973         OC_LOG(INFO, TAG, PCF("Target ActionSet is NULL"));
 974         goto exit;
 975     }
 976     else if (info->ehRequest == NULL)
 977     {
 978         OC_LOG(INFO, TAG, PCF("Target ActionSet is NULL"));
 979         goto exit;
 980     }
 981 #ifndef WITH_ARDUINO
 982     pthread_mutex_lock(&lock);
 983 #endif
 984     DoAction(info->resource, info->actionset, info->ehRequest);
 985 #ifndef WITH_ARDUINO
 986     pthread_mutex_unlock(&lock);
 987 #endif
 988
 989     if (info->actionset->type == RECURSIVE)
 990     {
 991         ScheduledResourceInfo *schedule;
 992         schedule = (ScheduledResourceInfo *) OICMalloc(
 993                 sizeof(ScheduledResourceInfo));
 994
 995         if (schedule)
 996         {
 997             OC_LOG(INFO, TAG, PCF("Building New Call Info."));
 998             memset(schedule, 0, sizeof(ScheduledResourceInfo));
 999
1000             if (info->actionset->timesteps > 0)
1001             {
1002 #ifndef WITH_ARDUINO
1003                 pthread_mutex_lock(&lock);
1004 #endif
1005                 schedule->resource = info->resource;
1006                 schedule->actionset = info->actionset;
1007                 schedule->ehRequest = info->ehRequest;
1008
1009                 schedule->time = registerTimer(info->actionset->timesteps,
1010                         &schedule->timer_id,
1011                         &DoScheduledGroupAction);
1012
1013                 OC_LOG(INFO, TAG, PCF("Reregisteration."));
1014 #ifndef WITH_ARDUINO
1015                 pthread_mutex_unlock(&lock);
1016 #endif
1017                 AddScheduledResource(&scheduleResourceList, schedule);
1018             }
1019         }
1020     }
1021
1022     RemoveScheduledResource(&scheduleResourceList, info);
1023
1024     exit:
1025
1026     return;
1027 }
1028
1029 OCStackResult BuildCollectionGroupActionJSONResponse(
1030         OCMethod method/*OCEntityHandlerFlag flag*/, OCResource *resource,
1031         OCEntityHandlerRequest *ehRequest)
1032 {
1033     OCStackResult stackRet = OC_STACK_ERROR;
1034
1035     OC_LOG(INFO, TAG, PCF("Group Action is requested."));
1036     // if (stackRet == OC_STACK_OK)
1037     {
1038         char *doWhat = NULL;
1039         char *details = NULL;
1040
1041         size_t bufferLength = 0;
1042         unsigned char buffer[MAX_RESPONSE_LENGTH] = { 0 };
1043         unsigned char *bufferPtr = NULL;
1044
1045         bufferPtr = buffer;
1046
1047         OCResource * collResource = (OCResource *) ehRequest->resource;
1048
1049         char *jsonResponse;
1050
1051         stackRet = ExtractKeyValueFromRequest((char *) ehRequest->reqJSONPayload,
1052                 &doWhat, &details);
1053
1054         if(stackRet != OC_STACK_OK)
1055         {
1056             OC_LOG_V(ERROR, TAG, "ExtractKeyValueFromRequest failed: %d", stackRet);
1057             return stackRet;
1058         }
1059
1060         stackRet = OC_STACK_ERROR;
1061
1062         cJSON *json;
1063         cJSON *format;
1064
1065         if (method == OC_REST_PUT)
1066         {
1067             json = cJSON_CreateObject();
1068             cJSON_AddStringToObject(json, "href", resource->uri);
1069             cJSON_AddItemToObject(json, "rep", format = cJSON_CreateObject());
1070
1071             OC_LOG(INFO, TAG, PCF("Group Action[PUT]."));
1072
1073             if (strcmp(doWhat, ACTIONSET) == 0)
1074             {
1075                 OCActionSet *actionSet = NULL;
1076                 stackRet = BuildActionSetFromString(&actionSet, details);
1077
1078                 if(stackRet == OC_STACK_OK)
1079                 {
1080                     if (actionSet != NULL)
1081                     {
1082                         stackRet = AddActionSet(&resource->actionsetHead,
1083                                 actionSet);
1084                         if (stackRet == OC_STACK_ERROR)
1085                         {
1086                             if(actionSet != NULL)
1087                             {
1088                                 DeleteActionSet( &actionSet );
1089                             }
1090                             OC_LOG(INFO, TAG, PCF("Duplicated ActionSet "));
1091                         }
1092                     }
1093                 }
1094                 else
1095                 {
1096                     stackRet = OC_STACK_ERROR;
1097                 }
1098
1099             }
1100             else if (strcmp(doWhat, DELETE_ACTIONSET) == 0)
1101             {
1102                 if (FindAndDeleteActionSet(&resource, details) == OC_STACK_OK)
1103                 {
1104                     stackRet = OC_STACK_OK;
1105                 }
1106                 else
1107                 {
1108                     stackRet = OC_STACK_ERROR;
1109                 }
1110             }
1111
1112             jsonResponse = cJSON_Print(json);
1113             cJSON_Delete(json);
1114
1115             strcat((char *) bufferPtr, jsonResponse);
1116
1117             bufferLength = strlen((const char *) buffer);
1118             if (bufferLength > 0)
1119             {
1120                 OCEntityHandlerResponse response = { 0 };
1121                 if(stackRet == OC_STACK_OK)
1122                     response.ehResult = OC_EH_OK;
1123                 else
1124                     response.ehResult = OC_EH_ERROR;
1125                 response.payload = (char*)buffer;
1126                 response.payloadSize = bufferLength + 1;
1127                 response.persistentBufferFlag = 0;
1128                 response.requestHandle =
1129                         (OCRequestHandle) ehRequest->requestHandle;
1130                 response.resourceHandle = (OCResourceHandle) collResource;
1131                 stackRet = OCDoResponse(&response);
1132             }
1133         }
1134
1135         if (method == OC_REST_POST)
1136         {
1137             OCActionSet *actionset = NULL;
1138
1139             json = cJSON_CreateObject();
1140             cJSON_AddStringToObject(json, "href", resource->uri);
1141
1142             if ((strcmp(doWhat, DO_ACTION) == 0)
1143                     || (strcmp(doWhat, "DoScheduledAction") == 0))
1144             {
1145                 char *pActionsetName = NULL;
1146                 long int delay = -1;
1147
1148                 if (strcmp(doWhat, "DoScheduledAction") == 0)
1149                 {
1150                     stackRet = ExtractActionSetNameAndDelaytime(details,
1151                             &pActionsetName, &delay);
1152
1153                     OCFREE(details)
1154                     details = pActionsetName;
1155                 }
1156                 else
1157                 {
1158                     stackRet = OC_STACK_OK;
1159                 }
1160
1161                 if (stackRet == OC_STACK_OK)
1162                 {
1163                     if (GetActionSet(details, resource->actionsetHead,
1164                             &actionset) != OC_STACK_OK)
1165                     {
1166                         OC_LOG(INFO, TAG, PCF("ERROR"));
1167                         stackRet = OC_STACK_ERROR;
1168                     }
1169
1170                     if (actionset == NULL)
1171                     {
1172                         OC_LOG(INFO, TAG, PCF("Cannot Find ActionSet"));
1173                         stackRet = OC_STACK_ERROR;
1174                     }
1175                     else
1176                     {
1177                         OC_LOG(INFO, TAG, PCF("Group Action[POST]."));
1178                         if (actionset->type == NONE)
1179                         {
1180                             OC_LOG_V(INFO, TAG, "Execute ActionSet : %s",
1181                                     actionset->actionsetName);
1182                             unsigned int num = GetNumOfTargetResource(
1183                                     actionset->head);
1184
1185                             ((OCServerRequest *) ehRequest->requestHandle)->ehResponseHandler =
1186                                     HandleAggregateResponse;
1187                             ((OCServerRequest *) ehRequest->requestHandle)->numResponses =
1188                                     num + 1;
1189
1190                             DoAction(resource, actionset,
1191                                     (OCServerRequest*) ehRequest->requestHandle);
1192                             stackRet = OC_STACK_OK;
1193                         }
1194                         else
1195                         {
1196                             OC_LOG_V(INFO, TAG, "Execute Scheduled ActionSet : %s",
1197                                     actionset->actionsetName);
1198
1199                             delay =
1200                                     (delay == -1 ? actionset->timesteps : delay);
1201
1202                             ScheduledResourceInfo *schedule;
1203                             schedule = (ScheduledResourceInfo *) OICMalloc(
1204                                     sizeof(ScheduledResourceInfo));
1205
1206                             if (schedule)
1207                             {
1208                                 OC_LOG(INFO, TAG, PCF("Building New Call Info."));
1209                                 memset(schedule, 0,
1210                                         sizeof(ScheduledResourceInfo));
1211
1212                                 schedule->resource = resource;
1213                                 schedule->actionset = actionset;
1214                                 schedule->ehRequest =
1215                                         (OCServerRequest*) ehRequest->requestHandle;
1216
1217                                 if (delay > 0)
1218                                 {
1219                                     OC_LOG_V(INFO, TAG, "delay_time is %lf seconds.",
1220                                             actionset->timesteps);
1221
1222                                     schedule->time = registerTimer(delay,
1223                                             &schedule->timer_id,
1224                                             &DoScheduledGroupAction);
1225
1226                                     AddScheduledResource(&scheduleResourceList,
1227                                             schedule);
1228                                     stackRet = OC_STACK_OK;
1229                                 }
1230                                 else
1231                                 {
1232                                     stackRet = OC_STACK_ERROR;
1233                                 }
1234                             }
1235                         }
1236                     }
1237                 }
1238             }
1239             else if (strcmp(doWhat, "CancelAction") == 0)
1240             {
1241                 ScheduledResourceInfo *info =
1242                         GetScheduledResourceByActionSetName(scheduleResourceList, details);
1243
1244                 if(info != NULL)
1245                 {
1246                     unregisterTimer(info->timer_id);
1247
1248                     RemoveScheduledResource(&scheduleResourceList, info);
1249                     stackRet = OC_STACK_OK;
1250                 }
1251                 else
1252                 {
1253                     stackRet = OC_STACK_ERROR;
1254                 }
1255             }
1256
1257             else if (strcmp(doWhat, GET_ACTIONSET) == 0)
1258             {
1259                 char *plainText = NULL;
1260                 OCActionSet *actionset = NULL;
1261
1262                 cJSON_AddItemToObject(json, "rep", format =
1263                         cJSON_CreateObject());
1264                 GetActionSet(details, resource->actionsetHead, &actionset);
1265                 if (actionset != NULL)
1266                 {
1267                     BuildStringFromActionSet(actionset, &plainText);
1268
1269                     if (plainText != NULL)
1270                     {
1271                         cJSON_AddStringToObject(format, ACTIONSET, plainText);
1272                     }
1273                     OICFree(plainText);
1274                     stackRet = OC_STACK_OK;
1275                 }
1276             }
1277
1278
1279             jsonResponse = cJSON_Print(json);
1280             cJSON_Delete(json);
1281
1282             strcat((char *) bufferPtr, jsonResponse);
1283
1284             bufferLength = strlen((const char *) buffer);
1285             if (bufferLength > 0)
1286             {
1287                 OCEntityHandlerResponse response = { 0 };
1288                 if(stackRet == OC_STACK_OK)
1289                     response.ehResult = OC_EH_OK;
1290                 else
1291                     response.ehResult = OC_EH_ERROR;
1292                 response.payload = (char *)buffer;
1293                 response.payloadSize = bufferLength + 1;
1294                 response.persistentBufferFlag = 0;
1295                 response.requestHandle =
1296                         (OCRequestHandle) ehRequest->requestHandle;
1297                 response.resourceHandle = (OCResourceHandle) collResource;
1298                 stackRet = OCDoResponse(&response);
1299             }
1300         }
1301
1302         OCFREE(doWhat)
1303         OCFREE(details)
1304     }
1305
1306     return stackRet;
1307 }