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     return OCDoResource(handle, OC_REST_PUT, targetUri,
 909     NULL, (char *) action, OC_ETHERNET, 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 *) OCMalloc(
 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 *) OCMalloc(
 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         ExtractKeyValueFromRequest((char *) ehRequest->reqJSONPayload, &doWhat,
1052                 &details);
1053
1054         cJSON *json;
1055         cJSON *format;
1056
1057         if (method == OC_REST_PUT)
1058         {
1059             json = cJSON_CreateObject();
1060             cJSON_AddStringToObject(json, "href", resource->uri);
1061             cJSON_AddItemToObject(json, "rep", format = cJSON_CreateObject());
1062
1063             OC_LOG(INFO, TAG, PCF("Group Action[PUT]."));
1064
1065             if (strcmp(doWhat, ACTIONSET) == 0)
1066             {
1067                 OCActionSet *actionSet = NULL;
1068                 stackRet = BuildActionSetFromString(&actionSet, details);
1069
1070                 if(stackRet == OC_STACK_OK)
1071                 {
1072                     if (actionSet != NULL)
1073                     {
1074                         stackRet = AddActionSet(&resource->actionsetHead,
1075                                 actionSet);
1076                         if (stackRet == OC_STACK_ERROR)
1077                         {
1078                             if(actionSet != NULL)
1079                             {
1080                                 DeleteActionSet( &actionSet );
1081                             }
1082                             OC_LOG(INFO, TAG, PCF("Duplicated ActionSet "));
1083                         }
1084                     }
1085                 }
1086                 else
1087                 {
1088                     stackRet = OC_STACK_ERROR;
1089                 }
1090
1091             }
1092             else if (strcmp(doWhat, DELETE_ACTIONSET) == 0)
1093             {
1094                 if (FindAndDeleteActionSet(&resource, details) == OC_STACK_OK)
1095                 {
1096                     stackRet = OC_STACK_OK;
1097                 }
1098                 else
1099                 {
1100                     stackRet = OC_STACK_ERROR;
1101                 }
1102             }
1103
1104             jsonResponse = cJSON_Print(json);
1105             cJSON_Delete(json);
1106
1107             strcat((char *) bufferPtr, jsonResponse);
1108
1109             bufferLength = strlen((const char *) buffer);
1110             if (bufferLength > 0)
1111             {
1112                 OCEntityHandlerResponse response = { 0 };
1113                 if(stackRet == OC_STACK_OK)
1114                     response.ehResult = OC_EH_OK;
1115                 else
1116                     response.ehResult = OC_EH_ERROR;
1117                 response.payload = (char*)buffer;
1118                 response.payloadSize = bufferLength + 1;
1119                 response.persistentBufferFlag = 0;
1120                 response.requestHandle =
1121                         (OCRequestHandle) ehRequest->requestHandle;
1122                 response.resourceHandle = (OCResourceHandle) collResource;
1123                 stackRet = OCDoResponse(&response);
1124             }
1125         }
1126
1127         if (method == OC_REST_POST)
1128         {
1129             OCActionSet *actionset = NULL;
1130
1131             json = cJSON_CreateObject();
1132             cJSON_AddStringToObject(json, "href", resource->uri);
1133
1134             if ((strcmp(doWhat, DO_ACTION) == 0)
1135                     || (strcmp(doWhat, "DoScheduledAction") == 0))
1136             {
1137                 char *pActionsetName = NULL;
1138                 long int delay = -1;
1139
1140                 if (strcmp(doWhat, "DoScheduledAction") == 0)
1141                 {
1142                     stackRet = ExtractActionSetNameAndDelaytime(details,
1143                             &pActionsetName, &delay);
1144
1145                     OCFREE(details)
1146                     details = pActionsetName;
1147                 }
1148                 else
1149                 {
1150                     stackRet = OC_STACK_OK;
1151                 }
1152
1153                 if (stackRet == OC_STACK_OK)
1154                 {
1155                     if (GetActionSet(details, resource->actionsetHead,
1156                             &actionset) != OC_STACK_OK)
1157                     {
1158                         OC_LOG(INFO, TAG, PCF("ERROR"));
1159                         stackRet = OC_STACK_ERROR;
1160                     }
1161
1162                     if (actionset == NULL)
1163                     {
1164                         OC_LOG(INFO, TAG, PCF("Cannot Find ActionSet"));
1165                         stackRet = OC_STACK_ERROR;
1166                     }
1167                     else
1168                     {
1169                         OC_LOG(INFO, TAG, PCF("Group Action[POST]."));
1170                         if (actionset->type == NONE)
1171                         {
1172                             OC_LOG_V(INFO, TAG, "Execute ActionSet : %s",
1173                                     actionset->actionsetName);
1174                             unsigned int num = GetNumOfTargetResource(
1175                                     actionset->head);
1176
1177                             ((OCServerRequest *) ehRequest->requestHandle)->ehResponseHandler =
1178                                     HandleAggregateResponse;
1179                             ((OCServerRequest *) ehRequest->requestHandle)->numResponses =
1180                                     num + 1;
1181
1182                             DoAction(resource, actionset,
1183                                     (OCServerRequest*) ehRequest->requestHandle);
1184                             stackRet = OC_STACK_OK;
1185                         }
1186                         else
1187                         {
1188                             OC_LOG_V(INFO, TAG, "Execute Scheduled ActionSet : %s",
1189                                     actionset->actionsetName);
1190
1191                             delay =
1192                                     (delay == -1 ? actionset->timesteps : delay);
1193
1194                             ScheduledResourceInfo *schedule;
1195                             schedule = (ScheduledResourceInfo *) OCMalloc(
1196                                     sizeof(ScheduledResourceInfo));
1197
1198                             if (schedule)
1199                             {
1200                                 OC_LOG(INFO, TAG, PCF("Building New Call Info."));
1201                                 memset(schedule, 0,
1202                                         sizeof(ScheduledResourceInfo));
1203
1204                                 schedule->resource = resource;
1205                                 schedule->actionset = actionset;
1206                                 schedule->ehRequest =
1207                                         (OCServerRequest*) ehRequest->requestHandle;
1208
1209                                 if (delay > 0)
1210                                 {
1211                                     OC_LOG_V(INFO, TAG, "delay_time is %lf seconds.",
1212                                             actionset->timesteps);
1213
1214                                     schedule->time = registerTimer(delay,
1215                                             &schedule->timer_id,
1216                                             &DoScheduledGroupAction);
1217
1218                                     AddScheduledResource(&scheduleResourceList,
1219                                             schedule);
1220                                     stackRet = OC_STACK_OK;
1221                                 }
1222                                 else
1223                                 {
1224                                     stackRet = OC_STACK_ERROR;
1225                                 }
1226                             }
1227                         }
1228                     }
1229                 }
1230             }
1231             else if (strcmp(doWhat, "CancelAction") == 0)
1232             {
1233                 ScheduledResourceInfo *info =
1234                         GetScheduledResourceByActionSetName(scheduleResourceList, details);
1235
1236                 if(info != NULL)
1237                 {
1238                     unregisterTimer(info->timer_id);
1239
1240                     RemoveScheduledResource(&scheduleResourceList, info);
1241                     stackRet = OC_STACK_OK;
1242                 }
1243                 else
1244                 {
1245                     stackRet = OC_STACK_ERROR;
1246                 }
1247             }
1248
1249             else if (strcmp(doWhat, GET_ACTIONSET) == 0)
1250             {
1251                 char *plainText = NULL;
1252                 OCActionSet *actionset = NULL;
1253
1254                 cJSON_AddItemToObject(json, "rep", format =
1255                         cJSON_CreateObject());
1256                 GetActionSet(details, resource->actionsetHead, &actionset);
1257                 if (actionset != NULL)
1258                 {
1259                     BuildStringFromActionSet(actionset, &plainText);
1260
1261                     if (plainText != NULL)
1262                     {
1263                         cJSON_AddStringToObject(format, ACTIONSET, plainText);
1264                     }
1265
1266                     stackRet = OC_STACK_OK;
1267                 }
1268             }
1269
1270
1271             jsonResponse = cJSON_Print(json);
1272             cJSON_Delete(json);
1273
1274             strcat((char *) bufferPtr, jsonResponse);
1275
1276             bufferLength = strlen((const char *) buffer);
1277             if (bufferLength > 0)
1278             {
1279                 OCEntityHandlerResponse response = { 0 };
1280                 if(stackRet == OC_STACK_OK)
1281                     response.ehResult = OC_EH_OK;
1282                 else
1283                     response.ehResult = OC_EH_ERROR;
1284                 response.payload = (char *)buffer;
1285                 response.payloadSize = bufferLength + 1;
1286                 response.persistentBufferFlag = 0;
1287                 response.requestHandle =
1288                         (OCRequestHandle) ehRequest->requestHandle;
1289                 response.resourceHandle = (OCResourceHandle) collResource;
1290                 stackRet = OCDoResponse(&response);
1291             }
1292         }
1293
1294         OCFREE(doWhat)
1295         OCFREE(details)
1296     }
1297
1298     return stackRet;
1299 }