Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 1 | /******************************************************************************* |
| 2 | * |
| 3 | * Module Name: utstring - Common functions for strings and characters |
| 4 | * |
| 5 | ******************************************************************************/ |
| 6 | |
| 7 | /* |
David E. Box | 82a8094 | 2015-02-05 15:20:45 +0800 | [diff] [blame] | 8 | * Copyright (C) 2000 - 2015, Intel Corp. |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 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: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 189 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 190 | break; |
| 191 | |
| 192 | default: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 193 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 194 | /* Invalid Base */ |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 195 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 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 | |
Lv Zheng | 10622bf | 2013-10-29 09:30:02 +0800 | [diff] [blame] | 313 | all_done: |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 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 | |
Lv Zheng | 10622bf | 2013-10-29 09:30:02 +0800 | [diff] [blame] | 321 | error_exit: |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 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 |
Bob Moore | 0fb3adf | 2013-07-17 09:48:40 +0800 | [diff] [blame] | 336 | * max_length - Maximum output length. Used to constrain the |
| 337 | * length of strings during debug output only. |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 338 | * |
| 339 | * RETURN: None |
| 340 | * |
| 341 | * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape |
| 342 | * sequences. |
| 343 | * |
| 344 | ******************************************************************************/ |
| 345 | |
Bob Moore | 0fb3adf | 2013-07-17 09:48:40 +0800 | [diff] [blame] | 346 | void acpi_ut_print_string(char *string, u16 max_length) |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 347 | { |
| 348 | u32 i; |
| 349 | |
| 350 | if (!string) { |
| 351 | acpi_os_printf("<\"NULL STRING PTR\">"); |
| 352 | return; |
| 353 | } |
| 354 | |
| 355 | acpi_os_printf("\""); |
David Binderman | 5d42b0f | 2014-04-04 12:36:55 +0800 | [diff] [blame] | 356 | for (i = 0; (i < max_length) && string[i]; i++) { |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 357 | |
| 358 | /* Escape sequences */ |
| 359 | |
| 360 | switch (string[i]) { |
| 361 | case 0x07: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 362 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 363 | acpi_os_printf("\\a"); /* BELL */ |
| 364 | break; |
| 365 | |
| 366 | case 0x08: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 367 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 368 | acpi_os_printf("\\b"); /* BACKSPACE */ |
| 369 | break; |
| 370 | |
| 371 | case 0x0C: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 372 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 373 | acpi_os_printf("\\f"); /* FORMFEED */ |
| 374 | break; |
| 375 | |
| 376 | case 0x0A: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 377 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 378 | acpi_os_printf("\\n"); /* LINEFEED */ |
| 379 | break; |
| 380 | |
| 381 | case 0x0D: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 382 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 383 | acpi_os_printf("\\r"); /* CARRIAGE RETURN */ |
| 384 | break; |
| 385 | |
| 386 | case 0x09: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 387 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 388 | acpi_os_printf("\\t"); /* HORIZONTAL TAB */ |
| 389 | break; |
| 390 | |
| 391 | case 0x0B: |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 392 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 393 | acpi_os_printf("\\v"); /* VERTICAL TAB */ |
| 394 | break; |
| 395 | |
| 396 | case '\'': /* Single Quote */ |
| 397 | case '\"': /* Double Quote */ |
| 398 | case '\\': /* Backslash */ |
Chao Guan | 1d1ea1b | 2013-06-08 00:58:14 +0000 | [diff] [blame] | 399 | |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 400 | acpi_os_printf("\\%c", (int)string[i]); |
| 401 | break; |
| 402 | |
| 403 | default: |
| 404 | |
| 405 | /* Check for printable character or hex escape */ |
| 406 | |
| 407 | if (ACPI_IS_PRINT(string[i])) { |
| 408 | /* This is a normal character */ |
| 409 | |
| 410 | acpi_os_printf("%c", (int)string[i]); |
| 411 | } else { |
| 412 | /* All others will be Hex escapes */ |
| 413 | |
| 414 | acpi_os_printf("\\x%2.2X", (s32) string[i]); |
| 415 | } |
| 416 | break; |
| 417 | } |
| 418 | } |
| 419 | acpi_os_printf("\""); |
| 420 | |
| 421 | if (i == max_length && string[i]) { |
| 422 | acpi_os_printf("..."); |
| 423 | } |
| 424 | } |
| 425 | |
| 426 | /******************************************************************************* |
| 427 | * |
| 428 | * FUNCTION: acpi_ut_valid_acpi_char |
| 429 | * |
| 430 | * PARAMETERS: char - The character to be examined |
| 431 | * position - Byte position (0-3) |
| 432 | * |
| 433 | * RETURN: TRUE if the character is valid, FALSE otherwise |
| 434 | * |
| 435 | * DESCRIPTION: Check for a valid ACPI character. Must be one of: |
| 436 | * 1) Upper case alpha |
| 437 | * 2) numeric |
| 438 | * 3) underscore |
| 439 | * |
| 440 | * We allow a '!' as the last character because of the ASF! table |
| 441 | * |
| 442 | ******************************************************************************/ |
| 443 | |
| 444 | u8 acpi_ut_valid_acpi_char(char character, u32 position) |
| 445 | { |
| 446 | |
| 447 | if (!((character >= 'A' && character <= 'Z') || |
| 448 | (character >= '0' && character <= '9') || (character == '_'))) { |
| 449 | |
| 450 | /* Allow a '!' in the last position */ |
| 451 | |
| 452 | if (character == '!' && position == 3) { |
| 453 | return (TRUE); |
| 454 | } |
| 455 | |
| 456 | return (FALSE); |
| 457 | } |
| 458 | |
| 459 | return (TRUE); |
| 460 | } |
| 461 | |
| 462 | /******************************************************************************* |
| 463 | * |
| 464 | * FUNCTION: acpi_ut_valid_acpi_name |
| 465 | * |
Bob Moore | de8e7db | 2013-06-08 00:59:44 +0000 | [diff] [blame] | 466 | * PARAMETERS: name - The name to be examined. Does not have to |
| 467 | * be NULL terminated string. |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 468 | * |
| 469 | * RETURN: TRUE if the name is valid, FALSE otherwise |
| 470 | * |
| 471 | * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: |
| 472 | * 1) Upper case alpha |
| 473 | * 2) numeric |
| 474 | * 3) underscore |
| 475 | * |
| 476 | ******************************************************************************/ |
| 477 | |
Bob Moore | de8e7db | 2013-06-08 00:59:44 +0000 | [diff] [blame] | 478 | u8 acpi_ut_valid_acpi_name(char *name) |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 479 | { |
| 480 | u32 i; |
| 481 | |
| 482 | ACPI_FUNCTION_ENTRY(); |
| 483 | |
| 484 | for (i = 0; i < ACPI_NAME_SIZE; i++) { |
Bob Moore | de8e7db | 2013-06-08 00:59:44 +0000 | [diff] [blame] | 485 | if (!acpi_ut_valid_acpi_char(name[i], i)) { |
Bob Moore | 42f8fb7 | 2013-01-11 13:08:51 +0100 | [diff] [blame] | 486 | return (FALSE); |
| 487 | } |
| 488 | } |
| 489 | |
| 490 | return (TRUE); |
| 491 | } |
| 492 | |
| 493 | /******************************************************************************* |
| 494 | * |
| 495 | * FUNCTION: acpi_ut_repair_name |
| 496 | * |
| 497 | * PARAMETERS: name - The ACPI name to be repaired |
| 498 | * |
| 499 | * RETURN: Repaired version of the name |
| 500 | * |
| 501 | * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and |
| 502 | * return the new name. NOTE: the Name parameter must reside in |
| 503 | * read/write memory, cannot be a const. |
| 504 | * |
| 505 | * An ACPI Name must consist of valid ACPI characters. We will repair the name |
| 506 | * if necessary because we don't want to abort because of this, but we want |
| 507 | * all namespace names to be printable. A warning message is appropriate. |
| 508 | * |
| 509 | * This issue came up because there are in fact machines that exhibit |
| 510 | * this problem, and we want to be able to enable ACPI support for them, |
| 511 | * even though there are a few bad names. |
| 512 | * |
| 513 | ******************************************************************************/ |
| 514 | |
| 515 | void acpi_ut_repair_name(char *name) |
| 516 | { |
| 517 | u32 i; |
| 518 | u8 found_bad_char = FALSE; |
| 519 | u32 original_name; |
| 520 | |
| 521 | ACPI_FUNCTION_NAME(ut_repair_name); |
| 522 | |
| 523 | ACPI_MOVE_NAME(&original_name, name); |
| 524 | |
| 525 | /* Check each character in the name */ |
| 526 | |
| 527 | for (i = 0; i < ACPI_NAME_SIZE; i++) { |
| 528 | if (acpi_ut_valid_acpi_char(name[i], i)) { |
| 529 | continue; |
| 530 | } |
| 531 | |
| 532 | /* |
| 533 | * Replace a bad character with something printable, yet technically |
| 534 | * still invalid. This prevents any collisions with existing "good" |
| 535 | * names in the namespace. |
| 536 | */ |
| 537 | name[i] = '*'; |
| 538 | found_bad_char = TRUE; |
| 539 | } |
| 540 | |
| 541 | if (found_bad_char) { |
| 542 | |
| 543 | /* Report warning only if in strict mode or debug mode */ |
| 544 | |
| 545 | if (!acpi_gbl_enable_interpreter_slack) { |
| 546 | ACPI_WARNING((AE_INFO, |
| 547 | "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", |
| 548 | original_name, name)); |
| 549 | } else { |
| 550 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
| 551 | "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", |
| 552 | original_name, name)); |
| 553 | } |
| 554 | } |
| 555 | } |
| 556 | |
| 557 | #if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP |
| 558 | /******************************************************************************* |
| 559 | * |
| 560 | * FUNCTION: ut_convert_backslashes |
| 561 | * |
| 562 | * PARAMETERS: pathname - File pathname string to be converted |
| 563 | * |
| 564 | * RETURN: Modifies the input Pathname |
| 565 | * |
| 566 | * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within |
| 567 | * the entire input file pathname string. |
| 568 | * |
| 569 | ******************************************************************************/ |
| 570 | |
| 571 | void ut_convert_backslashes(char *pathname) |
| 572 | { |
| 573 | |
| 574 | if (!pathname) { |
| 575 | return; |
| 576 | } |
| 577 | |
| 578 | while (*pathname) { |
| 579 | if (*pathname == '\\') { |
| 580 | *pathname = '/'; |
| 581 | } |
| 582 | |
| 583 | pathname++; |
| 584 | } |
| 585 | } |
| 586 | #endif |
Bob Moore | 7342447 | 2013-10-29 09:29:21 +0800 | [diff] [blame] | 587 | |
| 588 | #if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION) |
| 589 | /******************************************************************************* |
| 590 | * |
| 591 | * FUNCTION: acpi_ut_safe_strcpy, acpi_ut_safe_strcat, acpi_ut_safe_strncat |
| 592 | * |
| 593 | * PARAMETERS: Adds a "DestSize" parameter to each of the standard string |
| 594 | * functions. This is the size of the Destination buffer. |
| 595 | * |
| 596 | * RETURN: TRUE if the operation would overflow the destination buffer. |
| 597 | * |
| 598 | * DESCRIPTION: Safe versions of standard Clib string functions. Ensure that |
| 599 | * the result of the operation will not overflow the output string |
| 600 | * buffer. |
| 601 | * |
| 602 | * NOTE: These functions are typically only helpful for processing |
| 603 | * user input and command lines. For most ACPICA code, the |
| 604 | * required buffer length is precisely calculated before buffer |
| 605 | * allocation, so the use of these functions is unnecessary. |
| 606 | * |
| 607 | ******************************************************************************/ |
| 608 | |
| 609 | u8 acpi_ut_safe_strcpy(char *dest, acpi_size dest_size, char *source) |
| 610 | { |
| 611 | |
| 612 | if (ACPI_STRLEN(source) >= dest_size) { |
| 613 | return (TRUE); |
| 614 | } |
| 615 | |
| 616 | ACPI_STRCPY(dest, source); |
| 617 | return (FALSE); |
| 618 | } |
| 619 | |
| 620 | u8 acpi_ut_safe_strcat(char *dest, acpi_size dest_size, char *source) |
| 621 | { |
| 622 | |
| 623 | if ((ACPI_STRLEN(dest) + ACPI_STRLEN(source)) >= dest_size) { |
| 624 | return (TRUE); |
| 625 | } |
| 626 | |
| 627 | ACPI_STRCAT(dest, source); |
| 628 | return (FALSE); |
| 629 | } |
| 630 | |
| 631 | u8 |
| 632 | acpi_ut_safe_strncat(char *dest, |
| 633 | acpi_size dest_size, |
| 634 | char *source, acpi_size max_transfer_length) |
| 635 | { |
| 636 | acpi_size actual_transfer_length; |
| 637 | |
| 638 | actual_transfer_length = |
| 639 | ACPI_MIN(max_transfer_length, ACPI_STRLEN(source)); |
| 640 | |
| 641 | if ((ACPI_STRLEN(dest) + actual_transfer_length) >= dest_size) { |
| 642 | return (TRUE); |
| 643 | } |
| 644 | |
| 645 | ACPI_STRNCAT(dest, source, max_transfer_length); |
| 646 | return (FALSE); |
| 647 | } |
| 648 | #endif |