service/notification-manager/NotificationManager/src/virtualResource.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "virtualResource.h"
  22
  23
  24 MirrorResourceList *createMirrorResourceList()
  25 {
  26     MirrorResourceList *mirrorResourceList = (MirrorResourceList *)malloc(sizeof(MirrorResourceList));
  27     if (!mirrorResourceList)
  28     {
  29         OC_LOG_V(DEBUG, VR_TAG,"Virtual Resource List Creation Fail.");
  30     }
  31     else
  32     {
  33         mirrorResourceList->headerNode = NULL;
  34         mirrorResourceList->tailNode = NULL;
  35     }
  36
  37     return mirrorResourceList;
  38 }
  39
  40 MirrorResource *createMirrorResource()
  41 {
  42     MirrorResource *mirrorResource = (MirrorResource*)malloc(sizeof(MirrorResource));
  43     if (!mirrorResource)
  44     {
  45         OC_LOG_V(DEBUG, VR_TAG,"Virtual Resource List Creation Fail.");
  46     }
  47     else
  48     {
  49         mirrorResource->resourceHandle[OIC_REQUEST_HANDLE] = NULL;
  50         mirrorResource->resourceHandle[OIC_MIRROR_HANDLE] = NULL;
  51         mirrorResource->address[OIC_SOURCE_ADDRESS]    = NULL;
  52         mirrorResource->address[OIC_MIRROR_ADDRESS]   = NULL;
  53
  54         mirrorResource->rep    = NULL;
  55         mirrorResource->uri    = NULL;
  56         mirrorResource->next   = NULL;
  57
  58         mirrorResource->prop.countResourceType = 0;
  59         mirrorResource->prop.resourceType = NULL;
  60         mirrorResource->prop.countInterface = 0;
  61         mirrorResource->prop.resourceInterfaceName = NULL;
  62     }
  63
  64     return mirrorResource;
  65 }
  66
  67 OCStackResult destroyMirrorResourceList(MirrorResourceList *mirrorResourceList)
  68 {
  69     OC_LOG_V(DEBUG, VR_TAG,"enter destroyVirtualResourceList");
  70     if(mirrorResourceList)
  71     {
  72         while (mirrorResourceList->headerNode)
  73         {
  74             deleteMirrorResourceFromList(mirrorResourceList, mirrorResourceList->headerNode);
  75         }
  76
  77         free(mirrorResourceList);
  78     }
  79     else
  80     {
  81         return OC_STACK_INVALID_PARAM;
  82     }
  83
  84     return OC_STACK_OK;
  85 }
  86
  87 OCStackResult destroyMirrorResource(MirrorResource *mirrorResource)
  88 {
  89     OC_LOG_V(DEBUG, VR_TAG,"enter destroy virtual resource.");
  90     if(mirrorResource)
  91     {
  92         if(mirrorResource->next)
  93         {
  94             mirrorResource->next = NULL;
  95         }
  96         if (mirrorResource->rep)
  97         {
  98             cJSON_Delete(mirrorResource->rep);
  99         }
 100         if (mirrorResource->uri)
 101         {
 102             free(mirrorResource->uri);
 103         }
 104         if (mirrorResource->address[OIC_SOURCE_ADDRESS])
 105         {
 106             free(mirrorResource->address[OIC_SOURCE_ADDRESS]);
 107         }
 108         if (mirrorResource->address[OIC_MIRROR_ADDRESS])
 109         {
 110             free(mirrorResource->address[OIC_MIRROR_ADDRESS]);
 111         }
 112         if (mirrorResource->prop.resourceType)
 113         {
 114             int i = 0;
 115             for (i = 0; i < mirrorResource->prop.countResourceType; ++i)
 116             {
 117                 free(mirrorResource->prop.resourceType[i]);
 118                 mirrorResource->prop.resourceType[i] = NULL;
 119             }
 120             free(mirrorResource->prop.resourceType);
 121             mirrorResource->prop.countResourceType = 0;
 122         }
 123         if (mirrorResource->prop.resourceInterfaceName)
 124         {
 125             int i = 0;
 126             for (i = 0; i < mirrorResource->prop.countInterface; ++i)
 127             {
 128                 free(mirrorResource->prop.resourceInterfaceName[i]);
 129                 mirrorResource->prop.resourceInterfaceName[i] = NULL;
 130             }
 131             free(mirrorResource->prop.resourceInterfaceName);
 132             mirrorResource->prop.countInterface = 0;
 133         }
 134         free(mirrorResource);
 135     }
 136     else
 137     {
 138         return OC_STACK_INVALID_PARAM;
 139     }
 140
 141     return OC_STACK_OK;
 142 }
 143
 144 OCStackResult insertMirrorResource(MirrorResourceList *mirrorResourceList,
 145                                    MirrorResource *mirrorResource)
 146 {
 147     if (mirrorResourceList == NULL || mirrorResource == NULL)
 148     {
 149         return OC_STACK_INVALID_PARAM;
 150     }
 151
 152     if (mirrorResourceList->headerNode == NULL)
 153     {
 154         mirrorResourceList->headerNode = mirrorResource;
 155         mirrorResourceList->tailNode = mirrorResource;
 156     }
 157     else
 158     {
 159         mirrorResourceList->tailNode->next = mirrorResource;
 160         mirrorResourceList->tailNode = mirrorResource;
 161     }
 162
 163     return OC_STACK_OK;
 164 }
 165
 166 MirrorResource *findMirrorResourceUsingAddressAndURI(MirrorResourceList *mirrorResourceList,
 167         const char *address, OICResourceCoordinatorParamType paramType, const char *uri)
 168 {
 169     if (mirrorResourceList->headerNode == NULL)
 170     {
 171         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : Empty Virtual Resource List.");
 172         return NULL;
 173     }
 174     if (mirrorResourceList == NULL || address == NULL)
 175     {
 176         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : invalid parameter.");
 177         return NULL;
 178     }
 179
 180     MirrorResource *tempMirrorResource = mirrorResourceList->headerNode;
 181     while (tempMirrorResource != NULL)
 182     {
 183         OC_LOG_V(DEBUG, VR_TAG,"node's uri = %s", tempMirrorResource->uri);
 184         if (strcmp(tempMirrorResource->address[paramType], address) == 0) // if(It is Same)
 185         {
 186             if (strcmp(tempMirrorResource->uri, uri) == 0) // if(It is Same)
 187             {
 188                 return tempMirrorResource;
 189             }
 190         }
 191         tempMirrorResource = tempMirrorResource->next;
 192     }
 193
 194     return NULL;
 195 }
 196
 197 MirrorResource *findMirrorResourceUsingHandle(MirrorResourceList *mirrorResourceList,
 198         OCResourceHandle handle, OICResourceCoordinatorParamType paramType)
 199 {
 200     if (mirrorResourceList == NULL || handle == NULL)
 201     {
 202         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : invalid parameter.");
 203         return NULL;
 204     }
 205     if (mirrorResourceList->headerNode == NULL)
 206     {
 207         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : Empty Virtual Resource List.");
 208         return NULL;
 209     }
 210
 211     MirrorResource *tempMirrorResource = mirrorResourceList->headerNode;
 212     while (tempMirrorResource != NULL)
 213     {
 214         if (tempMirrorResource->resourceHandle[paramType] == handle)
 215         {
 216             return tempMirrorResource;
 217         }
 218         tempMirrorResource = tempMirrorResource->next;
 219     }
 220
 221     return NULL;
 222 }
 223
 224 OCStackResult deleteMirrorResourceFromList(MirrorResourceList *mirrorResourceList,
 225         MirrorResource *mirrorResource)
 226 {
 227
 228     OC_LOG_V(DEBUG, VR_TAG,"enter delete virtual resource.");
 229
 230     if (mirrorResourceList == NULL || mirrorResource == NULL)
 231     {
 232         OC_LOG_V(DEBUG, VR_TAG,"Delete Virtual Resource : invalid parameter.");
 233         return OC_STACK_INVALID_PARAM;
 234     }
 235     if (mirrorResourceList->headerNode == NULL)
 236     {
 237         OC_LOG_V(DEBUG, VR_TAG,"Delete Virtual Resource : Empty Virtual Resource List.");
 238         return OC_STACK_ERROR;
 239     }
 240
 241     if (mirrorResource == mirrorResourceList->headerNode)
 242     {
 243         mirrorResourceList->headerNode = mirrorResourceList->headerNode->next;
 244         mirrorResource->next = NULL;
 245         return destroyMirrorResource(mirrorResource);
 246     }
 247
 248     MirrorResource *preNode = mirrorResourceList->headerNode;
 249     MirrorResource *curNode = preNode->next;
 250     while (curNode != NULL)
 251     {
 252         if (curNode == mirrorResource)
 253         {
 254             if (curNode == mirrorResourceList->tailNode)
 255             {
 256                 mirrorResourceList->tailNode = preNode;
 257                 preNode->next = NULL;
 258             }
 259             else
 260             {
 261                 preNode->next = curNode->next;
 262             }
 263             mirrorResource->next = NULL;
 264             return destroyMirrorResource(mirrorResource);
 265         }
 266         preNode = curNode;
 267         curNode = curNode->next;
 268     }
 269
 270     return OC_STACK_ERROR;
 271 }
 272
 273 OCStackResult ejectMirrorResource(MirrorResourceList *mirrorResourceList,
 274                                   MirrorResource *mirrorResource)
 275 {
 276     if (mirrorResourceList == NULL || mirrorResource == NULL)
 277     {
 278         OC_LOG_V(DEBUG, VR_TAG,"Eject Virtual Resource : invalid parameter.");
 279         return OC_STACK_INVALID_PARAM;
 280     }
 281     if (mirrorResourceList->headerNode == NULL)
 282     {
 283         OC_LOG_V(DEBUG, VR_TAG, "Eject Virtual Resource : Empty Virtual Resource List.");
 284     }
 285
 286     if (mirrorResource == mirrorResourceList->headerNode)
 287     {
 288         mirrorResourceList->headerNode = mirrorResourceList->headerNode->next;
 289         return OC_STACK_OK;
 290     }
 291
 292     MirrorResource *preNode = mirrorResourceList->headerNode;
 293     MirrorResource *curNode = preNode->next;
 294     while (curNode != NULL)
 295     {
 296         if (curNode == mirrorResource)
 297         {
 298             if(curNode == mirrorResourceList->headerNode)
 299             {
 300                 mirrorResourceList->headerNode = NULL;
 301                 mirrorResourceList->tailNode = NULL;
 302             }
 303             else if(curNode == mirrorResourceList->tailNode)
 304             {
 305                 mirrorResourceList->tailNode = preNode;
 306             }
 307             else
 308             {
 309             preNode->next = curNode->next;
 310             }
 311             return OC_STACK_OK;
 312         }
 313         preNode = curNode;
 314         curNode = curNode->next;
 315     }
 316
 317     return OC_STACK_ERROR;
 318
 319 }
 320
 321 MirrorResource *cloneMirrorResource(MirrorResource *sourceMirrorResource)
 322 {
 323     MirrorResource *clonedMirrorResource = createMirrorResource();
 324
 325     int sizeofstr = 0;
 326     int i = 0;
 327
 328     clonedMirrorResource->rep = cJSON_Parse(cJSON_PrintUnformatted(sourceMirrorResource->rep));
 329
 330     sizeofstr = strlen(sourceMirrorResource->uri) + 1;
 331     clonedMirrorResource->uri = (char *)malloc(sizeof(char) * sizeofstr);
 332     memset(clonedMirrorResource->uri, '\0', sizeofstr);
 333     strcpy(clonedMirrorResource->uri, sourceMirrorResource->uri);
 334
 335     for (i = OIC_SOURCE_ADDRESS; i < OIC_MIRROR_ADDRESS; ++i)
 336     {
 337         sizeofstr = strlen(sourceMirrorResource->address[i]) + 1;
 338         clonedMirrorResource->address[i] = (char *)malloc(sizeof(char) * sizeofstr);
 339         memset(clonedMirrorResource->address[i], '\0', sizeofstr);
 340         strcpy(clonedMirrorResource->address[i], sourceMirrorResource->address[i]);
 341     }
 342
 343     // copy prop ??
 344
 345     return clonedMirrorResource;
 346 }
 347
 348 MirrorResourceList *findMirrorResourceListUsingAddress(MirrorResourceList *mirrorResourceList,
 349         const char *address, OICResourceCoordinatorParamType paramType)
 350 {
 351
 352     MirrorResource *tempNode = mirrorResourceList->headerNode;
 353     int i = 0;
 354     while (tempNode != NULL)
 355     {
 356         OC_LOG_V(DEBUG, VR_TAG, "%d's uri = %s", i++, tempNode->uri);
 357         tempNode = tempNode->next;
 358     }
 359
 360     if (mirrorResourceList == NULL || address == NULL)
 361     {
 362         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource List : invalid parameter.");
 363         return NULL;
 364     }
 365     if (mirrorResourceList->headerNode == NULL)
 366     {
 367         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource List : Empty Virtual Resource List.");
 368         return NULL;
 369     }
 370
 371     MirrorResourceList *resultMirrorResourceList = createMirrorResourceList();
 372     MirrorResource *mirrorResource = mirrorResourceList->headerNode;
 373     while (mirrorResource != NULL)
 374     {
 375         if (strcmp(mirrorResource->address[paramType], address) == 0) // if(It is Same)
 376         {
 377             insertMirrorResource(resultMirrorResourceList, cloneMirrorResource(mirrorResource));
 378         }
 379         mirrorResource = mirrorResource->next;
 380     }
 381
 382     return resultMirrorResourceList;
 383 }
 384
 385
 386 OCStackResult printMirrorResourceList(MirrorResourceList *mirrorResourceList)
 387 {
 388     if (mirrorResourceList == NULL)
 389     {
 390         OC_LOG_V(DEBUG, VR_TAG, "print Virtual Resource list : invalid parameter.");
 391         return OC_STACK_INVALID_PARAM;
 392     }
 393     if (mirrorResourceList->headerNode == NULL)
 394     {
 395         OC_LOG_V(DEBUG, VR_TAG, "print Virtual Resource list : Empty Virtual Resource List.");
 396         return OC_STACK_INVALID_PARAM;
 397     }
 398     OC_LOG_V(DEBUG, VR_TAG, "==============================================================");
 399     MirrorResource *mirrorResource = mirrorResourceList->headerNode;
 400     int i = 0;
 401     while (mirrorResource != NULL)
 402     {
 403         OC_LOG_V(DEBUG, VR_TAG, "%d's uri = %s", i++, mirrorResource->uri);
 404         mirrorResource = mirrorResource->next;
 405     }
 406     OC_LOG_V(DEBUG, VR_TAG, "==============================================================");
 407
 408     return OC_STACK_OK;
 409 }