Merge test folder of test branch
[iotivity.git] / test / src / tc / pm / gtest / csdk / src / helper / PMCsdkCertHelper.cpp
1 /******************************************************************
2  *
3  * Copyright 2017 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 "PMCsdkCertHelper.h"
22 #include "PMCsdkCallbackHelper.h"
23 #include "PMCsdkUtilityHelper.h"
24
25 int PMCsdkCertHelper::g_OwnDevCount = 0;
26 int PMCsdkCertHelper::g_UnownDevCount = 0;
27 int PMCsdkCertHelper::g_motPMDevCount = 0;
28 char* PMCsdkCertHelper::g_csrVal = NULL;
29 OCPersistentStorage PMCsdkCertHelper::pstStr =
30 { 0, 0, 0, 0, 0 };
31 ByteArray s_trustCertChainArray =
32 { 0, 0 };
33
34 FILE* PMCsdkCertHelper::fopenProvManager(const char* path, const char* mode)
35 {
36     OC_UNUSED(path);
37     return fopen(SVR_DB_FILE_NAME, mode);
38 }
39
40 int PMCsdkCertHelper::waitCallbackRet(void)
41 {
42     __FUNC_IN__
43
44     for (int i = 0; CALLBACK_TIMEOUT > i; ++i)
45     {
46         IOTIVITYTEST_LOG(DEBUG, "PMCsdkCertHelper::waitCallbackRet Loop = %d", i);
47
48         if (true == PMCsdkCallbackHelper::s_CBInvoked)
49         {
50             return CALLBACK_INVOKED;
51         }
52
53         CommonUtil::waitInSecond(DELAY_SHORT);
54
55         if (OC_STACK_OK != OCProcess())
56         {
57             IOTIVITYTEST_LOG(ERROR, "OCStack process error");
58             return CALLBACK_NOT_INVOKED;
59         }
60     }
61
62     __FUNC_OUT__
63     return CALLBACK_NOT_INVOKED;
64 }
65
66
67
68 void PMCsdkCertHelper::trustCertChainChangeCB(void *ctx, uint16_t credId, uint8_t *trustCertChain,
69         size_t chainSize)
70 {
71     __FUNC_IN__
72
73     IOTIVITYTEST_LOG(INFO, "Provision Cert SUCCEEDED - ctx: %s", (char* ) ctx);
74
75     IOTIVITYTEST_LOG(INFO, "CRED ID : %d", credId);
76
77     OIC_LOG_BUFFER(DEBUG, "Cert Cb", trustCertChain, chainSize);
78
79     PMCsdkCallbackHelper::s_CBInvoked= true;
80
81     __FUNC_OUT__
82 }
83
84 void PMCsdkCertHelper::getCsrForCertProvCB(void* ctx, size_t nOfRes, OCPMGetCsrResult_t* arr,
85 bool hasError)
86 {
87     if (!hasError)
88     {
89         if (nOfRes != 1)
90         {
91             IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
92         }
93
94         if (arr[0].encoding == OIC_ENCODING_DER)
95         {
96             OCStackResult res = OCConvertDerCSRToPem((char*) arr[0].csr, arr[0].csrLen, &g_csrVal);
97             if (res != OC_STACK_OK)
98             {
99                 IOTIVITYTEST_LOG(ERROR,
100                         "getCsrForCertProvCB FAILED (CSR re-encoding failed) - error: %d, ctx: %s",
101                         res, (char* )ctx);
102             }
103             PMCsdkCallbackHelper::s_CBInvoked= true;
104         }
105         else if (arr[0].encoding == OIC_ENCODING_PEM)
106         {
107             g_csrVal = (char*) OICCalloc(1, arr[0].csrLen);
108             if (g_csrVal == NULL)
109             {
110                 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (memory allocation) - ctx: %s",
111                         (char* )ctx);
112             }
113
114             memcpy(g_csrVal, arr[0].csr, arr[0].csrLen);
115
116             IOTIVITYTEST_LOG(INFO, "getCsrForCertProvCB success");
117             PMCsdkCallbackHelper::s_CBInvoked= true;
118         }
119         else
120         {
121             IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (unknown encoding) - ctx: %s",
122                     (char* )ctx);
123         }
124     }
125     else
126     {
127         IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
128     }
129
130 }
131
132 // CAPI for Provisioning Manager
133
134 PMCsdkCertHelper::PMCsdkCertHelper()
135 {
136     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Constructor");
137 }
138
139 bool PMCsdkCertHelper::initProvisionClient(int clientOTMType, char* chDBPath)
140 {
141     __FUNC_IN__
142
143     pstStr.open = PMCsdkCertHelper::fopenProvManager;
144     pstStr.read = fread;
145     pstStr.write = fwrite;
146     pstStr.close = fclose;
147     pstStr.unlink = unlink;
148
149     if (OC_STACK_OK != OCRegisterPersistentStorageHandler(&pstStr))
150     {
151         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCRegisterPersistentStorageHandler error");
152         return false;
153     }
154
155     // initialize OC stack and provisioning manager
156     if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
157     {
158         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCStack init error");
159         return false;
160     }
161
162     if (access(PRVN_DB_FILE_NAME, F_OK) != -1)
163     {
164         IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Provisioning DB file already exists.");
165     }
166     else
167     {
168         IOTIVITYTEST_LOG(DEBUG, "[PMHelper] No provisioning DB file, creating new ");
169     }
170
171     IOTIVITYTEST_LOG(INFO, "************OCInitPM In************");
172
173     if (OC_STACK_OK != OCInitPM(chDBPath))
174     {
175         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCInitPM Error");
176         return false;
177     }
178
179     __FUNC_OUT__
180     return true;
181 }
182
183 bool PMCsdkCertHelper::provisionCRL(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
184         OicSecCrl_t *crl, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
185 {
186     __FUNC_IN__
187
188     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
189     OCStackResult result = OC_STACK_OK;
190     //OCProvisionCRL(ctx, selectedDeviceInfo, crl, resultCallback);
191
192     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCProvisionCRL returns %s",
193             CommonUtil::getOCStackResult(result));
194
195     if (expectedResult != result)
196     {
197         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
198         return false;
199     }
200
201     if (OC_STACK_OK == result)
202     {
203         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
204         {
205             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
206             return false;
207         }
208     }
209
210     __FUNC_OUT__
211     return true;
212 }
213
214 bool PMCsdkCertHelper::provisionTrustCertChain(void *ctx, OicSecCredType_t type, uint16_t credId,
215         const OCProvisionDev_t *selectedDeviceInfo, OCProvisionResultCB resultCallback,
216         OCStackResult expectedResult)
217 {
218     __FUNC_IN__
219
220     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
221     OCStackResult result = OCProvisionTrustCertChain(ctx, type, credId, selectedDeviceInfo,
222             resultCallback);
223     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] provisionTrustCertChain returns %s",
224             CommonUtil::getOCStackResult(result));
225
226     if (expectedResult != result)
227     {
228         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
229         return false;
230     }
231
232     if (OC_STACK_OK == result)
233     {
234         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
235         {
236             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
237             return false;
238         }
239     }
240
241     __FUNC_OUT__
242     return true;
243 }
244
245 bool PMCsdkCertHelper::saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
246         OicEncodingType_t encodingType, uint16_t *credId, OCStackResult expectedResult)
247 {
248     __FUNC_IN__
249
250     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
251
252     OCStackResult result = OCSaveTrustCertChain(trustCertChain, chainSize, encodingType, credId);
253     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveTrustCertChain returns %s",
254             CommonUtil::getOCStackResult(result));
255
256     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
257
258     if (expectedResult != result)
259     {
260         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
261         return false;
262     }
263
264     IOTIVITYTEST_LOG(DEBUG, "saveTrustCertChain OUT");
265     return true;
266 }
267
268 bool PMCsdkCertHelper::registerTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB,
269         OCStackResult expectedResult)
270 {
271     __FUNC_IN__
272
273     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
274
275     OCStackResult result = OCRegisterTrustCertChainNotifier(cb, CB);
276     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCRegisterTrustCertChainNotifier returns %s",
277             CommonUtil::getOCStackResult(result));
278
279     if (expectedResult != result)
280     {
281         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
282         return false;
283     }
284
285     __FUNC_OUT__
286     return true;
287 }
288
289 bool PMCsdkCertHelper::removeTrustCertChainNotifier()
290 {
291     __FUNC_IN__
292
293     OCRemoveTrustCertChainNotifier();
294
295     __FUNC_OUT__
296     return true;
297 }
298
299 bool PMCsdkCertHelper::readTrustCertChain(uint16_t credId, uint8_t **trustCertChain,
300         size_t *chainSize, OCStackResult expectedResult)
301 {
302     __FUNC_IN__
303
304     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
305
306     OCStackResult result = OCReadTrustCertChain(credId, trustCertChain, chainSize);
307
308     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCReadTrustCertChain returns %s",
309             CommonUtil::getOCStackResult(result));
310
311     if (expectedResult != result)
312     {
313         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
314         return false;
315     }
316
317     if (OC_STACK_OK == result && OC_STACK_OK == expectedResult)
318     {
319         OIC_LOG_BUFFER(DEBUG, TAG, *trustCertChain, *chainSize);
320     }
321
322     __FUNC_OUT__
323     return true;
324 }
325
326 bool PMCsdkCertHelper::provisionCertificate(void *ctx, const OCProvisionDev_t *pDev,
327         const char* pemCert, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
328 {
329     __FUNC_IN__
330
331     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
332     OCStackResult result = OCProvisionCertificate(ctx, pDev, pemCert, resultCallback);
333     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCProvisionCertificate returns %s",
334             CommonUtil::getOCStackResult(result));
335
336     if (expectedResult != result)
337     {
338         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
339         return false;
340     }
341
342     if (OC_STACK_OK == result)
343     {
344         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
345         {
346             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
347             return false;
348         }
349     }
350
351     __FUNC_OUT__
352     return true;
353 }
354
355 bool PMCsdkCertHelper::saveOwnCertChain(const char* cert, const char* key, uint16_t *credId,
356         OCStackResult expectedResult)
357 {
358     __FUNC_IN__
359
360     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
361
362     OCStackResult result = OCSaveOwnCertChain(cert, key, credId);
363     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnCertChain returns %s",
364             CommonUtil::getOCStackResult(result));
365
366     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
367
368     if (expectedResult != result)
369     {
370         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
371         return false;
372     }
373
374     IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
375     return true;
376 }
377
378 bool PMCsdkCertHelper::saveOwnRoleCert(const char* cert, uint16_t *credId,
379         OCStackResult expectedResult)
380 {
381     __FUNC_IN__
382
383     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
384
385     OCStackResult result = OCSaveOwnRoleCert(cert, credId);
386     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnRoleCert returns %s",
387             CommonUtil::getOCStackResult(result));
388
389     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
390
391     if (expectedResult != result)
392     {
393         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
394         return false;
395     }
396
397     IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
398     return true;
399 }
400
401 bool PMCsdkCertHelper::generateKeyPair(char **publicKey, size_t *publicKeyLen, char **privateKey,
402         size_t *privateKeyLen, OCStackResult expectedResult)
403 {
404     __FUNC_IN__
405
406     OCStackResult result = OCGenerateKeyPair(publicKey, publicKeyLen, privateKey, privateKeyLen);
407     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateKeyPair returns %s",
408             CommonUtil::getOCStackResult(result));
409
410     if (expectedResult != result)
411     {
412         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
413         return false;
414     }
415
416     IOTIVITYTEST_LOG(DEBUG, "OCGenerateKeyPair OUT");
417     return true;
418 }
419
420 bool PMCsdkCertHelper::generateRandomSerialNumber(char **serial, size_t *serialLen,
421         OCStackResult expectedResult)
422 {
423     __FUNC_IN__
424
425     OCStackResult result = OCGenerateRandomSerialNumber(serial, serialLen);
426     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateRandomSerialNumber returns %s",
427             CommonUtil::getOCStackResult(result));
428
429     if (expectedResult != result)
430     {
431         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
432         return false;
433     }
434
435     IOTIVITYTEST_LOG(DEBUG, "OCGenerateRandomSerialNumber OUT");
436     return true;
437 }
438
439 bool PMCsdkCertHelper::generateCACertificate(const char *subject, const char *subjectPublicKey,
440         const char *issuerCert, const char *issuerPrivateKey, const char *serial,
441         const char *notValidBefore, const char *notValidAfter, char **certificate,
442         size_t *certificateLen, OCStackResult expectedResult)
443 {
444     __FUNC_IN__
445
446     OCStackResult result = OCGenerateRootCACertificate(subject, subjectPublicKey, issuerCert,
447             issuerPrivateKey, serial, notValidBefore, notValidAfter, certificate, certificateLen);
448     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateRootCACertificate returns %s",
449             CommonUtil::getOCStackResult(result));
450
451     if (expectedResult != result)
452     {
453         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
454         return false;
455     }
456
457     IOTIVITYTEST_LOG(DEBUG, "OCGenerateRootCACertificate OUT");
458     return true;
459 }
460
461 bool PMCsdkCertHelper::getDeviceId(OCUUIdentity *deviceId, OCStackResult expectedResult)
462 {
463     __FUNC_IN__
464
465     OCStackResult result = OCGetDeviceId(deviceId);
466     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetDeviceId returns %s",
467             CommonUtil::getOCStackResult(result));
468
469     if (expectedResult != result)
470     {
471         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
472         return false;
473     }
474
475     IOTIVITYTEST_LOG(DEBUG, "OCGetDeviceId OUT");
476     return true;
477 }
478
479 bool PMCsdkCertHelper::getUuidFromCSR(const char* csr, OicUuid_t* uuid,
480         OCStackResult expectedResult)
481 {
482     __FUNC_IN__
483
484     OCStackResult result = OCGetUuidFromCSR(csr, uuid);
485     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetUuidFromCSR returns %s",
486             CommonUtil::getOCStackResult(result));
487
488     if (expectedResult != result)
489     {
490         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
491         return false;
492     }
493
494     IOTIVITYTEST_LOG(DEBUG, "OCGetUuidFromCSR OUT");
495     return true;
496 }
497
498 bool PMCsdkCertHelper::getPublicKeyFromCSR(const char* csr, char** publicKey,
499         OCStackResult expectedResult)
500 {
501     __FUNC_IN__
502
503     OCStackResult result = OCGetPublicKeyFromCSR(csr, publicKey);
504     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetPublicKeyFromCSR returns %s",
505             CommonUtil::getOCStackResult(result));
506
507     if (expectedResult != result)
508     {
509         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
510         return false;
511     }
512
513     IOTIVITYTEST_LOG(DEBUG, "OCGetPublicKeyFromCSR OUT");
514     return true;
515 }
516
517 bool PMCsdkCertHelper::generateIdentityCertificate(const OicUuid_t *subjectUuid,
518         const char *subjectPublicKey, const char *issuerCert, const char *issuerPrivateKey,
519         const char *serial, const char *notValidBefore, const char *notValidAfter,
520         char **certificate, size_t *certificateLen, OCStackResult expectedResult)
521 {
522     __FUNC_IN__
523
524     OCStackResult result = OCGenerateIdentityCertificate(subjectUuid, subjectPublicKey, issuerCert,
525             issuerPrivateKey, serial, notValidBefore, notValidAfter, certificate, certificateLen);
526     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateIdentityCertificate returns %s",
527             CommonUtil::getOCStackResult(result));
528
529     if (expectedResult != result)
530     {
531         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
532         return false;
533     }
534
535     IOTIVITYTEST_LOG(DEBUG, "OCGenerateIdentityCertificate OUT");
536     return true;
537 }
538
539 /**
540  * Helper Method for OCGetCSRResource
541  */
542 bool PMCsdkCertHelper::getCSRResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
543         OCGetCSRResultCB resultCallback, OCStackResult expectedResult)
544 {
545     __FUNC_IN__
546
547     PMCsdkCallbackHelper::s_CBInvoked = false;
548
549     OCStackResult res = OCGetCSRResource(ctx, selectedDeviceInfo, resultCallback);
550     IOTIVITYTEST_LOG(INFO, "[Cloud Acl]  OCGetCSRResource API returns: %s",
551             CommonUtil::getOCStackResult(res));
552
553     if (expectedResult != res)
554     {
555         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(res, expectedResult);
556         return false;
557     }
558
559     if (OC_STACK_OK == res)
560     {
561         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
562         {
563             m_failureMessage = PMCsdkUtilityHelper::setFailureMessage("CALLBACK Not invoked");
564             return false;
565         }
566     }
567
568     __FUNC_OUT__
569     return true;
570 }
571
572 bool PMCsdkCertHelper::verifyCSRSignature(const char* csr, OCStackResult expectedResult)
573 {
574     __FUNC_IN__
575
576     OCStackResult result = OCVerifyCSRSignature(csr);
577     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCVerifyCSRSignature returns %s",
578             CommonUtil::getOCStackResult(result));
579
580     if (expectedResult != result)
581     {
582         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
583         return false;
584     }
585
586     IOTIVITYTEST_LOG(DEBUG, "OCVerifyCSRSignature OUT");
587     return true;
588 }
589
590 bool PMCsdkCertHelper::readFile(const char *name, OCByteString *out)
591 {
592     FILE *file = NULL;
593     int length = 0;
594     uint8_t *buffer = NULL;
595     bool result = false;
596     size_t count, realCount;
597     //Open file
598     file = fopen(name, "rb");
599     if (!file)
600     {
601         IOTIVITYTEST_LOG(ERROR, "Unable to open file %s", name);
602         return result;
603     }
604
605     //Get file length
606     if (fseek(file, 0, SEEK_END))
607     {
608         IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_END");
609         goto exit;
610     }
611
612     length = ftell(file);
613     if (length < 0)
614     {
615         IOTIVITYTEST_LOG(ERROR, "Failed to ftell");
616         goto exit;
617     }
618
619     if (fseek(file, 0, SEEK_SET))
620     {
621         IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_SET");
622         goto exit;
623     }
624
625     //Allocate memory
626     buffer = (uint8_t *) malloc(length);
627     if (!buffer)
628     {
629         IOTIVITYTEST_LOG(ERROR, "Failed to allocate buffer");
630         goto exit;
631     }
632
633     //Read file contents into buffer
634     count = 1;
635     realCount = fread(buffer, length, count, file);
636     if (realCount != count)
637     {
638         IOTIVITYTEST_LOG(ERROR, "Read %d bytes %zu times instead of %zu", length, realCount, count);
639         goto exit;
640     }
641
642     out->bytes = buffer;
643     out->len = length;
644
645     result = true;
646     exit: fclose(file);
647     return result;
648 }
649
650 ByteArray_t PMCsdkCertHelper::getTrustCertChainArray()
651 {
652     __FUNC_IN__
653
654     ByteArray trustCertChainArray =
655     { 0, 0 };
656
657     FILE *fp = fopen("rootca.crt", "rb+");
658
659     if (fp)
660     {
661         size_t fsize;
662 #ifdef __WINDOWS__
663         if (_fseeki64(fp, 0, SEEK_END) == 0 && (fsize = _ftelli64(fp)) > 0)
664 #else
665         if (fseeko(fp, 0, SEEK_END) == 0 && (fsize = ftello(fp)) > 0)
666 #endif
667         {
668             trustCertChainArray.data = (uint8_t *) malloc(fsize);
669             trustCertChainArray.len = fsize;
670             if (NULL != trustCertChainArray.data)
671             {
672                 rewind(fp);
673
674                 if (fsize != fread(trustCertChainArray.data, 1, fsize, fp))
675                 {
676                     IOTIVITYTEST_LOG(ERROR, "Certiface not read completely");
677                 }
678
679                 fclose(fp);
680                 return trustCertChainArray;
681             }
682
683             cout << "Failed to allocate memory" << endl;
684             fclose(fp);
685         }
686     }
687
688     __FUNC_OUT__
689     return trustCertChainArray;
690 }
691
692 std::string PMCsdkCertHelper::getFailureMessage()
693 {
694     return m_failureMessage;
695 }