[IOT-2539] Clean sign-compare warnings
[iotivity.git] / resource / csdk / security / unittest / aclresourcetest.cpp
1 //******************************************************************
2 //
3 // Copyright 2015 Intel Mobile Communications GmbH 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 <gtest/gtest.h>
22 #include <coap/utlist.h>
23 #include <sys/stat.h>
24 #include "ocstack.h"
25 #include "psinterface.h"
26 #include "ocpayload.h"
27 #include "oic_malloc.h"
28 #include "oic_string.h"
29 #include "cainterface.h"
30 #include "secureresourcemanager.h"
31 #include "srmresourcestrings.h"
32 #include "aclresource.h"
33 #include "pstatresource.h"
34 #include "srmtestcommon.h"
35 #include "srmutility.h"
36 #include "logger.h"
37 #include "doxmresource.h"
38 #include "ocpayload.h"
39 #include "ocpayloadcbor.h"
40 #include "payload_logging.h"
41 #include "security_internals.h"
42 #include "acl_logging.h"
43
44 using namespace std;
45
46 #define TAG  "SRM-ACL-UT"
47
48 // These paths match jenkins build configuration.
49 const char* DEFAULT_ACL_FILE_NAME = "oic_unittest_default_acl.dat";
50 const char* ACL1_FILE_NAME = "oic_unittest_acl1.dat";
51
52 #define NUM_ACE_FOR_ANON_CLEAR_IN_DEFAULT_ACL (2)
53
54 static bool AddResourceToACE(OicSecAce_t* ace, const char* rsrcName,
55                              const char* typeName, const char* interfaceName)
56 {
57     OicSecRsrc_t* rsrc = NULL;
58
59     VERIFY_NOT_NULL(TAG, ace, ERROR);
60     VERIFY_NOT_NULL(TAG, rsrcName, ERROR);
61     VERIFY_NOT_NULL(TAG, interfaceName, ERROR);
62     VERIFY_NOT_NULL(TAG, typeName, ERROR);
63
64     rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
65     VERIFY_NOT_NULL(TAG, rsrc, ERROR);
66     rsrc->href = OICStrdup(rsrcName);
67     VERIFY_NOT_NULL(TAG, rsrc->href, ERROR);
68
69     rsrc->typeLen = 1;
70     rsrc->types = (char**)OICCalloc(1, sizeof(char*));
71     VERIFY_NOT_NULL(TAG, rsrc->types, ERROR);
72     rsrc->types[0] = OICStrdup(typeName);
73     VERIFY_NOT_NULL(TAG, rsrc->types[0], ERROR);
74
75     rsrc->interfaceLen = 1;
76     rsrc->interfaces = (char**)OICCalloc(1, sizeof(char*));
77     VERIFY_NOT_NULL(TAG, rsrc->interfaces, ERROR);
78     rsrc->interfaces[0] = OICStrdup(interfaceName);
79     VERIFY_NOT_NULL(TAG, rsrc->interfaces[0], ERROR);
80
81     LL_APPEND(ace->resources, rsrc);
82     return true;
83 exit:
84     if(rsrc)
85     {
86         if(rsrc->href)
87         {
88             OICFree(rsrc->href);
89             OICFree(rsrc->types[0]);
90             OICFree(rsrc->types);
91             OICFree(rsrc->interfaces[0]);
92             OICFree(rsrc->interfaces);
93         }
94         OICFree(rsrc);
95     }
96     return false;
97 }
98
99 static size_t GetNumberOfResource(const OicSecAce_t* ace)
100 {
101     size_t ret = 0;
102     OicSecRsrc_t* rsrc = NULL;
103     LL_FOREACH(ace->resources, rsrc)
104     {
105         ret++;
106     }
107
108     return ret;
109 }
110
111 TEST(ACLResourceTest, CBORDefaultACLConversion)
112 {
113     uint8_t defaultAclSub[] = {0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
114         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31};
115     uint8_t defaultAclOwnrs[] = {0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
116         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32};
117
118     OicSecAcl_t *defaultAcl = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t));
119     ASSERT_TRUE(NULL != defaultAcl);
120     OicSecAce_t *ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
121     ASSERT_TRUE(NULL != ace);
122     ace->permission = 2;
123     memcpy(ace->subjectuuid.id, defaultAclSub, sizeof(defaultAclSub));
124     LL_APPEND(defaultAcl->aces, ace);
125
126     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/res", "oic.wk.res", "oic.if.ll"));
127     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/d", "oic.wk.d", "oic.if.r"));
128     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/p", "oic.wk.p", "oic.if.r"));
129     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/res/types/d", "oic.wk.unknow", "oic.if.r"));
130     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/ad", "oic.wk.ad", "oic.if.baseline"));
131     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/sec/acl2", "oic.r.acl2", "oic.if.baseline"));
132     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/sec/doxm", "oic.r.doxm" ,"oic.if.baseline"));
133     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/sec/pstat", "oic.r.pstat" ,"oic.if.baseline"));
134
135     memcpy(defaultAcl->rownerID.id, defaultAclOwnrs, sizeof(defaultAclOwnrs));
136
137     size_t defaultAclSize = 0;
138     uint8_t *defaultPsStorage = NULL;
139     OCStackResult convRet = AclToCBORPayload(defaultAcl, OIC_SEC_ACL_V2, &defaultPsStorage, &defaultAclSize);
140     EXPECT_EQ(OC_STACK_OK, convRet);
141     ASSERT_TRUE(NULL != defaultPsStorage);
142     EXPECT_NE(static_cast<size_t>(0), defaultAclSize);
143
144     OicSecAcl_t* convertedAcl = CBORPayloadToAcl(defaultPsStorage, defaultAclSize);
145     ASSERT_TRUE(NULL != convertedAcl);
146
147     size_t rsrcCnt1 = 0;
148     size_t rsrcCnt2 = 0;
149     OicSecAce_t* tempAce = NULL;
150     LL_FOREACH(defaultAcl->aces, tempAce)
151     {
152         rsrcCnt1 += GetNumberOfResource(tempAce);
153     }
154     tempAce = NULL;
155     LL_FOREACH(convertedAcl->aces, tempAce)
156     {
157         rsrcCnt2 += GetNumberOfResource(tempAce);
158     }
159     EXPECT_EQ(rsrcCnt1, rsrcCnt2);
160
161     DeleteACLList(convertedAcl);
162     DeleteACLList(defaultAcl);
163     OICFree(defaultPsStorage);
164 }
165
166 TEST(ACLResourceTest, CBORACLConversion)
167 {
168     uint8_t ownrs[] = {0x32, 0x32, 0x32, 0x32,
169                        0x32, 0x32, 0x32, 0x32,
170                        0x32, 0x32, 0x32, 0x32,
171                        0x32, 0x32, 0x32, 0x32};
172     const char* subjectUuid[3] = {"0000000000000000",
173                                   "1111111111111111",
174                                   "2222222222222222"};
175     const uint16_t permission[3] = {2, 6, 31};
176     const size_t numOfRsrc[3] = {6, 2, 2};
177
178     OicSecAcl_t *secAcl = (OicSecAcl_t *) OICCalloc(1, sizeof(OicSecAcl_t));
179     ASSERT_TRUE(secAcl != NULL);
180     memcpy(secAcl->rownerID.id, ownrs, sizeof(ownrs));
181
182     OicSecAce_t *ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
183     ASSERT_TRUE(NULL != ace);
184     ace->permission = permission[0];
185     memcpy(ace->subjectuuid.id, subjectUuid[0], strlen(subjectUuid[0]));
186     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/res", "oic.wk.res", "oic.if.ll"));
187     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/d", "oic.wk.d", "oic.if.r"));
188     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/p", "oic.wk.p", "oic.if.r"));
189     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/res/types/d", "oic.wk.unknow", "oic.if.r"));
190     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/ad", "oic.wk.ad", "oic.if.baseline"));
191     EXPECT_EQ(true, AddResourceToACE(ace, "/oic/sec/acl2", "oic.r.acl2", "oic.if.baseline"));
192     LL_APPEND(secAcl->aces, ace);
193
194     OicSecAce_t *ace1 = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
195     ASSERT_TRUE(NULL != ace1);
196     ace1->permission = permission[1];
197     memcpy(ace1->subjectuuid.id, subjectUuid[1], strlen(subjectUuid[1]));
198     EXPECT_EQ(true, AddResourceToACE(ace1, "/oic/sec/doxm", "oic.r.doxm" ,"oic.if.baseline"));
199     EXPECT_EQ(true, AddResourceToACE(ace1, "/oic/sec/pstat", "oic.r.pstat" ,"oic.if.baseline"));
200     LL_APPEND(secAcl->aces, ace1);
201
202     OicSecAce_t *ace2 = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
203     ASSERT_TRUE(NULL != ace2);
204     ace2->permission = permission[2];
205     memcpy(ace2->subjectuuid.id, subjectUuid[2], strlen(subjectUuid[2]));
206     EXPECT_EQ(true, AddResourceToACE(ace2, "/oic/light", "oic.core", "oic.if.baseline"));
207     EXPECT_EQ(true, AddResourceToACE(ace2, "/oic/garage", "oic.core", "oic.if.baseline"));
208     LL_APPEND(secAcl->aces, ace2);
209
210     size_t size = 0;
211     uint8_t *psStorage = NULL;
212     EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(secAcl, OIC_SEC_ACL_V1, &psStorage, &size));
213     ASSERT_TRUE(NULL != psStorage);
214     OicSecAcl_t *acl = CBORPayloadToAcl(psStorage, size);
215     ASSERT_TRUE(NULL != acl);
216
217     size_t numberOfCheckedAce = 0;
218     OicSecAce_t* tempAce = NULL;
219     LL_FOREACH(acl->aces, tempAce)
220     {
221         if(memcmp(tempAce->subjectuuid.id, subjectUuid[0], strlen(subjectUuid[0])) == 0)
222         {
223             EXPECT_EQ(numOfRsrc[0], GetNumberOfResource(tempAce));
224             EXPECT_EQ(permission[0], tempAce->permission);
225             numberOfCheckedAce++;
226         }
227         if(memcmp(tempAce->subjectuuid.id, subjectUuid[1], strlen(subjectUuid[1])) == 0)
228         {
229             EXPECT_EQ(numOfRsrc[1], GetNumberOfResource(tempAce));
230             EXPECT_EQ(permission[1], tempAce->permission);
231             numberOfCheckedAce++;
232         }
233         if(memcmp(tempAce->subjectuuid.id, subjectUuid[2], strlen(subjectUuid[2])) == 0)
234         {
235             EXPECT_EQ(numOfRsrc[2], GetNumberOfResource(tempAce));
236             EXPECT_EQ(permission[2], tempAce->permission);
237             numberOfCheckedAce++;
238         }
239     }
240     EXPECT_EQ(3u, numberOfCheckedAce);
241
242     DeleteACLList(acl);
243     DeleteACLList(secAcl);
244     OICFree(psStorage);
245 }
246
247 //InitResource Tests
248 TEST(ACLResourceTest, InitAclResource)
249 {
250     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitACLResource());
251     EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitACLResource());
252 }
253
254 // Default ACL tests
255 TEST(ACLResourceTest, GetDefaultACLTests)
256 {
257     uint8_t *payload = NULL;
258     size_t size = 0;
259
260     ASSERT_TRUE(ReadCBORFile(DEFAULT_ACL_FILE_NAME, OIC_JSON_ACL_NAME, &payload, &size));
261     ASSERT_TRUE(NULL != payload);
262
263     OicSecAcl_t *psAcl = CBORPayloadToAcl(payload, size);
264     ASSERT_TRUE(NULL != psAcl);
265
266     OicSecAcl_t *acl = NULL;
267     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&acl));
268     ASSERT_TRUE(NULL != acl);
269
270     // Verify if the SRM generated default ACL matches with unit test default
271     if (acl && psAcl)
272     {
273         OicSecAce_t* tempAce1 = NULL;
274         OicSecAce_t* tempAce2 = NULL;
275
276         for(tempAce1 = acl->aces, tempAce2 = psAcl->aces;
277             tempAce1 && tempAce2; tempAce1 = tempAce1->next,
278             tempAce2 = tempAce2->next)
279         {
280             EXPECT_TRUE(memcmp(tempAce1->subjectuuid.id, tempAce2->subjectuuid.id, sizeof(tempAce1->subjectuuid.id)) == 0);
281             EXPECT_EQ(tempAce1->permission, tempAce2->permission);
282             EXPECT_EQ(GetNumberOfResource(tempAce1), GetNumberOfResource(tempAce2));
283         }
284     }
285
286     DeleteACLList(psAcl);
287     DeleteACLList(acl);
288     DeInitACLResource();
289     OICFree(payload);
290 }
291
292 // 'POST' ACL tests
293 TEST(ACLResourceTest, ACLPostTest)
294 {
295     // Intialize /pstat global, so that the GetDos() calls in aclresource.c
296     // can succeed, or all UPDATE requests will be rejected based on DOS.
297     OCStackResult res = InitPstatResourceToDefault();
298     ASSERT_TRUE(OC_STACK_OK == res);
299
300     // Read an ACL from the file
301     uint8_t *payload = NULL;
302     size_t size = 0;
303
304     static OCPersistentStorage ps = OCPersistentStorage();
305     SetPersistentHandler(&ps, true);
306
307     OicSecAcl_t *defaultAcl = NULL;
308     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&defaultAcl));
309     ASSERT_TRUE(defaultAcl != NULL);
310     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(defaultAcl));
311
312     ASSERT_TRUE(ReadCBORFile(ACL1_FILE_NAME, OIC_JSON_ACL_NAME, &payload, &size));
313     ASSERT_TRUE(NULL != payload);
314
315     OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size);
316     ASSERT_TRUE(NULL != securityPayload);
317
318     // Create Entity Handler POST request payload
319     OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
320     ehReq.method = OC_REST_POST;
321     ehReq.payload = (OCPayload *) securityPayload;
322
323     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
324     OicSecAcl_t *acl = CBORPayloadToAcl(payload, size);
325     ASSERT_TRUE(NULL != acl);
326
327     // Verify /acl2 Resource contains an ACE for a subject in acl local var
328     OicSecAce_t *savePtr = NULL;
329     savePtr = acl->aces;
330     while(OicSecAceUuidSubject != savePtr->subjectType)
331     {
332         savePtr = savePtr->next;
333     }
334     OicUuid_t uuid = savePtr->subjectuuid;
335 #ifndef NDEBUG
336     char uuidString[UUID_STRING_SIZE] = { 0 };
337     bool convertedUUID = OCConvertUuidToString(uuid.id, uuidString);
338     if (convertedUUID)
339     {
340         printf("asubjectuuidToFind.id = %s", uuidString);
341     }
342 #endif
343     savePtr = NULL;
344     const OicSecAce_t* subjectAcl = GetACLResourceData(&uuid, &savePtr);
345     ASSERT_TRUE(NULL != subjectAcl);
346
347     // Perform cleanup
348     OICFree(payload);
349     OCPayloadDestroy((OCPayload *) securityPayload);
350     DeInitACLResource();
351     DeleteACLList(acl);
352 }
353
354 extern "C" {
355     // gAcl is a pointer to the the global ACL used by SRM
356     extern OicSecAcl_t  *gAcl;
357 }
358
359 // GetACLResource tests
360 TEST(ACLResourceTest, GetACLResourceTests)
361 {
362     OicSecAcl_t *acl1 = NULL;
363     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&acl1));
364     ASSERT_TRUE(acl1 != NULL);
365     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(acl1));
366
367     // Verify that the default ACL file contains 2 ACE entries for the 'ANON_CLEAR' conntype subject
368     const OicSecAce_t *ace = NULL;
369     OicSecAce_t *savePtr = NULL;
370     OicSecConntype_t subjectConn = ANON_CLEAR;
371     int count = 0;
372
373     do
374     {
375         ace = GetACLResourceDataByConntype(subjectConn, &savePtr);
376         count = (NULL != ace) ? count + 1 : count;
377     } while (ace != NULL);
378
379     EXPECT_EQ(count, NUM_ACE_FOR_ANON_CLEAR_IN_DEFAULT_ACL);
380
381     /* Perform cleanup */
382     DeInitACLResource();
383 }
384
385 TEST(ACLResourceTest, DefaultAclAllowsRolesAccess)
386 {
387     /* Get and install the default ACL */
388     OicSecAcl_t *acl1 = NULL;
389     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&acl1));
390     ASSERT_TRUE(acl1 != NULL);
391     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(acl1));
392
393     /* Verify that the default ACL file allows AUTH_CRYPT RUD access to the /roles resource */
394     const OicSecAce_t *ace = NULL;
395     OicSecAce_t *savePtr = NULL;
396     OicSecConntype_t subjectConn = AUTH_CRYPT;
397     int found = 0;
398
399     while((ace = GetACLResourceDataByConntype(subjectConn, &savePtr)) != NULL)
400     {
401         ASSERT_TRUE(ace->resources != NULL);
402         OicSecRsrc_t* rsrc = NULL;
403         LL_FOREACH(ace->resources, rsrc)
404         {
405             if ((strcmp(rsrc->href, OIC_RSRC_ROLES_URI) == 0) &&
406                 (ace->permission == (PERMISSION_READ | PERMISSION_WRITE | PERMISSION_DELETE)))
407             {
408                 found = 1;
409                 break;
410             }
411         }
412     }
413
414     EXPECT_EQ(found, 1);
415
416     DeInitACLResource();
417 }
418
419
420 static OCStackResult populateAcl(OicSecAcl_t *acl,  int numRsrc)
421 {
422     OCStackResult ret = OC_STACK_ERROR;
423     OicSecAce_t* ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
424     VERIFY_NOT_NULL(TAG, ace, ERROR);
425
426     memcpy(ace->subjectuuid.id, "2222222222222222", sizeof(ace->subjectuuid.id));
427     EXPECT_EQ(true, AddResourceToACE(ace, "/a/led", "oic.core", "oic.if.r"));
428     if(2 == numRsrc)
429     {
430         EXPECT_EQ(true, AddResourceToACE(ace, "/a/fan", "oic.core", "oic.if.r"));
431     }
432     ace->permission = 6;
433     LL_APPEND(acl->aces, ace);
434
435     memcpy(acl->rownerID.id, "1111111111111111", sizeof(acl->rownerID.id));
436
437     ret = OC_STACK_OK;
438
439     return ret;
440 exit:
441     DeleteACLList(acl);
442     return ret;
443 }
444
445 //'DELETE' ACL test
446 TEST(ACLResourceTest, ACLDeleteWithSingleResourceTest)
447 {
448     // Intialize /pstat global, so that the GetDos() calls in aclresource.c
449     // can succeed, or all UPDATE requests will be rejected based on DOS.
450     OCStackResult res = InitPstatResourceToDefault();
451     ASSERT_TRUE(OC_STACK_OK == res);
452
453     static OCPersistentStorage ps = OCPersistentStorage();
454     SetPersistentHandler(&ps, true);
455
456     OicSecAcl_t *defaultAcl = NULL;
457     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&defaultAcl));
458     ASSERT_TRUE(defaultAcl != NULL);
459     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(defaultAcl));
460
461     //Populate ACL
462     OicSecAcl_t acl = OicSecAcl_t();
463     EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 1));
464
465     //GET CBOR POST payload
466     size_t size = 0;
467     uint8_t  *payload = NULL;
468     EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, OIC_SEC_ACL_V2, &payload, &size));
469     ASSERT_TRUE(NULL != payload);
470
471     // Security Payload
472     OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size);
473     ASSERT_TRUE(NULL != securityPayload);
474
475     // Create Entity Handler POST request payload
476     OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
477     ehReq.payload = (OCPayload *) securityPayload;
478     ehReq.method = OC_REST_POST;
479     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
480
481     // Verify if SRM contains ACE for the subject
482     OicSecAce_t* savePtr = NULL;
483     const OicSecAce_t* subjectAce1 = GetACLResourceData(&acl.aces->subjectuuid, &savePtr);
484     ASSERT_TRUE(NULL != subjectAce1);
485
486     // Create Entity Handler DELETE request
487     ehReq.method = OC_REST_DELETE;
488     char query[] = "subjectuuid=32323232-3232-3232-3232-323232323232;resources=/a/led";
489     ehReq.query = (char *)OICMalloc(strlen(query)+1);
490     ASSERT_TRUE(NULL !=  ehReq.query);
491     OICStrcpy(ehReq.query, strlen(query)+1, query);
492     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
493
494     // Verify if SRM has deleted ACE for the subject
495     savePtr = NULL;
496     const OicSecAce_t* subjectAce2 = GetACLResourceData(&acl.aces->subjectuuid, &savePtr);
497     ASSERT_TRUE(NULL == subjectAce2);
498
499     // Perform cleanup
500     DeInitACLResource();
501     OICFree(ehReq.query);
502     OCPayloadDestroy((OCPayload *)securityPayload);
503     OICFree(payload);
504 }
505
506 TEST(ACLResourceTest, ACLDeleteWithMultiResourceTest)
507 {
508     // Intialize /pstat global, so that the GetDos() calls in aclresource.c
509     // can succeed, or all UPDATE requests will be rejected based on DOS.
510     OCStackResult res = InitPstatResourceToDefault();
511     ASSERT_TRUE(OC_STACK_OK == res);
512
513     static OCPersistentStorage ps = OCPersistentStorage();
514     SetPersistentHandler(&ps, true);
515
516     OicSecAcl_t *defaultAcl = NULL;
517     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&defaultAcl));
518     ASSERT_TRUE(defaultAcl != NULL);
519     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(defaultAcl));
520
521     //Populate ACL
522     OicSecAcl_t acl = OicSecAcl_t();
523     EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 2));
524
525     //GET CBOR POST payload
526     size_t size = 0;
527     uint8_t *payload = NULL;
528     EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, OIC_SEC_ACL_V2, &payload, &size));
529     ASSERT_TRUE(NULL != payload);
530
531     // Security Payload
532     OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size);
533     ASSERT_TRUE(NULL!= securityPayload);
534
535     // Create Entity Handler POST request payload
536     OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
537     ehReq.method = OC_REST_POST;
538     ehReq.payload = (OCPayload *)securityPayload;
539     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
540
541     // Verify if SRM contains ACE for the subject with two resources
542     OicSecAce_t* savePtr = NULL;
543     const OicSecAce_t* subjectAce1 = GetACLResourceData(&acl.aces->subjectuuid, &savePtr);
544     ASSERT_TRUE(NULL != subjectAce1);
545     EXPECT_EQ(2u, GetNumberOfResource(subjectAce1));
546
547     printf("\n\n");
548     OicSecRsrc_t* rsrc = NULL;
549     LL_FOREACH(subjectAce1->resources, rsrc)
550     {
551         printf("%s\n", rsrc->href);
552     }
553     printf("\n\n");
554
555     // Create Entity Handler DELETE request
556     ehReq.method = OC_REST_DELETE;
557     char query[] = "subjectuuid=32323232-3232-3232-3232-323232323232;resources=/a/led";
558     ehReq.query = (char *)OICMalloc(strlen(query)+1);
559     ASSERT_TRUE(NULL != ehReq.query);
560     OICStrcpy(ehReq.query, strlen(query)+1, query);
561
562     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
563
564     // Verify if SRM contains ACL for the subject but only with one resource
565     savePtr = NULL;
566     const OicSecAce_t* subjectAce2 = GetACLResourceData(&acl.aces->subjectuuid, &savePtr);
567     ASSERT_TRUE(NULL != subjectAce2);
568     EXPECT_EQ(1u, GetNumberOfResource(subjectAce2));
569
570     // Perform cleanup
571     OCPayloadDestroy((OCPayload *)securityPayload);
572     DeInitACLResource();
573     OICFree(ehReq.query);
574     OICFree(payload);
575 }
576
577 //'GET' with query ACL test
578 TEST(ACLResourceTest, ACLGetWithQueryTest)
579 {
580     static OCPersistentStorage ps = OCPersistentStorage();
581     SetPersistentHandler(&ps, true);
582
583     OicSecAcl_t *defaultAcl = NULL;
584     EXPECT_EQ(OC_STACK_OK, GetDefaultACL(&defaultAcl));
585     ASSERT_TRUE(defaultAcl != NULL);
586     EXPECT_EQ(OC_STACK_OK, SetDefaultACL(defaultAcl));
587
588     //Populate ACL
589     OicSecAcl_t acl = OicSecAcl_t();
590     EXPECT_EQ(OC_STACK_OK, populateAcl(&acl, 1));
591
592     //GET CBOR POST payload
593     size_t size = 0;
594     uint8_t *payload = NULL;
595     EXPECT_EQ(OC_STACK_OK, AclToCBORPayload(&acl, OIC_SEC_ACL_V2, &payload, &size));
596     ASSERT_TRUE(NULL != payload);
597
598     // Security Payload
599     OCSecurityPayload *securityPayload = OCSecurityPayloadCreate(payload, size);
600     ASSERT_TRUE(NULL != securityPayload);
601
602     //Create Entity Handler POST request payload
603     OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
604     ehReq.method = OC_REST_POST;
605     ehReq.payload = (OCPayload *)securityPayload;
606     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
607
608     //Create Entity Handler GET request wit query
609     ehReq.method = OC_REST_GET;
610     char query[] = "subjectuuid=32323232-3232-3232-3232-323232323232;resources=/a/led";
611     ehReq.query = (char*)OICMalloc(strlen(query)+1);
612     ASSERT_TRUE(NULL != ehReq.query);
613     OICStrcpy(ehReq.query, strlen(query)+1, query);
614
615     ACLEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
616
617     // Perform cleanup
618     OCPayloadDestroy((OCPayload *)securityPayload);
619     DeInitACLResource();
620     OICFree(ehReq.query);
621     OICFree(payload);
622 }