1 /******************************************************************************* 2 * 3 * Module Name: utstring - Common functions for strings and characters 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acnamesp.h" 47 48 #define _COMPONENT ACPI_UTILITIES 49 ACPI_MODULE_NAME("utstring") 50 51 /* 52 * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit 53 * version of strtoul. 54 */ 55 #ifdef ACPI_ASL_COMPILER 56 /******************************************************************************* 57 * 58 * FUNCTION: acpi_ut_strlwr (strlwr) 59 * 60 * PARAMETERS: src_string - The source string to convert 61 * 62 * RETURN: None 63 * 64 * DESCRIPTION: Convert string to lowercase 65 * 66 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 67 * 68 ******************************************************************************/ 69 void acpi_ut_strlwr(char *src_string) 70 { 71 char *string; 72 73 ACPI_FUNCTION_ENTRY(); 74 75 if (!src_string) { 76 return; 77 } 78 79 /* Walk entire string, lowercasing the letters */ 80 81 for (string = src_string; *string; string++) { 82 *string = (char)ACPI_TOLOWER(*string); 83 } 84 85 return; 86 } 87 88 /****************************************************************************** 89 * 90 * FUNCTION: acpi_ut_stricmp (stricmp) 91 * 92 * PARAMETERS: string1 - first string to compare 93 * string2 - second string to compare 94 * 95 * RETURN: int that signifies string relationship. Zero means strings 96 * are equal. 97 * 98 * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare 99 * strings with no case sensitivity) 100 * 101 ******************************************************************************/ 102 103 int acpi_ut_stricmp(char *string1, char *string2) 104 { 105 int c1; 106 int c2; 107 108 do { 109 c1 = tolower((int)*string1); 110 c2 = tolower((int)*string2); 111 112 string1++; 113 string2++; 114 } 115 while ((c1 == c2) && (c1)); 116 117 return (c1 - c2); 118 } 119 #endif 120 121 /******************************************************************************* 122 * 123 * FUNCTION: acpi_ut_strupr (strupr) 124 * 125 * PARAMETERS: src_string - The source string to convert 126 * 127 * RETURN: None 128 * 129 * DESCRIPTION: Convert string to uppercase 130 * 131 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 132 * 133 ******************************************************************************/ 134 135 void acpi_ut_strupr(char *src_string) 136 { 137 char *string; 138 139 ACPI_FUNCTION_ENTRY(); 140 141 if (!src_string) { 142 return; 143 } 144 145 /* Walk entire string, uppercasing the letters */ 146 147 for (string = src_string; *string; string++) { 148 *string = (char)ACPI_TOUPPER(*string); 149 } 150 151 return; 152 } 153 154 /******************************************************************************* 155 * 156 * FUNCTION: acpi_ut_strtoul64 157 * 158 * PARAMETERS: string - Null terminated string 159 * base - Radix of the string: 16 or ACPI_ANY_BASE; 160 * ACPI_ANY_BASE means 'in behalf of to_integer' 161 * ret_integer - Where the converted integer is returned 162 * 163 * RETURN: Status and Converted value 164 * 165 * DESCRIPTION: Convert a string into an unsigned value. Performs either a 166 * 32-bit or 64-bit conversion, depending on the current mode 167 * of the interpreter. 168 * NOTE: Does not support Octal strings, not needed. 169 * 170 ******************************************************************************/ 171 172 acpi_status acpi_ut_strtoul64(char *string, u32 base, u64 *ret_integer) 173 { 174 u32 this_digit = 0; 175 u64 return_value = 0; 176 u64 quotient; 177 u64 dividend; 178 u32 to_integer_op = (base == ACPI_ANY_BASE); 179 u32 mode32 = (acpi_gbl_integer_byte_width == 4); 180 u8 valid_digits = 0; 181 u8 sign_of0x = 0; 182 u8 term = 0; 183 184 ACPI_FUNCTION_TRACE_STR(ut_stroul64, string); 185 186 switch (base) { 187 case ACPI_ANY_BASE: 188 case 16: 189 190 break; 191 192 default: 193 194 /* Invalid Base */ 195 196 return_ACPI_STATUS(AE_BAD_PARAMETER); 197 } 198 199 if (!string) { 200 goto error_exit; 201 } 202 203 /* Skip over any white space in the buffer */ 204 205 while ((*string) && (ACPI_IS_SPACE(*string) || *string == '\t')) { 206 string++; 207 } 208 209 if (to_integer_op) { 210 /* 211 * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'. 212 * We need to determine if it is decimal or hexadecimal. 213 */ 214 if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) { 215 sign_of0x = 1; 216 base = 16; 217 218 /* Skip over the leading '0x' */ 219 string += 2; 220 } else { 221 base = 10; 222 } 223 } 224 225 /* Any string left? Check that '0x' is not followed by white space. */ 226 227 if (!(*string) || ACPI_IS_SPACE(*string) || *string == '\t') { 228 if (to_integer_op) { 229 goto error_exit; 230 } else { 231 goto all_done; 232 } 233 } 234 235 /* 236 * Perform a 32-bit or 64-bit conversion, depending upon the current 237 * execution mode of the interpreter 238 */ 239 dividend = (mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; 240 241 /* Main loop: convert the string to a 32- or 64-bit integer */ 242 243 while (*string) { 244 if (ACPI_IS_DIGIT(*string)) { 245 246 /* Convert ASCII 0-9 to Decimal value */ 247 248 this_digit = ((u8)*string) - '0'; 249 } else if (base == 10) { 250 251 /* Digit is out of range; possible in to_integer case only */ 252 253 term = 1; 254 } else { 255 this_digit = (u8)ACPI_TOUPPER(*string); 256 if (ACPI_IS_XDIGIT((char)this_digit)) { 257 258 /* Convert ASCII Hex char to value */ 259 260 this_digit = this_digit - 'A' + 10; 261 } else { 262 term = 1; 263 } 264 } 265 266 if (term) { 267 if (to_integer_op) { 268 goto error_exit; 269 } else { 270 break; 271 } 272 } else if ((valid_digits == 0) && (this_digit == 0) 273 && !sign_of0x) { 274 275 /* Skip zeros */ 276 string++; 277 continue; 278 } 279 280 valid_digits++; 281 282 if (sign_of0x 283 && ((valid_digits > 16) 284 || ((valid_digits > 8) && mode32))) { 285 /* 286 * This is to_integer operation case. 287 * No any restrictions for string-to-integer conversion, 288 * see ACPI spec. 289 */ 290 goto error_exit; 291 } 292 293 /* Divide the digit into the correct position */ 294 295 (void)acpi_ut_short_divide((dividend - (u64)this_digit), 296 base, "ient, NULL); 297 298 if (return_value > quotient) { 299 if (to_integer_op) { 300 goto error_exit; 301 } else { 302 break; 303 } 304 } 305 306 return_value *= base; 307 return_value += this_digit; 308 string++; 309 } 310 311 /* All done, normal exit */ 312 313 all_done: 314 315 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 316 ACPI_FORMAT_UINT64(return_value))); 317 318 *ret_integer = return_value; 319 return_ACPI_STATUS(AE_OK); 320 321 error_exit: 322 /* Base was set/validated above */ 323 324 if (base == 10) { 325 return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT); 326 } else { 327 return_ACPI_STATUS(AE_BAD_HEX_CONSTANT); 328 } 329 } 330 331 /******************************************************************************* 332 * 333 * FUNCTION: acpi_ut_print_string 334 * 335 * PARAMETERS: string - Null terminated ASCII string 336 * max_length - Maximum output length 337 * 338 * RETURN: None 339 * 340 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 341 * sequences. 342 * 343 ******************************************************************************/ 344 345 void acpi_ut_print_string(char *string, u8 max_length) 346 { 347 u32 i; 348 349 if (!string) { 350 acpi_os_printf("<\"NULL STRING PTR\">"); 351 return; 352 } 353 354 acpi_os_printf("\""); 355 for (i = 0; string[i] && (i < max_length); i++) { 356 357 /* Escape sequences */ 358 359 switch (string[i]) { 360 case 0x07: 361 362 acpi_os_printf("\\a"); /* BELL */ 363 break; 364 365 case 0x08: 366 367 acpi_os_printf("\\b"); /* BACKSPACE */ 368 break; 369 370 case 0x0C: 371 372 acpi_os_printf("\\f"); /* FORMFEED */ 373 break; 374 375 case 0x0A: 376 377 acpi_os_printf("\\n"); /* LINEFEED */ 378 break; 379 380 case 0x0D: 381 382 acpi_os_printf("\\r"); /* CARRIAGE RETURN */ 383 break; 384 385 case 0x09: 386 387 acpi_os_printf("\\t"); /* HORIZONTAL TAB */ 388 break; 389 390 case 0x0B: 391 392 acpi_os_printf("\\v"); /* VERTICAL TAB */ 393 break; 394 395 case '\'': /* Single Quote */ 396 case '\"': /* Double Quote */ 397 case '\\': /* Backslash */ 398 399 acpi_os_printf("\\%c", (int)string[i]); 400 break; 401 402 default: 403 404 /* Check for printable character or hex escape */ 405 406 if (ACPI_IS_PRINT(string[i])) { 407 /* This is a normal character */ 408 409 acpi_os_printf("%c", (int)string[i]); 410 } else { 411 /* All others will be Hex escapes */ 412 413 acpi_os_printf("\\x%2.2X", (s32) string[i]); 414 } 415 break; 416 } 417 } 418 acpi_os_printf("\""); 419 420 if (i == max_length && string[i]) { 421 acpi_os_printf("..."); 422 } 423 } 424 425 /******************************************************************************* 426 * 427 * FUNCTION: acpi_ut_valid_acpi_char 428 * 429 * PARAMETERS: char - The character to be examined 430 * position - Byte position (0-3) 431 * 432 * RETURN: TRUE if the character is valid, FALSE otherwise 433 * 434 * DESCRIPTION: Check for a valid ACPI character. Must be one of: 435 * 1) Upper case alpha 436 * 2) numeric 437 * 3) underscore 438 * 439 * We allow a '!' as the last character because of the ASF! table 440 * 441 ******************************************************************************/ 442 443 u8 acpi_ut_valid_acpi_char(char character, u32 position) 444 { 445 446 if (!((character >= 'A' && character <= 'Z') || 447 (character >= '0' && character <= '9') || (character == '_'))) { 448 449 /* Allow a '!' in the last position */ 450 451 if (character == '!' && position == 3) { 452 return (TRUE); 453 } 454 455 return (FALSE); 456 } 457 458 return (TRUE); 459 } 460 461 /******************************************************************************* 462 * 463 * FUNCTION: acpi_ut_valid_acpi_name 464 * 465 * PARAMETERS: name - The name to be examined. Does not have to 466 * be NULL terminated string. 467 * 468 * RETURN: TRUE if the name is valid, FALSE otherwise 469 * 470 * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 471 * 1) Upper case alpha 472 * 2) numeric 473 * 3) underscore 474 * 475 ******************************************************************************/ 476 477 u8 acpi_ut_valid_acpi_name(char *name) 478 { 479 u32 i; 480 481 ACPI_FUNCTION_ENTRY(); 482 483 for (i = 0; i < ACPI_NAME_SIZE; i++) { 484 if (!acpi_ut_valid_acpi_char(name[i], i)) { 485 return (FALSE); 486 } 487 } 488 489 return (TRUE); 490 } 491 492 /******************************************************************************* 493 * 494 * FUNCTION: acpi_ut_repair_name 495 * 496 * PARAMETERS: name - The ACPI name to be repaired 497 * 498 * RETURN: Repaired version of the name 499 * 500 * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and 501 * return the new name. NOTE: the Name parameter must reside in 502 * read/write memory, cannot be a const. 503 * 504 * An ACPI Name must consist of valid ACPI characters. We will repair the name 505 * if necessary because we don't want to abort because of this, but we want 506 * all namespace names to be printable. A warning message is appropriate. 507 * 508 * This issue came up because there are in fact machines that exhibit 509 * this problem, and we want to be able to enable ACPI support for them, 510 * even though there are a few bad names. 511 * 512 ******************************************************************************/ 513 514 void acpi_ut_repair_name(char *name) 515 { 516 u32 i; 517 u8 found_bad_char = FALSE; 518 u32 original_name; 519 520 ACPI_FUNCTION_NAME(ut_repair_name); 521 522 ACPI_MOVE_NAME(&original_name, name); 523 524 /* Check each character in the name */ 525 526 for (i = 0; i < ACPI_NAME_SIZE; i++) { 527 if (acpi_ut_valid_acpi_char(name[i], i)) { 528 continue; 529 } 530 531 /* 532 * Replace a bad character with something printable, yet technically 533 * still invalid. This prevents any collisions with existing "good" 534 * names in the namespace. 535 */ 536 name[i] = '*'; 537 found_bad_char = TRUE; 538 } 539 540 if (found_bad_char) { 541 542 /* Report warning only if in strict mode or debug mode */ 543 544 if (!acpi_gbl_enable_interpreter_slack) { 545 ACPI_WARNING((AE_INFO, 546 "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 547 original_name, name)); 548 } else { 549 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 550 "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 551 original_name, name)); 552 } 553 } 554 } 555 556 #if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP 557 /******************************************************************************* 558 * 559 * FUNCTION: ut_convert_backslashes 560 * 561 * PARAMETERS: pathname - File pathname string to be converted 562 * 563 * RETURN: Modifies the input Pathname 564 * 565 * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within 566 * the entire input file pathname string. 567 * 568 ******************************************************************************/ 569 570 void ut_convert_backslashes(char *pathname) 571 { 572 573 if (!pathname) { 574 return; 575 } 576 577 while (*pathname) { 578 if (*pathname == '\\') { 579 *pathname = '/'; 580 } 581 582 pathname++; 583 } 584 } 585 #endif 586