1 /*
2  * Copyright (C) 2021 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 <gtest/gtest.h>
16 
17 #include "dhcp_logger.h"
18 #include "dhcp_options.h"
19 #include "dhcp_client_def.h"
20 #include "dhcp_s_define.h"
21 #include "securec.h"
22 
23 #include <cstdio>
24 #include <cstdlib>
25 #include <cstring>
26 
27 DEFINE_DHCPLOG_DHCP_LABEL("DhcpOptionsTest");
28 
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 class DhcpOptionsTest : public testing::Test {
33 public:
SetUpTestCase()34     static void SetUpTestCase()
35     {}
TearDownTestCase()36     static void TearDownTestCase()
37     {}
SetUp()38     virtual void SetUp()
39     {}
TearDown()40     virtual void TearDown()
41     {}
42 };
43 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_SUCCESS, TestSize.Level1)44 HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_SUCCESS, TestSize.Level1)
45 {
46     DHCP_LOGE("enter GetDhcpOptionDataLen_SUCCESS");
47     EXPECT_GT(GetDhcpOptionDataLen(DHCP_MESSAGE_TYPE_OPTION), 0);
48 }
49 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_FAILED, TestSize.Level1)50 HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_FAILED, TestSize.Level1)
51 {
52     EXPECT_EQ(GetDhcpOptionDataLen(PAD_OPTION), 0);
53     EXPECT_EQ(GetDhcpOptionDataLen(CLIENT_IDENTIFIER_OPTION), 0);
54     EXPECT_EQ(GetDhcpOptionDataLen(DOMAIN_NAME_SERVER_OPTION), 0);
55     EXPECT_EQ(GetDhcpOptionDataLen(DOMAIN_NAME_OPTION), 0);
56 }
57 
HWTEST_F(DhcpOptionsTest, GetDhcpOption_SUCCESS, TestSize.Level1)58 HWTEST_F(DhcpOptionsTest, GetDhcpOption_SUCCESS, TestSize.Level1)
59 {
60     struct DhcpPacket packet;
61     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
62 
63     int endIndex = 0;
64     uint8_t *pOption = packet.options;
65     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
66     endIndex += DHCP_OPT_CODE_BYTES;
67 
68     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
69     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
70     uint32_t u32Data = 3226272231;
71     ASSERT_TRUE(
72         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
73     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
74 
75     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
76     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
77     uint8_t uData = DHCP_DISCOVER;
78     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
79     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
80 
81     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
82 
83     size_t len = 0;
84     EXPECT_NE(GetDhcpOption(&packet, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
85 }
86 
HWTEST_F(DhcpOptionsTest, GetDhcpOption_FAILED, TestSize.Level1)87 HWTEST_F(DhcpOptionsTest, GetDhcpOption_FAILED, TestSize.Level1)
88 {
89     size_t len = 0;
90     EXPECT_EQ(GetDhcpOption(nullptr, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
91 
92     struct DhcpPacket packet;
93     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
94 
95     int endIndex = 0;
96     uint8_t *pOption = packet.options;
97     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
98     endIndex += DHCP_OPT_CODE_BYTES;
99 
100     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
101     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
102     uint32_t u32Data = 3226272231;
103     ASSERT_TRUE(
104         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
105     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
106 
107     pOption[endIndex + DHCP_OPT_CODE_INDEX] = OPTION_OVERLOAD_OPTION;
108     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
109     uint8_t uData = FILE_FIELD | SNAME_FIELD;
110     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
111     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
112 
113     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
114 
115     len = 0;
116     EXPECT_EQ(GetDhcpOption(&packet, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
117 }
118 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_SUCCESS, TestSize.Level1)119 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_SUCCESS, TestSize.Level1)
120 {
121     struct DhcpPacket packet;
122     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
123 
124     uint8_t *pOption = packet.options;
125     pOption[DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
126     pOption[DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
127     uint8_t uData = DHCP_DISCOVER;
128     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
129 
130     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
131     pOption[endIndex] = END_OPTION;
132 
133     uint8_t u8Message = 0;
134     EXPECT_EQ(true, GetDhcpOptionUint8(&packet, DHCP_MESSAGE_TYPE_OPTION, &u8Message));
135 }
136 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_FAILED, TestSize.Level1)137 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_FAILED, TestSize.Level1)
138 {
139     uint8_t u8Message = 0;
140     EXPECT_EQ(false, GetDhcpOptionUint8(nullptr, DHCP_MESSAGE_TYPE_OPTION, &u8Message));
141 }
142 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_SUCCESS, TestSize.Level1)143 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_SUCCESS, TestSize.Level1)
144 {
145     struct DhcpPacket packet;
146     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
147 
148     int endIndex = 0;
149     uint8_t *pOption = packet.options;
150     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
151     endIndex += DHCP_OPT_CODE_BYTES;
152 
153     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
154     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
155     uint8_t uData = DHCP_DISCOVER;
156     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
157     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
158 
159     pOption[endIndex + DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
160     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
161     uint32_t u32Data = ONE_HOURS_SEC;
162     ASSERT_TRUE(
163         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
164     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
165 
166     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
167 
168     u32Data = 0;
169     EXPECT_EQ(true, GetDhcpOptionUint32(&packet, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
170 }
171 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_FAILED, TestSize.Level1)172 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_FAILED, TestSize.Level1)
173 {
174     uint32_t u32Data = 0;
175     EXPECT_EQ(false, GetDhcpOptionUint32(nullptr, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
176 
177     struct DhcpPacket packet;
178     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
179 
180     int endIndex = 0;
181     uint8_t *pOption = packet.options;
182     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
183     endIndex += DHCP_OPT_CODE_BYTES;
184 
185     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
186     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
187     uint8_t uData = DHCP_DISCOVER;
188     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
189     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
190 
191     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
192 
193     u32Data = 0;
194     EXPECT_EQ(false, GetDhcpOptionUint32(&packet, DHCP_MESSAGE_TYPE_OPTION, &u32Data));
195 
196     pOption[endIndex + DHCP_OPT_CODE_INDEX] = OPTION_OVERLOAD_OPTION;
197     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
198     uData = FILE_FIELD | SNAME_FIELD;
199     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
200     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
201 
202     pOption[endIndex + DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
203     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
204     u32Data = ONE_HOURS_SEC;
205     ASSERT_TRUE(
206         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
207     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
208 
209     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
210 
211     u32Data = 0;
212     EXPECT_EQ(false, GetDhcpOptionUint32(&packet, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
213 }
214 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_SUCCESS, TestSize.Level1)215 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_SUCCESS, TestSize.Level1)
216 {
217     struct DhcpPacket packet;
218     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
219 
220     int endIndex = 0;
221     uint8_t *pOption = packet.options;
222     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
223     endIndex += DHCP_OPT_CODE_BYTES;
224 
225     pOption[endIndex + DHCP_OPT_CODE_INDEX] = ROUTER_OPTION;
226     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES + DHCP_UINT32_BYTES;
227     uint32_t u32Data1 = 3226272231;
228     uint32_t u32Data2 = 3226272232;
229     ASSERT_TRUE(
230         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data1, DHCP_UINT32_BYTES) == EOK);
231     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX + DHCP_UINT32_BYTES,
232                     DHCP_UINT32_BYTES,
233                     &u32Data2,
234                     DHCP_UINT32_BYTES) == EOK);
235     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
236 
237     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
238 
239     uint32_t uData1 = 0;
240     uint32_t uData2 = 0;
241     EXPECT_EQ(true, GetDhcpOptionUint32n(&packet, ROUTER_OPTION, &uData1, &uData2));
242 }
243 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_FAILED, TestSize.Level1)244 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_FAILED, TestSize.Level1)
245 {
246     uint32_t uData1 = 0;
247     uint32_t uData2 = 0;
248     EXPECT_EQ(false, GetDhcpOptionUint32n(nullptr, ROUTER_OPTION, &uData1, &uData2));
249 
250     struct DhcpPacket packet;
251     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
252 
253     int endIndex = 0;
254     uint8_t *pOption = packet.options;
255     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
256     endIndex += DHCP_OPT_CODE_BYTES;
257 
258     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
259     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
260     uint8_t uData = DHCP_DISCOVER;
261     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
262     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
263 
264     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
265 
266     EXPECT_EQ(false, GetDhcpOptionUint32n(nullptr, DHCP_MESSAGE_TYPE_OPTION, &uData1, &uData2));
267 }
268 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_SUCCESS, TestSize.Level1)269 HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_SUCCESS, TestSize.Level1)
270 {
271     char buf[VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES] = {0};
272     ASSERT_TRUE(snprintf_s(buf,
273                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX,
274                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX - 1,
275                     "%s-%s",
276                     DHCPC_NAME,
277                     DHCPC_VERSION) >= 0);
278 
279     struct DhcpPacket packet;
280     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
281 
282     uint8_t *pOption = packet.options;
283     pOption[DHCP_OPT_CODE_INDEX] = VENDOR_SPECIFIC_INFO_OPTION;
284     pOption[DHCP_OPT_LEN_INDEX] = strlen(buf);
285     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX,
286                     VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES,
287                     buf,
288                     strlen(buf)) == EOK);
289 
290     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
291     pOption[endIndex] = END_OPTION;
292 
293     char *pVendor = GetDhcpOptionString(&packet, VENDOR_SPECIFIC_INFO_OPTION);
294     ASSERT_TRUE(pVendor != NULL);
295     free(pVendor);
296 }
297 
HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_FAILED, TestSize.Level1)298 HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_FAILED, TestSize.Level1)
299 {
300     EXPECT_EQ(nullptr, GetDhcpOptionString(nullptr, VENDOR_SPECIFIC_INFO_OPTION));
301 }
302 
HWTEST_F(DhcpOptionsTest, GetEndOptionIndex_SUCCESS, TestSize.Level1)303 HWTEST_F(DhcpOptionsTest, GetEndOptionIndex_SUCCESS, TestSize.Level1)
304 {
305     struct DhcpPacket packet;
306     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
307 
308     int endIndex = 0;
309     uint8_t *pOption = packet.options;
310     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
311     endIndex += DHCP_OPT_CODE_BYTES;
312 
313     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
314     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
315     uint32_t u32Data = 3226272231;
316     ASSERT_TRUE(
317         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
318     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
319 
320     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
321 
322     EXPECT_GE(GetEndOptionIndex(packet.options), 0);
323 }
324 
HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_SUCCESS, TestSize.Level1)325 HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_SUCCESS, TestSize.Level1)
326 {
327     struct DhcpPacket packet;
328     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
329     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
330 
331     uint8_t option[DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + DHCP_UINT32_BYTES];
332     option[DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
333     option[DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
334     uint32_t uData = ONE_HOURS_SEC;
335     ASSERT_TRUE(memcpy_s(option + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &uData, DHCP_UINT32_BYTES) == EOK);
336     int nLen = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + option[DHCP_OPT_LEN_INDEX];
337 
338     EXPECT_GT(AddOptStrToOpts(packet.options, option, nLen), 0);
339 }
340 
HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_FAILED, TestSize.Level1)341 HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_FAILED, TestSize.Level1)
342 {
343     struct DhcpPacket packet;
344     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
345 
346     int endIndex = 0;
347     uint8_t *pOption = packet.options;
348     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
349 
350     uint8_t option[DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + DHCP_UINT32_BYTES];
351     option[DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
352     option[DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
353     uint32_t uData = ONE_HOURS_SEC;
354     ASSERT_TRUE(memcpy_s(option + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &uData, DHCP_UINT32_BYTES) == EOK);
355     EXPECT_EQ(AddOptStrToOpts(pOption, option, DHCP_OPT_CODE_BYTES), 0);
356 
357     option[DHCP_OPT_LEN_INDEX] = (uint8_t)(DHCP_OPTIONS_SIZE - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES);
358     EXPECT_EQ(AddOptStrToOpts(pOption, option, DHCP_OPTIONS_SIZE), 0);
359 }
360 
HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_SUCCESS, TestSize.Level1)361 HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_SUCCESS, TestSize.Level1)
362 {
363     struct DhcpPacket packet;
364     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
365     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
366 
367     uint8_t data1 = DHCP_REQUEST;
368     uint16_t data2 = 1;
369     uint32_t data3 = ONE_HOURS_SEC;
370     EXPECT_GT(AddOptValueToOpts(packet.options, DHCP_MESSAGE_TYPE_OPTION, data1), 0);
371     EXPECT_GT(AddOptValueToOpts(packet.options, INTERFACE_MTU_OPTION, data2), 0);
372     EXPECT_GT(AddOptValueToOpts(packet.options, IP_ADDRESS_LEASE_TIME_OPTION, data3), 0);
373 }
374 
HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_FAILED, TestSize.Level1)375 HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_FAILED, TestSize.Level1)
376 {
377     struct DhcpPacket packet;
378     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
379     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
380 
381     EXPECT_EQ(AddOptValueToOpts(packet.options, PAD_OPTION, 0), 0);
382 }
383 }  // namespace OHOS