1 /******************************************************************************* 2 * 3 * Module Name: utstring - Common functions for strings and characters 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 45 #define __UTSTRING_C__ 46 47 #include "acpi.h" 48 #include "accommon.h" 49 #include "acnamesp.h" 50 51 52 #define _COMPONENT ACPI_UTILITIES 53 ACPI_MODULE_NAME ("utstring") 54 55 56 /* 57 * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit 58 * version of strtoul. 59 */ 60 61 #ifdef ACPI_ASL_COMPILER 62 /******************************************************************************* 63 * 64 * FUNCTION: AcpiUtStrlwr (strlwr) 65 * 66 * PARAMETERS: SrcString - The source string to convert 67 * 68 * RETURN: None 69 * 70 * DESCRIPTION: Convert string to lowercase 71 * 72 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 73 * 74 ******************************************************************************/ 75 76 void 77 AcpiUtStrlwr ( 78 char *SrcString) 79 { 80 char *String; 81 82 83 ACPI_FUNCTION_ENTRY (); 84 85 86 if (!SrcString) 87 { 88 return; 89 } 90 91 /* Walk entire string, lowercasing the letters */ 92 93 for (String = SrcString; *String; String++) 94 { 95 *String = (char) ACPI_TOLOWER (*String); 96 } 97 98 return; 99 } 100 101 102 /****************************************************************************** 103 * 104 * FUNCTION: AcpiUtStricmp (stricmp) 105 * 106 * PARAMETERS: String1 - first string to compare 107 * String2 - second string to compare 108 * 109 * RETURN: int that signifies string relationship. Zero means strings 110 * are equal. 111 * 112 * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare 113 * strings with no case sensitivity) 114 * 115 ******************************************************************************/ 116 117 int 118 AcpiUtStricmp ( 119 char *String1, 120 char *String2) 121 { 122 int c1; 123 int c2; 124 125 126 do 127 { 128 c1 = tolower ((int) *String1); 129 c2 = tolower ((int) *String2); 130 131 String1++; 132 String2++; 133 } 134 while ((c1 == c2) && (c1)); 135 136 return (c1 - c2); 137 } 138 #endif 139 140 141 /******************************************************************************* 142 * 143 * FUNCTION: AcpiUtStrupr (strupr) 144 * 145 * PARAMETERS: SrcString - The source string to convert 146 * 147 * RETURN: None 148 * 149 * DESCRIPTION: Convert string to uppercase 150 * 151 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 152 * 153 ******************************************************************************/ 154 155 void 156 AcpiUtStrupr ( 157 char *SrcString) 158 { 159 char *String; 160 161 162 ACPI_FUNCTION_ENTRY (); 163 164 165 if (!SrcString) 166 { 167 return; 168 } 169 170 /* Walk entire string, uppercasing the letters */ 171 172 for (String = SrcString; *String; String++) 173 { 174 *String = (char) ACPI_TOUPPER (*String); 175 } 176 177 return; 178 } 179 180 181 /******************************************************************************* 182 * 183 * FUNCTION: AcpiUtStrtoul64 184 * 185 * PARAMETERS: String - Null terminated string 186 * Base - Radix of the string: 16 or ACPI_ANY_BASE; 187 * ACPI_ANY_BASE means 'in behalf of ToInteger' 188 * RetInteger - Where the converted integer is returned 189 * 190 * RETURN: Status and Converted value 191 * 192 * DESCRIPTION: Convert a string into an unsigned value. Performs either a 193 * 32-bit or 64-bit conversion, depending on the current mode 194 * of the interpreter. 195 * NOTE: Does not support Octal strings, not needed. 196 * 197 ******************************************************************************/ 198 199 ACPI_STATUS 200 AcpiUtStrtoul64 ( 201 char *String, 202 UINT32 Base, 203 UINT64 *RetInteger) 204 { 205 UINT32 ThisDigit = 0; 206 UINT64 ReturnValue = 0; 207 UINT64 Quotient; 208 UINT64 Dividend; 209 UINT32 ToIntegerOp = (Base == ACPI_ANY_BASE); 210 UINT32 Mode32 = (AcpiGbl_IntegerByteWidth == 4); 211 UINT8 ValidDigits = 0; 212 UINT8 SignOf0x = 0; 213 UINT8 Term = 0; 214 215 216 ACPI_FUNCTION_TRACE_STR (UtStroul64, String); 217 218 219 switch (Base) 220 { 221 case ACPI_ANY_BASE: 222 case 16: 223 224 break; 225 226 default: 227 228 /* Invalid Base */ 229 230 return_ACPI_STATUS (AE_BAD_PARAMETER); 231 } 232 233 if (!String) 234 { 235 goto ErrorExit; 236 } 237 238 /* Skip over any white space in the buffer */ 239 240 while ((*String) && (ACPI_IS_SPACE (*String) || *String == '\t')) 241 { 242 String++; 243 } 244 245 if (ToIntegerOp) 246 { 247 /* 248 * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'. 249 * We need to determine if it is decimal or hexadecimal. 250 */ 251 if ((*String == '0') && (ACPI_TOLOWER (*(String + 1)) == 'x')) 252 { 253 SignOf0x = 1; 254 Base = 16; 255 256 /* Skip over the leading '0x' */ 257 String += 2; 258 } 259 else 260 { 261 Base = 10; 262 } 263 } 264 265 /* Any string left? Check that '0x' is not followed by white space. */ 266 267 if (!(*String) || ACPI_IS_SPACE (*String) || *String == '\t') 268 { 269 if (ToIntegerOp) 270 { 271 goto ErrorExit; 272 } 273 else 274 { 275 goto AllDone; 276 } 277 } 278 279 /* 280 * Perform a 32-bit or 64-bit conversion, depending upon the current 281 * execution mode of the interpreter 282 */ 283 Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; 284 285 /* Main loop: convert the string to a 32- or 64-bit integer */ 286 287 while (*String) 288 { 289 if (ACPI_IS_DIGIT (*String)) 290 { 291 /* Convert ASCII 0-9 to Decimal value */ 292 293 ThisDigit = ((UINT8) *String) - '0'; 294 } 295 else if (Base == 10) 296 { 297 /* Digit is out of range; possible in ToInteger case only */ 298 299 Term = 1; 300 } 301 else 302 { 303 ThisDigit = (UINT8) ACPI_TOUPPER (*String); 304 if (ACPI_IS_XDIGIT ((char) ThisDigit)) 305 { 306 /* Convert ASCII Hex char to value */ 307 308 ThisDigit = ThisDigit - 'A' + 10; 309 } 310 else 311 { 312 Term = 1; 313 } 314 } 315 316 if (Term) 317 { 318 if (ToIntegerOp) 319 { 320 goto ErrorExit; 321 } 322 else 323 { 324 break; 325 } 326 } 327 else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x) 328 { 329 /* Skip zeros */ 330 String++; 331 continue; 332 } 333 334 ValidDigits++; 335 336 if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32))) 337 { 338 /* 339 * This is ToInteger operation case. 340 * No any restrictions for string-to-integer conversion, 341 * see ACPI spec. 342 */ 343 goto ErrorExit; 344 } 345 346 /* Divide the digit into the correct position */ 347 348 (void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit), 349 Base, &Quotient, NULL); 350 351 if (ReturnValue > Quotient) 352 { 353 if (ToIntegerOp) 354 { 355 goto ErrorExit; 356 } 357 else 358 { 359 break; 360 } 361 } 362 363 ReturnValue *= Base; 364 ReturnValue += ThisDigit; 365 String++; 366 } 367 368 /* All done, normal exit */ 369 370 AllDone: 371 372 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 373 ACPI_FORMAT_UINT64 (ReturnValue))); 374 375 *RetInteger = ReturnValue; 376 return_ACPI_STATUS (AE_OK); 377 378 379 ErrorExit: 380 /* Base was set/validated above */ 381 382 if (Base == 10) 383 { 384 return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT); 385 } 386 else 387 { 388 return_ACPI_STATUS (AE_BAD_HEX_CONSTANT); 389 } 390 } 391 392 393 /******************************************************************************* 394 * 395 * FUNCTION: AcpiUtPrintString 396 * 397 * PARAMETERS: String - Null terminated ASCII string 398 * MaxLength - Maximum output length. Used to constrain the 399 * length of strings during debug output only. 400 * 401 * RETURN: None 402 * 403 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 404 * sequences. 405 * 406 ******************************************************************************/ 407 408 void 409 AcpiUtPrintString ( 410 char *String, 411 UINT16 MaxLength) 412 { 413 UINT32 i; 414 415 416 if (!String) 417 { 418 AcpiOsPrintf ("<\"NULL STRING PTR\">"); 419 return; 420 } 421 422 AcpiOsPrintf ("\""); 423 for (i = 0; String[i] && (i < MaxLength); i++) 424 { 425 /* Escape sequences */ 426 427 switch (String[i]) 428 { 429 case 0x07: 430 431 AcpiOsPrintf ("\\a"); /* BELL */ 432 break; 433 434 case 0x08: 435 436 AcpiOsPrintf ("\\b"); /* BACKSPACE */ 437 break; 438 439 case 0x0C: 440 441 AcpiOsPrintf ("\\f"); /* FORMFEED */ 442 break; 443 444 case 0x0A: 445 446 AcpiOsPrintf ("\\n"); /* LINEFEED */ 447 break; 448 449 case 0x0D: 450 451 AcpiOsPrintf ("\\r"); /* CARRIAGE RETURN*/ 452 break; 453 454 case 0x09: 455 456 AcpiOsPrintf ("\\t"); /* HORIZONTAL TAB */ 457 break; 458 459 case 0x0B: 460 461 AcpiOsPrintf ("\\v"); /* VERTICAL TAB */ 462 break; 463 464 case '\'': /* Single Quote */ 465 case '\"': /* Double Quote */ 466 case '\\': /* Backslash */ 467 468 AcpiOsPrintf ("\\%c", (int) String[i]); 469 break; 470 471 default: 472 473 /* Check for printable character or hex escape */ 474 475 if (ACPI_IS_PRINT (String[i])) 476 { 477 /* This is a normal character */ 478 479 AcpiOsPrintf ("%c", (int) String[i]); 480 } 481 else 482 { 483 /* All others will be Hex escapes */ 484 485 AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]); 486 } 487 break; 488 } 489 } 490 AcpiOsPrintf ("\""); 491 492 if (i == MaxLength && String[i]) 493 { 494 AcpiOsPrintf ("..."); 495 } 496 } 497 498 499 /******************************************************************************* 500 * 501 * FUNCTION: AcpiUtValidAcpiChar 502 * 503 * PARAMETERS: Char - The character to be examined 504 * Position - Byte position (0-3) 505 * 506 * RETURN: TRUE if the character is valid, FALSE otherwise 507 * 508 * DESCRIPTION: Check for a valid ACPI character. Must be one of: 509 * 1) Upper case alpha 510 * 2) numeric 511 * 3) underscore 512 * 513 * We allow a '!' as the last character because of the ASF! table 514 * 515 ******************************************************************************/ 516 517 BOOLEAN 518 AcpiUtValidAcpiChar ( 519 char Character, 520 UINT32 Position) 521 { 522 523 if (!((Character >= 'A' && Character <= 'Z') || 524 (Character >= '0' && Character <= '9') || 525 (Character == '_'))) 526 { 527 /* Allow a '!' in the last position */ 528 529 if (Character == '!' && Position == 3) 530 { 531 return (TRUE); 532 } 533 534 return (FALSE); 535 } 536 537 return (TRUE); 538 } 539 540 541 /******************************************************************************* 542 * 543 * FUNCTION: AcpiUtValidAcpiName 544 * 545 * PARAMETERS: Name - The name to be examined. Does not have to 546 * be NULL terminated string. 547 * 548 * RETURN: TRUE if the name is valid, FALSE otherwise 549 * 550 * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 551 * 1) Upper case alpha 552 * 2) numeric 553 * 3) underscore 554 * 555 ******************************************************************************/ 556 557 BOOLEAN 558 AcpiUtValidAcpiName ( 559 char *Name) 560 { 561 UINT32 i; 562 563 564 ACPI_FUNCTION_ENTRY (); 565 566 567 for (i = 0; i < ACPI_NAME_SIZE; i++) 568 { 569 if (!AcpiUtValidAcpiChar (Name[i], i)) 570 { 571 return (FALSE); 572 } 573 } 574 575 return (TRUE); 576 } 577 578 579 /******************************************************************************* 580 * 581 * FUNCTION: AcpiUtRepairName 582 * 583 * PARAMETERS: Name - The ACPI name to be repaired 584 * 585 * RETURN: Repaired version of the name 586 * 587 * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and 588 * return the new name. NOTE: the Name parameter must reside in 589 * read/write memory, cannot be a const. 590 * 591 * An ACPI Name must consist of valid ACPI characters. We will repair the name 592 * if necessary because we don't want to abort because of this, but we want 593 * all namespace names to be printable. A warning message is appropriate. 594 * 595 * This issue came up because there are in fact machines that exhibit 596 * this problem, and we want to be able to enable ACPI support for them, 597 * even though there are a few bad names. 598 * 599 ******************************************************************************/ 600 601 void 602 AcpiUtRepairName ( 603 char *Name) 604 { 605 UINT32 i; 606 BOOLEAN FoundBadChar = FALSE; 607 UINT32 OriginalName; 608 609 610 ACPI_FUNCTION_NAME (UtRepairName); 611 612 613 ACPI_MOVE_NAME (&OriginalName, Name); 614 615 /* Check each character in the name */ 616 617 for (i = 0; i < ACPI_NAME_SIZE; i++) 618 { 619 if (AcpiUtValidAcpiChar (Name[i], i)) 620 { 621 continue; 622 } 623 624 /* 625 * Replace a bad character with something printable, yet technically 626 * still invalid. This prevents any collisions with existing "good" 627 * names in the namespace. 628 */ 629 Name[i] = '*'; 630 FoundBadChar = TRUE; 631 } 632 633 if (FoundBadChar) 634 { 635 /* Report warning only if in strict mode or debug mode */ 636 637 if (!AcpiGbl_EnableInterpreterSlack) 638 { 639 ACPI_WARNING ((AE_INFO, 640 "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 641 OriginalName, Name)); 642 } 643 else 644 { 645 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 646 "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 647 OriginalName, Name)); 648 } 649 } 650 } 651 652 653 #if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP 654 /******************************************************************************* 655 * 656 * FUNCTION: UtConvertBackslashes 657 * 658 * PARAMETERS: Pathname - File pathname string to be converted 659 * 660 * RETURN: Modifies the input Pathname 661 * 662 * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within 663 * the entire input file pathname string. 664 * 665 ******************************************************************************/ 666 667 void 668 UtConvertBackslashes ( 669 char *Pathname) 670 { 671 672 if (!Pathname) 673 { 674 return; 675 } 676 677 while (*Pathname) 678 { 679 if (*Pathname == '\\') 680 { 681 *Pathname = '/'; 682 } 683 684 Pathname++; 685 } 686 } 687 #endif 688 689 #if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION) 690 /******************************************************************************* 691 * 692 * FUNCTION: AcpiUtSafeStrcpy, AcpiUtSafeStrcat, AcpiUtSafeStrncat 693 * 694 * PARAMETERS: Adds a "DestSize" parameter to each of the standard string 695 * functions. This is the size of the Destination buffer. 696 * 697 * RETURN: TRUE if the operation would overflow the destination buffer. 698 * 699 * DESCRIPTION: Safe versions of standard Clib string functions. Ensure that 700 * the result of the operation will not overflow the output string 701 * buffer. 702 * 703 * NOTE: These functions are typically only helpful for processing 704 * user input and command lines. For most ACPICA code, the 705 * required buffer length is precisely calculated before buffer 706 * allocation, so the use of these functions is unnecessary. 707 * 708 ******************************************************************************/ 709 710 BOOLEAN 711 AcpiUtSafeStrcpy ( 712 char *Dest, 713 ACPI_SIZE DestSize, 714 char *Source) 715 { 716 717 if (ACPI_STRLEN (Source) >= DestSize) 718 { 719 return (TRUE); 720 } 721 722 ACPI_STRCPY (Dest, Source); 723 return (FALSE); 724 } 725 726 BOOLEAN 727 AcpiUtSafeStrcat ( 728 char *Dest, 729 ACPI_SIZE DestSize, 730 char *Source) 731 { 732 733 if ((ACPI_STRLEN (Dest) + ACPI_STRLEN (Source)) >= DestSize) 734 { 735 return (TRUE); 736 } 737 738 ACPI_STRCAT (Dest, Source); 739 return (FALSE); 740 } 741 742 BOOLEAN 743 AcpiUtSafeStrncat ( 744 char *Dest, 745 ACPI_SIZE DestSize, 746 char *Source, 747 ACPI_SIZE MaxTransferLength) 748 { 749 ACPI_SIZE ActualTransferLength; 750 751 752 ActualTransferLength = ACPI_MIN (MaxTransferLength, ACPI_STRLEN (Source)); 753 754 if ((ACPI_STRLEN (Dest) + ActualTransferLength) >= DestSize) 755 { 756 return (TRUE); 757 } 758 759 ACPI_STRNCAT (Dest, Source, MaxTransferLength); 760 return (FALSE); 761 } 762 #endif 763