Merge test folder of test branch
[iotivity.git] / test / src / testapp / cloud / cloud_server.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  *      LICENSE-2.0" target="_blank">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
22 #include <stddef.h>
23 #include <string>
24
25 #include "logger.h"
26 #include "ocpayload.h"
27 #include "ocstack.h"
28 #include "oic_malloc.h"
29 #include "oic_string.h"
30 #include "OCAccountManager.h"
31 #include "OCApi.h"
32 #include "OCPlatform.h"
33 #include "OCPlatform_impl.h"
34 #include "payload_logging.h"
35 #include "rd_client.h"
36
37 #ifdef __SECURED__
38 #include "cathreadpool.h"
39 #include "utlist.h"
40 #include "casecurityinterface.h"
41 #include "occloudprovisioning.h"
42 #include "ocprovisioningmanager.h"
43 #include "securevirtualresourcetypes.h"
44 #include "srmutility.h"
45 #include "ssl_ciphersuites.h"
46 #include "utils.h"
47 #include "pmtypes.h"
48 #include "oxmjustworks.h"
49 #include "oxmrandompin.h"
50 #include "ca_adapter_net_ssl.h"
51 #include "CAManager.h"
52 #endif
53
54 #include "CommonUtil.h"
55 #include "Configuration.h"
56 #include "CloudCommonUtil.h"
57 #include "CommonProperties.h"
58 #include "IotivityTest_Logger.h"
59
60 using namespace std;
61 using namespace OC;
62
63 #define ROOT_CERT "rootca.crt"
64 const char* CLOUD_SVR_CBOR_DAT = "cloud.dat";
65 static OCPersistentStorage g_pstStr;
66 static string g_authprovider = "github";
67 static string g_authCode = "";
68 static string g_uid = "";
69 static string g_accesstoken = "";
70 static string g_hostAddress = "";
71 static OCAccountManager::Ptr g_accountMgr = nullptr;
72
73 static char* g_ctx = (char*)"cloud";
74 static OCDevAddr g_endPoint;
75 static int g_isCbInvoked = CALLBACK_NOT_INVOKED;
76
77 #ifdef __SECURED__
78 void deleteAcl();
79 void createAcl();
80 void getAclID();
81 #endif
82
83 #ifdef __SECURED__
84
85 #define TAG "CLOUD SIMULATOR"
86
87 static bool readFile(const char *name, OCByteString *out)
88 {
89     FILE *file = NULL;
90     int length = 0;
91     uint8_t *buffer = NULL;
92     bool result = false;
93
94     //Open file
95     file = fopen(name, "rb");
96     if (!file)
97     {
98         OIC_LOG_V(ERROR, TAG, "Unable to open file %s", name);
99         return result;
100     }
101
102     //Get file length
103     if (fseek(file, 0, SEEK_END))
104     {
105         OIC_LOG(ERROR, TAG, "Failed to SEEK_END");
106     }
107
108     length = ftell(file);
109     if (length < 0)
110     {
111         OIC_LOG(ERROR, TAG, "Failed to ftell");
112     }
113
114     if (fseek(file, 0, SEEK_SET))
115     {
116     }
117
118     //Allocate memory
119     buffer = (uint8_t *)malloc(length);
120     if (!buffer)
121     {
122         OIC_LOG(ERROR, TAG, "Failed to allocate buffer");
123     }
124
125     //Read file contents into buffer
126     size_t count = 1;
127     size_t realCount = fread(buffer, length, count, file);
128     if (realCount != count)
129     {
130         OIC_LOG_V(ERROR, TAG, "Read %d bytes %" PRIuPTR " times instead of %" PRIuPTR, length, realCount, count);
131     }
132
133     out->bytes = buffer;
134     out->len = length;
135
136     result = true;
137
138     fclose(file);
139     return result;
140 }
141
142 int saveTrustCert(void)
143 {
144     __FUNC_IN__
145     OCStackResult res = OC_STACK_ERROR;
146     uint16_t g_credId = 0;
147     OIC_LOG(INFO, TAG, "Save Trust Cert. Chain into Cred of SVR");
148
149     ByteArray_t trustCertChainArray =
150     {   0, 0};
151     if (!readFile(ROOT_CERT, (OCByteString *)&trustCertChainArray))
152     {
153         OIC_LOG_V(ERROR, TAG, "Can't read %s file", ROOT_CERT);
154         return OC_STACK_ERROR;
155     }
156
157     OIC_LOG_BUFFER(DEBUG, TAG, trustCertChainArray.data, trustCertChainArray.len);
158
159     res = OCSaveTrustCertChain(trustCertChainArray.data, trustCertChainArray.len, OIC_ENCODING_PEM, &g_credId);
160
161     if (OC_STACK_OK != res)
162     {
163         OIC_LOG(ERROR, TAG, "OCSaveTrustCertChain API error");
164     }
165     else
166     {
167         OIC_LOG_V(INFO, TAG, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d.\n", g_credId);
168     }
169     OICFree(trustCertChainArray.data);
170
171     __FUNC_OUT__
172     return res;
173 }
174
175 #ifdef __TLS_ON__
176 void enableTlsMode()
177 {
178     setCoapPrefix(true);
179     if (CA_STATUS_OK != saveTrustCert())
180     {
181         IOTIVITYTEST_LOG(ERROR, "saveTrustCert returned an error");
182     }
183
184     uint16_t cipher = MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256;
185     if (CA_STATUS_OK != CASelectCipherSuite(cipher, CA_ADAPTER_TCP))
186     {
187         IOTIVITYTEST_LOG(ERROR, "CASelectCipherSuite returned an error");
188     }
189 }
190 #endif
191
192 #endif
193
194 static int waitCallbackRet()
195 {
196     IOTIVITYTEST_LOG(DEBUG, "Waiting for Callback to be invoked");
197
198     for (int i = 0; CALLBACK_TIMEOUT > i; ++i)
199     {
200         if (CALLBACK_INVOKED == g_isCbInvoked)
201         {
202             return CALLBACK_INVOKED;
203         }
204
205         sleep(DELAY_SHORT);
206         printf("Second Elapsed : %d seconds\n", i);
207
208         if (OC_STACK_OK != OCProcess())
209         {
210             printf("OCStack process error\n");
211             return CALLBACK_NOT_INVOKED;
212         }
213     }
214
215     return CALLBACK_NOT_INVOKED;
216 }
217
218 FILE* controllerOpen(const char *path, const char *mode)
219 {
220     if (0 == strncmp(path, OC_SECURITY_DB_DAT_FILE_NAME, strlen(OC_SECURITY_DB_DAT_FILE_NAME)))
221     {
222         return fopen(path, mode);
223     }
224     else
225     {
226         return fopen(CLOUD_SVR_CBOR_DAT, mode);
227     }
228 }
229
230 void initServer()
231 {
232     __FUNC_IN__
233
234     g_pstStr.open = controllerOpen;
235     g_pstStr.read = fread;
236     g_pstStr.write = fwrite;
237     g_pstStr.close = fclose;
238     g_pstStr.unlink = unlink;
239
240     if (OC_STACK_OK != OCRegisterPersistentStorageHandler(&g_pstStr))
241     {
242         IOTIVITYTEST_LOG(ERROR, "[CLOUD SIMULATOR] OCRegisterPersistentStorageHandler error");
243         return;
244     }
245
246     // initialize OC stack and provisioning manager
247     if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
248     {
249         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCStack init error");
250         return;
251     }
252
253     IOTIVITYTEST_LOG(INFO, "[CLOUD SIMULATOR] Host Addess : %s", g_hostAddress.c_str());
254
255     g_accountMgr = OCPlatform::constructAccountManagerObject(g_hostAddress, CT_ADAPTER_TCP);
256     __FUNC_OUT__
257 }
258
259 #ifdef __SECURED__
260 static void createAclCb(void* g_ctx, OCStackResult result, void* data)
261 {
262     OC_UNUSED(g_ctx);
263     OC_UNUSED(data);
264
265     IOTIVITYTEST_LOG(INFO, "%s: Received result = %d for g_ctx : %s", __func__, result,
266             (char* )g_ctx);
267
268     if (result <= OC_STACK_RESOURCE_CHANGED)
269     {
270         char* dataChar = (char*) data;
271         IOTIVITYTEST_LOG(INFO, "Received Data: %s", dataChar);
272     }
273
274     g_isCbInvoked = true;
275 }
276
277 static void getAclIdCb(void* g_ctx, OCStackResult result, void* data)
278 {
279     OC_UNUSED(g_ctx);
280     OC_UNUSED(data);
281
282     IOTIVITYTEST_LOG(INFO, "%s: Received result = %d for g_ctx : %s", __func__, result,
283             (char* )g_ctx);
284
285     if (result == OC_STACK_OK)
286     {
287         char* dataChar = (char*) data;
288         IOTIVITYTEST_LOG(INFO, "Received Data: %s", dataChar);
289     }
290
291     g_isCbInvoked = true;
292 }
293
294 void createAcl()
295 {
296     __FUNC_IN__
297     g_isCbInvoked = CALLBACK_NOT_INVOKED;
298     OCStackResult result = OCCloudAclIdCreate(g_ctx, DEFAULT_OWNER_ID, DEFAULT_DEV_ID, &g_endPoint,
299             createAclCb);
300     IOTIVITYTEST_LOG(INFO, "[Cloud Server] OCCloudAclIdCreate returns %s", CommonUtil::getOCStackResult(result));
301
302     if (OC_STACK_OK != result)
303     {
304         IOTIVITYTEST_LOG(ERROR, "[Cloud Server] OCCloudAclIdCreate returns %s",
305                 CommonUtil::getOCStackResult(result));
306         return;
307     }
308
309     if (OC_STACK_OK == result)
310     {
311         if (CALLBACK_NOT_INVOKED == waitCallbackRet())
312         {
313             IOTIVITYTEST_LOG(ERROR, "[Cloud Server] Callback Not Invoked");
314             return;
315         }
316     }
317     __FUNC_OUT__
318 }
319
320 void getAclId()
321 {
322     __FUNC_IN__
323     g_isCbInvoked = CALLBACK_NOT_INVOKED;
324     OCStackResult result = OCCloudGetAclIdByDevice(g_ctx, DEFAULT_DEV_ID, &g_endPoint, getAclIdCb);
325     IOTIVITYTEST_LOG(INFO, "[Cloud Server] OCCloudGetAclIdByDevice returns %s",
326             CommonUtil::getOCStackResult(result));
327
328     if (OC_STACK_OK != result)
329     {
330         IOTIVITYTEST_LOG(ERROR, "[Cloud Server] OCCloudAclIdCreate returns %s",
331                 CommonUtil::getOCStackResult(result));
332         return;
333     }
334
335     if (OC_STACK_OK == result)
336     {
337         if (CALLBACK_NOT_INVOKED == waitCallbackRet())
338         {
339             IOTIVITYTEST_LOG(ERROR, "[Cloud Server] ERROR");
340             return;
341         }
342     }
343     __FUNC_OUT__
344 }
345
346 #endif
347
348 int main()
349 {
350     bool isInitialized = true;
351 #ifdef __SECURED__
352     IOTIVITYTEST_LOG(INFO, "SECURED MODE : On");
353 #else
354     IOTIVITYTEST_LOG(INFO, "SECURED MODE : Off");
355 #endif
356
357 #ifdef __TLS_ON__
358     IOTIVITYTEST_LOG(INFO, "TLS MODE : On");
359 #else
360     IOTIVITYTEST_LOG(INFO, "TLS MODE : Off");
361 #endif
362
363     g_hostAddress = CloudCommonUtil::getDefaultHostAddess();
364
365     initServer();
366 #ifdef __SECURED__
367     g_endPoint = CloudCommonUtil::getDefaultEndPoint();
368 #ifdef __TLS_ON__
369     enableTlsMode();
370 #endif
371 #endif
372
373     isInitialized = CloudCommonUtil::signUp(g_accountMgr);
374
375     if (isInitialized)
376     {
377
378         isInitialized = CloudCommonUtil::signIn(g_accountMgr);
379
380 #ifdef __SECURED__
381         if (isInitialized)
382         {
383             createAcl();
384             getAclId();
385             CloudCommonUtil::signOut(g_accountMgr);
386         }
387 #endif
388     }
389
390     IOTIVITYTEST_LOG(INFO, "Cloud Initialization %s", isInitialized ? "Successful" : "Failed");
391
392     return 0;
393 }