1 /*
2 * Copyright (c) 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 #include <arpa/inet.h>
16 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18 #include <netinet/in.h>
19 #include "securec.h"
20
21 #define private public
22 #include "clatd_packet_converter.h"
23 #include "net_manager_constants.h"
24
25 using namespace testing;
26
27 namespace OHOS {
28 namespace nmd {
29 using namespace testing::ext;
30
31 static constexpr const char *V4ADDR = "192.0.0.0";
32 static constexpr const char *V6ADDR_UDP_ICMP = "2408:8456:3242:b272:28fb:90b4:fdc6:ce53";
33 static constexpr const char *V6ADDR_TCP = "2408:8456:3226:d7a4:a265:ca6:72b2:3ef6";
34 static constexpr const char *PREFIXADDR = "2407:c080:7ef:ffff::";
35
36 // clang-format off
37 static const uint8_t V4_UDP_PACKET_TX[] = {
38 0x45, 0x00, 0x00, 0x20, 0x68, 0x69, 0x40, 0x00, 0x40, 0x11, 0x5d, 0xa5, 0xc0, 0x00, 0x00, 0x00,
39 0x8b, 0x09, 0x29, 0xb5, 0x95, 0xd4, 0x14, 0x51, 0x00, 0x0c, 0x70, 0x1d, 0x15, 0xcd, 0x5b, 0x07,
40 };
41
42 static const uint8_t V6_UDP_PACKET_TX[] = {
43 0x60, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x11, 0x40, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42, 0xb2, 0x72,
44 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
45 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x95, 0xd4, 0x14, 0x51, 0x00, 0x0c, 0x30, 0xc9,
46 0x15, 0xcd, 0x5b, 0x07
47 };
48
49 static const uint8_t V6_INVALID_PROTOCOL_PACKET_TX[] = {
50 0x60, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x99, 0x40, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42, 0xb2, 0x72,
51 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
52 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x95, 0xd4, 0x14, 0x51, 0x00, 0x0c, 0x30, 0xc9,
53 0x15, 0xcd, 0x5b, 0x07
54 };
55
56 static const uint8_t V6_UDP_PACKET_RX[] = {
57 0x69, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x11, 0x29, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
58 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42, 0xb2, 0x72,
59 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x14, 0x51, 0x95, 0xd4, 0x00, 0x0c, 0x33, 0x2d,
60 0x36, 0x37, 0x38, 0x39
61 };
62
63 static const uint8_t V4_UDP_PACKET_RX[] = {
64 0x45, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x29, 0x11, 0xdd, 0x0e, 0x8b, 0x09, 0x29, 0xb5,
65 0xc0, 0x00, 0x00, 0x00, 0x14, 0x51, 0x95, 0xd4, 0x00, 0x0c, 0x72, 0x81, 0x36, 0x37, 0x38, 0x39,
66 };
67
68 static const uint8_t V4_TCP_PACKET_TX[] = {
69 0x45, 0x00, 0x00, 0x3c, 0x7a, 0x91, 0x40, 0x00, 0x40, 0x06, 0x4b, 0x6c, 0xc0, 0x00, 0x00, 0x00,
70 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0, 0x00, 0x00, 0x00, 0x00,
71 0xa0, 0x02, 0xff, 0xff, 0x37, 0x8b, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34, 0x04, 0x02, 0x08, 0x0a,
72 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x08
73 };
74
75 static const uint8_t V4_TCP_PACKET_FRAG_TX[] = {
76 0x45, 0x00, 0x00, 0x3c, 0x7a, 0x91, 0x1f, 0xff, 0x40, 0x06, 0x4b, 0x6c, 0xc0, 0x00, 0x00, 0x00,
77 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0, 0x00, 0x00, 0x00, 0x00,
78 0xa0, 0x02, 0xff, 0xff, 0x37, 0x8b, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34, 0x04, 0x02, 0x08, 0x0a,
79 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x08
80 };
81
82 static const uint8_t V4_TCP_INVALID_1[] = {0x45};
83
84 static const uint8_t V4_TCP_INVALID_2[] = {
85 0x11, 0x00, 0x00, 0x3c, 0x7a, 0x91, 0x40, 0x00, 0x40, 0x06, 0x4b, 0x6c, 0xc0, 0x00, 0x00, 0x00,
86 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0, 0x00, 0x00, 0x00, 0x00,
87 0xa0, 0x02, 0xff, 0xff, 0x37, 0x8b, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34, 0x04, 0x02, 0x08, 0x0a,
88 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x08
89 };
90
91 static const uint8_t V4_TCP_INVALID_3[] = {
92 0xFF, 0x00, 0x00, 0x3c, 0x7a, 0x91, 0x40, 0x00, 0x40, 0x06, 0x4b, 0x6c, 0xc0, 0x00, 0x00, 0x00,
93 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0, 0x00, 0x00, 0x00, 0x00,
94 0xa0, 0x02, 0xff, 0xff, 0x37, 0x8b, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34, 0x04, 0x02, 0x08, 0x0a,
95 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03
96 };
97
98 static const uint8_t V4_TCP_INVALID_4[] = {
99 0x59, 0x00, 0x00, 0x3c, 0x7a, 0x91, 0x40, 0x00, 0x40, 0x06, 0x4b, 0x6c, 0xc0, 0x00, 0x00, 0x00,
100 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0, 0x00, 0x00, 0x00, 0x00,
101 0xa0, 0x02, 0xff, 0xff, 0x37, 0x8b, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34, 0x04, 0x02, 0x08, 0x0a,
102 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x08
103 };
104
105 static const uint8_t V6_TCP_PACKET_TX[] = {
106 0x60, 0x00, 0x00, 0x00, 0x00, 0x28, 0x06, 0x40, 0x24, 0x08, 0x84, 0x56, 0x32, 0x26, 0xd7, 0xa4,
107 0xa2, 0x65, 0x0c, 0xa6, 0x72, 0xb2, 0x3e, 0xf6, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
108 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0xca, 0x66, 0x1f, 0x90, 0xd5, 0xd3, 0x06, 0xc0,
109 0x00, 0x00, 0x00, 0x00, 0xa0, 0x02, 0xff, 0xff, 0xf8, 0x36, 0x00, 0x00, 0x02, 0x04, 0x05, 0x34,
110 0x04, 0x02, 0x08, 0x0a, 0x11, 0xa2, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x08,
111 };
112
113 static const uint8_t V6_TCP_PACKET_RX[] = {
114 0x69, 0x00, 0x00, 0x00, 0x00, 0x28, 0x06, 0x2a, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
115 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x24, 0x08, 0x84, 0x56, 0x32, 0x26, 0xd7, 0xa4,
116 0xa2, 0x65, 0x0c, 0xa6, 0x72, 0xb2, 0x3e, 0xf6, 0x1f, 0x90, 0xca, 0x66, 0x97, 0x37, 0x91, 0xdc,
117 0xd5, 0xd3, 0x06, 0xc1, 0xa0, 0x12, 0xfe, 0x88, 0x15, 0x25, 0x00, 0x00, 0x02, 0x04, 0x04, 0xb0,
118 0x04, 0x02, 0x08, 0x0a, 0x50, 0x73, 0x6b, 0x75, 0x11, 0xa2, 0xc4, 0x08, 0x01, 0x03, 0x03, 0x07
119 };
120
121 static const uint8_t V4_TCP_PACKET_RX[] = {
122 0x45, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x40, 0x00, 0x2a, 0x06, 0xdb, 0xfd, 0x8b, 0x09, 0x29, 0xb5,
123 0xc0, 0x00, 0x00, 0x00, 0x1f, 0x90, 0xca, 0x66, 0x97, 0x37, 0x91, 0xdc, 0xd5, 0xd3, 0x06, 0xc1,
124 0xa0, 0x12, 0xfe, 0x88, 0x54, 0x79, 0x00, 0x00, 0x02, 0x04, 0x04, 0xb0, 0x04, 0x02, 0x08, 0x0a,
125 0x50, 0x73, 0x6b, 0x75, 0x11, 0xa2, 0xc4, 0x08, 0x01, 0x03, 0x03, 0x07
126 };
127
128 static const uint8_t V4_ICMP_PACKET_TX[] = {
129 0x45, 0x00, 0x00, 0x54, 0xec, 0x22, 0x40, 0x00, 0x40, 0x01, 0xd9, 0xc7, 0xc0, 0x00, 0x00, 0x00,
130 0x8b, 0x09, 0x29, 0xb5, 0x08, 0x00, 0x85, 0xc1, 0x00, 0x01, 0x01, 0x00, 0x62, 0x3d, 0x0f, 0x00,
131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
133 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134 0x00, 0x00, 0x00, 0x00
135 };
136
137 static const uint8_t V6_ICMP_PACKET_TX[] = {
138 0x60, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3a, 0x40, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42, 0xb2, 0x72,
139 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
140 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x80, 0x00, 0x59, 0x33, 0x00, 0x01, 0x01, 0x00,
141 0x62, 0x3d, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
142 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
143 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
145 };
146
147 static const uint8_t V6_ICMP_PACKET_RX[] = {
148 0x69, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3a, 0x2a, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff, 0xff,
149 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42, 0xb2, 0x72,
150 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x81, 0x00, 0x58, 0x33, 0x00, 0x01, 0x01, 0x00,
151 0x62, 0x3d, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
152 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
153 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
154 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
155 };
156
157 static const uint8_t V6_ICMP_PACKET_FRAGMENT[] = {
158 0x69, 0x00, 0x00, 0x00, 0x00, 0x40, 0x2c, 0x2a, 0x24, 0x07, 0xc0, 0x80, 0x07, 0xef, 0xff,
159 0xff, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x09, 0x29, 0xb5, 0x24, 0x08, 0x84, 0x56, 0x32, 0x42,
160 0xb2, 0x72, 0x28, 0xfb, 0x90, 0xb4, 0xfd, 0xc6, 0xce, 0x53, 0x81, 0x00, 0x58, 0x33, 0x00,
161 0x01, 0x01, 0x00, 0x62, 0x3d, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
162 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
163 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
164 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
165 };
166
167
168 static const uint8_t V4_ICMP_PACKET_RX[] = {
169 0x45, 0x00, 0x00, 0x54, 0x00, 0x00, 0x40, 0x00, 0x2a, 0x01, 0xdb, 0xea, 0x8b, 0x09, 0x29, 0xb5,
170 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xc1, 0x00, 0x01, 0x01, 0x00, 0x62, 0x3d, 0x0f, 0x00,
171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
172 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
173 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174 0x00, 0x00, 0x00, 0x00
175 };
176
177 class MockClatdPacketConverter : public ClatdPacketConverter {
178 public:
MockClatdPacketConverter(const uint8_t * inputPacket,size_t inputPacketSize,ClatdConvertType convertType,const in_addr & v4Addr,const in6_addr & v6Addr,const in6_addr & prefixAddr)179 MockClatdPacketConverter(const uint8_t *inputPacket, size_t inputPacketSize, ClatdConvertType convertType,
180 const in_addr &v4Addr, const in6_addr &v6Addr, const in6_addr &prefixAddr)
181 : ClatdPacketConverter(inputPacket, inputPacketSize, convertType, v4Addr, v6Addr, prefixAddr)
182 {
183 }
184 MOCK_METHOD3(WriteFragHeader, size_t(ip6_frag *ip6FragHeader, ip6_hdr *ip6Header, const iphdr *ipHeader));
185 };
186
187 // clang-format on
188 class ClatdPacketConverterTest : public ::testing::Test {
189 public:
190 void SetUp() override;
191 void TearDown() override;
192 bool IsTranslatedPacketCorrect(std::vector<iovec> iovPackets, const uint8_t *packet);
193
194 in_addr v4Addr_{};
195 in6_addr v6Addr_{};
196 in6_addr prefixAddr_{};
197 };
198
SetUp()199 void ClatdPacketConverterTest::SetUp()
200 {
201 inet_pton(AF_INET, V4ADDR, &v4Addr_.s_addr);
202 inet_pton(AF_INET6, PREFIXADDR, &prefixAddr_);
203 }
204
TearDown()205 void ClatdPacketConverterTest::TearDown() {}
206
IsTranslatedPacketCorrect(std::vector<iovec> iovPackets,const uint8_t * packet)207 bool ClatdPacketConverterTest::IsTranslatedPacketCorrect(std::vector<iovec> iovPackets, const uint8_t *packet)
208 {
209 if (memcmp(iovPackets[CLATD_IPHDR].iov_base, packet, iovPackets[CLATD_IPHDR].iov_len) != 0) {
210 return false;
211 }
212 packet += iovPackets[CLATD_IPHDR].iov_len;
213 if (memcmp(iovPackets[CLATD_TPHDR].iov_base, packet, iovPackets[CLATD_TPHDR].iov_len) != 0) {
214 return false;
215 }
216 packet += iovPackets[CLATD_TPHDR].iov_len;
217 if (memcmp(iovPackets[CLATD_PAYLOAD].iov_base, packet, iovPackets[CLATD_PAYLOAD].iov_len) != 0) {
218 return false;
219 }
220 return true;
221 }
222
223 /**
224 * @tc.name: ClatdPacketConverterTranslateUdpTest001
225 * @tc.desc: Test ClatdPacketConverter translate ipv4 udp packet.
226 * @tc.type: FUNC
227 */
228 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateUdpTest001, TestSize.Level1)
229 {
230 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
231 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
232 V4_UDP_PACKET_TX, sizeof(V4_UDP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
233 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
234
235 std::vector<iovec> iovPackets(CLATD_MAX);
236 int effectivePos = 0;
237 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
238
239 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V6_UDP_PACKET_TX), true);
240 }
241
242 /**
243 * @tc.name: ClatdPacketConverterTranslateUdpTest002
244 * @tc.desc: Test ClatdPacketConverter translate ipv6 udp packet.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateUdpTest002, TestSize.Level1)
248 {
249 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
250 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
251 V6_UDP_PACKET_RX, sizeof(V6_UDP_PACKET_RX), CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
252 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
253
254 std::vector<iovec> iovPackets(CLATD_MAX);
255 int effectivePos = 0;
256 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
257
258 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V4_UDP_PACKET_RX), true);
259 }
260
261 /**
262 * @tc.name: ClatdPacketConverterTranslateTcpTest001
263 * @tc.desc: Test ClatdPacketConverter translate ipv4 tcp packet.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateTcpTest001, TestSize.Level1)
267 {
268 inet_pton(AF_INET6, V6ADDR_TCP, &v6Addr_);
269 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
270 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
271 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
272
273 std::vector<iovec> iovPackets(CLATD_MAX);
274 int effectivePos = 0;
275 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
276
277 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V6_TCP_PACKET_TX), true);
278 }
279
280 /**
281 * @tc.name: ClatdPacketConverterTranslateTcpTest002
282 * @tc.desc: Test ClatdPacketConverter translate ipv6 tcp packet.
283 * @tc.type: FUNC
284 */
285 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateTcpTest002, TestSize.Level1)
286 {
287 inet_pton(AF_INET6, V6ADDR_TCP, &v6Addr_);
288 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
289 V6_TCP_PACKET_RX, sizeof(V6_TCP_PACKET_RX), CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
290 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
291
292 std::vector<iovec> iovPackets(CLATD_MAX);
293 int effectivePos = 0;
294 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
295
296 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V4_TCP_PACKET_RX), true);
297 }
298
299 /**
300 * @tc.name: ClatdPacketConverterTranslateIcmpTest001
301 * @tc.desc: Test ClatdPacketConverter translate ipv4 icmp packet.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateIcmpTest001, TestSize.Level1)
305 {
306 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
307 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
308 V4_ICMP_PACKET_TX, sizeof(V4_ICMP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
309 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
310
311 std::vector<iovec> iovPackets(CLATD_MAX);
312 int effectivePos = 0;
313 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
314
315 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V6_ICMP_PACKET_TX), true);
316 }
317
318 /**
319 * @tc.name: ClatdPacketConverterTranslateIcmpTest002
320 * @tc.desc: Test ClatdPacketConverter translate ipv6 icmp packet.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(ClatdPacketConverterTest, ClatdPacketConverterTranslateIcmpTest002, TestSize.Level1)
324 {
325 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
326 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
327 V6_ICMP_PACKET_RX, sizeof(V6_ICMP_PACKET_RX), CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
328 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_SUCCESS);
329
330 std::vector<iovec> iovPackets(CLATD_MAX);
331 int effectivePos = 0;
332 clatdPacketConverter->GetConvertedPacket(iovPackets, effectivePos);
333
334 EXPECT_EQ(IsTranslatedPacketCorrect(iovPackets, V4_ICMP_PACKET_RX), true);
335 }
336
337 HWTEST_F(ClatdPacketConverterTest, ConvertPacketErr, TestSize.Level1)
338 {
339 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
340 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
341 V6_ICMP_PACKET_RX, sizeof(V6_ICMP_PACKET_RX), CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
342 clatdPacketConverter->convertType_ = static_cast<ClatdConvertType>(3);
343 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
344 }
345
346 HWTEST_F(ClatdPacketConverterTest, ConvertPacketInvalidV6Packet, TestSize.Level1)
347 {
348 inet_pton(AF_INET6, V6ADDR_UDP_ICMP, &v6Addr_);
349 auto clatdPacketConverter =
350 std::make_unique<ClatdPacketConverter>(V6_INVALID_PROTOCOL_PACKET_TX, sizeof(V6_INVALID_PROTOCOL_PACKET_TX),
351 CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
352 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
353 auto clatdPacketConverter2 =
354 std::make_unique<ClatdPacketConverter>(V6_INVALID_PROTOCOL_PACKET_TX, sizeof(ip6_hdr) - 1,
355 CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
356 EXPECT_EQ(clatdPacketConverter2->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
357 auto clatdPacketConverter3 = std::make_unique<ClatdPacketConverter>(
358 V6_ICMP_PACKET_FRAGMENT, sizeof(V6_ICMP_PACKET_FRAGMENT), CONVERT_FROM_V6_TO_V4, v4Addr_, v6Addr_, prefixAddr_);
359 EXPECT_EQ(clatdPacketConverter3->ConvertPacket(false), NETMANAGER_SUCCESS);
360 }
361
362 HWTEST_F(ClatdPacketConverterTest, ConvertPacketInvalidV4Packet, TestSize.Level1)
363 {
364 inet_pton(AF_INET6, V6ADDR_TCP, &v6Addr_);
365 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
366 V4_TCP_INVALID_1, sizeof(V4_TCP_INVALID_1), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
367 EXPECT_EQ(clatdPacketConverter->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
368 auto clatdPacketConverter2 = std::make_unique<ClatdPacketConverter>(
369 V4_TCP_INVALID_2, sizeof(V4_TCP_INVALID_2), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
370 EXPECT_EQ(clatdPacketConverter2->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
371 auto clatdPacketConverter3 = std::make_unique<ClatdPacketConverter>(
372 V4_TCP_INVALID_3, sizeof(V4_TCP_INVALID_3), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
373 EXPECT_EQ(clatdPacketConverter3->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
374 auto clatdPacketConverter4 = std::make_unique<ClatdPacketConverter>(
375 V4_TCP_INVALID_4, sizeof(V4_TCP_INVALID_4), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
376 EXPECT_EQ(clatdPacketConverter4->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
377 auto clatdPacketConverter5 = std::make_unique<ClatdPacketConverter>(
378 V4_TCP_PACKET_FRAG_TX, sizeof(V4_TCP_PACKET_FRAG_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
379 EXPECT_EQ(clatdPacketConverter4->ConvertPacket(false), NETMANAGER_ERR_INVALID_PARAMETER);
380 }
381
382 HWTEST_F(ClatdPacketConverterTest, IsV6PacketValidTest, TestSize.Level1)
383 {
384 ip6_hdr ip6Header;
385 size_t packetSize;
386 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
387 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
388 packetSize = sizeof(ip6_hdr) - 1;
389 EXPECT_FALSE(clatdPacketConverter->IsV6PacketValid(&ip6Header, packetSize));
390 packetSize = sizeof(ip6_hdr);
391 in6_addr multicastAddr;
392 inet_pton(AF_INET6, "ff00::8", &multicastAddr);
393 memcpy_s(&ip6Header.ip6_dst, sizeof(ip6Header.ip6_dst), &multicastAddr, sizeof(multicastAddr));
394 EXPECT_FALSE(clatdPacketConverter->IsV6PacketValid(&ip6Header, packetSize));
395 memset_s(&ip6Header.ip6_src, sizeof(ip6Header.ip6_src), 0, sizeof(ip6Header.ip6_src));
396 memset_s(&ip6Header.ip6_dst, sizeof(ip6Header.ip6_dst), 0, sizeof(ip6Header.ip6_dst));
397 ip6Header.ip6_nxt = IPPROTO_TCP;
398 EXPECT_FALSE(clatdPacketConverter->IsV6PacketValid(&ip6Header, packetSize));
399 in6_addr loopbackAddr;
400 inet_pton(AF_INET6, "::1", &loopbackAddr);
401 memcpy_s(&ip6Header.ip6_src, sizeof(ip6Header.ip6_src), &loopbackAddr, sizeof(loopbackAddr));
402 memcpy_s(&ip6Header.ip6_dst, sizeof(ip6Header.ip6_dst), &loopbackAddr, sizeof(loopbackAddr));
403 ip6Header.ip6_nxt = IPPROTO_UDP;
404 EXPECT_FALSE(clatdPacketConverter->IsV6PacketValid(&ip6Header, packetSize));
405 }
406
407 HWTEST_F(ClatdPacketConverterTest, ConvertV4TpPacket_ShouldReturnSuccess_WhenGreProtocol, TestSize.Level1)
408 {
409 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
410 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
411 int32_t pos = 0;
412 iphdr ipHeader{};
413 ip6_hdr ip6Header{};
414 auto v6TpProtocol = IPPROTO_GRE;
415 auto tpLen = 100;
416 int32_t ret = clatdPacketConverter->ConvertV4TpPacket(pos, &ipHeader, &ip6Header, tpLen, v6TpProtocol);
417 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
418 }
419
420 HWTEST_F(ClatdPacketConverterTest, ConvertV6TpPacket_ShouldReturnSuccess_WhenGreProtocol, TestSize.Level1)
421 {
422 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
423 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
424 int32_t pos = 0;
425 iphdr ipHeader{};
426 ip6_hdr ip6Header{};
427 auto v6TpProtocol = IPPROTO_GRE;
428 auto tpLen = 100;
429 int32_t ret = clatdPacketConverter->ConvertV6TpPacket(pos, &ip6Header, &ipHeader, tpLen, v6TpProtocol);
430 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
431 }
432
433 HWTEST_F(ClatdPacketConverterTest, ConvertV4TpPacket_ShouldReturnSuccess_WhenEspProtocol, TestSize.Level1)
434 {
435 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
436 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
437 int32_t pos = 0;
438 iphdr ipHeader{};
439 ip6_hdr ip6Header{};
440 auto v6TpProtocol = IPPROTO_ESP;
441 auto tpLen = 100;
442 int32_t ret = clatdPacketConverter->ConvertV4TpPacket(pos, &ipHeader, &ip6Header, tpLen, v6TpProtocol);
443 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
444 }
445
446 HWTEST_F(ClatdPacketConverterTest, ConvertV4TpPacket_ShouldReturnError_WhenUnknownProtocol, TestSize.Level0)
447 {
448 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
449 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
450 int32_t pos = 0;
451 iphdr ipHeader{};
452 ip6_hdr ip6Header{};
453 auto v6TpProtocol = 255;
454 auto tpLen = 100;
455 int32_t ret = clatdPacketConverter->ConvertV4TpPacket(pos, &ipHeader, &ip6Header, tpLen, v6TpProtocol);
456 EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
457 }
458
459 HWTEST_F(ClatdPacketConverterTest, ConvertV4Packet_FragHeaderGreaterThanZero, TestSize.Level0) {
460 auto converter = std::make_unique<MockClatdPacketConverter>(
461 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
462 int32_t expectedResult = NETMANAGER_SUCCESS;
463 int pos = 0;
464
465 ON_CALL(*converter, WriteFragHeader).WillByDefault(testing::Return(50));
466
467 int32_t result = converter->ConvertV4Packet(pos, V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX));
468 EXPECT_EQ(result, expectedResult);
469 }
470
471 HWTEST_F(ClatdPacketConverterTest, ConvertIcmpTypeAndCodeTest, TestSize.Level0) {
472 auto clatdPacketConverter = std::make_unique<MockClatdPacketConverter>(
473 V4_TCP_PACKET_TX, sizeof(V4_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
474 uint8_t icmpType = ICMP_ECHO;
475 uint8_t icmpCode = 10;
476 uint8_t icmp6Type;
477 uint8_t icmp6Code;
478 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
479 EXPECT_EQ(icmp6Type, ICMP6_ECHO_REQUEST);
480 EXPECT_EQ(icmp6Code, icmpCode);
481 icmpType = ICMP_ECHOREPLY;
482 icmpCode = 10;
483 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
484 EXPECT_EQ(icmp6Type, ICMP6_ECHO_REPLY);
485 EXPECT_EQ(icmp6Code, icmpCode);
486 icmpType = ICMP_TIME_EXCEEDED;
487 icmpCode = 10;
488 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
489 EXPECT_EQ(icmp6Type, ICMP6_TIME_EXCEEDED);
490 EXPECT_EQ(icmp6Code, icmpCode);
491 icmpType = ICMP_DEST_UNREACH;
492 icmpCode = ICMP_UNREACH_NET;
493 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
494 EXPECT_EQ(icmp6Type, ICMP6_DST_UNREACH);
495 EXPECT_EQ(icmp6Code, ICMP6_DST_UNREACH_NOROUTE);
496 icmpType = ICMP_DEST_UNREACH;
497 icmpCode = ICMP_UNREACH_PORT;
498 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
499 EXPECT_EQ(icmp6Type, ICMP6_DST_UNREACH);
500 EXPECT_EQ(icmp6Code, ICMP6_DST_UNREACH_NOPORT);
501 icmpType = ICMP_DEST_UNREACH;
502 icmpCode = 10;
503 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
504 EXPECT_EQ(icmp6Type, ICMP6_DST_UNREACH);
505 icmpType = ICMP_DEST_UNREACH;
506 icmpCode = 99;
507 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
508 EXPECT_EQ(icmp6Type, ICMP6_PARAM_PROB);
509 icmpType = 10;
510 icmpCode = 10;
511 clatdPacketConverter->ConvertIcmpTypeAndCode(icmpType, icmpCode, icmp6Type, icmp6Code);
512 EXPECT_EQ(icmp6Type, ICMP6_PARAM_PROB);
513 }
514
515 HWTEST_F(ClatdPacketConverterTest, ConvertIcmpV6TypeAndCodeTest, TestSize.Level0) {
516 auto clatdPacketConverter = std::make_unique<MockClatdPacketConverter>(
517 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
518 uint8_t icmp6Type = ICMP6_ECHO_REQUEST;
519 uint8_t icmp6Code = 0;
520 uint8_t icmpType = 0;
521 uint8_t icmpCode = 0;
522 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
523 EXPECT_EQ(icmpType, ICMP_ECHO);
524 EXPECT_EQ(icmpCode, 0);
525 icmp6Type = ICMP6_ECHO_REPLY;
526 icmp6Code = 0;
527 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
528 EXPECT_EQ(icmpType, ICMP_ECHOREPLY);
529 EXPECT_EQ(icmpCode, 0);
530 icmp6Type = ICMP6_TIME_EXCEEDED;
531 icmp6Code = 0;
532 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
533 EXPECT_EQ(icmpType, ICMP_TIME_EXCEEDED);
534 EXPECT_EQ(icmpCode, 0);
535 icmp6Type = ICMP6_DST_UNREACH;
536 icmp6Code = ICMP6_DST_UNREACH_NOROUTE;
537 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
538 EXPECT_EQ(icmpType, ICMP_DEST_UNREACH);
539 EXPECT_EQ(icmpCode, ICMP_UNREACH_HOST);
540 icmp6Type = ICMP6_DST_UNREACH;
541 icmp6Code = ICMP6_DST_UNREACH_ADMIN;
542 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
543 EXPECT_EQ(icmpType, ICMP_DEST_UNREACH);
544 EXPECT_EQ(icmpCode, ICMP_UNREACH_HOST_PROHIB);
545 icmp6Type = ICMP6_DST_UNREACH;
546 icmp6Code = ICMP6_DST_UNREACH_NOPORT;
547 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
548 EXPECT_EQ(icmpType, ICMP_DEST_UNREACH);
549 EXPECT_EQ(icmpCode, ICMP_UNREACH_PORT);
550 icmp6Type = 99;
551 icmp6Code = 0;
552 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
553 EXPECT_EQ(icmpType, ICMP_PARAMETERPROB);
554 icmp6Type = ICMP6_DST_UNREACH;
555 icmp6Code = 99;
556 clatdPacketConverter->ConvertIcmpV6TypeAndCode(icmp6Type, icmp6Code, icmpType, icmpCode);
557 EXPECT_EQ(icmpType, ICMP_PARAMETERPROB);
558 }
559
560 HWTEST_F(ClatdPacketConverterTest, WriteFragHeaderTest, TestSize.Level0)
561 {
562 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
563 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
564 ip6_frag ip6FragHeader;
565 ip6_hdr ip6Header;
566 iphdr ipHeader;
567 ipHeader.frag_off = 0;
568 EXPECT_EQ(clatdPacketConverter->WriteFragHeader(&ip6FragHeader, &ip6Header, &ipHeader), 0);
569 ipHeader.frag_off = htons(1);
570 EXPECT_EQ(clatdPacketConverter->WriteFragHeader(&ip6FragHeader, &ip6Header, &ipHeader), sizeof(ip6FragHeader));
571 ipHeader.frag_off = htons(IP_MF);
572 clatdPacketConverter->WriteFragHeader(&ip6FragHeader, &ip6Header, &ipHeader);
573 EXPECT_EQ(ip6FragHeader.ip6f_offlg & IP6F_MORE_FRAG, IP6F_MORE_FRAG);
574 }
575
576 HWTEST_F(ClatdPacketConverterTest, IsTcpPacketValidTest, TestSize.Level0)
577 {
578 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
579 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
580 tcphdr tcpHeader{};
581 size_t packetSize = 0;
582 EXPECT_FALSE(clatdPacketConverter->IsTcpPacketValid(&tcpHeader, packetSize));
583 packetSize = sizeof(tcphdr);
584 tcpHeader.doff = htons(0);
585 EXPECT_FALSE(clatdPacketConverter->IsTcpPacketValid(&tcpHeader, packetSize));
586 tcpHeader.doff = packetSize / WORD_32BIT_IN_BYTE_UNIT + 1;
587 EXPECT_FALSE(clatdPacketConverter->IsTcpPacketValid(&tcpHeader, packetSize));
588 EXPECT_EQ(clatdPacketConverter->ConvertTcpPacket(0, &tcpHeader, 0, 0, packetSize),
589 NETMANAGER_ERR_INVALID_PARAMETER);
590 }
591
592 HWTEST_F(ClatdPacketConverterTest, ConvertUdpPacketTest, TestSize.Level0)
593 {
594 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
595 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
596 udphdr hdr{};
597 size_t tpLen = 0;
598 EXPECT_EQ(clatdPacketConverter->ConvertUdpPacket(0, &hdr, 0, 0, tpLen), NETMANAGER_ERR_INVALID_PARAMETER);
599 tpLen = sizeof(udphdr);
600 EXPECT_EQ(clatdPacketConverter->ConvertUdpPacket(0, &hdr, 0, 0, tpLen), NETMANAGER_SUCCESS);
601 }
602
603 HWTEST_F(ClatdPacketConverterTest, ConvertIcmpv6PacketTest, TestSize.Level0)
604 {
605 auto clatdPacketConverter = std::make_unique<ClatdPacketConverter>(
606 V6_TCP_PACKET_TX, sizeof(V6_TCP_PACKET_TX), CONVERT_FROM_V4_TO_V6, v4Addr_, v6Addr_, prefixAddr_);
607
608 size_t tpLen = 0;
609 icmp6_hdr hdr{};
610 EXPECT_EQ(clatdPacketConverter->ConvertIcmpv6Packet(0, &hdr, tpLen), NETMANAGER_ERR_INVALID_PARAMETER);
611 int pos = CLATD_TPHDR;
612 tpLen = sizeof(icmp6_hdr);
613 hdr.icmp6_type = ICMP6_TIME_EXCEEDED;
614 EXPECT_EQ(clatdPacketConverter->ConvertIcmpv6Packet(pos, &hdr, tpLen), NETMANAGER_ERR_INVALID_PARAMETER);
615 hdr.icmp6_type = ICMP6_ECHO_REQUEST - 1;
616 EXPECT_EQ(clatdPacketConverter->ConvertIcmpv6Packet(pos, &hdr, tpLen), NETMANAGER_ERR_INVALID_PARAMETER);
617 }
618 } // namespace nmd
619 } // namespace OHOS