drivers/acpi/acpica/utstring.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utstring - Common functions for strings and characters
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, 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  *
  53  * FUNCTION:    acpi_ut_print_string
  54  *
  55  * PARAMETERS:  string          - Null terminated ASCII string
  56  *              max_length      - Maximum output length. Used to constrain the
  57  *                                length of strings during debug output only.
  58  *
  59  * RETURN:      None
  60  *
  61  * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
  62  *              sequences.
  63  *
  64  ******************************************************************************/
  65 void acpi_ut_print_string(char *string, u16 max_length)
  66 {
  67         u32 i;
  68
  69         if (!string) {
  70                 acpi_os_printf("<\"NULL STRING PTR\">");
  71                 return;
  72         }
  73
  74         acpi_os_printf("\"");
  75         for (i = 0; (i < max_length) && string[i]; i++) {
  76
  77                 /* Escape sequences */
  78
  79                 switch (string[i]) {
  80                 case 0x07:
  81
  82                         acpi_os_printf("\\a");  /* BELL */
  83                         break;
  84
  85                 case 0x08:
  86
  87                         acpi_os_printf("\\b");  /* BACKSPACE */
  88                         break;
  89
  90                 case 0x0C:
  91
  92                         acpi_os_printf("\\f");  /* FORMFEED */
  93                         break;
  94
  95                 case 0x0A:
  96
  97                         acpi_os_printf("\\n");  /* LINEFEED */
  98                         break;
  99
 100                 case 0x0D:
 101
 102                         acpi_os_printf("\\r");  /* CARRIAGE RETURN */
 103                         break;
 104
 105                 case 0x09:
 106
 107                         acpi_os_printf("\\t");  /* HORIZONTAL TAB */
 108                         break;
 109
 110                 case 0x0B:
 111
 112                         acpi_os_printf("\\v");  /* VERTICAL TAB */
 113                         break;
 114
 115                 case '\'':      /* Single Quote */
 116                 case '\"':      /* Double Quote */
 117                 case '\\':      /* Backslash */
 118
 119                         acpi_os_printf("\\%c", (int)string[i]);
 120                         break;
 121
 122                 default:
 123
 124                         /* Check for printable character or hex escape */
 125
 126                         if (isprint((int)string[i])) {
 127                                 /* This is a normal character */
 128
 129                                 acpi_os_printf("%c", (int)string[i]);
 130                         } else {
 131                                 /* All others will be Hex escapes */
 132
 133                                 acpi_os_printf("\\x%2.2X", (s32) string[i]);
 134                         }
 135                         break;
 136                 }
 137         }
 138         acpi_os_printf("\"");
 139
 140         if (i == max_length && string[i]) {
 141                 acpi_os_printf("...");
 142         }
 143 }
 144
 145 /*******************************************************************************
 146  *
 147  * FUNCTION:    acpi_ut_valid_acpi_char
 148  *
 149  * PARAMETERS:  char            - The character to be examined
 150  *              position        - Byte position (0-3)
 151  *
 152  * RETURN:      TRUE if the character is valid, FALSE otherwise
 153  *
 154  * DESCRIPTION: Check for a valid ACPI character. Must be one of:
 155  *              1) Upper case alpha
 156  *              2) numeric
 157  *              3) underscore
 158  *
 159  *              We allow a '!' as the last character because of the ASF! table
 160  *
 161  ******************************************************************************/
 162
 163 u8 acpi_ut_valid_acpi_char(char character, u32 position)
 164 {
 165
 166         if (!((character >= 'A' && character <= 'Z') ||
 167               (character >= '0' && character <= '9') || (character == '_'))) {
 168
 169                 /* Allow a '!' in the last position */
 170
 171                 if (character == '!' && position == 3) {
 172                         return (TRUE);
 173                 }
 174
 175                 return (FALSE);
 176         }
 177
 178         return (TRUE);
 179 }
 180
 181 /*******************************************************************************
 182  *
 183  * FUNCTION:    acpi_ut_valid_acpi_name
 184  *
 185  * PARAMETERS:  name            - The name to be examined. Does not have to
 186  *                                be NULL terminated string.
 187  *
 188  * RETURN:      TRUE if the name is valid, FALSE otherwise
 189  *
 190  * DESCRIPTION: Check for a valid ACPI name. Each character must be one of:
 191  *              1) Upper case alpha
 192  *              2) numeric
 193  *              3) underscore
 194  *
 195  ******************************************************************************/
 196
 197 u8 acpi_ut_valid_acpi_name(char *name)
 198 {
 199         u32 i;
 200
 201         ACPI_FUNCTION_ENTRY();
 202
 203         for (i = 0; i < ACPI_NAME_SIZE; i++) {
 204                 if (!acpi_ut_valid_acpi_char(name[i], i)) {
 205                         return (FALSE);
 206                 }
 207         }
 208
 209         return (TRUE);
 210 }
 211
 212 /*******************************************************************************
 213  *
 214  * FUNCTION:    acpi_ut_repair_name
 215  *
 216  * PARAMETERS:  name            - The ACPI name to be repaired
 217  *
 218  * RETURN:      Repaired version of the name
 219  *
 220  * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and
 221  *              return the new name. NOTE: the Name parameter must reside in
 222  *              read/write memory, cannot be a const.
 223  *
 224  * An ACPI Name must consist of valid ACPI characters. We will repair the name
 225  * if necessary because we don't want to abort because of this, but we want
 226  * all namespace names to be printable. A warning message is appropriate.
 227  *
 228  * This issue came up because there are in fact machines that exhibit
 229  * this problem, and we want to be able to enable ACPI support for them,
 230  * even though there are a few bad names.
 231  *
 232  ******************************************************************************/
 233
 234 void acpi_ut_repair_name(char *name)
 235 {
 236         u32 i;
 237         u8 found_bad_char = FALSE;
 238         u32 original_name;
 239
 240         ACPI_FUNCTION_NAME(ut_repair_name);
 241
 242         ACPI_MOVE_NAME(&original_name, name);
 243
 244         /* Check each character in the name */
 245
 246         for (i = 0; i < ACPI_NAME_SIZE; i++) {
 247                 if (acpi_ut_valid_acpi_char(name[i], i)) {
 248                         continue;
 249                 }
 250
 251                 /*
 252                  * Replace a bad character with something printable, yet technically
 253                  * still invalid. This prevents any collisions with existing "good"
 254                  * names in the namespace.
 255                  */
 256                 name[i] = '*';
 257                 found_bad_char = TRUE;
 258         }
 259
 260         if (found_bad_char) {
 261
 262                 /* Report warning only if in strict mode or debug mode */
 263
 264                 if (!acpi_gbl_enable_interpreter_slack) {
 265                         ACPI_WARNING((AE_INFO,
 266                                       "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]",
 267                                       original_name, name));
 268                 } else {
 269                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 270                                           "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]",
 271                                           original_name, name));
 272                 }
 273         }
 274 }
 275
 276 #if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP
 277 /*******************************************************************************
 278  *
 279  * FUNCTION:    ut_convert_backslashes
 280  *
 281  * PARAMETERS:  pathname        - File pathname string to be converted
 282  *
 283  * RETURN:      Modifies the input Pathname
 284  *
 285  * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within
 286  *              the entire input file pathname string.
 287  *
 288  ******************************************************************************/
 289
 290 void ut_convert_backslashes(char *pathname)
 291 {
 292
 293         if (!pathname) {
 294                 return;
 295         }
 296
 297         while (*pathname) {
 298                 if (*pathname == '\\') {
 299                         *pathname = '/';
 300                 }
 301
 302                 pathname++;
 303         }
 304 }
 305 #endif