• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2024 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 
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22 
23 #include <arpa/inet.h>
24 #include <list>
25 #include "clatd.h"
26 #include "clat_utils.h"
27 #include "net_manager_constants.h"
28 
29 namespace OHOS {
30 namespace nmd {
31 namespace {
32 using namespace testing::ext;
33 using namespace OHOS::NetManagerStandard;
34 constexpr int V4ADDR_BIT_LEN = 32;
35 }
36 
37 bool IsIpv4AddressFree(const in_addr_t v4Addr);
38 in_addr_t GetAvailableIpv4Address(const in_addr initV4Addr, const int16_t prefixLen);
39 int32_t GetSuitableIpv6Address(const std::string &v6IfaceStr, const in_addr v4Addr,
40     const in6_addr &nat64Prefix, in6_addr &v6Addr, const uint32_t mark);
41 
42 class ClatdTest : public testing::Test {
43 public:
SetUpTestCase()44     static void SetUpTestCase() {}
45 
TearDownTestCase()46     static void TearDownTestCase() {}
47 
SetUp()48     void SetUp() {}
49 
TearDown()50     void TearDown() {}
51 };
52 
53 HWTEST_F(ClatdTest, IsIpv4AddressFreeTest001, TestSize.Level1)
54 {
55     std::string v4AddrStr;
56     FreeTunV4Addr(v4AddrStr);
57 
58     v4AddrStr = "192.168.1.1";
59     in_addr v4Addr;
60     inet_pton(AF_INET, v4AddrStr.c_str(), &v4Addr);
61     auto ret = IsIpv4AddressFree(v4Addr.s_addr);
62 
63     ret = IsIpv4AddressFree(v4Addr.s_addr);
64     EXPECT_FALSE(ret);
65     FreeTunV4Addr(v4AddrStr);
66 }
67 
68 HWTEST_F(ClatdTest, GetAvailableIpv4AddressTest001, TestSize.Level1)
69 {
70     in_addr initV4Addr;
71     int16_t prefixLen = -1;
72     auto ret = GetAvailableIpv4Address(initV4Addr, prefixLen);
73     EXPECT_EQ(ret, INADDR_NONE);
74 
75     prefixLen = V4ADDR_BIT_LEN + 1;
76     ret = GetAvailableIpv4Address(initV4Addr, prefixLen);
77     EXPECT_EQ(ret, INADDR_NONE);
78 
79     initV4Addr.s_addr = 0;
80     prefixLen = 0;
81     ret = GetAvailableIpv4Address(initV4Addr, prefixLen);
82     EXPECT_EQ(ret, 0);
83 }
84 
85 HWTEST_F(ClatdTest, SelectIpv4AddressTest001, TestSize.Level1)
86 {
87     std::string initV4AddrStr;
88     int prefixLen = -1;
89     std::string v4AddrStr;
90     auto ret = SelectIpv4Address(initV4AddrStr, prefixLen, v4AddrStr);
91     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
92 
93     initV4AddrStr = "192.168.1.1";
94     ret = SelectIpv4Address(initV4AddrStr, prefixLen, v4AddrStr);
95     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
96 }
97 
98 HWTEST_F(ClatdTest, GetSuitableIpv6AddressTest001, TestSize.Level1)
99 {
100     std::string v6IfaceStr = "eth0";
101     in_addr v4Addr;
102     in6_addr nat64Prefix, v6Addr;
103     uint32_t mark = 100;
104     inet_pton(AF_INET, "192.0.2.1", &v4Addr);
105     inet_pton(AF_INET6, "64:ff9b::", &nat64Prefix);
106     auto ret = GetSuitableIpv6Address(v6IfaceStr, v4Addr, nat64Prefix, v6Addr, mark);
107     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
108 }
109 
110 HWTEST_F(ClatdTest, GenerateIpv6AddressTest001, TestSize.Level1)
111 {
112     std::string v6IfaceStr;
113     std::string v4AddrStr;
114     std::string prefix64Str;
115     uint32_t mark = 1;
116     std::string v6AddrStr;
117     auto ret = GenerateIpv6Address(v6IfaceStr, v4AddrStr, prefix64Str, mark, v6AddrStr);
118     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
119 
120     v6IfaceStr = "eth0";
121     ret = GenerateIpv6Address(v6IfaceStr, v4AddrStr, prefix64Str, mark, v6AddrStr);
122     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
123 
124     v4AddrStr = "192.168.1.1";
125     ret = GenerateIpv6Address(v6IfaceStr, v4AddrStr, prefix64Str, mark, v6AddrStr);
126     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
127 
128     prefix64Str = "2001:db8::";
129     ret = GenerateIpv6Address(v6IfaceStr, v4AddrStr, prefix64Str, mark, v6AddrStr);
130     EXPECT_NE(ret, NETMANAGER_SUCCESS);
131 }
132 
133 HWTEST_F(ClatdTest, CreateTunInterfaceTest001, TestSize.Level1)
134 {
135     std::string tunIface = "eth0";
136     int fd = -1;
137     auto ret = CreateTunInterface(tunIface, fd);
138     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
139 
140     tunIface = "9999999999999999999";
141     ret = CreateTunInterface(tunIface, fd);
142     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
143 }
144 
145 HWTEST_F(ClatdTest, OpenPacketSocketTest001, TestSize.Level1)
146 {
147     int readSock6 = -1;
148     auto ret = OpenPacketSocket(readSock6);
149     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
150 }
151 
152 HWTEST_F(ClatdTest, OpenRawSocket6Test001, TestSize.Level1)
153 {
154     int writeSock6 = -1;
155     auto ret = OpenRawSocket6(0, writeSock6);
156     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
157 }
158 
159 HWTEST_F(ClatdTest, ConfigureWriteSocketTest001, TestSize.Level1)
160 {
161     int sockFd = -1;
162     std::string v6Iface;
163     auto ret = ConfigureWriteSocket(sockFd, v6Iface);
164     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
165 
166     sockFd = 0;
167     ret = ConfigureWriteSocket(sockFd, v6Iface);
168     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
169 
170     OpenRawSocket6(0, sockFd);
171     ret = ConfigureWriteSocket(sockFd, v6Iface);
172     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
173 }
174 
175 HWTEST_F(ClatdTest, ConfigureReadSocketTest001, TestSize.Level1)
176 {
177     int sockFd = -1;
178     std::string addrStr;
179     int ifIndex = 0;
180     auto ret = ConfigureReadSocket(sockFd, addrStr, ifIndex);
181     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
182 
183     sockFd = 0;
184     ret = ConfigureReadSocket(sockFd, addrStr, ifIndex);
185     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
186 
187     addrStr = "2001:db8:85a3::8a2e:370:7334";
188     ret = ConfigureReadSocket(sockFd, addrStr, ifIndex);
189     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
190 
191     OpenPacketSocket(sockFd);
192     ret = ConfigureReadSocket(sockFd, addrStr, ifIndex);
193     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
194 }
195 
196 HWTEST_F(ClatdTest, SetTunInterfaceAddressTest001, TestSize.Level1)
197 {
198     std::string ifName = "eth0";
199     std::string tunAddr;
200     int32_t prefix = 0;
201     auto ret = SetTunInterfaceAddress(ifName, tunAddr, prefix);
202     EXPECT_EQ(ret, NETMANAGER_ERROR);
203 
204     tunAddr = "9999999999999999999";
205     ret = SetTunInterfaceAddress(ifName, tunAddr, prefix);
206     EXPECT_EQ(ret, NETMANAGER_ERROR);
207 
208     tunAddr = "192.168.1.1";
209     ret = SetTunInterfaceAddress(ifName, tunAddr, prefix);
210     EXPECT_EQ(ret, NETMANAGER_ERROR);
211 }
212 
213 HWTEST_F(ClatdTest, SetTunInterfaceAddressTest002, TestSize.Level1)
214 {
215     std::string ifName = "eth0";
216     std::string tunAddr = "192.168.1.1";
217     int32_t prefix = V4ADDR_BIT_LEN + 1;
218     auto ret = SetTunInterfaceAddress(ifName, tunAddr, prefix);
219     EXPECT_EQ(ret, NETMANAGER_ERROR);
220 
221     prefix = V4ADDR_BIT_LEN;
222     ret = SetTunInterfaceAddress(ifName, tunAddr, prefix);
223     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
224 }
225 
226 } // namespace nmd
227 } // namespace OHOS