1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17 #include <sys/socket.h>
18
19 #include "client_trans_tcp_direct_listener.c"
20 #include "client_trans_tcp_direct_manager.c"
21 #include "client_trans_tcp_direct_message.c"
22
23 #include "softbus_access_token_test.h"
24 #include "softbus_app_info.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27 #include "trans_tcp_direct_tlv_mock.h"
28
29 #define TDC_TLV_ELEMENT 5
30 #define DATA_SIZE 4
31 #define PKG_HEAD_SIZE 32
32 #define TRANS_TEST_FD 1000
33 #define TRANS_TEST_CHANNEL_ID 1
34 #define TEST_DATA_LEN 100
35
36 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
37
38 using namespace testing;
39 using namespace testing::ext;
40
41 namespace OHOS {
42
43 class TransTcpDirectMockTest : public testing::Test {
44 public:
TransTcpDirectMockTest()45 TransTcpDirectMockTest()
46 {}
~TransTcpDirectMockTest()47 ~TransTcpDirectMockTest()
48 {}
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
SetUp()51 void SetUp() override
52 {}
TearDown()53 void TearDown() override
54 {}
55 };
56
SetUpTestCase(void)57 void TransTcpDirectMockTest::SetUpTestCase(void)
58 {
59 SetAccessTokenPermission("dsoftbusTransTest");
60 g_tcpDirectChannelInfoList = CreateSoftBusList();
61 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
62 }
63
TearDownTestCase(void)64 void TransTcpDirectMockTest::TearDownTestCase(void)
65 {
66 DestroySoftBusList(g_tcpDirectChannelInfoList);
67 g_tcpDirectChannelInfoList = nullptr;
68 }
69
70 /**
71 * @tc.name: BuildNeedAckTlvData001
72 * @tc.desc: BuildNeedAckTlvData
73 * @tc.type: FUNC
74 * @tc.require:
75 */
76 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData001, TestSize.Level0)
77 {
78 int32_t bufferSize = 0;
79 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
80 ASSERT_NE(data, nullptr);
81 data->magicNum = MAGIC_NUMBER;
82 data->tlvCount = TDC_TLV_ELEMENT;
83 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
84 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_MEM_ERR));
85 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
86 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
87 SoftBusFree(data);
88 }
89
90 /**
91 * @tc.name: BuildNeedAckTlvData002
92 * @tc.desc: BuildNeedAckTlvData
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData002, TestSize.Level0)
97 {
98 int32_t bufferSize = 0;
99 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
100 ASSERT_NE(data, nullptr);
101 data->magicNum = MAGIC_NUMBER;
102 data->tlvCount = TDC_TLV_ELEMENT;
103 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
104 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_MALLOC_ERR));
105 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
106 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
107 SoftBusFree(data);
108 }
109
110 /**
111 * @tc.name: BuildNeedAckTlvData003
112 * @tc.desc: BuildNeedAckTlvData
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData003, TestSize.Level0)
117 {
118 int32_t bufferSize = 0;
119 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
120 ASSERT_NE(data, nullptr);
121 data->magicNum = MAGIC_NUMBER;
122 data->tlvCount = TDC_TLV_ELEMENT;
123 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
124 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK));
125 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
126 EXPECT_EQ(ret, SOFTBUS_OK);
127 SoftBusFree(data);
128 }
129
130 /**
131 * @tc.name: BuildDataHead001
132 * @tc.desc: BuildDataHead
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(TransTcpDirectMockTest, BuildDataHead001, TestSize.Level0)
137 {
138 int32_t bufferSize = 0;
139 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
140 ASSERT_NE(data, nullptr);
141 data->magicNum = MAGIC_NUMBER;
142 data->tlvCount = TDC_TLV_ELEMENT;
143 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
144 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_MEM_ERR));
145 int32_t ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
146 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
147
148 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_MALLOC_ERR));
149 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
150 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
151
152 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK)).WillOnce(
153 Return(SOFTBUS_MALLOC_ERR));
154 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
155 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
156
157 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK)).WillOnce(
158 Return(SOFTBUS_OK));
159 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
160 SoftBusFree(data);
161 EXPECT_EQ(ret, SOFTBUS_OK);
162 }
163
164 /**
165 * @tc.name: TransTdcParseTlv001
166 * @tc.desc: TransTdcParseTlv and PackTcpDataPacketHead
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(TransTcpDirectMockTest, TransTdcParseTlv001, TestSize.Level0)
171 {
172 TcpDataPacketHead data;
173 data.magicNumber = MAGIC_NUMBER;
174 data.seq = 1;
175 data.flags = 0;
176 data.dataLen = DATA_SIZE;
177 PackTcpDataPacketHead(&data);
178 uint32_t bufferSize = 0;
179 int32_t ret = TransTdcParseTlv(TEST_DATA_LEN, nullptr, nullptr, &bufferSize);
180 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
181 }
182
183 /**
184 * @tc.name: TransTdcSetPendingPacket001
185 * @tc.desc: TransTdcSetPendingPacket
186 * @tc.type: FUNC
187 * @tc.require:
188 */
189 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket001, TestSize.Level0)
190 {
191 const char *data = "test";
192 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
193 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
194 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
195 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
196 }
197
198 /**
199 * @tc.name: TransTdcSetPendingPacket002
200 * @tc.desc: TransTdcSetPendingPacket
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket002, TestSize.Level0)
205 {
206 const char *data = "test";
207 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
208 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
209 EXPECT_CALL(tcpDirectMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(
210 SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
211 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
212 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
213 }
214
215 /**
216 * @tc.name: TransTdcSetPendingPacket003
217 * @tc.desc: TransTdcSetPendingPacket
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket003, TestSize.Level0)
222 {
223 const char *data = "test";
224 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
225 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
226 EXPECT_CALL(tcpDirectMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(SOFTBUS_OK));
227 EXPECT_CALL(tcpDirectMock, DeleteDataSeqInfoList).WillOnce(Return(SOFTBUS_TRANS_DATA_SEQ_INFO_NOT_FOUND));
228 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
229 EXPECT_EQ(ret, SOFTBUS_TRANS_DATA_SEQ_INFO_NOT_FOUND);
230 }
231
232 /**
233 * @tc.name: TransTcpSetTos001
234 * @tc.desc: TransTcpSetTos
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(TransTcpDirectMockTest, TransTcpSetTos001, TestSize.Level0)
239 {
240 TcpDirectChannelInfo channel;
241 channel.channelId = 1;
242 int32_t ret = TransTcpSetTos(nullptr, 0);
243 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
244
245 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
246 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
247 ret = TransTcpSetTos(&channel, 0);
248 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NAME_NO_EXIST);
249
250 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
251 EXPECT_CALL(tcpDirectMock, SetIpTos).WillOnce(Return(SOFTBUS_TCP_SOCKET_ERR));
252 ret = TransTcpSetTos(&channel, 0);
253 EXPECT_EQ(ret, SOFTBUS_TCP_SOCKET_ERR);
254
255 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
256 EXPECT_CALL(tcpDirectMock, SetIpTos).WillOnce(Return(SOFTBUS_OK));
257 ret = TransTcpSetTos(&channel, 0);
258 EXPECT_EQ(ret, SOFTBUS_OK);
259 }
260
261 /**
262 * @tc.name: TransSetTosSendData001
263 * @tc.desc: TransSetTosSendData
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(TransTcpDirectMockTest, TransSetTosSendData001, TestSize.Level0)
268 {
269 int32_t newPkgHeadSize = PKG_HEAD_SIZE;
270 const char *buf = "test";
271 uint32_t outLen = DATA_SIZE;
272 int32_t ret = TransSetTosSendData(nullptr, const_cast<char *>(buf), newPkgHeadSize, 0, outLen);
273 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
274 }
275
276 /**
277 * @tc.name: TransTdcSendBytes001
278 * @tc.desc: TransTdcSendBytes
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(TransTcpDirectMockTest, TransTdcSendBytes001, TestSize.Level0)
283 {
284 int32_t channelId = 1;
285 const char *data = "data";
286 uint32_t len = DATA_SIZE;
287 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
288 ASSERT_NE(info, nullptr);
289
290 info->channelId = channelId;
291 info->detail.needRelease = true;
292 info->detail.sequence = 2;
293 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
294 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
295 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
296
297 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
298 EXPECT_CALL(tcpDirectMock, AddPendingPacket).WillOnce(Return(SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_PENDING));
299 int32_t ret = TransTdcSendBytes(channelId, data, len, true);
300 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_PENDING);
301
302 EXPECT_CALL(tcpDirectMock, AddPendingPacket).WillOnce(Return(SOFTBUS_OK));
303 ret = TransTdcSendBytes(channelId, data, len, true);
304 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
305 ListDelete(&info->node);
306 SoftBusFree(info);
307 }
308
309 /**
310 * @tc.name: TransTdcSendBytes002
311 * @tc.desc: TransTdcSendBytes
312 * @tc.type: FUNC
313 * @tc.require:
314 */
315 HWTEST_F(TransTcpDirectMockTest, TransTdcSendBytes002, TestSize.Level0)
316 {
317 int32_t channelId = 1;
318 const char *data = "data";
319 uint32_t len = DATA_SIZE;
320 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
321 ASSERT_NE(info, nullptr);
322
323 info->channelId = channelId;
324 info->detail.needRelease = false;
325 info->detail.sequence = 2;
326 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
327 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
328 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
329
330 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
331 EXPECT_CALL(tcpDirectMock, AddPendingPacket).WillOnce(Return(SOFTBUS_OK));
332 int32_t ret = TransTdcSendBytes(channelId, data, len, true);
333 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
334 ListDelete(&info->node);
335 SoftBusFree(info);
336 }
337
338 /**
339 * @tc.name: TransTdcAsyncSendBytes001
340 * @tc.desc: TransTdcAsyncSendBytes
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(TransTcpDirectMockTest, TransTdcAsyncSendBytes001, TestSize.Level0)
345 {
346 int32_t ret = TransTdcAsyncSendBytes(1, nullptr, 1, 1);
347 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
348
349 const char *data = "test";
350 ret = TransTdcAsyncSendBytes(1, data, 0, 1);
351 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
352
353 ret = TransTdcAsyncSendBytes(1, nullptr, 0, 1);
354 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
355
356 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
357 ASSERT_NE(info, nullptr);
358
359 info->channelId = 1;
360 info->detail.needRelease = true;
361 info->detail.sequence = 2;
362 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
363 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
364 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
365
366 ret = TransTdcAsyncSendBytes(1, data, DATA_SIZE, 1);
367 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
368 ListDelete(&info->node);
369 SoftBusFree(info);
370 }
371
372 /**
373 * @tc.name: TransTdcSendAck001
374 * @tc.desc: TransTdcSendAck
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(TransTcpDirectMockTest, TransTdcSendAck001, TestSize.Level0)
379 {
380 int32_t channelId = 1;
381 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
382 ASSERT_NE(info, nullptr);
383
384 info->channelId = channelId;
385 info->detail.needRelease = true;
386 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
387 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
388 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
389
390 int32_t ret = TransTdcSendAck(channelId, 1);
391 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
392 ListDelete(&info->node);
393 SoftBusFree(info);
394 }
395
396 /**
397 * @tc.name: TransTdcNeedSendAck002
398 * @tc.desc: TransTdcNeedSendAck
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(TransTcpDirectMockTest, TransTdcNeedSendAck001, TestSize.Level0)
403 {
404 int32_t channelId = 1;
405 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
406 ASSERT_NE(info, nullptr);
407
408 info->channelId = channelId;
409 info->detail.needRelease = false;
410 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
411 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
412 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
413 int32_t ret = TransTdcNeedSendAck(info, 1, 0, false);
414 EXPECT_EQ(ret, SOFTBUS_OK);
415 ListDelete(&info->node);
416 SoftBusFree(info);
417 }
418
419 /**
420 * @tc.name: TransTdcProcessBytesDataByFlag001
421 * @tc.desc: TransTdcProcessBytesDataByFlag
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(TransTcpDirectMockTest, TransTdcProcessBytesDataByFlag001, TestSize.Level0)
426 {
427 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
428 ASSERT_NE(info, nullptr);
429 info->detail.needRelease = false;
430 info->channelId = TRANS_TEST_CHANNEL_ID;
431 info->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
432 info->detail.fd = TRANS_TEST_FD;
433 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
434 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
435 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
436 TcpDataTlvPacketHead *head = reinterpret_cast<TcpDataTlvPacketHead *>(SoftBusCalloc(sizeof(TcpDataTlvPacketHead)));
437 ASSERT_NE(head, nullptr);
438 head->flags = FLAG_BYTES;
439 const char *plain = "plain";
440 head->seq = 1;
441 head->dataSeq = 0;
442 head->needAck = false;
443 head->flags = FLAG_ACK;
444 int32_t ret = TransTdcProcessBytesDataByFlag(head, info, const_cast<char *>(plain), (uint32_t)strlen(plain));
445 EXPECT_EQ(ret, SOFTBUS_OK);
446
447 head->flags = FILE_FIRST_FRAME;
448 ret = TransTdcProcessBytesDataByFlag(head, info, const_cast<char *>(plain), (uint32_t)strlen(plain));
449 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
450 ListDelete(&info->node);
451 SoftBusFree(info);
452 SoftBusFree(head);
453 }
454
455 /**
456 * @tc.name: TransTdcProcessTlvData001
457 * @tc.desc: TransTdcProcessTlvData
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(TransTcpDirectMockTest, TransTdcProcessTlvData001, TestSize.Level0)
462 {
463 TransDataListInit();
464 TcpDirectChannelInfo channel;
465 channel.channelId = 1;
466 TcpDataTlvPacketHead *head = reinterpret_cast<TcpDataTlvPacketHead *>(SoftBusCalloc(sizeof(TcpDataTlvPacketHead)));
467 ASSERT_NE(head, nullptr);
468 head->flags = FLAG_BYTES;
469 int32_t ret = TransTdcProcessTlvData(channel, head, PKG_HEAD_SIZE);
470 EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
471 SoftBusFree(head);
472 TransDataListDeinit();
473 }
474 } // namespace OHOS