1 /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 */
5
6 #include "util.h"
7
8 #include <ctype.h>
9 #include <errno.h>
10 #include <limits.h>
11 #include <stdarg.h>
12 #include <stdbool.h>
13 #include <stdint.h>
14 #include <stdio.h>
15 #include <string.h>
16
17 #include "libconstants.h"
18 #include "libsyscalls.h"
19
20 /*
21 * These are syscalls used by the syslog() C library call. You can find them
22 * by running a simple test program. See below for x86_64 behavior:
23 * $ cat test.c
24 * #include <syslog.h>
25 * main() { syslog(0, "foo"); }
26 * $ gcc test.c -static
27 * $ strace ./a.out
28 * ...
29 * socket(PF_FILE, SOCK_DGRAM|SOCK_CLOEXEC, 0) = 3 <- look for socket connection
30 * connect(...) <- important
31 * sendto(...) <- important
32 * exit_group(0) <- finish!
33 */
34 #if defined(__x86_64__)
35 #if defined(__ANDROID__)
36 const char *log_syscalls[] = {"socket", "connect", "fcntl", "writev"};
37 #else
38 const char *log_syscalls[] = {"socket", "connect", "sendto", "writev"};
39 #endif
40 #elif defined(__i386__)
41 #if defined(__ANDROID__)
42 const char *log_syscalls[] = {"socketcall", "writev", "fcntl64",
43 "clock_gettime"};
44 #else
45 const char *log_syscalls[] = {"socketcall", "time", "writev"};
46 #endif
47 #elif defined(__arm__)
48 #if defined(__ANDROID__)
49 const char *log_syscalls[] = {"clock_gettime", "connect", "fcntl64", "socket",
50 "writev"};
51 #else
52 const char *log_syscalls[] = {"socket", "connect", "gettimeofday", "send",
53 "writev"};
54 #endif
55 #elif defined(__aarch64__)
56 #if defined(__ANDROID__)
57 const char *log_syscalls[] = {"connect", "fcntl", "sendto", "socket", "writev"};
58 #else
59 const char *log_syscalls[] = {"socket", "connect", "send", "writev"};
60 #endif
61 #elif defined(__powerpc__) || defined(__ia64__) || defined(__hppa__) || \
62 defined(__sparc__) || defined(__mips__)
63 const char *log_syscalls[] = {"socket", "connect", "send"};
64 #else
65 #error "Unsupported platform"
66 #endif
67
68 const size_t log_syscalls_len = ARRAY_SIZE(log_syscalls);
69
70 /* clang-format off */
71 static struct logging_config_t {
72 /* The logging system to use. The default is syslog. */
73 enum logging_system_t logger;
74
75 /* File descriptor to log to. Only used when logger is LOG_TO_FD. */
76 int fd;
77
78 /* Minimum priority to log. Only used when logger is LOG_TO_FD. */
79 int min_priority;
80 } logging_config = {
81 .logger = LOG_TO_SYSLOG,
82 };
83 /* clang-format on */
84
85 #if defined(USE_EXIT_ON_DIE)
86 #define do_abort() exit(1)
87 #else
88 #define do_abort() abort()
89 #endif
90
91 #if defined(__clang__)
92 #define attribute_no_optimize __attribute__((optnone))
93 #else
94 #define attribute_no_optimize __attribute__((__optimize__(0)))
95 #endif
96
97 /* Forces the compiler to perform no optimizations on |var|. */
alias(const void * var)98 static void attribute_no_optimize alias(const void *var)
99 {
100 (void)var;
101 }
102
do_fatal_log(int priority,const char * format,...)103 void do_fatal_log(int priority, const char *format, ...)
104 {
105 va_list args, stack_args;
106 va_start(args, format);
107 va_copy(stack_args, args);
108 if (logging_config.logger == LOG_TO_SYSLOG) {
109 vsyslog(priority, format, args);
110 } else {
111 vdprintf(logging_config.fd, format, args);
112 dprintf(logging_config.fd, "\n");
113 }
114 va_end(args);
115
116 /*
117 * Write another copy of the first few characters of the message into a
118 * stack-based buffer so that it can appear in minidumps. Choosing a
119 * small-ish buffer size since breakpad will only pick up the first few
120 * kilobytes of each stack, so that will prevent this buffer from
121 * kicking out other stack frames.
122 */
123 char log_line[512];
124 vsnprintf(log_line, sizeof(log_line), format, stack_args);
125 va_end(stack_args);
126 alias(log_line);
127 do_abort();
128 }
129
do_log(int priority,const char * format,...)130 void do_log(int priority, const char *format, ...)
131 {
132 if (logging_config.logger == LOG_TO_SYSLOG) {
133 va_list args;
134 va_start(args, format);
135 vsyslog(priority, format, args);
136 va_end(args);
137 return;
138 }
139
140 if (logging_config.min_priority < priority)
141 return;
142
143 va_list args;
144 va_start(args, format);
145 vdprintf(logging_config.fd, format, args);
146 va_end(args);
147 dprintf(logging_config.fd, "\n");
148 }
149
lookup_syscall(const char * name)150 int lookup_syscall(const char *name)
151 {
152 const struct syscall_entry *entry = syscall_table;
153 for (; entry->name && entry->nr >= 0; ++entry)
154 if (!strcmp(entry->name, name))
155 return entry->nr;
156 return -1;
157 }
158
lookup_syscall_name(int nr)159 const char *lookup_syscall_name(int nr)
160 {
161 const struct syscall_entry *entry = syscall_table;
162 for (; entry->name && entry->nr >= 0; ++entry)
163 if (entry->nr == nr)
164 return entry->name;
165 return NULL;
166 }
167
parse_single_constant(char * constant_str,char ** endptr)168 long int parse_single_constant(char *constant_str, char **endptr)
169 {
170 const struct constant_entry *entry = constant_table;
171 long int res = 0;
172 for (; entry->name; ++entry) {
173 if (!strcmp(entry->name, constant_str)) {
174 *endptr = constant_str + strlen(constant_str);
175 return entry->value;
176 }
177 }
178
179 errno = 0;
180 res = strtol(constant_str, endptr, 0);
181 if (errno == ERANGE) {
182 if (res == LONG_MAX) {
183 /* See if the constant fits in an unsigned long int. */
184 errno = 0;
185 res = strtoul(constant_str, endptr, 0);
186 if (errno == ERANGE) {
187 /*
188 * On unsigned overflow, use the same convention
189 * as when strtol(3) finds no digits: set
190 * |*endptr| to |constant_str| and return 0.
191 */
192 warn("unsigned overflow: '%s'", constant_str);
193 *endptr = constant_str;
194 return 0;
195 }
196 } else if (res == LONG_MIN) {
197 /*
198 * Same for signed underflow: set |*endptr| to
199 * |constant_str| and return 0.
200 */
201 warn("signed underflow: '%s'", constant_str);
202 *endptr = constant_str;
203 return 0;
204 }
205 }
206 if (**endptr != '\0') {
207 warn("trailing garbage after constant: '%s'", constant_str);
208 *endptr = constant_str;
209 return 0;
210 }
211 return res;
212 }
213
tokenize_parenthesized_expression(char ** stringp)214 static char *tokenize_parenthesized_expression(char **stringp)
215 {
216 char *ret = NULL, *found = NULL;
217 size_t paren_count = 1;
218
219 /* If the string is NULL, there are no parens to be found. */
220 if (stringp == NULL || *stringp == NULL)
221 return NULL;
222
223 /* If the string is not on an open paren, the results are undefined. */
224 if (**stringp != '(')
225 return NULL;
226
227 for (found = *stringp + 1; *found; ++found) {
228 switch (*found) {
229 case '(':
230 ++paren_count;
231 break;
232 case ')':
233 --paren_count;
234 if (!paren_count) {
235 *found = '\0';
236 ret = *stringp + 1;
237 *stringp = found + 1;
238 return ret;
239 }
240 break;
241 }
242 }
243
244 /* We got to the end without finding the closing paren. */
245 warn("unclosed parenthesis: '%s'", *stringp);
246 return NULL;
247 }
248
parse_constant(char * constant_str,char ** endptr)249 long int parse_constant(char *constant_str, char **endptr)
250 {
251 long int value = 0, current_value;
252 char *group, *lastpos = constant_str;
253
254 /*
255 * If |endptr| is provided, parsing errors are signaled as |endptr|
256 * pointing to |constant_str|.
257 */
258 if (endptr)
259 *endptr = constant_str;
260
261 /*
262 * Try to parse constant expressions. Valid constant expressions are:
263 *
264 * - A number that can be parsed with strtol(3).
265 * - A named constant expression.
266 * - A parenthesized, valid constant expression.
267 * - A valid constant expression prefixed with the unary bitwise
268 * complement operator ~.
269 * - A series of valid constant expressions separated by pipes. Note
270 * that since |constant_str| is an atom, there can be no spaces
271 * between the constant and the pipe.
272 *
273 * If there is an error parsing any of the constants, the whole process
274 * fails.
275 */
276 while (constant_str && *constant_str) {
277 bool negate = false;
278 if (*constant_str == '~') {
279 negate = true;
280 ++constant_str;
281 }
282 if (*constant_str == '(') {
283 group =
284 tokenize_parenthesized_expression(&constant_str);
285 if (group == NULL)
286 return 0;
287 char *end = group;
288 /* Recursively parse the parenthesized subexpression. */
289 current_value = parse_constant(group, &end);
290 if (end == group)
291 return 0;
292 if (constant_str && *constant_str) {
293 /*
294 * If this is not the end of the atom, there
295 * should be another | followed by more stuff.
296 */
297 if (*constant_str != '|') {
298 warn("unterminated constant "
299 "expression: '%s'",
300 constant_str);
301 return 0;
302 }
303 ++constant_str;
304 if (*constant_str == '\0') {
305 warn("unterminated constant "
306 "expression: '%s'",
307 constant_str);
308 return 0;
309 }
310 }
311 lastpos = end;
312 } else {
313 group = tokenize(&constant_str, "|");
314 char *end = group;
315 current_value = parse_single_constant(group, &end);
316 if (end == group)
317 return 0;
318 lastpos = end;
319 }
320 if (negate)
321 current_value = ~current_value;
322 value |= current_value;
323 }
324 if (endptr)
325 *endptr = lastpos;
326 return value;
327 }
328
329 /*
330 * parse_size, specified as a string with a decimal number in bytes,
331 * possibly with one 1-character suffix like "10K" or "6G".
332 * Assumes both pointers are non-NULL.
333 *
334 * Returns 0 on success, negative errno on failure.
335 * Only writes to result on success.
336 */
parse_size(size_t * result,const char * sizespec)337 int parse_size(size_t *result, const char *sizespec)
338 {
339 const char prefixes[] = "KMGTPE";
340 size_t i, multiplier = 1, nsize, size = 0;
341 unsigned long long parsed;
342 const size_t len = strlen(sizespec);
343 char *end;
344
345 if (len == 0 || sizespec[0] == '-')
346 return -EINVAL;
347
348 for (i = 0; i < sizeof(prefixes); ++i) {
349 if (sizespec[len - 1] == prefixes[i]) {
350 #if __WORDSIZE == 32
351 if (i >= 3)
352 return -ERANGE;
353 #endif
354 multiplier = 1024;
355 while (i-- > 0)
356 multiplier *= 1024;
357 break;
358 }
359 }
360
361 /* We only need size_t but strtoul(3) is too small on IL32P64. */
362 parsed = strtoull(sizespec, &end, 10);
363 if (parsed == ULLONG_MAX)
364 return -errno;
365 if (parsed >= SIZE_MAX)
366 return -ERANGE;
367 if ((multiplier != 1 && end != sizespec + len - 1) ||
368 (multiplier == 1 && end != sizespec + len))
369 return -EINVAL;
370 size = (size_t)parsed;
371
372 nsize = size * multiplier;
373 if (nsize / multiplier != size)
374 return -ERANGE;
375 *result = nsize;
376 return 0;
377 }
378
strip(char * s)379 char *strip(char *s)
380 {
381 char *end;
382 while (*s && isblank(*s))
383 s++;
384 end = s + strlen(s) - 1;
385 while (end >= s && *end && (isblank(*end) || *end == '\n'))
386 end--;
387 *(end + 1) = '\0';
388 return s;
389 }
390
tokenize(char ** stringp,const char * delim)391 char *tokenize(char **stringp, const char *delim)
392 {
393 char *ret = NULL;
394
395 /* If the string is NULL, there are no tokens to be found. */
396 if (stringp == NULL || *stringp == NULL)
397 return NULL;
398
399 /*
400 * If the delimiter is NULL or empty,
401 * the full string makes up the only token.
402 */
403 if (delim == NULL || *delim == '\0') {
404 ret = *stringp;
405 *stringp = NULL;
406 return ret;
407 }
408
409 char *found = strstr(*stringp, delim);
410 if (!found) {
411 /*
412 * The delimiter was not found, so the full string
413 * makes up the only token, and we're done.
414 */
415 ret = *stringp;
416 *stringp = NULL;
417 } else {
418 /* There's a token here, possibly empty. That's OK. */
419 *found = '\0';
420 ret = *stringp;
421 *stringp = found + strlen(delim);
422 }
423
424 return ret;
425 }
426
path_join(const char * external_path,const char * internal_path)427 char *path_join(const char *external_path, const char *internal_path)
428 {
429 char *path;
430 size_t pathlen;
431
432 /* One extra char for '/' and one for '\0', hence + 2. */
433 pathlen = strlen(external_path) + strlen(internal_path) + 2;
434 path = malloc(pathlen);
435 snprintf(path, pathlen, "%s/%s", external_path, internal_path);
436
437 return path;
438 }
439
consumebytes(size_t length,char ** buf,size_t * buflength)440 void *consumebytes(size_t length, char **buf, size_t *buflength)
441 {
442 char *p = *buf;
443 if (length > *buflength)
444 return NULL;
445 *buf += length;
446 *buflength -= length;
447 return p;
448 }
449
consumestr(char ** buf,size_t * buflength)450 char *consumestr(char **buf, size_t *buflength)
451 {
452 size_t len = strnlen(*buf, *buflength);
453 if (len == *buflength)
454 /* There's no null-terminator. */
455 return NULL;
456 return consumebytes(len + 1, buf, buflength);
457 }
458
init_logging(enum logging_system_t logger,int fd,int min_priority)459 void init_logging(enum logging_system_t logger, int fd, int min_priority)
460 {
461 logging_config.logger = logger;
462 logging_config.fd = fd;
463 logging_config.min_priority = min_priority;
464 }
465