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 == NULL || address == NULL)
 170     {
 171         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : invalid parameter.");
 172         return NULL;
 173     }
 174     if (mirrorResourceList->headerNode == NULL)
 175     {
 176         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource : Empty Virtual Resource List.");
 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         return OC_STACK_ERROR;
 285     }
 286
 287     if (mirrorResource == mirrorResourceList->headerNode)
 288     {
 289         mirrorResourceList->headerNode = mirrorResourceList->headerNode->next;
 290         return OC_STACK_OK;
 291     }
 292
 293     MirrorResource *preNode = mirrorResourceList->headerNode;
 294     MirrorResource *curNode = preNode->next;
 295     while (curNode != NULL)
 296     {
 297         if (curNode == mirrorResource)
 298         {
 299             if(curNode == mirrorResourceList->headerNode)
 300             {
 301                 mirrorResourceList->headerNode = NULL;
 302                 mirrorResourceList->tailNode = NULL;
 303             }
 304             else if(curNode == mirrorResourceList->tailNode)
 305             {
 306                 mirrorResourceList->tailNode = preNode;
 307             }
 308             else
 309             {
 310             preNode->next = curNode->next;
 311             }
 312             return OC_STACK_OK;
 313         }
 314         preNode = curNode;
 315         curNode = curNode->next;
 316     }
 317
 318     return OC_STACK_ERROR;
 319
 320 }
 321
 322 MirrorResource *cloneMirrorResource(MirrorResource *sourceMirrorResource)
 323 {
 324     MirrorResource *clonedMirrorResource = createMirrorResource();
 325
 326     int sizeofstr = 0;
 327     int i = 0;
 328
 329     clonedMirrorResource->rep = cJSON_Parse(cJSON_PrintUnformatted(sourceMirrorResource->rep));
 330
 331     sizeofstr = strlen(sourceMirrorResource->uri) + 1;
 332     clonedMirrorResource->uri = (char *)malloc(sizeof(char) * sizeofstr);
 333     memset(clonedMirrorResource->uri, '\0', sizeofstr);
 334     strcpy(clonedMirrorResource->uri, sourceMirrorResource->uri);
 335
 336     for (i = OIC_SOURCE_ADDRESS; i < OIC_MIRROR_ADDRESS; ++i)
 337     {
 338         sizeofstr = strlen(sourceMirrorResource->address[i]) + 1;
 339         clonedMirrorResource->address[i] = (char *)malloc(sizeof(char) * sizeofstr);
 340         memset(clonedMirrorResource->address[i], '\0', sizeofstr);
 341         strcpy(clonedMirrorResource->address[i], sourceMirrorResource->address[i]);
 342     }
 343
 344     return clonedMirrorResource;
 345 }
 346
 347 MirrorResourceList *findMirrorResourceListUsingAddress(MirrorResourceList *mirrorResourceList,
 348         const char *address, OICResourceCoordinatorParamType paramType)
 349 {
 350     if (mirrorResourceList == NULL || address == NULL)
 351     {
 352         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource List : invalid parameter.");
 353         return NULL;
 354     }
 355     if (mirrorResourceList->headerNode == NULL)
 356     {
 357         OC_LOG_V(DEBUG, VR_TAG,"Find Virtual Resource List : Empty Virtual Resource List.");
 358         return NULL;
 359     }
 360
 361     MirrorResource *tempNode = mirrorResourceList->headerNode;
 362     while (tempNode != NULL)
 363     {
 364         OC_LOG_V(DEBUG, VR_TAG, "uri = %s", tempNode->uri);
 365         tempNode = tempNode->next;
 366     }
 367
 368
 369     MirrorResourceList *resultMirrorResourceList = createMirrorResourceList();
 370     MirrorResource *mirrorResource = mirrorResourceList->headerNode;
 371     while (mirrorResource != NULL)
 372     {
 373         if (strcmp(mirrorResource->address[paramType], address) == 0) // if(It is Same)
 374         {
 375             insertMirrorResource(resultMirrorResourceList, cloneMirrorResource(mirrorResource));
 376         }
 377         mirrorResource = mirrorResource->next;
 378     }
 379
 380     return resultMirrorResourceList;
 381 }
 382
 383
 384 OCStackResult printMirrorResourceList(MirrorResourceList *mirrorResourceList)
 385 {
 386     if (mirrorResourceList == NULL)
 387     {
 388         OC_LOG_V(DEBUG, VR_TAG, "print Virtual Resource list : invalid parameter.");
 389         return OC_STACK_INVALID_PARAM;
 390     }
 391     if (mirrorResourceList->headerNode == NULL)
 392     {
 393         OC_LOG_V(DEBUG, VR_TAG, "print Virtual Resource list : Empty Virtual Resource List.");
 394         return OC_STACK_INVALID_PARAM;
 395     }
 396     OC_LOG_V(DEBUG, VR_TAG, "==============================================================");
 397     MirrorResource *mirrorResource = mirrorResourceList->headerNode;
 398     while (mirrorResource != NULL)
 399     {
 400         OC_LOG_V(DEBUG, VR_TAG, "uri = %s", mirrorResource->uri);
 401         mirrorResource = mirrorResource->next;
 402     }
 403     OC_LOG_V(DEBUG, VR_TAG, "==============================================================");
 404
 405     return OC_STACK_OK;
 406 }