74ec60469640e4c0cd96752c09f8e128afc4fe8a
[sfrench/cifs-2.6.git] / 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 *const units_10[] = {
29                 "B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL
30         };
31         static const char *const units_2[] = {
32                 "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB",
33                 NULL
34         };
35         static const char *const *const units_str[] = {
36                 [STRING_UNITS_10] = units_10,
37                 [STRING_UNITS_2] = units_2,
38         };
39         static const unsigned int divisor[] = {
40                 [STRING_UNITS_10] = 1000,
41                 [STRING_UNITS_2] = 1024,
42         };
43         int i, j;
44         u64 remainder = 0, sf_cap;
45         char tmp[8];
46
47         tmp[0] = '\0';
48         i = 0;
49         if (size >= divisor[units]) {
50                 while (size >= divisor[units] && units_str[units][i]) {
51                         remainder = do_div(size, divisor[units]);
52                         i++;
53                 }
54
55                 sf_cap = size;
56                 for (j = 0; sf_cap*10 < 1000; j++)
57                         sf_cap *= 10;
58
59                 if (j) {
60                         remainder *= 1000;
61                         do_div(remainder, divisor[units]);
62                         snprintf(tmp, sizeof(tmp), ".%03lld",
63                                  (unsigned long long)remainder);
64                         tmp[j+1] = '\0';
65                 }
66         }
67
68         snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
69                  tmp, units_str[units][i]);
70
71         return 0;
72 }
73 EXPORT_SYMBOL(string_get_size);
74
75 static bool unescape_space(char **src, char **dst)
76 {
77         char *p = *dst, *q = *src;
78
79         switch (*q) {
80         case 'n':
81                 *p = '\n';
82                 break;
83         case 'r':
84                 *p = '\r';
85                 break;
86         case 't':
87                 *p = '\t';
88                 break;
89         case 'v':
90                 *p = '\v';
91                 break;
92         case 'f':
93                 *p = '\f';
94                 break;
95         default:
96                 return false;
97         }
98         *dst += 1;
99         *src += 1;
100         return true;
101 }
102
103 static bool unescape_octal(char **src, char **dst)
104 {
105         char *p = *dst, *q = *src;
106         u8 num;
107
108         if (isodigit(*q) == 0)
109                 return false;
110
111         num = (*q++) & 7;
112         while (num < 32 && isodigit(*q) && (q - *src < 3)) {
113                 num <<= 3;
114                 num += (*q++) & 7;
115         }
116         *p = num;
117         *dst += 1;
118         *src = q;
119         return true;
120 }
121
122 static bool unescape_hex(char **src, char **dst)
123 {
124         char *p = *dst, *q = *src;
125         int digit;
126         u8 num;
127
128         if (*q++ != 'x')
129                 return false;
130
131         num = digit = hex_to_bin(*q++);
132         if (digit < 0)
133                 return false;
134
135         digit = hex_to_bin(*q);
136         if (digit >= 0) {
137                 q++;
138                 num = (num << 4) | digit;
139         }
140         *p = num;
141         *dst += 1;
142         *src = q;
143         return true;
144 }
145
146 static bool unescape_special(char **src, char **dst)
147 {
148         char *p = *dst, *q = *src;
149
150         switch (*q) {
151         case '\"':
152                 *p = '\"';
153                 break;
154         case '\\':
155                 *p = '\\';
156                 break;
157         case 'a':
158                 *p = '\a';
159                 break;
160         case 'e':
161                 *p = '\e';
162                 break;
163         default:
164                 return false;
165         }
166         *dst += 1;
167         *src += 1;
168         return true;
169 }
170
171 /**
172  * string_unescape - unquote characters in the given string
173  * @src:        source buffer (escaped)
174  * @dst:        destination buffer (unescaped)
175  * @size:       size of the destination buffer (0 to unlimit)
176  * @flags:      combination of the flags (bitwise OR):
177  *      %UNESCAPE_SPACE:
178  *              '\f' - form feed
179  *              '\n' - new line
180  *              '\r' - carriage return
181  *              '\t' - horizontal tab
182  *              '\v' - vertical tab
183  *      %UNESCAPE_OCTAL:
184  *              '\NNN' - byte with octal value NNN (1 to 3 digits)
185  *      %UNESCAPE_HEX:
186  *              '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
187  *      %UNESCAPE_SPECIAL:
188  *              '\"' - double quote
189  *              '\\' - backslash
190  *              '\a' - alert (BEL)
191  *              '\e' - escape
192  *      %UNESCAPE_ANY:
193  *              all previous together
194  *
195  * Description:
196  * The function unquotes characters in the given string.
197  *
198  * Because the size of the output will be the same as or less than the size of
199  * the input, the transformation may be performed in place.
200  *
201  * Caller must provide valid source and destination pointers. Be aware that
202  * destination buffer will always be NULL-terminated. Source string must be
203  * NULL-terminated as well.
204  *
205  * Return:
206  * The amount of the characters processed to the destination buffer excluding
207  * trailing '\0' is returned.
208  */
209 int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
210 {
211         char *out = dst;
212
213         while (*src && --size) {
214                 if (src[0] == '\\' && src[1] != '\0' && size > 1) {
215                         src++;
216                         size--;
217
218                         if (flags & UNESCAPE_SPACE &&
219                                         unescape_space(&src, &out))
220                                 continue;
221
222                         if (flags & UNESCAPE_OCTAL &&
223                                         unescape_octal(&src, &out))
224                                 continue;
225
226                         if (flags & UNESCAPE_HEX &&
227                                         unescape_hex(&src, &out))
228                                 continue;
229
230                         if (flags & UNESCAPE_SPECIAL &&
231                                         unescape_special(&src, &out))
232                                 continue;
233
234                         *out++ = '\\';
235                 }
236                 *out++ = *src++;
237         }
238         *out = '\0';
239
240         return out - dst;
241 }
242 EXPORT_SYMBOL(string_unescape);