1 /* 2 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include "qdf_mem.h" 20 #include "qdf_trace.h" 21 #include "qdf_types.h" 22 #include "qdf_types_test.h" 23 24 #define WHITESPACE "\t\n\r \x20" 25 26 #define ut_bool_pass(str, exp) __ut_bool(str, QDF_STATUS_SUCCESS, exp) 27 #define ut_bool_fail(str) __ut_bool(str, QDF_STATUS_E_FAILURE, false) 28 29 static uint32_t 30 __ut_bool(const char *str, QDF_STATUS exp_status, bool exp_value) 31 { 32 bool value; 33 QDF_STATUS status = qdf_bool_parse(str, &value); 34 35 if (status != exp_status) { 36 qdf_nofl_alert("FAIL: qdf_bool_parse(\"%s\") -> status %d; expected status %d", 37 str, status, exp_status); 38 return 1; 39 } 40 41 if (QDF_IS_STATUS_ERROR(status)) 42 return 0; 43 44 if (value != exp_value) { 45 qdf_nofl_alert("FAIL: qdf_bool_parse(\"%s\") -> %s; expected %s", 46 str, value ? "true" : "false", 47 exp_value ? "true" : "false"); 48 return 1; 49 } 50 51 return 0; 52 } 53 54 static uint32_t qdf_types_ut_bool_parse(void) 55 { 56 uint32_t errors = 0; 57 58 errors += ut_bool_pass("1", true); 59 errors += ut_bool_pass("y", true); 60 errors += ut_bool_pass("Y", true); 61 errors += ut_bool_pass("0", false); 62 errors += ut_bool_pass("n", false); 63 errors += ut_bool_pass("N", false); 64 errors += ut_bool_pass(WHITESPACE "1" WHITESPACE, true); 65 66 errors += ut_bool_fail("true"); 67 errors += ut_bool_fail("false"); 68 errors += ut_bool_fail("日本"); 69 70 return errors; 71 } 72 73 #define ut_int32_pass(str, exp) __ut_int32(str, QDF_STATUS_SUCCESS, exp) 74 #define ut_int32_fail(str, exp_status) __ut_int32(str, exp_status, 0) 75 76 static uint32_t 77 __ut_int32(const char *str, QDF_STATUS exp_status, int32_t exp_value) 78 { 79 int32_t value; 80 QDF_STATUS status = qdf_int32_parse(str, &value); 81 82 if (status != exp_status) { 83 qdf_nofl_alert("FAIL: qdf_int32_parse(\"%s\") -> status %d; expected status %d", 84 str, status, exp_status); 85 return 1; 86 } 87 88 if (QDF_IS_STATUS_ERROR(status)) 89 return 0; 90 91 if (value != exp_value) { 92 qdf_nofl_alert("FAIL: qdf_int32_parse(\"%s\") -> %d; expected %d", 93 str, value, exp_value); 94 return 1; 95 } 96 97 return 0; 98 } 99 100 static uint32_t qdf_types_ut_int32_parse(void) 101 { 102 uint32_t errors = 0; 103 104 errors += ut_int32_pass("1", 1); 105 errors += ut_int32_pass("+1", 1); 106 errors += ut_int32_pass("-1", -1); 107 errors += ut_int32_pass(WHITESPACE "1" WHITESPACE, 1); 108 errors += ut_int32_fail("1;", QDF_STATUS_E_FAILURE); 109 errors += ut_int32_pass(" 2147483647", 2147483647); 110 errors += ut_int32_fail(" 2147483648", QDF_STATUS_E_RANGE); 111 errors += ut_int32_pass("-2147483648", -2147483647 - 1); 112 errors += ut_int32_fail("-2147483649", QDF_STATUS_E_RANGE); 113 errors += ut_int32_fail("日本", QDF_STATUS_E_FAILURE); 114 115 return errors; 116 } 117 118 #define ut_int64_pass(str, exp) __ut_int64(str, QDF_STATUS_SUCCESS, exp) 119 #define ut_int64_fail(str, exp_status) __ut_int64(str, exp_status, 0) 120 121 static uint32_t 122 __ut_int64(const char *str, QDF_STATUS exp_status, int64_t exp_value) 123 { 124 int64_t value; 125 QDF_STATUS status = qdf_int64_parse(str, &value); 126 127 if (status != exp_status) { 128 qdf_nofl_alert("FAIL: qdf_int64_parse(\"%s\") -> status %d; expected status %d", 129 str, status, exp_status); 130 return 1; 131 } 132 133 if (QDF_IS_STATUS_ERROR(status)) 134 return 0; 135 136 if (value != exp_value) { 137 qdf_nofl_alert("FAIL: qdf_int64_parse(\"%s\") -> %lld; expected %lld", 138 str, value, exp_value); 139 return 1; 140 } 141 142 return 0; 143 } 144 145 static uint32_t qdf_types_ut_int64_parse(void) 146 { 147 uint32_t errors = 0; 148 149 errors += ut_int64_pass("1", 1); 150 errors += ut_int64_pass("+1", 1); 151 errors += ut_int64_pass("-1", -1); 152 errors += ut_int64_pass(WHITESPACE "1" WHITESPACE, 1); 153 errors += ut_int64_fail("1;", QDF_STATUS_E_FAILURE); 154 errors += ut_int64_pass(" 9223372036854775807", 9223372036854775807ll); 155 errors += ut_int64_fail(" 9223372036854775808", QDF_STATUS_E_RANGE); 156 errors += ut_int64_pass("-9223372036854775808", 157 -9223372036854775807ll - 1); 158 errors += ut_int64_fail("-9223372036854775809", QDF_STATUS_E_RANGE); 159 errors += ut_int64_fail("日本", QDF_STATUS_E_FAILURE); 160 161 return errors; 162 } 163 164 #define ut_uint32_pass(str, exp) __ut_uint32(str, QDF_STATUS_SUCCESS, exp) 165 #define ut_uint32_fail(str, exp_status) __ut_uint32(str, exp_status, 0) 166 167 static uint32_t 168 __ut_uint32(const char *str, QDF_STATUS exp_status, uint32_t exp_value) 169 { 170 uint32_t value; 171 QDF_STATUS status = qdf_uint32_parse(str, &value); 172 173 if (status != exp_status) { 174 qdf_nofl_alert("FAIL: qdf_uint32_parse(\"%s\") -> status %d; expected status %d", 175 str, status, exp_status); 176 return 1; 177 } 178 179 if (QDF_IS_STATUS_ERROR(status)) 180 return 0; 181 182 if (value != exp_value) { 183 qdf_nofl_alert("FAIL: qdf_uint32_parse(\"%s\") -> %d; expected %d", 184 str, value, exp_value); 185 return 1; 186 } 187 188 return 0; 189 } 190 191 static uint32_t qdf_types_ut_uint32_parse(void) 192 { 193 uint32_t errors = 0; 194 195 errors += ut_uint32_pass("1", 1); 196 errors += ut_uint32_pass("+1", 1); 197 errors += ut_uint32_pass(WHITESPACE "1" WHITESPACE, 1); 198 errors += ut_uint32_fail("1;", QDF_STATUS_E_FAILURE); 199 errors += ut_uint32_pass("4294967295", 4294967295U); 200 errors += ut_uint32_fail("4294967296", QDF_STATUS_E_RANGE); 201 errors += ut_uint32_pass(" 0", 0); 202 errors += ut_uint32_fail("-1", QDF_STATUS_E_RANGE); 203 errors += ut_uint32_fail("日本", QDF_STATUS_E_FAILURE); 204 205 return errors; 206 } 207 208 #define ut_uint64_pass(str, exp) __ut_uint64(str, QDF_STATUS_SUCCESS, exp) 209 #define ut_uint64_fail(str, exp_status) __ut_uint64(str, exp_status, 0) 210 211 static uint32_t 212 __ut_uint64(const char *str, QDF_STATUS exp_status, uint64_t exp_value) 213 { 214 uint64_t value; 215 QDF_STATUS status = qdf_uint64_parse(str, &value); 216 217 if (status != exp_status) { 218 qdf_nofl_alert("FAIL: qdf_uint64_parse(\"%s\") -> status %d; expected status %d", 219 str, status, exp_status); 220 return 1; 221 } 222 223 if (QDF_IS_STATUS_ERROR(status)) 224 return 0; 225 226 if (value != exp_value) { 227 qdf_nofl_alert("FAIL: qdf_uint64_parse(\"%s\") -> %llu; expected %llu", 228 str, value, exp_value); 229 return 1; 230 } 231 232 return 0; 233 } 234 235 static uint32_t qdf_types_ut_uint64_parse(void) 236 { 237 uint32_t errors = 0; 238 239 errors += ut_uint64_pass("1", 1); 240 errors += ut_uint64_pass("+1", 1); 241 errors += ut_uint64_pass(WHITESPACE "1" WHITESPACE, 1); 242 errors += ut_uint64_fail("1;", QDF_STATUS_E_FAILURE); 243 errors += ut_uint64_pass("18446744073709551615", 244 18446744073709551615ull); 245 errors += ut_uint64_fail("18446744073709551616", QDF_STATUS_E_RANGE); 246 errors += ut_uint64_pass(" 0", 0); 247 errors += ut_uint64_fail("-1", QDF_STATUS_E_RANGE); 248 errors += ut_uint64_fail("日本", QDF_STATUS_E_FAILURE); 249 250 return errors; 251 } 252 253 static uint32_t qdf_types_ut_int_formats_parse(void) 254 { 255 uint32_t errors = 0; 256 257 errors += ut_uint64_pass("0b01", 1); 258 errors += ut_uint64_pass("0o01234567", 342391); 259 errors += ut_uint64_pass("0123456789", 123456789); 260 errors += ut_uint64_pass("0x0123456789abcdef", 81985529216486895ll); 261 262 errors += ut_uint64_fail("0b012", QDF_STATUS_E_FAILURE); 263 errors += ut_uint64_fail("0o012345678", QDF_STATUS_E_FAILURE); 264 errors += ut_uint64_fail("0123456789a", QDF_STATUS_E_FAILURE); 265 errors += ut_uint64_fail("0x0123456789abcdefg", QDF_STATUS_E_FAILURE); 266 267 return errors; 268 } 269 270 #define ut_mac_pass(str, exp) __ut_mac(str, #str, QDF_STATUS_SUCCESS, &(exp)) 271 #define ut_mac_fail(str) __ut_mac(str, #str, QDF_STATUS_E_FAILURE, NULL) 272 273 static uint32_t 274 __ut_mac(const char *str, const char *display_str, QDF_STATUS exp_status, 275 struct qdf_mac_addr *exp_value) 276 { 277 struct qdf_mac_addr value; 278 QDF_STATUS status = qdf_mac_parse(str, &value); 279 280 if (status != exp_status) { 281 qdf_nofl_alert("FAIL: qdf_mac_parse(%s) -> status %d; expected status %d", 282 display_str, status, exp_status); 283 return 1; 284 } 285 286 if (QDF_IS_STATUS_ERROR(status)) 287 return 0; 288 289 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 290 qdf_nofl_alert("FAIL: qdf_mac_parse(%s) -> " QDF_MAC_ADDR_STR 291 "; expected " QDF_MAC_ADDR_STR, 292 display_str, 293 QDF_MAC_ADDR_ARRAY(value.bytes), 294 QDF_MAC_ADDR_ARRAY(exp_value->bytes)); 295 return 1; 296 } 297 298 return 0; 299 } 300 301 static uint32_t qdf_types_ut_mac_parse(void) 302 { 303 uint32_t errors = 0; 304 struct qdf_mac_addr addr_aabbccddeeff = { { 305 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff } }; 306 struct qdf_mac_addr addr_0123456789ab = { { 307 0x01, 0x23, 0x45, 0x67, 0x89, 0xab } }; 308 309 errors += ut_mac_fail(""); 310 errors += ut_mac_fail("test"); 311 errors += ut_mac_fail("¥円"); 312 errors += ut_mac_pass("aabbccddeeff", addr_aabbccddeeff); 313 errors += ut_mac_pass("AABBCCDDEEFF", addr_aabbccddeeff); 314 errors += ut_mac_fail("aa:bbccddeeff"); 315 errors += ut_mac_fail("aabbccddee:ff"); 316 errors += ut_mac_pass("aa:bb:cc:dd:ee:ff", addr_aabbccddeeff); 317 errors += ut_mac_pass("01:23:45:67:89:ab", addr_0123456789ab); 318 errors += ut_mac_fail("01:23:45:67:89:ab:cd:ef"); 319 errors += ut_mac_fail("01:23:45\0:67:89:ab"); 320 errors += ut_mac_pass(WHITESPACE "01:23:45:67:89:ab" WHITESPACE, 321 addr_0123456789ab); 322 errors += ut_mac_pass("01:23:45:67:89:ab\n", addr_0123456789ab); 323 errors += ut_mac_fail("01:23:45:67:89:ab\t ,"); 324 325 return errors; 326 } 327 328 #define ut_ipv4_pass(str, exp) __ut_ipv4(str, #str, QDF_STATUS_SUCCESS, &(exp)) 329 #define ut_ipv4_fail(str) __ut_ipv4(str, #str, QDF_STATUS_E_FAILURE, NULL) 330 331 static uint32_t 332 __ut_ipv4(const char *str, const char *display_str, QDF_STATUS exp_status, 333 struct qdf_ipv4_addr *exp_value) 334 { 335 struct qdf_ipv4_addr value; 336 QDF_STATUS status = qdf_ipv4_parse(str, &value); 337 338 if (status != exp_status) { 339 qdf_nofl_alert("FAIL: qdf_ipv4_parse(%s) -> status %d; expected status %d", 340 display_str, status, exp_status); 341 return 1; 342 } 343 344 if (QDF_IS_STATUS_ERROR(status)) 345 return 0; 346 347 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 348 qdf_nofl_alert("FAIL: qdf_ipv4_parse(%s) -> " QDF_IPV4_ADDR_STR 349 "; expected " QDF_IPV4_ADDR_STR, 350 display_str, 351 QDF_IPV4_ADDR_ARRAY(value.bytes), 352 QDF_IPV4_ADDR_ARRAY(exp_value->bytes)); 353 return 1; 354 } 355 356 return 0; 357 } 358 359 static uint32_t qdf_types_ut_ipv4_parse(void) 360 { 361 uint32_t errors = 0; 362 struct qdf_ipv4_addr addr_0000 = { { 0, 0, 0, 0 } }; 363 struct qdf_ipv4_addr addr_127001 = { { 127, 0, 0, 1 } }; 364 struct qdf_ipv4_addr addr_0112123 = { { 0, 1, 12, 123 } }; 365 struct qdf_ipv4_addr addr_255255255255 = { { 255, 255, 255, 255 } }; 366 367 errors += ut_ipv4_fail(""); 368 errors += ut_ipv4_fail("test"); 369 errors += ut_ipv4_fail("¥円"); 370 errors += ut_ipv4_pass("0.0.0.0", addr_0000); 371 errors += ut_ipv4_pass("127.0.0.1", addr_127001); 372 errors += ut_ipv4_pass("255.255.255.255", addr_255255255255); 373 errors += ut_ipv4_fail(".0.0.1"); 374 errors += ut_ipv4_fail("127.0.0."); 375 errors += ut_ipv4_fail("abc.123.123.123"); 376 errors += ut_ipv4_fail("256.0.0.0"); 377 errors += ut_ipv4_pass("0.1.12.123", addr_0112123); 378 errors += ut_ipv4_pass(WHITESPACE "0.1.12.123" WHITESPACE, 379 addr_0112123); 380 errors += ut_ipv4_fail("0.1.12\0.123"); 381 errors += ut_ipv4_fail("0.1.12.123 ,"); 382 383 return errors; 384 } 385 386 #define ut_ipv6_pass(str, exp) __ut_ipv6(str, #str, QDF_STATUS_SUCCESS, &(exp)) 387 #define ut_ipv6_fail(str) __ut_ipv6(str, #str, QDF_STATUS_E_FAILURE, NULL) 388 389 static uint32_t 390 __ut_ipv6(const char *str, const char *display_str, QDF_STATUS exp_status, 391 struct qdf_ipv6_addr *exp_value) 392 { 393 struct qdf_ipv6_addr value; 394 QDF_STATUS status = qdf_ipv6_parse(str, &value); 395 396 if (status != exp_status) { 397 qdf_nofl_alert("FAIL: qdf_ipv6_parse(%s) -> status %d; expected status %d", 398 display_str, status, exp_status); 399 return 1; 400 } 401 402 if (QDF_IS_STATUS_ERROR(status)) 403 return 0; 404 405 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 406 qdf_nofl_alert("FAIL: qdf_ipv6_parse(%s) -> " QDF_IPV6_ADDR_STR 407 "; expected " QDF_IPV6_ADDR_STR, 408 display_str, 409 QDF_IPV6_ADDR_ARRAY(value.bytes), 410 QDF_IPV6_ADDR_ARRAY(exp_value->bytes)); 411 return 1; 412 } 413 414 return 0; 415 } 416 417 static uint32_t qdf_types_ut_ipv6_parse(void) 418 { 419 uint32_t errors = 0; 420 struct qdf_ipv6_addr addr_00000000000000000000000000000000 = { { 421 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 422 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 423 } }; 424 struct qdf_ipv6_addr addr_00000000000000000000000000000001 = { { 425 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 426 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 427 } }; 428 struct qdf_ipv6_addr addr_00010000000000000000000000000000 = { { 429 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 430 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 431 } }; 432 struct qdf_ipv6_addr addr_0123456789abcdefabcdef0123456789 = { { 433 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 434 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 435 } }; 436 struct qdf_ipv6_addr addr_20010db885a3000000008a2e03707334 = { { 437 0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 438 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34, 439 } }; 440 struct qdf_ipv6_addr addr_ff020000000000000000000000000001 = { { 441 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 443 } }; 444 struct qdf_ipv6_addr addr_00000000000000000000ffffc0000280 = { { 445 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 446 0x00, 0x00, 0xff, 0xff, 0xc0, 0x00, 0x02, 0x80, 447 } }; 448 struct qdf_ipv6_addr addr_00010000000000000000000000000001 = { { 449 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 450 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 451 } }; 452 453 errors += ut_ipv6_fail(""); 454 errors += ut_ipv6_fail("test"); 455 errors += ut_ipv6_fail("¥円"); 456 errors += ut_ipv6_pass("::", 457 addr_00000000000000000000000000000000); 458 errors += ut_ipv6_pass("::0", 459 addr_00000000000000000000000000000000); 460 errors += ut_ipv6_pass("0:0:0:0:0:0:0:0", 461 addr_00000000000000000000000000000000); 462 errors += ut_ipv6_pass("::1", 463 addr_00000000000000000000000000000001); 464 errors += ut_ipv6_pass("1::", 465 addr_00010000000000000000000000000000); 466 errors += ut_ipv6_pass("0:0:0:0:0:0:0:1", 467 addr_00000000000000000000000000000001); 468 errors += ut_ipv6_pass("0123:4567:89ab:cdef:ABCD:EF01:2345:6789", 469 addr_0123456789abcdefabcdef0123456789); 470 errors += ut_ipv6_fail("::0123:4567:89ab:cdef:ABCD:EF01:2345:6789"); 471 errors += ut_ipv6_fail("0123:4567:89ab:cdef:ABCD:EF01:2345:6789::"); 472 errors += ut_ipv6_pass("2001:0db8:85a3:0000:0000:8a2e:0370:7334", 473 addr_20010db885a3000000008a2e03707334); 474 errors += ut_ipv6_pass("2001:db8:85a3:0:0:8a2e:370:7334", 475 addr_20010db885a3000000008a2e03707334); 476 errors += ut_ipv6_pass("2001:db8:85a3::8a2e:370:7334", 477 addr_20010db885a3000000008a2e03707334); 478 errors += ut_ipv6_pass("ff02::1", 479 addr_ff020000000000000000000000000001); 480 errors += ut_ipv6_pass("::ffff:c000:0280", 481 addr_00000000000000000000ffffc0000280); 482 errors += ut_ipv6_fail(":0:0:0:0:0:0:1"); 483 errors += ut_ipv6_fail(":0:0::0:0:1"); 484 errors += ut_ipv6_fail("0:0:0:0:0:0:0:"); 485 errors += ut_ipv6_fail("0:0:0::0:0:"); 486 errors += ut_ipv6_fail("0:0::0:0::0:0"); 487 errors += ut_ipv6_fail("xyz::zyx"); 488 errors += ut_ipv6_pass(WHITESPACE "1::1" WHITESPACE, 489 addr_00010000000000000000000000000001); 490 errors += ut_ipv6_fail("1\0::1"); 491 errors += ut_ipv6_fail("1::1 ,"); 492 errors += ut_ipv6_fail("abcd"); 493 494 return errors; 495 } 496 497 uint32_t qdf_types_unit_test(void) 498 { 499 uint32_t errors = 0; 500 501 errors += qdf_types_ut_bool_parse(); 502 errors += qdf_types_ut_int32_parse(); 503 errors += qdf_types_ut_int64_parse(); 504 errors += qdf_types_ut_uint32_parse(); 505 errors += qdf_types_ut_uint64_parse(); 506 errors += qdf_types_ut_int_formats_parse(); 507 errors += qdf_types_ut_mac_parse(); 508 errors += qdf_types_ut_ipv4_parse(); 509 errors += qdf_types_ut_ipv6_parse(); 510 511 return errors; 512 } 513 514