1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_connection.h"
22 #include "auth_connection.c"
23 #include "auth_interface.h"
24 #include "auth_interface.c"
25 #include "auth_manager.h"
26 #include "auth_manager.c"
27 #include "auth_session_fsm.h"
28 #include "auth_session_fsm.c"
29 #include "auth_session_key.h"
30 #include "auth_session_key.c"
31 #include "auth_session_message.h"
32 #include "auth_session_message.c"
33 #include "softbus_errcode.h"
34 #include "softbus_log.h"
35 #include "softbus_socket.h"
36
37 namespace OHOS {
38 using namespace testing::ext;
39 constexpr uint32_t TEST_DATA_LEN = 30;
40
41 class AuthOtherTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase()49 void AuthOtherTest::SetUpTestCase()
50 {
51 int32_t ret = AuthCommonInit();
52 EXPECT_TRUE(ret == SOFTBUS_OK);
53 }
54
TearDownTestCase()55 void AuthOtherTest::TearDownTestCase()
56 {
57 AuthCommonDeinit();
58 }
59
SetUp()60 void AuthOtherTest::SetUp()
61 {
62 LOG_INFO("AuthOtherTest start.");
63 }
64
TearDown()65 void AuthOtherTest::TearDown() {}
66
OnConnectResultTest(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)67 void OnConnectResultTest(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo)
68 {
69 (void)requestId;
70 (void)connId;
71 (void)result;
72 (void)connInfo;
73 }
74
OnDisconnectedTest(uint64_t connId,const AuthConnInfo * connInfo)75 void OnDisconnectedTest(uint64_t connId, const AuthConnInfo *connInfo)
76 {
77 (void)connId;
78 (void)connInfo;
79 }
80
OnDataReceivedTest(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)81 void OnDataReceivedTest(uint64_t connId, const AuthConnInfo *connInfo, bool fromServer,
82 const AuthDataHead *head, const uint8_t *data)
83 {
84 (void)connId;
85 (void)connInfo;
86 (void)fromServer;
87 (void)head;
88 (void)data;
89 }
90
OnDeviceNotTrustedTest(const char * udid)91 void OnDeviceNotTrustedTest(const char *udid)
92 {
93 (void)udid;
94 }
95
OnDeviceVerifyPassTest(int64_t authId,const NodeInfo * info)96 void OnDeviceVerifyPassTest(int64_t authId, const NodeInfo *info)
97 {
98 (void)authId;
99 (void)info;
100 }
101
OnDeviceDisconnectTest(int64_t authId)102 void OnDeviceDisconnectTest(int64_t authId)
103 {
104 (void)authId;
105 }
106
OnGroupCreatedTest(const char * groupId,int32_t groupType)107 void OnGroupCreatedTest(const char *groupId, int32_t groupType)
108 {
109 (void)groupId;
110 (void)groupType;
111 }
112
OnGroupDeletedTest(const char * groupId)113 void OnGroupDeletedTest(const char *groupId)
114 {
115 (void)groupId;
116 }
117
118 /*
119 * @tc.name: ADD_CONN_REQUEST_TEST_001
120 * @tc.desc: add conn request test
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124 HWTEST_F(AuthOtherTest, ADD_CONN_REQUEST_TEST_001, TestSize.Level1)
125 {
126 AuthConnInfo connInfo;
127 uint32_t requestId = 0;
128 int32_t fd = 0;
129
130 int32_t ret = AddConnRequest(&connInfo, requestId, fd);
131 EXPECT_TRUE(ret == SOFTBUS_OK);
132 ConnRequest *item = FindConnRequestByRequestId(requestId);
133 EXPECT_TRUE(item != nullptr);
134 DelConnRequest(nullptr);
135 DelConnRequest(item);
136 }
137
138 /*
139 * @tc.name: HANDLE_CONNCONNECT_TIMEOUT_TEST_001
140 * @tc.desc: handle connConnect timeout test
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(AuthOtherTest, HANDLE_CONNCONNECT_TIMEOUT_TEST_001, TestSize.Level1)
145 {
146 const void *para = "testdata";
147
148 HandleConnConnectTimeout(nullptr);
149 HandleConnConnectTimeout(para);
150 }
151
152 /*
153 * @tc.name: REMOVE_FUNC_TEST_001
154 * @tc.desc: remove func test
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(AuthOtherTest, REMOVE_FUNC_TEST_001, TestSize.Level1)
159 {
160 uint32_t obj = 1;
161 uint32_t param = 1;
162
163 int32_t ret = RemoveFunc(nullptr, static_cast<void *>(¶m));
164 EXPECT_TRUE(ret == SOFTBUS_ERR);
165 ret = RemoveFunc(static_cast<void *>(&obj), nullptr);
166 EXPECT_TRUE(ret == SOFTBUS_ERR);
167 ret = RemoveFunc(static_cast<void *>(&obj), static_cast<void *>(¶m));
168 EXPECT_TRUE(ret == SOFTBUS_OK);
169 }
170
171 /*
172 * @tc.name: HANDLE_CONN_CONNECT_CMD_TEST_001
173 * @tc.desc: handle conn connect cmd test
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(AuthOtherTest, HANDLE_CONN_CONNECT_CMD_TEST_001, TestSize.Level1)
178 {
179 ConnCmdInfo info;
180
181 (void)memset_s(&info, sizeof(ConnCmdInfo), 0, sizeof(ConnCmdInfo));
182 HandleConnConnectCmd(nullptr);
183 HandleConnConnectCmd(reinterpret_cast<void *>(&info));
184 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
185 HandleConnConnectCmd(reinterpret_cast<void *>(&info));
186 }
187
188 /*
189 * @tc.name: HANDLE_CONN_CONNECT_RESULT_TEST_001
190 * @tc.desc: handle conn connect result test
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(AuthOtherTest, HANDLE_CONN_CONNECT_RESULT_TEST_001, TestSize.Level1)
195 {
196 int32_t para = 0;
197
198 HandleConnConnectResult(nullptr);
199 HandleConnConnectResult(reinterpret_cast<void *>(¶));
200 }
201
202 /*
203 * @tc.name: ON_WIFI_DATA_RECEIVED_TEST_001
204 * @tc.desc: on wifi data received test
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(AuthOtherTest, ON_WIFI_DATA_RECEIVED_TEST_001, TestSize.Level1)
209 {
210 int32_t fd = 0;
211 AuthDataHead head;
212 const uint8_t data[TEST_DATA_LEN] = { 0 };
213
214 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
215 OnWiFiDataReceived(AUTH, fd, nullptr, data);
216 OnWiFiDataReceived(AUTH, fd, &head, nullptr);
217 OnWiFiDataReceived(AUTH, fd, &head, data);
218 }
219
220 /*
221 * @tc.name: ON_COMM_DISCONNECTED_TEST_001
222 * @tc.desc: on comm disconnected test
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(AuthOtherTest, ON_COMM_DISCONNECTED_TEST_001, TestSize.Level1)
227 {
228 uint32_t connectionId = 0;
229 ConnectionInfo info;
230
231 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
232 OnCommDisconnected(connectionId, nullptr);
233 OnCommDisconnected(connectionId, &info);
234 }
235
236 /*
237 * @tc.name: ON_COMM_CONNECT_SUCC_TEST_001
238 * @tc.desc: on comm connect succ test
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(AuthOtherTest, ON_COMM_CONNECT_SUCC_TEST_001, TestSize.Level1)
243 {
244 uint32_t requestId = 0;
245 uint32_t connectionId = 0;
246 ConnectionInfo info;
247
248 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
249 OnCommConnectSucc(requestId, connectionId, nullptr);
250 OnCommConnectSucc(requestId, connectionId, &info);
251 }
252
253 /*
254 * @tc.name: CHECK_ACTIVE_AUTH_CONNECTION_TEST_001
255 * @tc.desc: check active auth connection test
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(AuthOtherTest, CHECK_ACTIVE_AUTH_CONNECTION_TEST_001, TestSize.Level1)
260 {
261 AuthConnInfo connInfo;
262
263 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
264 bool ret = CheckActiveAuthConnection(nullptr);
265 EXPECT_TRUE(ret == false);
266 ret = CheckActiveAuthConnection(&connInfo);
267 EXPECT_TRUE(ret == false);
268 }
269
270 /*
271 * @tc.name: AUTH_GET_META_TYPE_TEST_001
272 * @tc.desc: auth get meta type test
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(AuthOtherTest, AUTH_GET_META_TYPE_TEST_001, TestSize.Level1)
277 {
278 int64_t authId = 0;
279 bool isMetaAuth = false;
280
281 int32_t ret = AuthGetMetaType(authId, nullptr);
282 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
283 ret = AuthGetMetaType(authId, &isMetaAuth);
284 EXPECT_TRUE(ret == SOFTBUS_OK);
285 }
286
287 /*
288 * @tc.name: REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001
289 * @tc.desc: remove auth manager by auth id test
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AuthOtherTest, REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001, TestSize.Level1)
294 {
295 int64_t authSeq = 0;
296 AuthSessionInfo info;
297 AuthConnInfo connInfo;
298 const char *udid = "000";
299 uint64_t connId = 0;
300 uint64_t errConnId = 1;
301 const char *ip = "192.168.12.1";
302
303 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
304 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
305 (void)strcpy_s(info.udid, UDID_BUF_LEN, udid);
306 (void)strcpy_s(info.uuid, UUID_BUF_LEN, udid);
307 info.connId = 0;
308 info.isServer = true;
309 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
310 ListInit(&g_authServerList);
311 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
312 AuthManager *auth = NewAuthManager(authSeq, &info);
313 EXPECT_TRUE(auth != nullptr);
314 int64_t ret = GetAuthIdByConnId(errConnId, true);
315 EXPECT_TRUE(ret == AUTH_INVALID_ID);
316 ret = GetAuthIdByConnId(connId, true);
317 EXPECT_TRUE(ret != AUTH_INVALID_ID);
318 connInfo.type = AUTH_LINK_TYPE_WIFI;
319 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
320 ret = GetActiveAuthIdByConnInfo(&connInfo);
321 EXPECT_TRUE(ret == AUTH_INVALID_ID);
322 RemoveAuthManagerByAuthId(authSeq);
323 RemoveAuthManagerByConnInfo(&connInfo, true);
324 RemoveNotPassedAuthManagerByUdid(udid);
325 }
326
327 /*
328 * @tc.name: NOTIFY_DEVICE_VERIFY_PASSED_TEST_001
329 * @tc.desc: notify device verify passed test
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(AuthOtherTest, NOTIFY_DEVICE_VERIFY_PASSED_TEST_001, TestSize.Level1)
334 {
335 int64_t authId = 0;
336 int64_t errAuthId = 1;
337 NodeInfo nodeInfo;
338 AuthSessionInfo info;
339
340 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
341 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
342 info.isServer = true;
343 info.connInfo.type = AUTH_LINK_TYPE_BLE;
344 AuthManager *auth = NewAuthManager(authId, &info);
345 EXPECT_TRUE(auth != nullptr);
346 NotifyDeviceVerifyPassed(errAuthId, &nodeInfo);
347 g_verifyListener.onDeviceVerifyPass = nullptr;
348 NotifyDeviceVerifyPassed(authId, &nodeInfo);
349 g_verifyListener.onDeviceVerifyPass = OnDeviceVerifyPassTest,
350 NotifyDeviceVerifyPassed(authId, &nodeInfo);
351 DelAuthManager(auth, true);
352 }
353
354 /*
355 * @tc.name: AUTH_MANAGER_SET_AUTH_PASSED_TEST_001
356 * @tc.desc: auth manager set auth passed test
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_AUTH_PASSED_TEST_001, TestSize.Level1)
361 {
362 int64_t authSeq = 0;
363 int64_t errAuthId = 1;
364 AuthSessionInfo info;
365 int32_t reason = 0;
366
367 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
368 AuthManager *auth = NewAuthManager(authSeq, &info);
369 EXPECT_TRUE(auth != nullptr);
370 AuthManagerSetAuthPassed(authSeq, nullptr);
371 AuthManagerSetAuthPassed(errAuthId, &info);
372 AuthManagerSetAuthPassed(authSeq, &info);
373 AuthManagerSetAuthFailed(errAuthId, &info, reason);
374 AuthManagerSetAuthFailed(authSeq, &info, reason);
375 DelAuthManager(auth, true);
376 }
377
378 /*
379 * @tc.name: HANDLE_CONNECTION_DATA_TEST_001
380 * @tc.desc: handle connection data test
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(AuthOtherTest, HANDLE_CONNECTION_DATA_TEST_001, TestSize.Level1)
385 {
386 uint64_t connId = 0;
387 int64_t authId = 0;
388 AuthConnInfo connInfo;
389 AuthDataHead head;
390 AuthSessionInfo info;
391 const uint8_t *data = nullptr;
392 bool fromServer = true;
393 const char *ip = "192.168.12.1";
394
395 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
396 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
397 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
398 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
399 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
400 AuthManager *auth = NewAuthManager(authId, &info);
401 EXPECT_TRUE(auth != nullptr);
402 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
403 connInfo.type = AUTH_LINK_TYPE_WIFI;
404 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
405 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
406 DelAuthManager(auth, true);
407 }
408
409
OnConnOpenedTest(uint32_t requestId,int64_t authId)410 static void OnConnOpenedTest(uint32_t requestId, int64_t authId)
411 {
412 ALOGI("OnConnOpenedTest: requestId = %d, authId = %" PRId64 ".", requestId, authId);
413 }
414
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)415 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
416 {
417 ALOGI("OnConnOpenFailedTest: requestId = %d, reason = %d.", requestId, reason);
418 }
419
420 /*
421 * @tc.name: AUTH_DEVICE_OPEN_CONN_TEST_001
422 * @tc.desc: auth device open conn test
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(AuthOtherTest, AUTH_DEVICE_OPEN_CONN_TEST_001, TestSize.Level1)
427 {
428 AuthSessionInfo info;
429 AuthConnInfo connInfo;
430 uint32_t requestId = 0;
431 int64_t authId = 0;
432 const char *ip = "192.168.12.1";
433 AuthConnCallback cb = {
434 .onConnOpened = OnConnOpenedTest,
435 .onConnOpenFailed = OnConnOpenFailedTest,
436 };
437
438 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
439 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
440 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
441 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
442 AuthManager *auth = NewAuthManager(authId, &info);
443 EXPECT_TRUE(auth != nullptr);
444 connInfo.type = AUTH_LINK_TYPE_WIFI;
445 int32_t ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
446 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
447 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
448 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
449 EXPECT_TRUE(ret == SOFTBUS_OK);
450 connInfo.type = AUTH_LINK_TYPE_BR;
451 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
452 EXPECT_TRUE(ret != SOFTBUS_OK);
453 }
454
455 /*
456 * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_001
457 * @tc.desc: update auth request conn info test
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_001, TestSize.Level1)
462 {
463 AuthConnInfo connInfo;
464 AuthRequest request;
465
466 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
467 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
468 int32_t ret = FindAuthRequestByConnInfo(&connInfo, &request);
469 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
470 }
471
472 /*
473 * @tc.name: HANDLE_UPDATE_SESSION_KEY_EVENT_TEST_001
474 * @tc.desc: handle update session key event test
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(AuthOtherTest, HANDLE_UPDATE_SESSION_KEY_EVENT_TEST_001, TestSize.Level1)
479 {
480 int64_t authId = 1;
481 HandleUpdateSessionKeyEvent(nullptr);
482 HandleUpdateSessionKeyEvent(&authId);
483 }
484
485 /*
486 * @tc.name: RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001
487 * @tc.desc: rmove update session key func test
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(AuthOtherTest, RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001, TestSize.Level1)
492 {
493 int64_t authId = 1;
494 int64_t para = 0;
495 int32_t ret = RemoveUpdateSessionKeyFunc(nullptr, nullptr);
496 EXPECT_TRUE(ret == SOFTBUS_ERR);
497 ret = RemoveUpdateSessionKeyFunc(&authId, nullptr);
498 EXPECT_TRUE(ret == SOFTBUS_ERR);
499 ret = RemoveUpdateSessionKeyFunc(&authId, ¶);
500 EXPECT_TRUE(ret == SOFTBUS_ERR);
501 ret = RemoveUpdateSessionKeyFunc(&authId, &authId);
502 EXPECT_TRUE(ret == SOFTBUS_OK);
503 }
504
505 /*
506 * @tc.name: POST_CLOSE_ACK_MESSAGE_TEST_001
507 * @tc.desc: post close ack message test
508 * @tc.type: FUNC
509 * @tc.require:
510 */
511 HWTEST_F(AuthOtherTest, POST_CLOSE_ACK_MESSAGE_TEST_001, TestSize.Level1)
512 {
513 int64_t authSeq = 0;
514 AuthSessionInfo info;
515 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
516 int32_t ret = PostCloseAckMessage(authSeq, nullptr);
517 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
518 ret = PostCloseAckMessage(authSeq, &info);
519 EXPECT_TRUE(ret == SOFTBUS_ERR);
520 }
521 } // namespace OHOS
522