1 /*
2 * Copyright (c) 2022-2023 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 <securec.h>
17
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_trans_def.h"
22 #include "softbus_json_utils.h"
23 #include "softbus_app_info.h"
24 #include "softbus_config_type.h"
25 #include "softbus_server_frame.h"
26 #include "softbus_adapter_mem.h"
27 #include "client_trans_message_service.h"
28 #include "client_trans_message_service.c"
29 #include "client_trans_session_manager.h"
30 #include "client_trans_socket_manager.h"
31 #include "softbus_common.h"
32 #include "trans_log.h"
33 #include "softbus_feature_config.h"
34 #include "softbus_conn_interface.h"
35 #include "auth_interface.h"
36 #include "bus_center_manager.h"
37 #include "trans_session_service.h"
38
39
40 #define TRANS_TEST_SESSION_ID 10
41 #define TRANS_TEST_CHANNEL_ID 1000
42 #define TRANS_TEST_FILE_ENCRYPT 10
43 #define TRANS_TEST_ALGORITHM 1
44 #define TRANS_TEST_CRC 1
45 #define TRANS_TEST_AUTH_DATA "test auth message data"
46 #define TRANS_TEST_MAX_MSG_LEN (1 * 1024)
47 #define TRANS_TEST_MAX_BYTES_LEN (2 * 1024)
48 #define TRANS_TEST_BEYOND_MAX_MSG_LEN (6 * 1024)
49 #define TRANS_TEST_BEYOND_MAX_BYTES_LEN (6 * 1024 * 1024)
50 #define TRANS_TEST_SEND_LEN 123
51 #define TRANS_TEST_FILE_COUNT 2
52
53 #define TRANS_TEST_INVALID_SEND_LEN (1024 * 1024)
54
55 using namespace testing::ext;
56
57 namespace OHOS {
58
59 const char *g_pkgName = "dms";
60 const char *g_sessionName = "ohos.distributedschedule.dms.test";
61 const char *g_sessionKey = "www.huaweitest.com";
62 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
63 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
64 const char *g_groupId = "TEST_GROUP_ID";
65 static SessionAttribute g_sessionAttr = {
66 .dataType = TYPE_BYTES,
67 };
68 class TransClientMsgServiceTest : public testing::Test {
69 public:
TransClientMsgServiceTest()70 TransClientMsgServiceTest()
71 {}
~TransClientMsgServiceTest()72 ~TransClientMsgServiceTest()
73 {}
74 static void SetUpTestCase(void);
75 static void TearDownTestCase(void);
76 void SetUp() override
77 {}
78 void TearDown() override
79 {}
80 };
81
SetUpTestCase(void)82 void TransClientMsgServiceTest::SetUpTestCase(void)
83 {
84 SoftbusConfigInit();
85 ConnServerInit();
86 AuthInit();
87 BusCenterServerInit();
88 TransServerInit();
89 int32_t ret = TransClientInit();
90 ASSERT_EQ(ret, SOFTBUS_OK);
91 }
92
TearDownTestCase(void)93 void TransClientMsgServiceTest::TearDownTestCase(void)
94 {
95 ConnServerDeinit();
96 AuthDeinit();
97 BusCenterServerDeinit();
98 TransServerDeinit();
99 }
100
OnSessionOpened(int32_t sessionId, int32_t result)101 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
102 {
103 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
104 return SOFTBUS_OK;
105 }
106
OnSessionClosed(int32_t sessionId)107 static void OnSessionClosed(int32_t sessionId)
108 {
109 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
110 }
111
OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)112 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
113 {
114 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
115 }
116
OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)117 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
118 {
119 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
120 }
121
OnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)122 static void OnStreamReceived(int32_t sessionId, const StreamData *data,
123 const StreamData *ext, const StreamFrameInfo *param)
124 {
125 TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
126 }
127
OnQosEvent(int32_t sessionId, int32_t eventId, int32_t tvCount, const QosTv *tvList)128 static void OnQosEvent(int32_t sessionId, int32_t eventId, int32_t tvCount, const QosTv *tvList)
129 {
130 TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
131 }
132
133 static ISessionListener g_sessionlistener = {
134 .OnSessionOpened = OnSessionOpened,
135 .OnSessionClosed = OnSessionClosed,
136 .OnBytesReceived = OnBytesReceived,
137 .OnMessageReceived = OnMessageReceived,
138 .OnStreamReceived = OnStreamReceived,
139 .OnQosEvent = OnQosEvent,
140 };
141
TestGenerateCommParam(SessionParam *sessionParam)142 static void TestGenerateCommParam(SessionParam *sessionParam)
143 {
144 sessionParam->sessionName = g_sessionName;
145 sessionParam->peerSessionName = g_sessionName;
146 sessionParam->peerDeviceId = g_deviceId;
147 sessionParam->groupId = g_groupId;
148 sessionParam->attr = &g_sessionAttr;
149 }
150
TestGenerateSession(const SessionParam *param)151 static SessionInfo *TestGenerateSession(const SessionParam *param)
152 {
153 SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
154 if (session == NULL) {
155 return NULL;
156 }
157
158 if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
159 strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
160 strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
161 SoftBusFree(session);
162 return NULL;
163 }
164
165 session->sessionId = TRANS_TEST_SESSION_ID;
166 session->channelId = TRANS_TEST_CHANNEL_ID;
167 session->channelType = CHANNEL_TYPE_BUTT;
168 session->isServer = false;
169 session->enableStatus = ENABLE_STATUS_INIT;
170 session->routeType = ROUTE_TYPE_ALL;
171 session->info.flag = TYPE_BYTES;
172 session->isEncrypt = true;
173 session->algorithm = TRANS_TEST_ALGORITHM;
174 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
175 session->crc = TRANS_TEST_CRC;
176
177 return session;
178 }
179
AddSessionServerAndSession( const char *sessionName, int32_t channelType, int32_t businessType, bool isServer, SessionEnableStatus enableStatus)180 static int32_t AddSessionServerAndSession(
181 const char *sessionName, int32_t channelType, int32_t businessType, bool isServer, SessionEnableStatus enableStatus)
182 {
183 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
184 if (sessionParam == NULL) {
185 return SOFTBUS_MALLOC_ERR;
186 }
187
188 TestGenerateCommParam(sessionParam);
189 sessionParam->sessionName = sessionName;
190 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
191 if (ret != SOFTBUS_OK) {
192 return ret;
193 }
194
195 SessionInfo *session = TestGenerateSession(sessionParam);
196 if (session == NULL) {
197 return SOFTBUS_MALLOC_ERR;
198 }
199
200 session->channelType = (ChannelType)channelType;
201 session->businessType = (BusinessType)businessType;
202 session->isServer = isServer;
203 session->enableStatus = enableStatus;
204 ret = ClientAddNewSession(sessionName, session);
205 if (ret != SOFTBUS_OK) {
206 return ret;
207 }
208
209 int32_t sessionId = 0;
210 bool isClosing = false;
211 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId, isClosing);
212 if (ret != SOFTBUS_OK) {
213 return ret;
214 }
215 SoftBusFree(sessionParam);
216 return sessionId;
217 }
218
DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)219 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
220 {
221 int32_t ret = ClientDeleteSession(sessionId);
222 EXPECT_EQ(ret, SOFTBUS_OK);
223 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
224 EXPECT_EQ(ret, SOFTBUS_OK);
225 }
226
227 /**
228 * @tc.name: TransClientMsgServiceTest01
229 * @tc.desc: Transmission sdk message service check send length with different parameters.
230 * @tc.type: FUNC
231 * @tc.require:
232 */
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)233 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)
234 {
235 int32_t ret = CheckSendLen(CHANNEL_TYPE_BUTT, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
236 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
237 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_INVALID_SEND_LEN, BUSINESS_TYPE_MESSAGE);
238 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
239 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
240 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
241 }
242
243 /**
244 * @tc.name: TransClientMsgServiceTest02
245 * @tc.desc: Transmission sdk message service send bytes with different parameters.
246 * @tc.type: FUNC
247 * @tc.require:
248 */
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)249 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)
250 {
251 int32_t sessionId =
252 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
253 ASSERT_GT(sessionId, 0);
254 int32_t ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, 0);
255 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
256 DeleteSessionServerAndSession(g_sessionName, sessionId);
257
258 sessionId =
259 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
260 ASSERT_GT(sessionId, 0);
261 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
262 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
263 DeleteSessionServerAndSession(g_sessionName, sessionId);
264
265 sessionId =
266 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
267 ASSERT_GT(sessionId, 0);
268 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_BYTES_LEN);
269 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
270 DeleteSessionServerAndSession(g_sessionName, sessionId);
271
272 sessionId =
273 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_INIT);
274 ASSERT_GT(sessionId, 0);
275 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
276 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
277 DeleteSessionServerAndSession(g_sessionName, sessionId);
278
279 sessionId = AddSessionServerAndSession(
280 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
281 ASSERT_GT(sessionId, 0);
282 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
283 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
284 DeleteSessionServerAndSession(g_sessionName, sessionId);
285 }
286
287 /**
288 * @tc.name: TransClientMsgServiceTest03
289 * @tc.desc: Transmission sdk message service send message with different parameters.
290 * @tc.type: FUNC
291 * @tc.require:
292 */
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)293 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)
294 {
295 int32_t sessionId =
296 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
297 ASSERT_GT(sessionId, 0);
298 int32_t ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, 0);
299 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
300 DeleteSessionServerAndSession(g_sessionName, sessionId);
301
302 sessionId =
303 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
304 ASSERT_GT(sessionId, 0);
305 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
306 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
307 DeleteSessionServerAndSession(g_sessionName, sessionId);
308
309 sessionId = AddSessionServerAndSession(
310 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
311 ASSERT_GT(sessionId, 0);
312 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_MSG_LEN);
313 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
314 DeleteSessionServerAndSession(g_sessionName, sessionId);
315
316 sessionId = AddSessionServerAndSession(
317 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_INIT);
318 ASSERT_GT(sessionId, 0);
319 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
320 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
321 DeleteSessionServerAndSession(g_sessionName, sessionId);
322
323 sessionId = AddSessionServerAndSession(
324 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
325 ASSERT_GT(sessionId, 0);
326 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
327 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
328 DeleteSessionServerAndSession(g_sessionName, sessionId);
329 }
330
331 /**
332 * @tc.name: TransClientMsgServiceTest04
333 * @tc.desc: Transmission sdk message service send stream with different parameters.
334 * @tc.type: FUNC
335 * @tc.require:
336 */
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)337 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)
338 {
339 char dataBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
340 StreamData data = {
341 .buf = dataBuf,
342 .bufLen = TRANS_TEST_MAX_MSG_LEN
343 };
344 char extBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
345 StreamData ext = {
346 .buf = extBuf,
347 .bufLen = TRANS_TEST_MAX_MSG_LEN
348 };
349 StreamFrameInfo streamFrameInfo = {0};
350 int32_t sessionId =
351 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
352 ASSERT_GT(sessionId, 0);
353 int32_t ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
354 EXPECT_EQ(ret, SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL);
355 DeleteSessionServerAndSession(g_sessionName, sessionId);
356
357 sessionId =
358 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
359 ASSERT_GT(sessionId, 0);
360 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
361 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
362 DeleteSessionServerAndSession(g_sessionName, sessionId);
363
364 sessionId =
365 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_INIT);
366 ASSERT_GT(sessionId, 0);
367 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
368 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
369 DeleteSessionServerAndSession(g_sessionName, sessionId);
370
371 sessionId =
372 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_SUCCESS);
373 ASSERT_GT(sessionId, 0);
374 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
375 EXPECT_NE(ret, SOFTBUS_OK);
376 DeleteSessionServerAndSession(g_sessionName, sessionId);
377 }
378
379 /**
380 * @tc.name: TransClientMsgServiceTest05
381 * @tc.desc: Transmission sdk message service send file with different parameters.
382 * @tc.type: FUNC
383 * @tc.require:
384 */
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)385 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)
386 {
387 const char *sFileList[TRANS_TEST_FILE_COUNT] = {
388 "/DATA/LOCAL/X",
389 "/DATA/LOCAL/Y"
390 };
391 const char *dFileList[TRANS_TEST_FILE_COUNT] = {
392 "/DATA/LOCAL/X",
393 "/DATA/LOCAL/Y"
394 };
395 int32_t sessionId =
396 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
397 ASSERT_GT(sessionId, 0);
398 int32_t ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
399 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
400 DeleteSessionServerAndSession(g_sessionName, sessionId);
401 sessionId = AddSessionServerAndSession(
402 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_INIT);
403 ASSERT_GT(sessionId, 0);
404 ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
405 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
406 DeleteSessionServerAndSession(g_sessionName, sessionId);
407 sessionId = AddSessionServerAndSession(
408 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
409 ASSERT_GT(sessionId, 0);
410 ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
411 EXPECT_EQ(ret, SOFTBUS_TRANS_CHANNEL_TYPE_INVALID);
412 DeleteSessionServerAndSession(g_sessionName, sessionId);
413 }
414 }
415