xref: /openbmc/linux/drivers/acpi/acpica/utnonansi.c (revision 0edbfea5)
1 /*******************************************************************************
2  *
3  * Module Name: utnonansi - Non-ansi C library functions
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 
47 #define _COMPONENT          ACPI_UTILITIES
48 ACPI_MODULE_NAME("utnonansi")
49 
50 /*
51  * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit
52  * version of strtoul.
53  */
54 /*******************************************************************************
55  *
56  * FUNCTION:    acpi_ut_strlwr (strlwr)
57  *
58  * PARAMETERS:  src_string      - The source string to convert
59  *
60  * RETURN:      None
61  *
62  * DESCRIPTION: Convert a string to lowercase
63  *
64  ******************************************************************************/
65 void acpi_ut_strlwr(char *src_string)
66 {
67 	char *string;
68 
69 	ACPI_FUNCTION_ENTRY();
70 
71 	if (!src_string) {
72 		return;
73 	}
74 
75 	/* Walk entire string, lowercasing the letters */
76 
77 	for (string = src_string; *string; string++) {
78 		*string = (char)tolower((int)*string);
79 	}
80 }
81 
82 /*******************************************************************************
83  *
84  * FUNCTION:    acpi_ut_strupr (strupr)
85  *
86  * PARAMETERS:  src_string      - The source string to convert
87  *
88  * RETURN:      None
89  *
90  * DESCRIPTION: Convert a string to uppercase
91  *
92  ******************************************************************************/
93 
94 void acpi_ut_strupr(char *src_string)
95 {
96 	char *string;
97 
98 	ACPI_FUNCTION_ENTRY();
99 
100 	if (!src_string) {
101 		return;
102 	}
103 
104 	/* Walk entire string, uppercasing the letters */
105 
106 	for (string = src_string; *string; string++) {
107 		*string = (char)toupper((int)*string);
108 	}
109 }
110 
111 /******************************************************************************
112  *
113  * FUNCTION:    acpi_ut_stricmp (stricmp)
114  *
115  * PARAMETERS:  string1             - first string to compare
116  *              string2             - second string to compare
117  *
118  * RETURN:      int that signifies string relationship. Zero means strings
119  *              are equal.
120  *
121  * DESCRIPTION: Case-insensitive string compare. Implementation of the
122  *              non-ANSI stricmp function.
123  *
124  ******************************************************************************/
125 
126 int acpi_ut_stricmp(char *string1, char *string2)
127 {
128 	int c1;
129 	int c2;
130 
131 	do {
132 		c1 = tolower((int)*string1);
133 		c2 = tolower((int)*string2);
134 
135 		string1++;
136 		string2++;
137 	}
138 	while ((c1 == c2) && (c1));
139 
140 	return (c1 - c2);
141 }
142 
143 #if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
144 /*******************************************************************************
145  *
146  * FUNCTION:    acpi_ut_safe_strcpy, acpi_ut_safe_strcat, acpi_ut_safe_strncat
147  *
148  * PARAMETERS:  Adds a "DestSize" parameter to each of the standard string
149  *              functions. This is the size of the Destination buffer.
150  *
151  * RETURN:      TRUE if the operation would overflow the destination buffer.
152  *
153  * DESCRIPTION: Safe versions of standard Clib string functions. Ensure that
154  *              the result of the operation will not overflow the output string
155  *              buffer.
156  *
157  * NOTE:        These functions are typically only helpful for processing
158  *              user input and command lines. For most ACPICA code, the
159  *              required buffer length is precisely calculated before buffer
160  *              allocation, so the use of these functions is unnecessary.
161  *
162  ******************************************************************************/
163 
164 u8 acpi_ut_safe_strcpy(char *dest, acpi_size dest_size, char *source)
165 {
166 
167 	if (strlen(source) >= dest_size) {
168 		return (TRUE);
169 	}
170 
171 	strcpy(dest, source);
172 	return (FALSE);
173 }
174 
175 u8 acpi_ut_safe_strcat(char *dest, acpi_size dest_size, char *source)
176 {
177 
178 	if ((strlen(dest) + strlen(source)) >= dest_size) {
179 		return (TRUE);
180 	}
181 
182 	strcat(dest, source);
183 	return (FALSE);
184 }
185 
186 u8
187 acpi_ut_safe_strncat(char *dest,
188 		     acpi_size dest_size,
189 		     char *source, acpi_size max_transfer_length)
190 {
191 	acpi_size actual_transfer_length;
192 
193 	actual_transfer_length = ACPI_MIN(max_transfer_length, strlen(source));
194 
195 	if ((strlen(dest) + actual_transfer_length) >= dest_size) {
196 		return (TRUE);
197 	}
198 
199 	strncat(dest, source, max_transfer_length);
200 	return (FALSE);
201 }
202 #endif
203 
204 /*******************************************************************************
205  *
206  * FUNCTION:    acpi_ut_strtoul64
207  *
208  * PARAMETERS:  string                  - Null terminated string
209  *              base                    - Radix of the string: 16 or 10 or
210  *                                        ACPI_ANY_BASE
211  *              max_integer_byte_width  - Maximum allowable integer,in bytes:
212  *                                        4 or 8 (32 or 64 bits)
213  *              ret_integer             - Where the converted integer is
214  *                                        returned
215  *
216  * RETURN:      Status and Converted value
217  *
218  * DESCRIPTION: Convert a string into an unsigned value. Performs either a
219  *              32-bit or 64-bit conversion, depending on the input integer
220  *              size (often the current mode of the interpreter).
221  *
222  * NOTES:       Negative numbers are not supported, as they are not supported
223  *              by ACPI.
224  *
225  *              acpi_gbl_integer_byte_width should be set to the proper width.
226  *              For the core ACPICA code, this width depends on the DSDT
227  *              version. For iASL, the default byte width is always 8 for the
228  *              parser, but error checking is performed later to flag cases
229  *              where a 64-bit constant is defined in a 32-bit DSDT/SSDT.
230  *
231  *              Does not support Octal strings, not needed at this time.
232  *
233  ******************************************************************************/
234 
235 acpi_status
236 acpi_ut_strtoul64(char *string,
237 		  u32 base, u32 max_integer_byte_width, u64 *ret_integer)
238 {
239 	u32 this_digit = 0;
240 	u64 return_value = 0;
241 	u64 quotient;
242 	u64 dividend;
243 	u8 valid_digits = 0;
244 	u8 sign_of0x = 0;
245 	u8 term = 0;
246 
247 	ACPI_FUNCTION_TRACE_STR(ut_strtoul64, string);
248 
249 	switch (base) {
250 	case ACPI_ANY_BASE:
251 	case 10:
252 	case 16:
253 
254 		break;
255 
256 	default:
257 
258 		/* Invalid Base */
259 
260 		return_ACPI_STATUS(AE_BAD_PARAMETER);
261 	}
262 
263 	if (!string) {
264 		goto error_exit;
265 	}
266 
267 	/* Skip over any white space in the buffer */
268 
269 	while ((*string) && (isspace((int)*string) || *string == '\t')) {
270 		string++;
271 	}
272 
273 	if (base == ACPI_ANY_BASE) {
274 		/*
275 		 * Base equal to ACPI_ANY_BASE means 'Either decimal or hex'.
276 		 * We need to determine if it is decimal or hexadecimal.
277 		 */
278 		if ((*string == '0') && (tolower((int)*(string + 1)) == 'x')) {
279 			sign_of0x = 1;
280 			base = 16;
281 
282 			/* Skip over the leading '0x' */
283 			string += 2;
284 		} else {
285 			base = 10;
286 		}
287 	}
288 
289 	/* Any string left? Check that '0x' is not followed by white space. */
290 
291 	if (!(*string) || isspace((int)*string) || *string == '\t') {
292 		if (base == ACPI_ANY_BASE) {
293 			goto error_exit;
294 		} else {
295 			goto all_done;
296 		}
297 	}
298 
299 	/*
300 	 * Perform a 32-bit or 64-bit conversion, depending upon the input
301 	 * byte width
302 	 */
303 	dividend = (max_integer_byte_width <= ACPI_MAX32_BYTE_WIDTH) ?
304 	    ACPI_UINT32_MAX : ACPI_UINT64_MAX;
305 
306 	/* Main loop: convert the string to a 32- or 64-bit integer */
307 
308 	while (*string) {
309 		if (isdigit((int)*string)) {
310 
311 			/* Convert ASCII 0-9 to Decimal value */
312 
313 			this_digit = ((u8)*string) - '0';
314 		} else if (base == 10) {
315 
316 			/* Digit is out of range; possible in to_integer case only */
317 
318 			term = 1;
319 		} else {
320 			this_digit = (u8)toupper((int)*string);
321 			if (isxdigit((int)this_digit)) {
322 
323 				/* Convert ASCII Hex char to value */
324 
325 				this_digit = this_digit - 'A' + 10;
326 			} else {
327 				term = 1;
328 			}
329 		}
330 
331 		if (term) {
332 			if (base == ACPI_ANY_BASE) {
333 				goto error_exit;
334 			} else {
335 				break;
336 			}
337 		} else if ((valid_digits == 0) && (this_digit == 0)
338 			   && !sign_of0x) {
339 
340 			/* Skip zeros */
341 			string++;
342 			continue;
343 		}
344 
345 		valid_digits++;
346 
347 		if (sign_of0x && ((valid_digits > 16) ||
348 				  ((valid_digits > 8)
349 				   && (max_integer_byte_width <=
350 				       ACPI_MAX32_BYTE_WIDTH)))) {
351 			/*
352 			 * This is to_integer operation case.
353 			 * No restrictions for string-to-integer conversion,
354 			 * see ACPI spec.
355 			 */
356 			goto error_exit;
357 		}
358 
359 		/* Divide the digit into the correct position */
360 
361 		(void)acpi_ut_short_divide((dividend - (u64)this_digit), base,
362 					   &quotient, NULL);
363 
364 		if (return_value > quotient) {
365 			if (base == ACPI_ANY_BASE) {
366 				goto error_exit;
367 			} else {
368 				break;
369 			}
370 		}
371 
372 		return_value *= base;
373 		return_value += this_digit;
374 		string++;
375 	}
376 
377 	/* All done, normal exit */
378 
379 all_done:
380 
381 	ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
382 			  ACPI_FORMAT_UINT64(return_value)));
383 
384 	*ret_integer = return_value;
385 	return_ACPI_STATUS(AE_OK);
386 
387 error_exit:
388 
389 	/* Base was set/validated above (10 or 16) */
390 
391 	if (base == 10) {
392 		return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT);
393 	} else {
394 		return_ACPI_STATUS(AE_BAD_HEX_CONSTANT);
395 	}
396 }
397 
398 #ifdef _OBSOLETE_FUNCTIONS
399 /* Removed: 01/2016 */
400 
401 /*******************************************************************************
402  *
403  * FUNCTION:    strtoul64
404  *
405  * PARAMETERS:  string              - Null terminated string
406  *              terminater          - Where a pointer to the terminating byte
407  *                                    is returned
408  *              base                - Radix of the string
409  *
410  * RETURN:      Converted value
411  *
412  * DESCRIPTION: Convert a string into an unsigned value.
413  *
414  ******************************************************************************/
415 
416 acpi_status strtoul64(char *string, u32 base, u64 *ret_integer)
417 {
418 	u32 index;
419 	u32 sign;
420 	u64 return_value = 0;
421 	acpi_status status = AE_OK;
422 
423 	*ret_integer = 0;
424 
425 	switch (base) {
426 	case 0:
427 	case 8:
428 	case 10:
429 	case 16:
430 
431 		break;
432 
433 	default:
434 		/*
435 		 * The specified Base parameter is not in the domain of
436 		 * this function:
437 		 */
438 		return (AE_BAD_PARAMETER);
439 	}
440 
441 	/* Skip over any white space in the buffer: */
442 
443 	while (isspace((int)*string) || *string == '\t') {
444 		++string;
445 	}
446 
447 	/*
448 	 * The buffer may contain an optional plus or minus sign.
449 	 * If it does, then skip over it but remember what is was:
450 	 */
451 	if (*string == '-') {
452 		sign = ACPI_SIGN_NEGATIVE;
453 		++string;
454 	} else if (*string == '+') {
455 		++string;
456 		sign = ACPI_SIGN_POSITIVE;
457 	} else {
458 		sign = ACPI_SIGN_POSITIVE;
459 	}
460 
461 	/*
462 	 * If the input parameter Base is zero, then we need to
463 	 * determine if it is octal, decimal, or hexadecimal:
464 	 */
465 	if (base == 0) {
466 		if (*string == '0') {
467 			if (tolower((int)*(++string)) == 'x') {
468 				base = 16;
469 				++string;
470 			} else {
471 				base = 8;
472 			}
473 		} else {
474 			base = 10;
475 		}
476 	}
477 
478 	/*
479 	 * For octal and hexadecimal bases, skip over the leading
480 	 * 0 or 0x, if they are present.
481 	 */
482 	if (base == 8 && *string == '0') {
483 		string++;
484 	}
485 
486 	if (base == 16 && *string == '0' && tolower((int)*(++string)) == 'x') {
487 		string++;
488 	}
489 
490 	/* Main loop: convert the string to an unsigned long */
491 
492 	while (*string) {
493 		if (isdigit((int)*string)) {
494 			index = ((u8)*string) - '0';
495 		} else {
496 			index = (u8)toupper((int)*string);
497 			if (isupper((int)index)) {
498 				index = index - 'A' + 10;
499 			} else {
500 				goto error_exit;
501 			}
502 		}
503 
504 		if (index >= base) {
505 			goto error_exit;
506 		}
507 
508 		/* Check to see if value is out of range: */
509 
510 		if (return_value > ((ACPI_UINT64_MAX - (u64)index) / (u64)base)) {
511 			goto error_exit;
512 		} else {
513 			return_value *= base;
514 			return_value += index;
515 		}
516 
517 		++string;
518 	}
519 
520 	/* If a minus sign was present, then "the conversion is negated": */
521 
522 	if (sign == ACPI_SIGN_NEGATIVE) {
523 		return_value = (ACPI_UINT32_MAX - return_value) + 1;
524 	}
525 
526 	*ret_integer = return_value;
527 	return (status);
528 
529 error_exit:
530 	switch (base) {
531 	case 8:
532 
533 		status = AE_BAD_OCTAL_CONSTANT;
534 		break;
535 
536 	case 10:
537 
538 		status = AE_BAD_DECIMAL_CONSTANT;
539 		break;
540 
541 	case 16:
542 
543 		status = AE_BAD_HEX_CONSTANT;
544 		break;
545 
546 	default:
547 
548 		/* Base validated above */
549 
550 		break;
551 	}
552 
553 	return (status);
554 }
555 #endif
556