Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2010-2014 Intel Corporation
3 : : */
4 : : #include <stdio.h>
5 : : #include <string.h>
6 : : #include <inttypes.h>
7 : :
8 : : #include <rte_string_fns.h>
9 : :
10 : : #include <cmdline_parse.h>
11 : : #include <cmdline_parse_ipaddr.h>
12 : :
13 : : #include "test_cmdline.h"
14 : :
15 : : #define IP4(a,b,c,d) {.s_addr = (uint32_t)(((a) & 0xff) | \
16 : : (((b) & 0xff) << 8) | \
17 : : (((c) & 0xff) << 16) | \
18 : : ((d) & 0xff) << 24)}
19 : :
20 : : #define U16_SWAP(x) \
21 : : (((x & 0xFF) << 8) | ((x & 0xFF00) >> 8))
22 : :
23 : : /* create IPv6 address, swapping bytes where needed */
24 : : #ifndef s6_addr16
25 : : #ifdef RTE_EXEC_ENV_WINDOWS
26 : : #define s6_addr16 u.Word
27 : : #else
28 : : #define s6_addr16 __u6_addr.__u6_addr16
29 : : #endif
30 : : #endif
31 : : #define IP6(a,b,c,d,e,f,g,h) .ipv6 = \
32 : : {.s6_addr16 = \
33 : : {U16_SWAP(a),U16_SWAP(b),U16_SWAP(c),U16_SWAP(d),\
34 : : U16_SWAP(e),U16_SWAP(f),U16_SWAP(g),U16_SWAP(h)}}
35 : :
36 : : /** these are defined in netinet/in.h but not present in linux headers */
37 : : #ifndef NIPQUAD
38 : :
39 : : #define NIPQUAD_FMT "%u.%u.%u.%u"
40 : : #define NIPQUAD(addr) \
41 : : (unsigned)((unsigned char *)&addr)[0], \
42 : : (unsigned)((unsigned char *)&addr)[1], \
43 : : (unsigned)((unsigned char *)&addr)[2], \
44 : : (unsigned)((unsigned char *)&addr)[3]
45 : :
46 : : #define NIP6_FMT "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
47 : : #define NIP6(addr) \
48 : : (unsigned)((addr).s6_addr[0]), \
49 : : (unsigned)((addr).s6_addr[1]), \
50 : : (unsigned)((addr).s6_addr[2]), \
51 : : (unsigned)((addr).s6_addr[3]), \
52 : : (unsigned)((addr).s6_addr[4]), \
53 : : (unsigned)((addr).s6_addr[5]), \
54 : : (unsigned)((addr).s6_addr[6]), \
55 : : (unsigned)((addr).s6_addr[7]), \
56 : : (unsigned)((addr).s6_addr[8]), \
57 : : (unsigned)((addr).s6_addr[9]), \
58 : : (unsigned)((addr).s6_addr[10]), \
59 : : (unsigned)((addr).s6_addr[11]), \
60 : : (unsigned)((addr).s6_addr[12]), \
61 : : (unsigned)((addr).s6_addr[13]), \
62 : : (unsigned)((addr).s6_addr[14]), \
63 : : (unsigned)((addr).s6_addr[15])
64 : :
65 : : #endif
66 : :
67 : :
68 : :
69 : : struct ipaddr_str {
70 : : const char * str;
71 : : cmdline_ipaddr_t addr;
72 : : unsigned flags;
73 : : };
74 : :
75 : : const struct ipaddr_str ipaddr_valid_strs[] = {
76 : : {"0.0.0.0", {AF_INET, {IP4(0,0,0,0)}, 0},
77 : : CMDLINE_IPADDR_V4},
78 : : {"0.0.0.0/0", {AF_INET, {IP4(0,0,0,0)}, 0},
79 : : CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
80 : : {"0.0.0.0/24", {AF_INET, {IP4(0,0,0,0)}, 24},
81 : : CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
82 : : {"192.168.1.0/24", {AF_INET, {IP4(192,168,1,0)}, 24},
83 : : CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
84 : : {"34.56.78.90/1", {AF_INET, {IP4(34,56,78,90)}, 1},
85 : : CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
86 : : {"::", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 0},
87 : : CMDLINE_IPADDR_V6},
88 : : {"::1", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 0},
89 : : CMDLINE_IPADDR_V6},
90 : : {"::1/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 32},
91 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
92 : : {"::/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 32},
93 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
94 : : /* RFC5952 requests that only lowercase should be used */
95 : : {"1234:5678:90ab:cdef:4321:8765:BA09:FEDC", {AF_INET6,
96 : : {IP6(0x1234,0x5678,0x90AB,0xCDEF,0x4321,0x8765,0xBA09,0xFEDC)},
97 : : 0},
98 : : CMDLINE_IPADDR_V6},
99 : : {"1234::1234/64", {AF_INET6,
100 : : {IP6(0x1234,0,0,0,0,0,0,0x1234)},
101 : : 64},
102 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
103 : : {"1234::/64", {AF_INET6,
104 : : {IP6(0x1234,0,0,0,0,0,0,0)},
105 : : 64},
106 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
107 : : {"1:1::1/32", {AF_INET6,
108 : : {IP6(1,1,0,0,0,0,0,1)},
109 : : 32},
110 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
111 : : {"1:2:3:4::/64", {AF_INET6,
112 : : {IP6(1,2,3,4,0,0,0,0)},
113 : : 64},
114 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
115 : : {"::ffff:192.168.1.0/64", {AF_INET6,
116 : : {IP6(0,0,0,0,0,0xFFFF,0xC0A8,0x100)},
117 : : 64},
118 : : CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
119 : : /* RFC5952 requests not using :: to skip one block of zeros*/
120 : : {"1::2:3:4:5:6:7", {AF_INET6,
121 : : {IP6(1,0,2,3,4,5,6,7)},
122 : : 0},
123 : : CMDLINE_IPADDR_V6},
124 : : };
125 : :
126 : : const char * ipaddr_garbage_addr4_strs[] = {
127 : : /* IPv4 */
128 : : "192.168.1.0 garbage",
129 : : "192.168.1.0\0garbage",
130 : : "192.168.1.0#garbage",
131 : : "192.168.1.0\tgarbage",
132 : : "192.168.1.0\rgarbage",
133 : : "192.168.1.0\ngarbage",
134 : : };
135 : : #define IPv4_GARBAGE_ADDR IP4(192,168,1,0)
136 : :
137 : : const char * ipaddr_garbage_addr6_strs[] = {
138 : : /* IPv6 */
139 : : "1:2:3:4::8 garbage",
140 : : "1:2:3:4::8#garbage",
141 : : "1:2:3:4::8\0garbage",
142 : : "1:2:3:4::8\rgarbage",
143 : : "1:2:3:4::8\ngarbage",
144 : : "1:2:3:4::8\tgarbage",
145 : : };
146 : : #define IPv6_GARBAGE_ADDR {IP6(1,2,3,4,0,0,0,8)}
147 : :
148 : : const char * ipaddr_garbage_network4_strs[] = {
149 : : /* IPv4 */
150 : : "192.168.1.0/24 garbage",
151 : : "192.168.1.0/24\0garbage",
152 : : "192.168.1.0/24#garbage",
153 : : "192.168.1.0/24\tgarbage",
154 : : "192.168.1.0/24\rgarbage",
155 : : "192.168.1.0/24\ngarbage",
156 : : };
157 : : #define IPv4_GARBAGE_PREFIX 24
158 : :
159 : : const char * ipaddr_garbage_network6_strs[] = {
160 : : /* IPv6 */
161 : : "1:2:3:4::8/64 garbage",
162 : : "1:2:3:4::8/64#garbage",
163 : : "1:2:3:4::8/64\0garbage",
164 : : "1:2:3:4::8/64\rgarbage",
165 : : "1:2:3:4::8/64\ngarbage",
166 : : "1:2:3:4::8/64\tgarbage",
167 : : };
168 : : #define IPv6_GARBAGE_PREFIX 64
169 : :
170 : : const char * ipaddr_invalid_strs[] = {
171 : : /** IPv4 **/
172 : :
173 : : /* invalid numbers */
174 : : "0.0.0.-1",
175 : : "0.0.-1.0",
176 : : "0.-1.0.0",
177 : : "-1.0.0.0",
178 : : "0.0.0.-1/24",
179 : : "256.123.123.123",
180 : : "255.256.123.123",
181 : : "255.255.256.123",
182 : : "255.255.255.256",
183 : : "256.123.123.123/24",
184 : : "255.256.123.123/24",
185 : : "255.255.256.123/24",
186 : : "255.255.255.256/24",
187 : : /* invalid network mask */
188 : : "1.2.3.4/33",
189 : : "1.2.3.4/33231313",
190 : : "1.2.3.4/-1",
191 : : "1.2.3.4/24/33",
192 : : "1.2.3.4/24/-1",
193 : : "1.2.3.4/24/",
194 : : /* wrong format */
195 : : "1/24"
196 : : "/24"
197 : : "123.123.123",
198 : : "123.123.123.",
199 : : "123.123.123.123.",
200 : : "123.123.123..123",
201 : : "123.123.123.123.123",
202 : : ".123.123.123",
203 : : ".123.123.123.123",
204 : : "123.123.123/24",
205 : : "123.123.123./24",
206 : : "123.123.123.123./24",
207 : : "123.123.123..123/24",
208 : : "123.123.123.123.123/24",
209 : : ".123.123.123/24",
210 : : ".123.123.123.123/24",
211 : : /* invalid characters */
212 : : "123.123.123.12F",
213 : : "123.123.12F.123",
214 : : "123.12F.123.123",
215 : : "12F.123.123.123",
216 : : "12J.123.123.123",
217 : : "123,123,123,123",
218 : : "123!123!123!12F",
219 : : "123.123.123.123/4F",
220 : :
221 : : /** IPv6 **/
222 : :
223 : : /* wrong format */
224 : : "::fffff",
225 : : "ffff:",
226 : : "1:2:3:4:5:6:7:192.168.1.1",
227 : : "1234:192.168.1.1:ffff::",
228 : : "1:2:3:4:5:6:7:890ab",
229 : : "1:2:3:4:5:6:7890a:b",
230 : : "1:2:3:4:5:67890:a:b",
231 : : "1:2:3:4:56789:0:a:b",
232 : : "1:2:3:45678:9:0:a:b",
233 : : "1:2:34567:8:9:0:a:b",
234 : : "1:23456:7:8:9:0:a:b",
235 : : "12345:6:7:8:9:0:a:b",
236 : : "1:::2",
237 : : "1::::2",
238 : : "::fffff/64",
239 : : "1::2::3",
240 : : "1::2::3/64",
241 : : ":1:2",
242 : : ":1:2/64",
243 : : ":1::2",
244 : : ":1::2/64",
245 : : "1::2:3:4:5:6:7:8/64",
246 : :
247 : : /* invalid network mask */
248 : : "1:2:3:4:5:6:7:8/129",
249 : : "1:2:3:4:5:6:7:8/-1",
250 : :
251 : : /* invalid characters */
252 : : "a:b:c:d:e:f:g::",
253 : :
254 : : /** misc **/
255 : :
256 : : /* too long */
257 : : "1234:1234:1234:1234:1234:1234:1234:1234:1234:1234:1234",
258 : : "random invalid text",
259 : : "",
260 : : "\0",
261 : : " ",
262 : : };
263 : :
264 : : static void
265 : 0 : dump_addr(cmdline_ipaddr_t addr)
266 : : {
267 [ # # # ]: 0 : switch (addr.family) {
268 : 0 : case AF_INET:
269 : : {
270 : 0 : printf(NIPQUAD_FMT " prefixlen=%u\n",
271 : : NIPQUAD(addr.addr.ipv4.s_addr), addr.prefixlen);
272 : : break;
273 : : }
274 : 0 : case AF_INET6:
275 : : {
276 : 0 : printf(NIP6_FMT " prefixlen=%u\n",
277 : 0 : NIP6(addr.addr.ipv6), addr.prefixlen);
278 : : break;
279 : : }
280 : : default:
281 : : printf("Can't dump: unknown address family.\n");
282 : : return;
283 : : }
284 : : }
285 : :
286 : :
287 : : static int
288 : 32 : is_addr_different(cmdline_ipaddr_t addr1, cmdline_ipaddr_t addr2)
289 : : {
290 [ + - ]: 32 : if (addr1.family != addr2.family)
291 : : return 1;
292 : :
293 [ + - ]: 32 : if (addr1.prefixlen != addr2.prefixlen)
294 : : return 1;
295 : :
296 [ + + - ]: 32 : switch (addr1.family) {
297 : : /* IPv4 */
298 : 10 : case AF_INET:
299 [ - + ]: 10 : if (memcmp(&addr1.addr.ipv4, &addr2.addr.ipv4,
300 : : sizeof(struct in_addr)) != 0)
301 : 0 : return 1;
302 : : break;
303 : : /* IPv6 */
304 : 22 : case AF_INET6:
305 : : {
306 [ - + ]: 22 : if (memcmp(&addr1.addr.ipv6, &addr2.addr.ipv6,
307 : : sizeof(struct in6_addr)) != 0)
308 : 0 : return 1;
309 : : break;
310 : : }
311 : : /* thing that should not be */
312 : : default:
313 : : return -1;
314 : : }
315 : : return 0;
316 : : }
317 : :
318 : : static int
319 : : can_parse_addr(unsigned addr_flags, unsigned test_flags)
320 : : {
321 : 240 : if ((test_flags & addr_flags) == addr_flags) {
322 : : /* if we are not trying to parse network addresses */
323 [ + + + + : 90 : if (test_flags < CMDLINE_IPADDR_NETWORK)
+ + ]
324 : : return 1;
325 : : /* if this is a network address */
326 [ + + ]: 32 : else if (addr_flags & CMDLINE_IPADDR_NETWORK)
327 : 22 : return 1;
328 : : }
329 : : return 0;
330 : : }
331 : :
332 : : int
333 : 1 : test_parse_ipaddr_valid(void)
334 : : {
335 : : cmdline_parse_token_ipaddr_t token;
336 : : char buf[CMDLINE_TEST_BUFSIZE];
337 : : cmdline_ipaddr_t result;
338 : : unsigned i;
339 : : uint8_t flags;
340 : : int ret;
341 : :
342 : : /* cover all cases in help */
343 [ + + ]: 8 : for (flags = 0x1; flags < 0x8; flags++) {
344 : 7 : token.ipaddr_data.flags = flags;
345 : :
346 : : memset(buf, 0, sizeof(buf));
347 : :
348 [ - + ]: 7 : if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
349 : : buf, sizeof(buf)) == -1) {
350 : : printf("Error: help rejected valid parameters!\n");
351 : 0 : return -1;
352 : : }
353 : : }
354 : :
355 : : /* test valid strings */
356 [ + + ]: 17 : for (i = 0; i < RTE_DIM(ipaddr_valid_strs); i++) {
357 : :
358 : : /* test each valid string against different flags */
359 [ + + ]: 128 : for (flags = 1; flags < 0x8; flags++) {
360 : :
361 : : /* skip bad flag */
362 [ + + ]: 112 : if (flags == CMDLINE_IPADDR_NETWORK)
363 : 16 : continue;
364 : :
365 : : /* clear out everything */
366 : : memset(buf, 0, sizeof(buf));
367 : : memset(&result, 0, sizeof(result));
368 : : memset(&token, 0, sizeof(token));
369 : :
370 : 96 : token.ipaddr_data.flags = flags;
371 : :
372 : 96 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
373 : : buf, sizeof(buf));
374 : :
375 : 96 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
376 : 96 : ipaddr_valid_strs[i].str, (void*)&result,
377 : : sizeof(result));
378 : :
379 : : /* if should have passed, or should have failed */
380 [ - + ]: 96 : if ((ret < 0) ==
381 [ + + ]: 96 : (can_parse_addr(ipaddr_valid_strs[i].flags, flags))) {
382 : : printf("Error: unexpected behavior when parsing %s as %s!\n",
383 : : ipaddr_valid_strs[i].str, buf);
384 : : printf("Parsed result: ");
385 : 0 : dump_addr(result);
386 : : printf("Expected result: ");
387 : 0 : dump_addr(ipaddr_valid_strs[i].addr);
388 : 0 : return -1;
389 : : }
390 [ + + ]: 96 : if (ret != -1 &&
391 [ - + ]: 32 : is_addr_different(result, ipaddr_valid_strs[i].addr)) {
392 : : printf("Error: result mismatch when parsing %s as %s!\n",
393 : : ipaddr_valid_strs[i].str, buf);
394 : : printf("Parsed result: ");
395 : 0 : dump_addr(result);
396 : : printf("Expected result: ");
397 : 0 : dump_addr(ipaddr_valid_strs[i].addr);
398 : 0 : return -1;
399 : : }
400 : : }
401 : : }
402 : :
403 : : /* test garbage ipv4 address strings */
404 [ + + ]: 7 : for (i = 0; i < RTE_DIM(ipaddr_garbage_addr4_strs); i++) {
405 : :
406 : 6 : struct in_addr tmp = IPv4_GARBAGE_ADDR;
407 : :
408 : : /* test each valid string against different flags */
409 [ + + ]: 48 : for (flags = 1; flags < 0x8; flags++) {
410 : :
411 : : /* skip bad flag */
412 [ + + ]: 42 : if (flags == CMDLINE_IPADDR_NETWORK)
413 : 6 : continue;
414 : :
415 : : /* clear out everything */
416 : : memset(buf, 0, sizeof(buf));
417 : : memset(&result, 0, sizeof(result));
418 : : memset(&token, 0, sizeof(token));
419 : :
420 : 36 : token.ipaddr_data.flags = flags;
421 : :
422 : 36 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
423 : : buf, sizeof(buf));
424 : :
425 : 36 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
426 : : ipaddr_garbage_addr4_strs[i], (void*)&result,
427 : : sizeof(result));
428 : :
429 : : /* if should have passed, or should have failed */
430 [ + + - + ]: 60 : if ((ret < 0) ==
431 : : (can_parse_addr(CMDLINE_IPADDR_V4, flags))) {
432 : 0 : printf("Error: unexpected behavior when parsing %s as %s!\n",
433 : : ipaddr_garbage_addr4_strs[i], buf);
434 : 0 : return -1;
435 : : }
436 [ + + ]: 36 : if (ret != -1 &&
437 [ - + ]: 12 : memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
438 : 0 : printf("Error: result mismatch when parsing %s as %s!\n",
439 : : ipaddr_garbage_addr4_strs[i], buf);
440 : 0 : return -1;
441 : : }
442 : : }
443 : : }
444 : :
445 : : /* test garbage ipv6 address strings */
446 [ + + ]: 7 : for (i = 0; i < RTE_DIM(ipaddr_garbage_addr6_strs); i++) {
447 : :
448 : 6 : cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
449 : :
450 : : /* test each valid string against different flags */
451 [ + + ]: 48 : for (flags = 1; flags < 0x8; flags++) {
452 : :
453 : : /* skip bad flag */
454 [ + + ]: 42 : if (flags == CMDLINE_IPADDR_NETWORK)
455 : 6 : continue;
456 : :
457 : : /* clear out everything */
458 : : memset(buf, 0, sizeof(buf));
459 : : memset(&result, 0, sizeof(result));
460 : : memset(&token, 0, sizeof(token));
461 : :
462 : 36 : token.ipaddr_data.flags = flags;
463 : :
464 : 36 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
465 : : buf, sizeof(buf));
466 : :
467 : 36 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
468 : : ipaddr_garbage_addr6_strs[i], (void*)&result,
469 : : sizeof(result));
470 : :
471 : : /* if should have passed, or should have failed */
472 [ + + - + ]: 60 : if ((ret < 0) ==
473 : : (can_parse_addr(CMDLINE_IPADDR_V6, flags))) {
474 : 0 : printf("Error: unexpected behavior when parsing %s as %s!\n",
475 : : ipaddr_garbage_addr6_strs[i], buf);
476 : 0 : return -1;
477 : : }
478 [ + + ]: 36 : if (ret != -1 &&
479 [ - + ]: 12 : memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
480 : 0 : printf("Error: result mismatch when parsing %s as %s!\n",
481 : : ipaddr_garbage_addr6_strs[i], buf);
482 : 0 : return -1;
483 : : }
484 : : }
485 : : }
486 : :
487 : :
488 : : /* test garbage ipv4 network strings */
489 [ + + ]: 7 : for (i = 0; i < RTE_DIM(ipaddr_garbage_network4_strs); i++) {
490 : :
491 : 6 : struct in_addr tmp = IPv4_GARBAGE_ADDR;
492 : :
493 : : /* test each valid string against different flags */
494 [ + + ]: 48 : for (flags = 1; flags < 0x8; flags++) {
495 : :
496 : : /* skip bad flag */
497 [ + + ]: 42 : if (flags == CMDLINE_IPADDR_NETWORK)
498 : 6 : continue;
499 : :
500 : : /* clear out everything */
501 : : memset(buf, 0, sizeof(buf));
502 : : memset(&result, 0, sizeof(result));
503 : : memset(&token, 0, sizeof(token));
504 : :
505 : 36 : token.ipaddr_data.flags = flags;
506 : :
507 : 36 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
508 : : buf, sizeof(buf));
509 : :
510 : 36 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
511 : : ipaddr_garbage_network4_strs[i], (void*)&result,
512 : : sizeof(result));
513 : :
514 : : /* if should have passed, or should have failed */
515 [ + + - + ]: 48 : if ((ret < 0) ==
516 : : (can_parse_addr(CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK, flags))) {
517 : 0 : printf("Error: unexpected behavior when parsing %s as %s!\n",
518 : : ipaddr_garbage_network4_strs[i], buf);
519 : 0 : return -1;
520 : : }
521 [ + + ]: 36 : if (ret != -1 &&
522 [ - + ]: 12 : memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
523 : 0 : printf("Error: result mismatch when parsing %s as %s!\n",
524 : : ipaddr_garbage_network4_strs[i], buf);
525 : 0 : return -1;
526 : : }
527 : : }
528 : : }
529 : :
530 : : /* test garbage ipv6 address strings */
531 [ + + ]: 7 : for (i = 0; i < RTE_DIM(ipaddr_garbage_network6_strs); i++) {
532 : :
533 : 6 : cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
534 : :
535 : : /* test each valid string against different flags */
536 [ + + ]: 48 : for (flags = 1; flags < 0x8; flags++) {
537 : :
538 : : /* skip bad flag */
539 [ + + ]: 42 : if (flags == CMDLINE_IPADDR_NETWORK)
540 : 6 : continue;
541 : :
542 : : /* clear out everything */
543 : : memset(buf, 0, sizeof(buf));
544 : : memset(&result, 0, sizeof(result));
545 : : memset(&token, 0, sizeof(token));
546 : :
547 : 36 : token.ipaddr_data.flags = flags;
548 : :
549 : 36 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
550 : : buf, sizeof(buf));
551 : :
552 : 36 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
553 : : ipaddr_garbage_network6_strs[i], (void*)&result,
554 : : sizeof(result));
555 : :
556 : : /* if should have passed, or should have failed */
557 [ + + - + ]: 48 : if ((ret < 0) ==
558 : : (can_parse_addr(CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK, flags))) {
559 : 0 : printf("Error: unexpected behavior when parsing %s as %s!\n",
560 : : ipaddr_garbage_network6_strs[i], buf);
561 : 0 : return -1;
562 : : }
563 [ + + ]: 36 : if (ret != -1 &&
564 [ - + ]: 12 : memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
565 : 0 : printf("Error: result mismatch when parsing %s as %s!\n",
566 : : ipaddr_garbage_network6_strs[i], buf);
567 : 0 : return -1;
568 : : }
569 : : }
570 : : }
571 : :
572 : : return 0;
573 : : }
574 : :
575 : : int
576 : 1 : test_parse_ipaddr_invalid_data(void)
577 : : {
578 : : cmdline_parse_token_ipaddr_t token;
579 : : char buf[CMDLINE_TEST_BUFSIZE];
580 : : cmdline_ipaddr_t result;
581 : : unsigned i;
582 : : uint8_t flags;
583 : : int ret;
584 : :
585 : : memset(&result, 0, sizeof(result));
586 : :
587 : : /* test invalid strings */
588 [ + + ]: 72 : for (i = 0; i < RTE_DIM(ipaddr_invalid_strs); i++) {
589 : :
590 : : /* test each valid string against different flags */
591 [ + + ]: 568 : for (flags = 1; flags < 0x8; flags++) {
592 : :
593 : : /* skip bad flag */
594 [ + + ]: 497 : if (flags == CMDLINE_IPADDR_NETWORK)
595 : 71 : continue;
596 : :
597 : : /* clear out everything */
598 : : memset(buf, 0, sizeof(buf));
599 : : memset(&token, 0, sizeof(token));
600 : :
601 : 426 : token.ipaddr_data.flags = flags;
602 : :
603 : 426 : cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
604 : : buf, sizeof(buf));
605 : :
606 : 426 : ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
607 : : ipaddr_invalid_strs[i], (void*)&result,
608 : : sizeof(result));
609 : :
610 [ - + ]: 426 : if (ret != -1) {
611 : 0 : printf("Error: parsing %s as %s succeeded!\n",
612 : : ipaddr_invalid_strs[i], buf);
613 : : printf("Parsed result: ");
614 : 0 : dump_addr(result);
615 : 0 : return -1;
616 : : }
617 : : }
618 : : }
619 : :
620 : : return 0;
621 : : }
622 : :
623 : : int
624 : 1 : test_parse_ipaddr_invalid_param(void)
625 : : {
626 : : cmdline_parse_token_ipaddr_t token;
627 : : char buf[CMDLINE_TEST_BUFSIZE];
628 : : cmdline_ipaddr_t result;
629 : :
630 : : snprintf(buf, sizeof(buf), "1.2.3.4");
631 : 1 : token.ipaddr_data.flags = CMDLINE_IPADDR_V4;
632 : :
633 : : /* null token */
634 [ - + ]: 1 : if (cmdline_parse_ipaddr(NULL, buf, (void*)&result,
635 : : sizeof(result)) != -1) {
636 : : printf("Error: parser accepted invalid parameters!\n");
637 : 0 : return -1;
638 : : }
639 : : /* null buffer */
640 [ - + ]: 1 : if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
641 : : NULL, (void*)&result, sizeof(result)) != -1) {
642 : : printf("Error: parser accepted invalid parameters!\n");
643 : 0 : return -1;
644 : : }
645 : : /* empty buffer */
646 [ - + ]: 1 : if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
647 : : "", (void*)&result, sizeof(result)) != -1) {
648 : : printf("Error: parser accepted invalid parameters!\n");
649 : 0 : return -1;
650 : : }
651 : : /* null result */
652 [ - + ]: 1 : if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
653 : : buf, NULL, 0) == -1) {
654 : : printf("Error: parser rejected null result!\n");
655 : 0 : return -1;
656 : : }
657 : :
658 : : /* null token */
659 [ - + ]: 1 : if (cmdline_get_help_ipaddr(NULL, buf, 0) != -1) {
660 : : printf("Error: help accepted invalid parameters!\n");
661 : 0 : return -1;
662 : : }
663 : : /* null buffer */
664 [ - + ]: 1 : if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
665 : : NULL, 0) != -1) {
666 : : printf("Error: help accepted invalid parameters!\n");
667 : 0 : return -1;
668 : : }
669 : : return 0;
670 : : }
|