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);
SetUp()76     void SetUp() override
77     {}
TearDown()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(int sessionId,int result)101 static int OnSessionOpened(int sessionId, int result)
102 {
103     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
104     return SOFTBUS_OK;
105 }
106 
OnSessionClosed(int sessionId)107 static void OnSessionClosed(int sessionId)
108 {
109     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
110 }
111 
OnBytesReceived(int sessionId,const void * data,unsigned int len)112 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
113 {
114     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
115 }
116 
OnMessageReceived(int sessionId,const void * data,unsigned int len)117 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
118 {
119     TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
120 }
121 
OnStreamReceived(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)122 static void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
123 {
124     TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
125 }
126 
OnQosEvent(int sessionId,int eventId,int tvCount,const QosTv * tvList)127 static void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
128 {
129     TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
130 }
131 
132 static ISessionListener g_sessionlistener = {
133     .OnSessionOpened = OnSessionOpened,
134     .OnSessionClosed = OnSessionClosed,
135     .OnBytesReceived = OnBytesReceived,
136     .OnMessageReceived = OnMessageReceived,
137     .OnStreamReceived = OnStreamReceived,
138     .OnQosEvent = OnQosEvent,
139 };
140 
TestGenerateCommParam(SessionParam * sessionParam)141 static void TestGenerateCommParam(SessionParam *sessionParam)
142 {
143     sessionParam->sessionName = g_sessionName;
144     sessionParam->peerSessionName = g_sessionName;
145     sessionParam->peerDeviceId = g_deviceId;
146     sessionParam->groupId = g_groupId;
147     sessionParam->attr = &g_sessionAttr;
148 }
149 
TestGenerateSession(const SessionParam * param)150 static SessionInfo *TestGenerateSession(const SessionParam *param)
151 {
152     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
153     if (session == NULL) {
154         return NULL;
155     }
156 
157     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
158         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
159         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
160         SoftBusFree(session);
161         return NULL;
162     }
163 
164     session->sessionId = TRANS_TEST_SESSION_ID;
165     session->channelId = TRANS_TEST_CHANNEL_ID;
166     session->channelType = CHANNEL_TYPE_BUTT;
167     session->isServer = false;
168     session->enableStatus = ENABLE_STATUS_INIT;
169     session->routeType = ROUTE_TYPE_ALL;
170     session->info.flag = TYPE_BYTES;
171     session->isEncrypt = true;
172     session->algorithm = TRANS_TEST_ALGORITHM;
173     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
174     session->crc = TRANS_TEST_CRC;
175 
176     return session;
177 }
178 
AddSessionServerAndSession(const char * sessionName,int32_t channelType,int32_t businessType,bool isServer,SessionEnableStatus enableStatus)179 static int32_t AddSessionServerAndSession(
180     const char *sessionName, int32_t channelType, int32_t businessType, bool isServer, SessionEnableStatus enableStatus)
181 {
182     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
183     if (sessionParam == NULL) {
184         return SOFTBUS_MALLOC_ERR;
185     }
186 
187     TestGenerateCommParam(sessionParam);
188     sessionParam->sessionName = sessionName;
189     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
190     if (ret != SOFTBUS_OK) {
191         return ret;
192     }
193 
194     SessionInfo *session = TestGenerateSession(sessionParam);
195     if (session == NULL) {
196         return SOFTBUS_MALLOC_ERR;
197     }
198 
199     session->channelType = (ChannelType)channelType;
200     session->businessType = (BusinessType)businessType;
201     session->isServer = isServer;
202     session->enableStatus = enableStatus;
203     ret = ClientAddNewSession(sessionName, session);
204     if (ret != SOFTBUS_OK) {
205         return ret;
206     }
207 
208     int32_t sessionId = 0;
209     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId);
210     if (ret != SOFTBUS_OK) {
211         return ret;
212     }
213     SoftBusFree(sessionParam);
214     return sessionId;
215 }
216 
DeleteSessionServerAndSession(const char * sessionName,int32_t sessionId)217 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
218 {
219     int32_t ret = ClientDeleteSession(sessionId);
220     EXPECT_EQ(ret, SOFTBUS_OK);
221     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
222     EXPECT_EQ(ret, SOFTBUS_OK);
223 }
224 
225 /**
226  * @tc.name: TransClientMsgServiceTest01
227  * @tc.desc: Transmission sdk message service check send length with different parameters.
228  * @tc.type: FUNC
229  * @tc.require:
230  */
231 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)
232 {
233     int ret = CheckSendLen(CHANNEL_TYPE_BUTT, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
234     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
235     ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_INVALID_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_SEND_LEN, BUSINESS_TYPE_MESSAGE);
238     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
239 }
240 
241 /**
242  * @tc.name: TransClientMsgServiceTest02
243  * @tc.desc: Transmission sdk message service send bytes with different parameters.
244  * @tc.type: FUNC
245  * @tc.require:
246  */
247 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)
248 {
249     int32_t sessionId =
250         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
251     ASSERT_GT(sessionId, 0);
252     int ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, 0);
253     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
254     DeleteSessionServerAndSession(g_sessionName, sessionId);
255 
256     sessionId =
257         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
258     ASSERT_GT(sessionId, 0);
259     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
260     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
261     DeleteSessionServerAndSession(g_sessionName, sessionId);
262 
263     sessionId =
264         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
265     ASSERT_GT(sessionId, 0);
266     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_BYTES_LEN);
267     EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
268     DeleteSessionServerAndSession(g_sessionName, sessionId);
269 
270     sessionId =
271         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_INIT);
272     ASSERT_GT(sessionId, 0);
273     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
274     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
275     DeleteSessionServerAndSession(g_sessionName, sessionId);
276 
277     sessionId = AddSessionServerAndSession(
278         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
279     ASSERT_GT(sessionId, 0);
280     ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
281     EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
282     DeleteSessionServerAndSession(g_sessionName, sessionId);
283 }
284 
285 /**
286  * @tc.name: TransClientMsgServiceTest03
287  * @tc.desc: Transmission sdk message service send message with different parameters.
288  * @tc.type: FUNC
289  * @tc.require:
290  */
291 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)
292 {
293     int32_t sessionId =
294         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
295     ASSERT_GT(sessionId, 0);
296     int ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, 0);
297     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
298     DeleteSessionServerAndSession(g_sessionName, sessionId);
299 
300     sessionId =
301         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
302     ASSERT_GT(sessionId, 0);
303     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
304     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
305     DeleteSessionServerAndSession(g_sessionName, sessionId);
306 
307     sessionId = AddSessionServerAndSession(
308         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
309     ASSERT_GT(sessionId, 0);
310     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_MSG_LEN);
311     EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
312     DeleteSessionServerAndSession(g_sessionName, sessionId);
313 
314     sessionId = AddSessionServerAndSession(
315         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_INIT);
316     ASSERT_GT(sessionId, 0);
317     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
318     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
319     DeleteSessionServerAndSession(g_sessionName, sessionId);
320 
321     sessionId = AddSessionServerAndSession(
322         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
323     ASSERT_GT(sessionId, 0);
324     ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
325     EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
326     DeleteSessionServerAndSession(g_sessionName, sessionId);
327 }
328 
329 /**
330  * @tc.name: TransClientMsgServiceTest04
331  * @tc.desc: Transmission sdk message service send stream with different parameters.
332  * @tc.type: FUNC
333  * @tc.require:
334  */
335 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)
336 {
337     char dataBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
338     StreamData data = {
339         .buf = dataBuf,
340         .bufLen = TRANS_TEST_MAX_MSG_LEN
341     };
342     char extBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
343     StreamData ext = {
344         .buf = extBuf,
345         .bufLen = TRANS_TEST_MAX_MSG_LEN
346     };
347     StreamFrameInfo streamFrameInfo = {0};
348     int32_t sessionId =
349         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
350     ASSERT_GT(sessionId, 0);
351     int ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
352     EXPECT_EQ(ret, SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL);
353     DeleteSessionServerAndSession(g_sessionName, sessionId);
354 
355     sessionId =
356         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
357     ASSERT_GT(sessionId, 0);
358     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
359     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
360     DeleteSessionServerAndSession(g_sessionName, sessionId);
361 
362     sessionId =
363         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_INIT);
364     ASSERT_GT(sessionId, 0);
365     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
366     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
367     DeleteSessionServerAndSession(g_sessionName, sessionId);
368 
369     sessionId =
370         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_SUCCESS);
371     ASSERT_GT(sessionId, 0);
372     ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
373     EXPECT_NE(ret, SOFTBUS_OK);
374     DeleteSessionServerAndSession(g_sessionName, sessionId);
375 }
376 
377 /**
378  * @tc.name: TransClientMsgServiceTest05
379  * @tc.desc: Transmission sdk message service send file with different parameters.
380  * @tc.type: FUNC
381  * @tc.require:
382  */
383 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)
384 {
385     const char *sFileList[TRANS_TEST_FILE_COUNT] = {
386         "/DATA/LOCAL/X",
387         "/DATA/LOCAL/Y"
388     };
389     const char *dFileList[TRANS_TEST_FILE_COUNT] = {
390         "/DATA/LOCAL/X",
391         "/DATA/LOCAL/Y"
392     };
393     int32_t sessionId =
394         AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
395     ASSERT_GT(sessionId, 0);
396     int ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
397     EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
398     DeleteSessionServerAndSession(g_sessionName, sessionId);
399     sessionId = AddSessionServerAndSession(
400         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_INIT);
401     ASSERT_GT(sessionId, 0);
402     ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
403     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
404     DeleteSessionServerAndSession(g_sessionName, sessionId);
405     sessionId = AddSessionServerAndSession(
406         g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
407     ASSERT_GT(sessionId, 0);
408     ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
409     EXPECT_EQ(ret, SOFTBUS_TRANS_CHANNEL_TYPE_INVALID);
410     DeleteSessionServerAndSession(g_sessionName, sessionId);
411 }
412 }