2 * Helpers for formatting and printing strings
4 * Copyright 31 August 2008 James Bottomley
5 * Copyright (C) 2013, Intel Corporation
7 #include <linux/kernel.h>
8 #include <linux/math64.h>
9 #include <linux/export.h>
10 #include <linux/ctype.h>
11 #include <linux/errno.h>
12 #include <linux/string.h>
13 #include <linux/string_helpers.h>
16 * string_get_size - get the size in the specified units
17 * @size: The size to be converted
18 * @units: units to use (powers of 1000 or 1024)
19 * @buf: buffer to format to
20 * @len: length of buffer
22 * This function returns a string formatted to 3 significant figures
23 * giving the size in the required units. Returns 0 on success or
24 * error on failure. @buf is always zero terminated.
27 int string_get_size(u64 size, const enum string_size_units units,
30 static const char *const units_10[] = {
31 "B", "kB", "MB", "GB", "TB", "PB", "EB"
33 static const char *const units_2[] = {
34 "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
36 static const char *const *const units_str[] = {
37 [STRING_UNITS_10] = units_10,
38 [STRING_UNITS_2] = units_2,
40 static const unsigned int divisor[] = {
41 [STRING_UNITS_10] = 1000,
42 [STRING_UNITS_2] = 1024,
45 u64 remainder = 0, sf_cap;
50 if (size >= divisor[units]) {
51 while (size >= divisor[units]) {
52 remainder = do_div(size, divisor[units]);
57 for (j = 0; sf_cap*10 < 1000; j++)
62 do_div(remainder, divisor[units]);
63 snprintf(tmp, sizeof(tmp), ".%03lld",
64 (unsigned long long)remainder);
69 snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
70 tmp, units_str[units][i]);
74 EXPORT_SYMBOL(string_get_size);
76 static bool unescape_space(char **src, char **dst)
78 char *p = *dst, *q = *src;
104 static bool unescape_octal(char **src, char **dst)
106 char *p = *dst, *q = *src;
109 if (isodigit(*q) == 0)
113 while (num < 32 && isodigit(*q) && (q - *src < 3)) {
123 static bool unescape_hex(char **src, char **dst)
125 char *p = *dst, *q = *src;
132 num = digit = hex_to_bin(*q++);
136 digit = hex_to_bin(*q);
139 num = (num << 4) | digit;
147 static bool unescape_special(char **src, char **dst)
149 char *p = *dst, *q = *src;
173 * string_unescape - unquote characters in the given string
174 * @src: source buffer (escaped)
175 * @dst: destination buffer (unescaped)
176 * @size: size of the destination buffer (0 to unlimit)
177 * @flags: combination of the flags (bitwise OR):
181 * '\r' - carriage return
182 * '\t' - horizontal tab
183 * '\v' - vertical tab
185 * '\NNN' - byte with octal value NNN (1 to 3 digits)
187 * '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
189 * '\"' - double quote
194 * all previous together
197 * The function unquotes characters in the given string.
199 * Because the size of the output will be the same as or less than the size of
200 * the input, the transformation may be performed in place.
202 * Caller must provide valid source and destination pointers. Be aware that
203 * destination buffer will always be NULL-terminated. Source string must be
204 * NULL-terminated as well.
207 * The amount of the characters processed to the destination buffer excluding
208 * trailing '\0' is returned.
210 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
214 while (*src && --size) {
215 if (src[0] == '\\' && src[1] != '\0' && size > 1) {
219 if (flags & UNESCAPE_SPACE &&
220 unescape_space(&src, &out))
223 if (flags & UNESCAPE_OCTAL &&
224 unescape_octal(&src, &out))
227 if (flags & UNESCAPE_HEX &&
228 unescape_hex(&src, &out))
231 if (flags & UNESCAPE_SPECIAL &&
232 unescape_special(&src, &out))
243 EXPORT_SYMBOL(string_unescape);
245 static int escape_passthrough(unsigned char c, char **dst, size_t *osz)
260 static int escape_space(unsigned char c, char **dst, size_t *osz)
297 static int escape_special(unsigned char c, char **dst, size_t *osz)
328 static int escape_null(unsigned char c, char **dst, size_t *osz)
347 static int escape_octal(unsigned char c, char **dst, size_t *osz)
355 *out++ = ((c >> 6) & 0x07) + '0';
356 *out++ = ((c >> 3) & 0x07) + '0';
357 *out++ = ((c >> 0) & 0x07) + '0';
365 static int escape_hex(unsigned char c, char **dst, size_t *osz)
374 *out++ = hex_asc_hi(c);
375 *out++ = hex_asc_lo(c);
384 * string_escape_mem - quote characters in the given memory buffer
385 * @src: source buffer (unescaped)
386 * @isz: source buffer size
387 * @dst: destination buffer (escaped)
388 * @osz: destination buffer size
389 * @flags: combination of the flags (bitwise OR):
393 * '\r' - carriage return
394 * '\t' - horizontal tab
395 * '\v' - vertical tab
403 * '\NNN' - byte with octal value NNN (3 digits)
405 * all previous together
407 * escape only non-printable characters (checked by isprint)
409 * all previous together
411 * '\xHH' - byte with hexadecimal value HH (2 digits)
412 * @esc: NULL-terminated string of characters any of which, if found in
413 * the source, has to be escaped
416 * The process of escaping byte buffer includes several parts. They are applied
417 * in the following sequence.
418 * 1. The character is matched to the printable class, if asked, and in
419 * case of match it passes through to the output.
420 * 2. The character is not matched to the one from @esc string and thus
421 * must go as is to the output.
422 * 3. The character is checked if it falls into the class given by @flags.
423 * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
424 * character. Note that they actually can't go together, otherwise
425 * %ESCAPE_HEX will be ignored.
427 * Caller must provide valid source and destination pointers. Be aware that
428 * destination buffer will not be NULL-terminated, thus caller have to append
432 * The amount of the characters processed to the destination buffer, or
433 * %-ENOMEM if the size of buffer is not enough to put an escaped character is
436 * Even in the case of error @dst pointer will be updated to point to the byte
437 * after the last processed character.
439 int string_escape_mem(const char *src, size_t isz, char **dst, size_t osz,
440 unsigned int flags, const char *esc)
442 char *out = *dst, *p = out;
443 bool is_dict = esc && *esc;
447 unsigned char c = *src++;
450 * Apply rules in the following sequence:
451 * - the character is printable, when @flags has
453 * - the @esc string is supplied and does not contain a
454 * character under question
455 * - the character doesn't fall into a class of symbols
456 * defined by given @flags
457 * In these cases we just pass through a character to the
460 if ((flags & ESCAPE_NP && isprint(c)) ||
461 (is_dict && !strchr(esc, c))) {
464 if (flags & ESCAPE_SPACE) {
465 ret = escape_space(c, &p, &osz);
472 if (flags & ESCAPE_SPECIAL) {
473 ret = escape_special(c, &p, &osz);
480 if (flags & ESCAPE_NULL) {
481 ret = escape_null(c, &p, &osz);
488 /* ESCAPE_OCTAL and ESCAPE_HEX always go last */
489 if (flags & ESCAPE_OCTAL) {
490 ret = escape_octal(c, &p, &osz);
495 if (flags & ESCAPE_HEX) {
496 ret = escape_hex(c, &p, &osz);
503 ret = escape_passthrough(c, &p, &osz);
515 EXPORT_SYMBOL(string_escape_mem);