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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_log.h"
22 #include "auth_tcp_connection.h"
23 #include "auth_tcp_connection.c"
24 #include "softbus_errcode.h"
25 #include "softbus_socket.h"
26
27 namespace OHOS {
28 using namespace testing::ext;
29 constexpr uint32_t TEST_DATA_LEN = 30;
30
31 class AuthTcpConnectionTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void AuthTcpConnectionTest::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void AuthTcpConnectionTest::TearDownTestCase() {}
44
SetUp()45 void AuthTcpConnectionTest::SetUp()
46 {
47 AUTH_LOGI(AUTH_TEST, "AuthTcpConnectionTest start.");
48 }
49
TearDown()50 void AuthTcpConnectionTest::TearDown() {}
51
52 /*
53 * @tc.name: UNPACK_SOCKET_PKT_TEST_001
54 * @tc.desc: unpack socket pkt test
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58 HWTEST_F(AuthTcpConnectionTest, UNPACK_SOCKET_PKT_TEST_001, TestSize.Level1)
59 {
60 const uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
61 uint32_t len = 1;
62 SocketPktHead head;
63 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
64 int32_t ret = UnpackSocketPkt(data, len, &head);
65 EXPECT_TRUE(ret == SOFTBUS_NO_ENOUGH_DATA);
66 len = AUTH_PKT_HEAD_LEN;
67 ret = UnpackSocketPkt(data, len, &head);
68 EXPECT_TRUE(ret == SOFTBUS_OK);
69 }
70
71 /*
72 * @tc.name: MODULE_TO_DATA_TYPE_TEST_001
73 * @tc.desc: module to data type test
74 * @tc.type: FUNC
75 * @tc.require:
76 */
77 HWTEST_F(AuthTcpConnectionTest, MODULE_TO_DATA_TYPE_TEST_001, TestSize.Level1)
78 {
79 int32_t module = MODULE_TRUST_ENGINE;
80 uint32_t ret = ModuleToDataType(module);
81 EXPECT_TRUE(ret == DATA_TYPE_DEVICE_ID);
82 module = MODULE_AUTH_SDK;
83 ret = ModuleToDataType(module);
84 EXPECT_TRUE(ret == DATA_TYPE_AUTH);
85 module = MODULE_AUTH_CONNECTION;
86 ret = ModuleToDataType(module);
87 EXPECT_TRUE(ret == DATA_TYPE_DEVICE_INFO);
88 module = MODULE_MESSAGE_SERVICE;
89 ret = ModuleToDataType(module);
90 EXPECT_TRUE(ret == DATA_TYPE_CONNECTION);
91 }
92
93 /*
94 * @tc.name: RECV_PACKET_HEAD_TEST_001
95 * @tc.desc: recv packet head test
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_HEAD_TEST_001, TestSize.Level1)
100 {
101 int32_t fd = 0;
102 SocketPktHead pktHead;
103 (void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
104 int32_t ret = RecvPacketHead(AUTH, fd, &pktHead);
105 EXPECT_NE(ret, SOFTBUS_OK);
106 }
107
108 /*
109 * @tc.name: RECV_PACKET_DATA_TEST_001
110 * @tc.desc: recv packet head test
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_DATA_TEST_001, TestSize.Level1)
115 {
116 int32_t fd = 0;
117 SocketPktHead pktHead;
118 uint8_t data[TEST_DATA_LEN] = { 0 };
119 (void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
120 pktHead.module = MODULE_AUTH_CHANNEL;
121 NotifyDataReceived(AUTH, fd, &pktHead, data);
122 pktHead.module = MODULE_AUTH_MSG;
123 NotifyDataReceived(AUTH, fd, &pktHead, data);
124 pktHead.module = MODULE_CONNECTION;
125 NotifyDataReceived(AUTH, fd, &pktHead, data);
126
127 uint32_t len = TEST_DATA_LEN;
128 uint8_t *packetData = RecvPacketData(fd, len);
129 EXPECT_TRUE(packetData == nullptr);
130 }
131
132 /*
133 * @tc.name: PROCESS_SOCKET_OUT_EVENT_TEST_001
134 * @tc.desc: process socket out event test
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_OUT_EVENT_TEST_001, TestSize.Level1)
139 {
140 int32_t fd = 0;
141 bool isClient = true;
142 NotifyConnected(AUTH, fd, isClient);
143 NotifyDisconnected(fd);
144 StopSocketListening(AUTH);
145
146 int32_t ret = ProcessSocketOutEvent(AUTH, fd);
147 EXPECT_TRUE(ret == SOFTBUS_ERR);
148 }
149
150 /*
151 * @tc.name: PROCESS_SOCKET_IN_EVENT_TEST_001
152 * @tc.desc: process socket in event test
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_IN_EVENT_TEST_001, TestSize.Level1)
157 {
158 int32_t fd = 0;
159 int32_t channelId = 0;
160 SocketPktHead head;
161 const uint8_t data[TEST_DATA_LEN] = { 0 };
162 (void)memset_s(&head, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
163 NotifyChannelDataReceived(channelId, &head, data);
164 NotifyChannelDisconnected(channelId);
165
166 int32_t ret = ProcessSocketInEvent(AUTH, fd);
167 EXPECT_TRUE(ret == SOFTBUS_ERR);
168 }
169
170 /*
171 * @tc.name: ON_CONNECT_EVENT_TEST_001
172 * @tc.desc: on connect event test
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(AuthTcpConnectionTest, ON_CONNECT_EVENT_TEST_001, TestSize.Level1)
177 {
178 ListenerModule module = AUTH_P2P;
179 int32_t cfd = -1;
180 ConnectOption clientAddr;
181 (void)memset_s(&clientAddr, sizeof(ConnectOption), 0, sizeof(ConnectOption));
182 int32_t ret = OnConnectEvent(module, cfd, &clientAddr);
183 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
184 cfd = 0;
185 ret = OnConnectEvent(module, cfd, &clientAddr);
186 EXPECT_TRUE(ret == SOFTBUS_ERR);
187 }
188
189 /*
190 * @tc.name: ON_DATA_EVENT_TEST_001
191 * @tc.desc: on data event test
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(AuthTcpConnectionTest, ON_DATA_EVENT_TEST_001, TestSize.Level1)
196 {
197 ListenerModule module = AUTH_P2P;
198 int32_t events = SOFTBUS_SOCKET_OUT;
199 int32_t fd = 0;
200 int32_t ret = OnDataEvent(module, events, fd);
201 EXPECT_TRUE(ret == SOFTBUS_ERR);
202 events = SOFTBUS_SOCKET_IN;
203 ret = OnDataEvent(module, events, fd);
204 EXPECT_TRUE(ret == SOFTBUS_ERR);
205 events = SOFTBUS_SOCKET_EXCEPTION;
206 ret = OnDataEvent(module, events, fd);
207 EXPECT_TRUE(ret == SOFTBUS_ERR);
208 }
209
210 /*
211 * @tc.name: START_SOCKET_LISTENING_TEST_001
212 * @tc.desc: start socket listening test
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(AuthTcpConnectionTest, START_SOCKET_LISTENING_TEST_001, TestSize.Level1)
217 {
218 LocalListenerInfo info = {
219 .type = CONNECT_TCP,
220 .socketOption = {
221 .addr = "192.168.12.1",
222 .port = 22,
223 .moduleId = AUTH,
224 .protocol = LNN_PROTOCOL_IP,
225 },
226 };
227 int32_t ret = StartSocketListening(AUTH, &info);
228 EXPECT_TRUE(ret == SOFTBUS_ERR);
229 }
230
231 /*
232 * @tc.name: SOCKET_GET_CONN_INFO_TEST_001
233 * @tc.desc: socket get conn info test
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(AuthTcpConnectionTest, SOCKET_GET_CONN_INFO_TEST_001, TestSize.Level1)
238 {
239 int32_t fd = 0;
240 AuthConnInfo connInfo;
241 bool isServer;
242 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
243 int32_t ret = SocketGetConnInfo(fd, nullptr, &isServer);
244 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
245 ret = SocketGetConnInfo(fd, &connInfo, nullptr);
246 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
247 ret = SocketGetConnInfo(fd, &connInfo, &isServer);
248 EXPECT_TRUE(ret == SOFTBUS_ERR);
249 }
250
251 /*
252 * @tc.name: SOCKET_CONNECT_INNER_TEST_001
253 * @tc.desc: SocketConnectInner test
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(AuthTcpConnectionTest, SOCKET_CONNECT_INNER_TEST_001, TestSize.Level1)
258 {
259 const char *localIp = "192.168.11.22";
260 const char *peerIp = "192.168.11.33";
261 int32_t ret = SocketConnectInner(nullptr, peerIp, 37025, AUTH, true);
262 EXPECT_TRUE(ret == AUTH_INVALID_FD);
263 ret = SocketConnectInner(localIp, nullptr, 37025, AUTH, true);
264 EXPECT_TRUE(ret == AUTH_INVALID_FD);
265 ret = SocketConnectInner(localIp, peerIp, 37025, AUTH, true);
266 EXPECT_TRUE(ret == SOFTBUS_CONN_SOCKET_GET_INTERFACE_ERR);
267 }
268
269 /*
270 * @tc.name: NIP_SOCKET_CONNECT_DEVICE_TEST_001
271 * @tc.desc: NipSocketConnectDevice test
272 * @tc.type: FUNC
273 * @tc.require:
274 */
275 HWTEST_F(AuthTcpConnectionTest, NIP_SOCKET_CONNECT_DEVICE_TEST_001, TestSize.Level1)
276 {
277 const char *addr = "192.168.11.44";
278 int32_t ret = NipSocketConnectDevice(AUTH, addr, 37025, true);
279 EXPECT_TRUE(ret == AUTH_INVALID_FD);
280 ret = NipSocketConnectDevice(AUTH, nullptr, 37025, true);
281 EXPECT_TRUE(ret == AUTH_INVALID_FD);
282 }
283
284 /*
285 * @tc.name: AUTH_OPEN_CHANNEL_WITH_ALL_IP_TEST_001
286 * @tc.desc: AuthOpenChannelWithAllIp test
287 * @tc.type: FUNC
288 * @tc.require:
289 */
290 HWTEST_F(AuthTcpConnectionTest, AUTH_OPEN_CHANNEL_WITH_ALL_IP_TEST_001, TestSize.Level1)
291 {
292 const char *localIp = "192.168.11.22";
293 const char *remoteIp = "192.168.11.33";
294 int32_t ret = AuthOpenChannelWithAllIp(localIp, remoteIp, 37025);
295 EXPECT_TRUE(ret == INVALID_CHANNEL_ID);
296 ret = AuthOpenChannelWithAllIp(nullptr, remoteIp, 37025);
297 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
298 ret = AuthOpenChannelWithAllIp(localIp, nullptr, 37025);
299 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
300 ret = AuthOpenChannelWithAllIp(localIp, remoteIp, 0);
301 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
302 }
303 } // namespace OHOS
304