1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file util.c
4 /// \brief Miscellaneous utility functions
5 //
6 // Author: Lasse Collin
7 //
8 // This file has been put into the public domain.
9 // You can do whatever you want with this file.
10 //
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #include "private.h"
14 #include <stdarg.h>
15
16
17 /// Buffers for uint64_to_str() and uint64_to_nicestr()
18 static char bufs[4][128];
19
20
21 // Thousand separator support in uint64_to_str() and uint64_to_nicestr():
22 //
23 // DJGPP 2.05 added support for thousands separators but it's broken
24 // at least under WinXP with Finnish locale that uses a non-breaking space
25 // as the thousands separator. Workaround by disabling thousands separators
26 // for DJGPP builds.
27 //
28 // MSVC doesn't support thousand separators.
29 #if defined(__DJGPP__) || defined(_MSC_VER)
30 # define FORMAT_THOUSAND_SEP(prefix, suffix) prefix suffix
31 # define check_thousand_sep(slot) do { } while (0)
32 #else
33 # define FORMAT_THOUSAND_SEP(prefix, suffix) ((thousand == WORKS) \
34 ? prefix "'" suffix \
35 : prefix suffix)
36
37 static enum { UNKNOWN, WORKS, BROKEN } thousand = UNKNOWN;
38
39 /// Check if thousands separator is supported. Run-time checking is easiest
40 /// because it seems to be sometimes lacking even on a POSIXish system.
41 /// Note that trying to use thousands separators when snprintf() doesn't
42 /// support them results in undefined behavior. This just has happened to
43 /// work well enough in practice.
44 ///
45 /// This must be called before using the FORMAT_THOUSAND_SEP macro.
46 static void
47 check_thousand_sep(uint32_t slot)
48 {
49 if (thousand == UNKNOWN) {
50 bufs[slot][0] = '\0';
51 snprintf(bufs[slot], sizeof(bufs[slot]), "%'u", 1U);
52 thousand = bufs[slot][0] == '1' ? WORKS : BROKEN;
53 }
54
55 return;
56 }
57 #endif
58
59
60 extern void *
61 xrealloc(void *ptr, size_t size)
62 {
63 assert(size > 0);
64
65 // Save ptr so that we can free it if realloc fails.
66 // The point is that message_fatal ends up calling stdio functions
67 // which in some libc implementations might allocate memory from
68 // the heap. Freeing ptr improves the chances that there's free
69 // memory for stdio functions if they need it.
70 void *p = ptr;
71 ptr = realloc(ptr, size);
72
73 if (ptr == NULL) {
74 const int saved_errno = errno;
75 free(p);
76 message_fatal("%s", strerror(saved_errno));
77 }
78
79 return ptr;
80 }
81
82
83 extern char *
84 xstrdup(const char *src)
85 {
86 assert(src != NULL);
87 const size_t size = strlen(src) + 1;
88 char *dest = xmalloc(size);
89 return memcpy(dest, src, size);
90 }
91
92
93 extern uint64_t
94 str_to_uint64(const char *name, const char *value, uint64_t min, uint64_t max)
95 {
96 uint64_t result = 0;
97
98 // Skip blanks.
99 while (*value == ' ' || *value == '\t')
100 ++value;
101
102 // Accept special value "max". Supporting "min" doesn't seem useful.
103 if (strcmp(value, "max") == 0)
104 return max;
105
106 if (*value < '0' || *value > '9')
107 message_fatal(_("%s: Value is not a non-negative "
108 "decimal integer"), value);
109
110 do {
111 // Don't overflow.
112 if (result > UINT64_MAX / 10)
113 goto error;
114
115 result *= 10;
116
117 // Another overflow check
118 const uint32_t add = (uint32_t)(*value - '0');
119 if (UINT64_MAX - add < result)
120 goto error;
121
122 result += add;
123 ++value;
124 } while (*value >= '0' && *value <= '9');
125
126 if (*value != '\0') {
127 // Look for suffix. Originally this supported both base-2
128 // and base-10, but since there seems to be little need
129 // for base-10 in this program, treat everything as base-2
130 // and also be more relaxed about the case of the first
131 // letter of the suffix.
132 uint64_t multiplier = 0;
133 if (*value == 'k' || *value == 'K')
134 multiplier = UINT64_C(1) << 10;
135 else if (*value == 'm' || *value == 'M')
136 multiplier = UINT64_C(1) << 20;
137 else if (*value == 'g' || *value == 'G')
138 multiplier = UINT64_C(1) << 30;
139
140 ++value;
141
142 // Allow also e.g. Ki, KiB, and KB.
143 if (*value != '\0' && strcmp(value, "i") != 0
144 && strcmp(value, "iB") != 0
145 && strcmp(value, "B") != 0)
146 multiplier = 0;
147
148 if (multiplier == 0) {
149 message(V_ERROR, _("%s: Invalid multiplier suffix"),
150 value - 1);
151 message_fatal(_("Valid suffixes are `KiB' (2^10), "
152 "`MiB' (2^20), and `GiB' (2^30)."));
153 }
154
155 // Don't overflow here either.
156 if (result > UINT64_MAX / multiplier)
157 goto error;
158
159 result *= multiplier;
160 }
161
162 if (result < min || result > max)
163 goto error;
164
165 return result;
166
167 error:
168 message_fatal(_("Value of the option `%s' must be in the range "
169 "[%" PRIu64 ", %" PRIu64 "]"),
170 name, min, max);
171 }
172
173
174 extern uint64_t
175 round_up_to_mib(uint64_t n)
176 {
177 return (n >> 20) + ((n & ((UINT32_C(1) << 20) - 1)) != 0);
178 }
179
180
181 extern const char *
182 uint64_to_str(uint64_t value, uint32_t slot)
183 {
184 assert(slot < ARRAY_SIZE(bufs));
185
186 check_thousand_sep(slot);
187
188 snprintf(bufs[slot], sizeof(bufs[slot]),
189 FORMAT_THOUSAND_SEP("%", PRIu64), value);
190
191 return bufs[slot];
192 }
193
194
195 extern const char *
196 uint64_to_nicestr(uint64_t value, enum nicestr_unit unit_min,
197 enum nicestr_unit unit_max, bool always_also_bytes,
198 uint32_t slot)
199 {
200 assert(unit_min <= unit_max);
201 assert(unit_max <= NICESTR_TIB);
202 assert(slot < ARRAY_SIZE(bufs));
203
204 check_thousand_sep(slot);
205
206 enum nicestr_unit unit = NICESTR_B;
207 char *pos = bufs[slot];
208 size_t left = sizeof(bufs[slot]);
209
210 if ((unit_min == NICESTR_B && value < 10000)
211 || unit_max == NICESTR_B) {
212 // The value is shown as bytes.
213 my_snprintf(&pos, &left, FORMAT_THOUSAND_SEP("%", "u"),
214 (unsigned int)value);
215 } else {
216 // Scale the value to a nicer unit. Unless unit_min and
217 // unit_max limit us, we will show at most five significant
218 // digits with one decimal place.
219 double d = (double)(value);
220 do {
221 d /= 1024.0;
222 ++unit;
223 } while (unit < unit_min || (d > 9999.9 && unit < unit_max));
224
225 my_snprintf(&pos, &left, FORMAT_THOUSAND_SEP("%", ".1f"), d);
226 }
227
228 static const char suffix[5][4] = { "B", "KiB", "MiB", "GiB", "TiB" };
229 my_snprintf(&pos, &left, " %s", suffix[unit]);
230
231 if (always_also_bytes && value >= 10000)
232 snprintf(pos, left, FORMAT_THOUSAND_SEP(" (%", PRIu64 " B)"),
233 value);
234
235 return bufs[slot];
236 }
237
238
239 extern void
240 my_snprintf(char **pos, size_t *left, const char *fmt, ...)
241 {
242 va_list ap;
243 va_start(ap, fmt);
244 const int len = vsnprintf(*pos, *left, fmt, ap);
245 va_end(ap);
246
247 // If an error occurred, we want the caller to think that the whole
248 // buffer was used. This way no more data will be written to the
249 // buffer. We don't need better error handling here, although it
250 // is possible that the result looks garbage on the terminal if
251 // e.g. an UTF-8 character gets split. That shouldn't (easily)
252 // happen though, because the buffers used have some extra room.
253 if (len < 0 || (size_t)(len) >= *left) {
254 *left = 0;
255 } else {
256 *pos += len;
257 *left -= (size_t)(len);
258 }
259
260 return;
261 }
262
263
264 extern bool
265 is_tty_stdin(void)
266 {
267 const bool ret = isatty(STDIN_FILENO);
268
269 if (ret)
270 message_error(_("Compressed data cannot be read from "
271 "a terminal"));
272
273 return ret;
274 }
275
276
277 extern bool
278 is_tty_stdout(void)
279 {
280 const bool ret = isatty(STDOUT_FILENO);
281
282 if (ret)
283 message_error(_("Compressed data cannot be written to "
284 "a terminal"));
285
286 return ret;
287 }