blob: 5939f63d90cde79fe1e09814765539a7e43a3c28 [file] [log] [blame]
James Bottomley3c9f3682008-08-31 10:13:54 -05001/*
2 * Helpers for formatting and printing strings
3 *
4 * Copyright 31 August 2008 James Bottomley
Andy Shevchenko16c7fa02013-04-30 15:27:30 -07005 * Copyright (C) 2013, Intel Corporation
James Bottomley3c9f3682008-08-31 10:13:54 -05006 */
James Bottomleyb9f28d82015-03-05 18:47:01 -08007#include <linux/bug.h>
James Bottomley3c9f3682008-08-31 10:13:54 -05008#include <linux/kernel.h>
9#include <linux/math64.h>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050010#include <linux/export.h>
Andy Shevchenko16c7fa02013-04-30 15:27:30 -070011#include <linux/ctype.h>
Andy Shevchenkoc8250382014-10-13 15:55:16 -070012#include <linux/errno.h>
13#include <linux/string.h>
James Bottomley3c9f3682008-08-31 10:13:54 -050014#include <linux/string_helpers.h>
15
16/**
17 * string_get_size - get the size in the specified units
James Bottomleyb9f28d82015-03-05 18:47:01 -080018 * @size: The size to be converted in blocks
19 * @blk_size: Size of the block (use 1 for size in bytes)
James Bottomley3c9f3682008-08-31 10:13:54 -050020 * @units: units to use (powers of 1000 or 1024)
21 * @buf: buffer to format to
22 * @len: length of buffer
23 *
24 * This function returns a string formatted to 3 significant figures
Rasmus Villemoesd1214c62015-02-12 15:01:50 -080025 * giving the size in the required units. @buf should have room for
26 * at least 9 bytes and will always be zero terminated.
James Bottomley3c9f3682008-08-31 10:13:54 -050027 *
28 */
James Bottomleyb9f28d82015-03-05 18:47:01 -080029void string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
Rasmus Villemoesd1214c62015-02-12 15:01:50 -080030 char *buf, int len)
James Bottomley3c9f3682008-08-31 10:13:54 -050031{
Mathias Krause142cda52014-08-06 16:09:31 -070032 static const char *const units_10[] = {
James Bottomleyb9f28d82015-03-05 18:47:01 -080033 "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
Mathias Krause142cda52014-08-06 16:09:31 -070034 };
35 static const char *const units_2[] = {
James Bottomleyb9f28d82015-03-05 18:47:01 -080036 "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"
Mathias Krause142cda52014-08-06 16:09:31 -070037 };
38 static const char *const *const units_str[] = {
39 [STRING_UNITS_10] = units_10,
James Bottomley3c9f3682008-08-31 10:13:54 -050040 [STRING_UNITS_2] = units_2,
41 };
Andrew Morton68aecfb2012-05-29 15:07:32 -070042 static const unsigned int divisor[] = {
James Bottomley3c9f3682008-08-31 10:13:54 -050043 [STRING_UNITS_10] = 1000,
44 [STRING_UNITS_2] = 1024,
45 };
46 int i, j;
James Bottomleyb9f28d82015-03-05 18:47:01 -080047 u32 remainder = 0, sf_cap, exp;
James Bottomley3c9f3682008-08-31 10:13:54 -050048 char tmp[8];
James Bottomleyb9f28d82015-03-05 18:47:01 -080049 const char *unit;
James Bottomley3c9f3682008-08-31 10:13:54 -050050
51 tmp[0] = '\0';
H. Peter Anvina8659592008-10-14 11:34:21 -070052 i = 0;
James Bottomleyb9f28d82015-03-05 18:47:01 -080053 if (!size)
54 goto out;
James Bottomley3c9f3682008-08-31 10:13:54 -050055
James Bottomleyb9f28d82015-03-05 18:47:01 -080056 while (blk_size >= divisor[units]) {
57 remainder = do_div(blk_size, divisor[units]);
58 i++;
James Bottomley3c9f3682008-08-31 10:13:54 -050059 }
60
James Bottomleyb9f28d82015-03-05 18:47:01 -080061 exp = divisor[units] / (u32)blk_size;
Vitaly Kuznetsov62bef582015-09-17 16:01:51 -070062 /*
63 * size must be strictly greater than exp here to ensure that remainder
64 * is greater than divisor[units] coming out of the if below.
65 */
66 if (size > exp) {
James Bottomleyb9f28d82015-03-05 18:47:01 -080067 remainder = do_div(size, divisor[units]);
68 remainder *= blk_size;
69 i++;
70 } else {
71 remainder *= size;
72 }
73
74 size *= blk_size;
75 size += remainder / divisor[units];
76 remainder %= divisor[units];
77
78 while (size >= divisor[units]) {
79 remainder = do_div(size, divisor[units]);
80 i++;
81 }
82
83 sf_cap = size;
84 for (j = 0; sf_cap*10 < 1000; j++)
85 sf_cap *= 10;
86
87 if (j) {
88 remainder *= 1000;
89 remainder /= divisor[units];
90 snprintf(tmp, sizeof(tmp), ".%03u", remainder);
91 tmp[j+1] = '\0';
92 }
93
94 out:
95 if (i >= ARRAY_SIZE(units_2))
96 unit = "UNK";
97 else
98 unit = units_str[units][i];
99
Rasmus Villemoes84b9fbe2015-02-12 15:01:48 -0800100 snprintf(buf, len, "%u%s %s", (u32)size,
James Bottomleyb9f28d82015-03-05 18:47:01 -0800101 tmp, unit);
James Bottomley3c9f3682008-08-31 10:13:54 -0500102}
103EXPORT_SYMBOL(string_get_size);
Andy Shevchenko16c7fa02013-04-30 15:27:30 -0700104
105static bool unescape_space(char **src, char **dst)
106{
107 char *p = *dst, *q = *src;
108
109 switch (*q) {
110 case 'n':
111 *p = '\n';
112 break;
113 case 'r':
114 *p = '\r';
115 break;
116 case 't':
117 *p = '\t';
118 break;
119 case 'v':
120 *p = '\v';
121 break;
122 case 'f':
123 *p = '\f';
124 break;
125 default:
126 return false;
127 }
128 *dst += 1;
129 *src += 1;
130 return true;
131}
132
133static bool unescape_octal(char **src, char **dst)
134{
135 char *p = *dst, *q = *src;
136 u8 num;
137
138 if (isodigit(*q) == 0)
139 return false;
140
141 num = (*q++) & 7;
142 while (num < 32 && isodigit(*q) && (q - *src < 3)) {
143 num <<= 3;
144 num += (*q++) & 7;
145 }
146 *p = num;
147 *dst += 1;
148 *src = q;
149 return true;
150}
151
152static bool unescape_hex(char **src, char **dst)
153{
154 char *p = *dst, *q = *src;
155 int digit;
156 u8 num;
157
158 if (*q++ != 'x')
159 return false;
160
161 num = digit = hex_to_bin(*q++);
162 if (digit < 0)
163 return false;
164
165 digit = hex_to_bin(*q);
166 if (digit >= 0) {
167 q++;
168 num = (num << 4) | digit;
169 }
170 *p = num;
171 *dst += 1;
172 *src = q;
173 return true;
174}
175
176static bool unescape_special(char **src, char **dst)
177{
178 char *p = *dst, *q = *src;
179
180 switch (*q) {
181 case '\"':
182 *p = '\"';
183 break;
184 case '\\':
185 *p = '\\';
186 break;
187 case 'a':
188 *p = '\a';
189 break;
190 case 'e':
191 *p = '\e';
192 break;
193 default:
194 return false;
195 }
196 *dst += 1;
197 *src += 1;
198 return true;
199}
200
Andy Shevchenkod2956342014-10-13 15:55:11 -0700201/**
202 * string_unescape - unquote characters in the given string
203 * @src: source buffer (escaped)
204 * @dst: destination buffer (unescaped)
205 * @size: size of the destination buffer (0 to unlimit)
206 * @flags: combination of the flags (bitwise OR):
207 * %UNESCAPE_SPACE:
208 * '\f' - form feed
209 * '\n' - new line
210 * '\r' - carriage return
211 * '\t' - horizontal tab
212 * '\v' - vertical tab
213 * %UNESCAPE_OCTAL:
214 * '\NNN' - byte with octal value NNN (1 to 3 digits)
215 * %UNESCAPE_HEX:
216 * '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
217 * %UNESCAPE_SPECIAL:
218 * '\"' - double quote
219 * '\\' - backslash
220 * '\a' - alert (BEL)
221 * '\e' - escape
222 * %UNESCAPE_ANY:
223 * all previous together
224 *
225 * Description:
226 * The function unquotes characters in the given string.
227 *
228 * Because the size of the output will be the same as or less than the size of
229 * the input, the transformation may be performed in place.
230 *
231 * Caller must provide valid source and destination pointers. Be aware that
232 * destination buffer will always be NULL-terminated. Source string must be
233 * NULL-terminated as well.
234 *
235 * Return:
236 * The amount of the characters processed to the destination buffer excluding
237 * trailing '\0' is returned.
238 */
Andy Shevchenko16c7fa02013-04-30 15:27:30 -0700239int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
240{
241 char *out = dst;
242
243 while (*src && --size) {
244 if (src[0] == '\\' && src[1] != '\0' && size > 1) {
245 src++;
246 size--;
247
248 if (flags & UNESCAPE_SPACE &&
249 unescape_space(&src, &out))
250 continue;
251
252 if (flags & UNESCAPE_OCTAL &&
253 unescape_octal(&src, &out))
254 continue;
255
256 if (flags & UNESCAPE_HEX &&
257 unescape_hex(&src, &out))
258 continue;
259
260 if (flags & UNESCAPE_SPECIAL &&
261 unescape_special(&src, &out))
262 continue;
263
264 *out++ = '\\';
265 }
266 *out++ = *src++;
267 }
268 *out = '\0';
269
270 return out - dst;
271}
272EXPORT_SYMBOL(string_unescape);
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700273
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700274static bool escape_passthrough(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700275{
276 char *out = *dst;
277
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700278 if (out < end)
279 *out = c;
280 *dst = out + 1;
281 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700282}
283
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700284static bool escape_space(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700285{
286 char *out = *dst;
287 unsigned char to;
288
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700289 switch (c) {
290 case '\n':
291 to = 'n';
292 break;
293 case '\r':
294 to = 'r';
295 break;
296 case '\t':
297 to = 't';
298 break;
299 case '\v':
300 to = 'v';
301 break;
302 case '\f':
303 to = 'f';
304 break;
305 default:
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700306 return false;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700307 }
308
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700309 if (out < end)
310 *out = '\\';
311 ++out;
312 if (out < end)
313 *out = to;
314 ++out;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700315
316 *dst = out;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700317 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700318}
319
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700320static bool escape_special(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700321{
322 char *out = *dst;
323 unsigned char to;
324
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700325 switch (c) {
326 case '\\':
327 to = '\\';
328 break;
329 case '\a':
330 to = 'a';
331 break;
332 case '\e':
333 to = 'e';
334 break;
335 default:
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700336 return false;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700337 }
338
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700339 if (out < end)
340 *out = '\\';
341 ++out;
342 if (out < end)
343 *out = to;
344 ++out;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700345
346 *dst = out;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700347 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700348}
349
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700350static bool escape_null(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700351{
352 char *out = *dst;
353
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700354 if (c)
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700355 return false;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700356
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700357 if (out < end)
358 *out = '\\';
359 ++out;
360 if (out < end)
361 *out = '0';
362 ++out;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700363
364 *dst = out;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700365 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700366}
367
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700368static bool escape_octal(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700369{
370 char *out = *dst;
371
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700372 if (out < end)
373 *out = '\\';
374 ++out;
375 if (out < end)
376 *out = ((c >> 6) & 0x07) + '0';
377 ++out;
378 if (out < end)
379 *out = ((c >> 3) & 0x07) + '0';
380 ++out;
381 if (out < end)
382 *out = ((c >> 0) & 0x07) + '0';
383 ++out;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700384
385 *dst = out;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700386 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700387}
388
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700389static bool escape_hex(unsigned char c, char **dst, char *end)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700390{
391 char *out = *dst;
392
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700393 if (out < end)
394 *out = '\\';
395 ++out;
396 if (out < end)
397 *out = 'x';
398 ++out;
399 if (out < end)
400 *out = hex_asc_hi(c);
401 ++out;
402 if (out < end)
403 *out = hex_asc_lo(c);
404 ++out;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700405
406 *dst = out;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700407 return true;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700408}
409
410/**
411 * string_escape_mem - quote characters in the given memory buffer
412 * @src: source buffer (unescaped)
413 * @isz: source buffer size
414 * @dst: destination buffer (escaped)
415 * @osz: destination buffer size
416 * @flags: combination of the flags (bitwise OR):
Kees Cookd89a3f72015-09-09 15:37:14 -0700417 * %ESCAPE_SPACE: (special white space, not space itself)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700418 * '\f' - form feed
419 * '\n' - new line
420 * '\r' - carriage return
421 * '\t' - horizontal tab
422 * '\v' - vertical tab
423 * %ESCAPE_SPECIAL:
424 * '\\' - backslash
425 * '\a' - alert (BEL)
426 * '\e' - escape
427 * %ESCAPE_NULL:
428 * '\0' - null
429 * %ESCAPE_OCTAL:
430 * '\NNN' - byte with octal value NNN (3 digits)
431 * %ESCAPE_ANY:
432 * all previous together
433 * %ESCAPE_NP:
434 * escape only non-printable characters (checked by isprint)
435 * %ESCAPE_ANY_NP:
436 * all previous together
437 * %ESCAPE_HEX:
438 * '\xHH' - byte with hexadecimal value HH (2 digits)
Kees Cookb40bdb72015-09-09 15:37:16 -0700439 * @only: NULL-terminated string containing characters used to limit
440 * the selected escape class. If characters are included in @only
Kees Cookd89a3f72015-09-09 15:37:14 -0700441 * that would not normally be escaped by the classes selected
442 * in @flags, they will be copied to @dst unescaped.
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700443 *
444 * Description:
445 * The process of escaping byte buffer includes several parts. They are applied
446 * in the following sequence.
447 * 1. The character is matched to the printable class, if asked, and in
448 * case of match it passes through to the output.
Kees Cookb40bdb72015-09-09 15:37:16 -0700449 * 2. The character is not matched to the one from @only string and thus
Kees Cookd89a3f72015-09-09 15:37:14 -0700450 * must go as-is to the output.
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700451 * 3. The character is checked if it falls into the class given by @flags.
452 * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
453 * character. Note that they actually can't go together, otherwise
454 * %ESCAPE_HEX will be ignored.
455 *
456 * Caller must provide valid source and destination pointers. Be aware that
457 * destination buffer will not be NULL-terminated, thus caller have to append
458 * it if needs.
459 *
460 * Return:
Rasmus Villemoes41416f22015-04-15 16:17:28 -0700461 * The total size of the escaped output that would be generated for
462 * the given input and flags. To check whether the output was
463 * truncated, compare the return value to osz. There is room left in
464 * dst for a '\0' terminator if and only if ret < osz.
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700465 */
Rasmus Villemoes41416f22015-04-15 16:17:28 -0700466int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
Kees Cookb40bdb72015-09-09 15:37:16 -0700467 unsigned int flags, const char *only)
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700468{
Rasmus Villemoes41416f22015-04-15 16:17:28 -0700469 char *p = dst;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700470 char *end = p + osz;
Kees Cookb40bdb72015-09-09 15:37:16 -0700471 bool is_dict = only && *only;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700472
473 while (isz--) {
474 unsigned char c = *src++;
475
476 /*
477 * Apply rules in the following sequence:
478 * - the character is printable, when @flags has
479 * %ESCAPE_NP bit set
Kees Cookb40bdb72015-09-09 15:37:16 -0700480 * - the @only string is supplied and does not contain a
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700481 * character under question
482 * - the character doesn't fall into a class of symbols
483 * defined by given @flags
484 * In these cases we just pass through a character to the
485 * output buffer.
486 */
487 if ((flags & ESCAPE_NP && isprint(c)) ||
Kees Cookb40bdb72015-09-09 15:37:16 -0700488 (is_dict && !strchr(only, c))) {
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700489 /* do nothing */
490 } else {
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700491 if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
492 continue;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700493
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700494 if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
495 continue;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700496
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700497 if (flags & ESCAPE_NULL && escape_null(c, &p, end))
498 continue;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700499
500 /* ESCAPE_OCTAL and ESCAPE_HEX always go last */
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700501 if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700502 continue;
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700503
504 if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700505 continue;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700506 }
507
Rasmus Villemoes3aeddc72015-04-15 16:17:25 -0700508 escape_passthrough(c, &p, end);
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700509 }
510
Rasmus Villemoes41416f22015-04-15 16:17:28 -0700511 return p - dst;
Andy Shevchenkoc8250382014-10-13 15:55:16 -0700512}
513EXPORT_SYMBOL(string_escape_mem);