lib/string_helpers.c

   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/string_helpers.h>
  12
  13 /**
  14  * string_get_size - get the size in the specified units
  15  * @size:       The size to be converted
  16  * @units:      units to use (powers of 1000 or 1024)
  17  * @buf:        buffer to format to
  18  * @len:        length of buffer
  19  *
  20  * This function returns a string formatted to 3 significant figures
  21  * giving the size in the required units.  Returns 0 on success or
  22  * error on failure.  @buf is always zero terminated.
  23  *
  24  */
  25 int string_get_size(u64 size, const enum string_size_units units,
  26                     char *buf, int len)
  27 {
  28         static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
  29                                    "EB", "ZB", "YB", NULL};
  30         static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
  31                                  "EiB", "ZiB", "YiB", NULL };
  32         static const char **units_str[] = {
  33                 [STRING_UNITS_10] =  units_10,
  34                 [STRING_UNITS_2] = units_2,
  35         };
  36         static const unsigned int divisor[] = {
  37                 [STRING_UNITS_10] = 1000,
  38                 [STRING_UNITS_2] = 1024,
  39         };
  40         int i, j;
  41         u64 remainder = 0, sf_cap;
  42         char tmp[8];
  43
  44         tmp[0] = '\0';
  45         i = 0;
  46         if (size >= divisor[units]) {
  47                 while (size >= divisor[units] && units_str[units][i]) {
  48                         remainder = do_div(size, divisor[units]);
  49                         i++;
  50                 }
  51
  52                 sf_cap = size;
  53                 for (j = 0; sf_cap*10 < 1000; j++)
  54                         sf_cap *= 10;
  55
  56                 if (j) {
  57                         remainder *= 1000;
  58                         do_div(remainder, divisor[units]);
  59                         snprintf(tmp, sizeof(tmp), ".%03lld",
  60                                  (unsigned long long)remainder);
  61                         tmp[j+1] = '\0';
  62                 }
  63         }
  64
  65         snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
  66                  tmp, units_str[units][i]);
  67
  68         return 0;
  69 }
  70 EXPORT_SYMBOL(string_get_size);
  71
  72 static bool unescape_space(char **src, char **dst)
  73 {
  74         char *p = *dst, *q = *src;
  75
  76         switch (*q) {
  77         case 'n':
  78                 *p = '\n';
  79                 break;
  80         case 'r':
  81                 *p = '\r';
  82                 break;
  83         case 't':
  84                 *p = '\t';
  85                 break;
  86         case 'v':
  87                 *p = '\v';
  88                 break;
  89         case 'f':
  90                 *p = '\f';
  91                 break;
  92         default:
  93                 return false;
  94         }
  95         *dst += 1;
  96         *src += 1;
  97         return true;
  98 }
  99
 100 static bool unescape_octal(char **src, char **dst)
 101 {
 102         char *p = *dst, *q = *src;
 103         u8 num;
 104
 105         if (isodigit(*q) == 0)
 106                 return false;
 107
 108         num = (*q++) & 7;
 109         while (num < 32 && isodigit(*q) && (q - *src < 3)) {
 110                 num <<= 3;
 111                 num += (*q++) & 7;
 112         }
 113         *p = num;
 114         *dst += 1;
 115         *src = q;
 116         return true;
 117 }
 118
 119 static bool unescape_hex(char **src, char **dst)
 120 {
 121         char *p = *dst, *q = *src;
 122         int digit;
 123         u8 num;
 124
 125         if (*q++ != 'x')
 126                 return false;
 127
 128         num = digit = hex_to_bin(*q++);
 129         if (digit < 0)
 130                 return false;
 131
 132         digit = hex_to_bin(*q);
 133         if (digit >= 0) {
 134                 q++;
 135                 num = (num << 4) | digit;
 136         }
 137         *p = num;
 138         *dst += 1;
 139         *src = q;
 140         return true;
 141 }
 142
 143 static bool unescape_special(char **src, char **dst)
 144 {
 145         char *p = *dst, *q = *src;
 146
 147         switch (*q) {
 148         case '\"':
 149                 *p = '\"';
 150                 break;
 151         case '\\':
 152                 *p = '\\';
 153                 break;
 154         case 'a':
 155                 *p = '\a';
 156                 break;
 157         case 'e':
 158                 *p = '\e';
 159                 break;
 160         default:
 161                 return false;
 162         }
 163         *dst += 1;
 164         *src += 1;
 165         return true;
 166 }
 167
 168 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
 169 {
 170         char *out = dst;
 171
 172         while (*src && --size) {
 173                 if (src[0] == '\\' && src[1] != '\0' && size > 1) {
 174                         src++;
 175                         size--;
 176
 177                         if (flags & UNESCAPE_SPACE &&
 178                                         unescape_space(&src, &out))
 179                                 continue;
 180
 181                         if (flags & UNESCAPE_OCTAL &&
 182                                         unescape_octal(&src, &out))
 183                                 continue;
 184
 185                         if (flags & UNESCAPE_HEX &&
 186                                         unescape_hex(&src, &out))
 187                                 continue;
 188
 189                         if (flags & UNESCAPE_SPECIAL &&
 190                                         unescape_special(&src, &out))
 191                                 continue;
 192
 193                         *out++ = '\\';
 194                 }
 195                 *out++ = *src++;
 196         }
 197         *out = '\0';
 198
 199         return out - dst;
 200 }
 201 EXPORT_SYMBOL(string_unescape);