projects/linux·blob v3.13-rc7 · refs

201 lines · 3.6 KiB

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 */
25int 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}
70EXPORT_SYMBOL(string_get_size);
71
72static 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
100static 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
119static 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
143static 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
168int 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}
201EXPORT_SYMBOL(string_unescape);