1 /* 2 * Helpers for formatting and printing strings 3 * 4 * Copyright 31 August 2008 James Bottomley 5 * Copyright (C) 2013, Intel Corporation 6 */ 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> 14 15 /** 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 21 * 22 * This function returns a string formatted to 3 significant figures 23 * giving the size in the required units. @buf should have room for 24 * at least 9 bytes and will always be zero terminated. 25 * 26 */ 27 void string_get_size(u64 size, const enum string_size_units units, 28 char *buf, int len) 29 { 30 static const char *const units_10[] = { 31 "B", "kB", "MB", "GB", "TB", "PB", "EB" 32 }; 33 static const char *const units_2[] = { 34 "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB" 35 }; 36 static const char *const *const units_str[] = { 37 [STRING_UNITS_10] = units_10, 38 [STRING_UNITS_2] = units_2, 39 }; 40 static const unsigned int divisor[] = { 41 [STRING_UNITS_10] = 1000, 42 [STRING_UNITS_2] = 1024, 43 }; 44 int i, j; 45 u32 remainder = 0, sf_cap; 46 char tmp[8]; 47 48 tmp[0] = '\0'; 49 i = 0; 50 if (size >= divisor[units]) { 51 while (size >= divisor[units]) { 52 remainder = do_div(size, divisor[units]); 53 i++; 54 } 55 56 sf_cap = size; 57 for (j = 0; sf_cap*10 < 1000; j++) 58 sf_cap *= 10; 59 60 if (j) { 61 remainder *= 1000; 62 remainder /= divisor[units]; 63 snprintf(tmp, sizeof(tmp), ".%03u", remainder); 64 tmp[j+1] = '\0'; 65 } 66 } 67 68 snprintf(buf, len, "%u%s %s", (u32)size, 69 tmp, units_str[units][i]); 70 } 71 EXPORT_SYMBOL(string_get_size); 72 73 static bool unescape_space(char **src, char **dst) 74 { 75 char *p = *dst, *q = *src; 76 77 switch (*q) { 78 case 'n': 79 *p = '\n'; 80 break; 81 case 'r': 82 *p = '\r'; 83 break; 84 case 't': 85 *p = '\t'; 86 break; 87 case 'v': 88 *p = '\v'; 89 break; 90 case 'f': 91 *p = '\f'; 92 break; 93 default: 94 return false; 95 } 96 *dst += 1; 97 *src += 1; 98 return true; 99 } 100 101 static bool unescape_octal(char **src, char **dst) 102 { 103 char *p = *dst, *q = *src; 104 u8 num; 105 106 if (isodigit(*q) == 0) 107 return false; 108 109 num = (*q++) & 7; 110 while (num < 32 && isodigit(*q) && (q - *src < 3)) { 111 num <<= 3; 112 num += (*q++) & 7; 113 } 114 *p = num; 115 *dst += 1; 116 *src = q; 117 return true; 118 } 119 120 static bool unescape_hex(char **src, char **dst) 121 { 122 char *p = *dst, *q = *src; 123 int digit; 124 u8 num; 125 126 if (*q++ != 'x') 127 return false; 128 129 num = digit = hex_to_bin(*q++); 130 if (digit < 0) 131 return false; 132 133 digit = hex_to_bin(*q); 134 if (digit >= 0) { 135 q++; 136 num = (num << 4) | digit; 137 } 138 *p = num; 139 *dst += 1; 140 *src = q; 141 return true; 142 } 143 144 static bool unescape_special(char **src, char **dst) 145 { 146 char *p = *dst, *q = *src; 147 148 switch (*q) { 149 case '\"': 150 *p = '\"'; 151 break; 152 case '\\': 153 *p = '\\'; 154 break; 155 case 'a': 156 *p = '\a'; 157 break; 158 case 'e': 159 *p = '\e'; 160 break; 161 default: 162 return false; 163 } 164 *dst += 1; 165 *src += 1; 166 return true; 167 } 168 169 /** 170 * string_unescape - unquote characters in the given string 171 * @src: source buffer (escaped) 172 * @dst: destination buffer (unescaped) 173 * @size: size of the destination buffer (0 to unlimit) 174 * @flags: combination of the flags (bitwise OR): 175 * %UNESCAPE_SPACE: 176 * '\f' - form feed 177 * '\n' - new line 178 * '\r' - carriage return 179 * '\t' - horizontal tab 180 * '\v' - vertical tab 181 * %UNESCAPE_OCTAL: 182 * '\NNN' - byte with octal value NNN (1 to 3 digits) 183 * %UNESCAPE_HEX: 184 * '\xHH' - byte with hexadecimal value HH (1 to 2 digits) 185 * %UNESCAPE_SPECIAL: 186 * '\"' - double quote 187 * '\\' - backslash 188 * '\a' - alert (BEL) 189 * '\e' - escape 190 * %UNESCAPE_ANY: 191 * all previous together 192 * 193 * Description: 194 * The function unquotes characters in the given string. 195 * 196 * Because the size of the output will be the same as or less than the size of 197 * the input, the transformation may be performed in place. 198 * 199 * Caller must provide valid source and destination pointers. Be aware that 200 * destination buffer will always be NULL-terminated. Source string must be 201 * NULL-terminated as well. 202 * 203 * Return: 204 * The amount of the characters processed to the destination buffer excluding 205 * trailing '\0' is returned. 206 */ 207 int string_unescape(char *src, char *dst, size_t size, unsigned int flags) 208 { 209 char *out = dst; 210 211 while (*src && --size) { 212 if (src[0] == '\\' && src[1] != '\0' && size > 1) { 213 src++; 214 size--; 215 216 if (flags & UNESCAPE_SPACE && 217 unescape_space(&src, &out)) 218 continue; 219 220 if (flags & UNESCAPE_OCTAL && 221 unescape_octal(&src, &out)) 222 continue; 223 224 if (flags & UNESCAPE_HEX && 225 unescape_hex(&src, &out)) 226 continue; 227 228 if (flags & UNESCAPE_SPECIAL && 229 unescape_special(&src, &out)) 230 continue; 231 232 *out++ = '\\'; 233 } 234 *out++ = *src++; 235 } 236 *out = '\0'; 237 238 return out - dst; 239 } 240 EXPORT_SYMBOL(string_unescape); 241 242 static bool escape_passthrough(unsigned char c, char **dst, char *end) 243 { 244 char *out = *dst; 245 246 if (out < end) 247 *out = c; 248 *dst = out + 1; 249 return true; 250 } 251 252 static bool escape_space(unsigned char c, char **dst, char *end) 253 { 254 char *out = *dst; 255 unsigned char to; 256 257 switch (c) { 258 case '\n': 259 to = 'n'; 260 break; 261 case '\r': 262 to = 'r'; 263 break; 264 case '\t': 265 to = 't'; 266 break; 267 case '\v': 268 to = 'v'; 269 break; 270 case '\f': 271 to = 'f'; 272 break; 273 default: 274 return false; 275 } 276 277 if (out < end) 278 *out = '\\'; 279 ++out; 280 if (out < end) 281 *out = to; 282 ++out; 283 284 *dst = out; 285 return true; 286 } 287 288 static bool escape_special(unsigned char c, char **dst, char *end) 289 { 290 char *out = *dst; 291 unsigned char to; 292 293 switch (c) { 294 case '\\': 295 to = '\\'; 296 break; 297 case '\a': 298 to = 'a'; 299 break; 300 case '\e': 301 to = 'e'; 302 break; 303 default: 304 return false; 305 } 306 307 if (out < end) 308 *out = '\\'; 309 ++out; 310 if (out < end) 311 *out = to; 312 ++out; 313 314 *dst = out; 315 return true; 316 } 317 318 static bool escape_null(unsigned char c, char **dst, char *end) 319 { 320 char *out = *dst; 321 322 if (c) 323 return false; 324 325 if (out < end) 326 *out = '\\'; 327 ++out; 328 if (out < end) 329 *out = '0'; 330 ++out; 331 332 *dst = out; 333 return true; 334 } 335 336 static bool escape_octal(unsigned char c, char **dst, char *end) 337 { 338 char *out = *dst; 339 340 if (out < end) 341 *out = '\\'; 342 ++out; 343 if (out < end) 344 *out = ((c >> 6) & 0x07) + '0'; 345 ++out; 346 if (out < end) 347 *out = ((c >> 3) & 0x07) + '0'; 348 ++out; 349 if (out < end) 350 *out = ((c >> 0) & 0x07) + '0'; 351 ++out; 352 353 *dst = out; 354 return true; 355 } 356 357 static bool escape_hex(unsigned char c, char **dst, char *end) 358 { 359 char *out = *dst; 360 361 if (out < end) 362 *out = '\\'; 363 ++out; 364 if (out < end) 365 *out = 'x'; 366 ++out; 367 if (out < end) 368 *out = hex_asc_hi(c); 369 ++out; 370 if (out < end) 371 *out = hex_asc_lo(c); 372 ++out; 373 374 *dst = out; 375 return true; 376 } 377 378 /** 379 * string_escape_mem - quote characters in the given memory buffer 380 * @src: source buffer (unescaped) 381 * @isz: source buffer size 382 * @dst: destination buffer (escaped) 383 * @osz: destination buffer size 384 * @flags: combination of the flags (bitwise OR): 385 * %ESCAPE_SPACE: 386 * '\f' - form feed 387 * '\n' - new line 388 * '\r' - carriage return 389 * '\t' - horizontal tab 390 * '\v' - vertical tab 391 * %ESCAPE_SPECIAL: 392 * '\\' - backslash 393 * '\a' - alert (BEL) 394 * '\e' - escape 395 * %ESCAPE_NULL: 396 * '\0' - null 397 * %ESCAPE_OCTAL: 398 * '\NNN' - byte with octal value NNN (3 digits) 399 * %ESCAPE_ANY: 400 * all previous together 401 * %ESCAPE_NP: 402 * escape only non-printable characters (checked by isprint) 403 * %ESCAPE_ANY_NP: 404 * all previous together 405 * %ESCAPE_HEX: 406 * '\xHH' - byte with hexadecimal value HH (2 digits) 407 * @esc: NULL-terminated string of characters any of which, if found in 408 * the source, has to be escaped 409 * 410 * Description: 411 * The process of escaping byte buffer includes several parts. They are applied 412 * in the following sequence. 413 * 1. The character is matched to the printable class, if asked, and in 414 * case of match it passes through to the output. 415 * 2. The character is not matched to the one from @esc string and thus 416 * must go as is to the output. 417 * 3. The character is checked if it falls into the class given by @flags. 418 * %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any 419 * character. Note that they actually can't go together, otherwise 420 * %ESCAPE_HEX will be ignored. 421 * 422 * Caller must provide valid source and destination pointers. Be aware that 423 * destination buffer will not be NULL-terminated, thus caller have to append 424 * it if needs. 425 * 426 * Return: 427 * The total size of the escaped output that would be generated for 428 * the given input and flags. To check whether the output was 429 * truncated, compare the return value to osz. There is room left in 430 * dst for a '\0' terminator if and only if ret < osz. 431 */ 432 int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz, 433 unsigned int flags, const char *esc) 434 { 435 char *p = dst; 436 char *end = p + osz; 437 bool is_dict = esc && *esc; 438 439 while (isz--) { 440 unsigned char c = *src++; 441 442 /* 443 * Apply rules in the following sequence: 444 * - the character is printable, when @flags has 445 * %ESCAPE_NP bit set 446 * - the @esc string is supplied and does not contain a 447 * character under question 448 * - the character doesn't fall into a class of symbols 449 * defined by given @flags 450 * In these cases we just pass through a character to the 451 * output buffer. 452 */ 453 if ((flags & ESCAPE_NP && isprint(c)) || 454 (is_dict && !strchr(esc, c))) { 455 /* do nothing */ 456 } else { 457 if (flags & ESCAPE_SPACE && escape_space(c, &p, end)) 458 continue; 459 460 if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end)) 461 continue; 462 463 if (flags & ESCAPE_NULL && escape_null(c, &p, end)) 464 continue; 465 466 /* ESCAPE_OCTAL and ESCAPE_HEX always go last */ 467 if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end)) 468 continue; 469 470 if (flags & ESCAPE_HEX && escape_hex(c, &p, end)) 471 continue; 472 } 473 474 escape_passthrough(c, &p, end); 475 } 476 477 return p - dst; 478 } 479 EXPORT_SYMBOL(string_escape_mem); 480