1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #include <stdio.h> 6 #include <string.h> 7 #include <inttypes.h> 8 9 #include <rte_ether.h> 10 #include <rte_string_fns.h> 11 12 #include <cmdline_parse.h> 13 #include <cmdline_parse_etheraddr.h> 14 15 #include "test_cmdline.h" 16 17 struct ether_addr_str { 18 const char * str; 19 uint64_t address; 20 }; 21 22 /* valid strings */ 23 const struct ether_addr_str ether_addr_valid_strs[] = { 24 {"01:23:45:67:89:AB", 0xAB8967452301ULL}, 25 {"4567:89AB:CDEF", 0xEFCDAB896745ULL}, 26 }; 27 28 /* valid strings with various garbage at the end. 29 * these strings are still valid because parser checks for 30 * end of token, which is either space chars, null char or 31 * a hash sign. 32 */ 33 const char * ether_addr_garbage_strs[] = { 34 "00:11:22:33:44:55\0garbage", 35 "00:11:22:33:44:55#garbage", 36 "00:11:22:33:44:55 garbage", 37 "00:11:22:33:44:55\tgarbage", 38 "00:11:22:33:44:55\ngarbage", 39 "00:11:22:33:44:55\rgarbage", 40 "00:11:22:33:44:55#", 41 "00:11:22:33:44:55 ", 42 "00:11:22:33:44:55\t", 43 "00:11:22:33:44:55\n", 44 "00:11:22:33:44:55\r", 45 }; 46 #define GARBAGE_ETHERADDR 0x554433221100ULL /* corresponding address */ 47 48 49 const char * ether_addr_invalid_strs[] = { 50 /* valid chars, invalid syntax */ 51 "0123:45:67:89:AB", 52 "01:23:4567:89:AB", 53 "01:23:45:67:89AB", 54 "012:345:678:9AB", 55 "01:23:45:67:89:ABC", 56 "01:23:45:67:89:A", 57 "01:23:45:67:89", 58 "01:23:45:67:89:AB:CD", 59 /* invalid chars, valid syntax */ 60 "IN:VA:LI:DC:HA:RS", 61 "INVA:LIDC:HARS", 62 /* misc */ 63 "01 23 45 67 89 AB", 64 "01.23.45.67.89.AB", 65 "01,23,45,67,89,AB", 66 "01:23:45\0:67:89:AB", 67 "01:23:45#:67:89:AB", 68 "random invalid text", 69 "random text", 70 "", 71 "\0", 72 " ", 73 }; 74 75 #define ETHERADDR_VALID_STRS_SIZE \ 76 (sizeof(ether_addr_valid_strs) / sizeof(ether_addr_valid_strs[0])) 77 #define ETHERADDR_GARBAGE_STRS_SIZE \ 78 (sizeof(ether_addr_garbage_strs) / sizeof(ether_addr_garbage_strs[0])) 79 #define ETHERADDR_INVALID_STRS_SIZE \ 80 (sizeof(ether_addr_invalid_strs) / sizeof(ether_addr_invalid_strs[0])) 81 82 83 84 static int 85 is_addr_different(const struct ether_addr addr, uint64_t num) 86 { 87 int i; 88 for (i = 0; i < ETHER_ADDR_LEN; i++, num >>= 8) 89 if (addr.addr_bytes[i] != (num & 0xFF)) { 90 return 1; 91 } 92 return 0; 93 } 94 95 /* test invalid parameters */ 96 int 97 test_parse_etheraddr_invalid_param(void) 98 { 99 char buf[CMDLINE_TEST_BUFSIZE]; 100 struct ether_addr result; 101 int ret = 0; 102 103 /* try all null */ 104 ret = cmdline_parse_etheraddr(NULL, NULL, NULL, 0); 105 if (ret != -1) { 106 printf("Error: parser accepted null parameters!\n"); 107 return -1; 108 } 109 110 /* try null buf */ 111 ret = cmdline_parse_etheraddr(NULL, NULL, (void*)&result, 112 sizeof(result)); 113 if (ret != -1) { 114 printf("Error: parser accepted null string!\n"); 115 return -1; 116 } 117 118 /* try null result */ 119 120 /* copy string to buffer */ 121 snprintf(buf, sizeof(buf), "%s", 122 ether_addr_valid_strs[0].str); 123 124 ret = cmdline_parse_etheraddr(NULL, buf, NULL, 0); 125 if (ret == -1) { 126 printf("Error: parser rejected null result!\n"); 127 return -1; 128 } 129 130 /* token is not used in ether_parse anyway so there's no point in 131 * testing it */ 132 133 /* test help function */ 134 memset(&buf, 0, sizeof(buf)); 135 136 /* coverage! */ 137 ret = cmdline_get_help_etheraddr(NULL, buf, sizeof(buf)); 138 if (ret < 0) { 139 printf("Error: help function failed with valid parameters!\n"); 140 return -1; 141 } 142 143 return 0; 144 } 145 146 /* test valid parameters but invalid data */ 147 int 148 test_parse_etheraddr_invalid_data(void) 149 { 150 int ret = 0; 151 unsigned i; 152 struct ether_addr result; 153 154 /* test full strings */ 155 for (i = 0; i < ETHERADDR_INVALID_STRS_SIZE; i++) { 156 157 memset(&result, 0, sizeof(struct ether_addr)); 158 159 ret = cmdline_parse_etheraddr(NULL, ether_addr_invalid_strs[i], 160 (void*)&result, sizeof(result)); 161 if (ret != -1) { 162 printf("Error: parsing %s succeeded!\n", 163 ether_addr_invalid_strs[i]); 164 return -1; 165 } 166 } 167 168 return 0; 169 } 170 171 /* test valid parameters and data */ 172 int 173 test_parse_etheraddr_valid(void) 174 { 175 int ret = 0; 176 unsigned i; 177 struct ether_addr result; 178 179 /* test full strings */ 180 for (i = 0; i < ETHERADDR_VALID_STRS_SIZE; i++) { 181 182 memset(&result, 0, sizeof(struct ether_addr)); 183 184 ret = cmdline_parse_etheraddr(NULL, ether_addr_valid_strs[i].str, 185 (void*)&result, sizeof(result)); 186 if (ret < 0) { 187 printf("Error: parsing %s failed!\n", 188 ether_addr_valid_strs[i].str); 189 return -1; 190 } 191 if (is_addr_different(result, ether_addr_valid_strs[i].address)) { 192 printf("Error: parsing %s failed: address mismatch!\n", 193 ether_addr_valid_strs[i].str); 194 return -1; 195 } 196 } 197 198 /* test garbage strings */ 199 for (i = 0; i < ETHERADDR_GARBAGE_STRS_SIZE; i++) { 200 201 memset(&result, 0, sizeof(struct ether_addr)); 202 203 ret = cmdline_parse_etheraddr(NULL, ether_addr_garbage_strs[i], 204 (void*)&result, sizeof(result)); 205 if (ret < 0) { 206 printf("Error: parsing %s failed!\n", 207 ether_addr_garbage_strs[i]); 208 return -1; 209 } 210 if (is_addr_different(result, GARBAGE_ETHERADDR)) { 211 printf("Error: parsing %s failed: address mismatch!\n", 212 ether_addr_garbage_strs[i]); 213 return -1; 214 } 215 } 216 217 return 0; 218 } 219