• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <stdint.h>
13 #include <stdio.h>
14 #include <string.h>
15 
16 #include "libconstants.h"
17 #include "libsyscalls.h"
18 
19 /*
20  * These are syscalls used by the syslog() C library call.  You can find them
21  * by running a simple test program.  See below for x86_64 behavior:
22  * $ cat test.c
23  * #include <syslog.h>
24  * main() { syslog(0, "foo"); }
25  * $ gcc test.c -static
26  * $ strace ./a.out
27  * ...
28  * socket(PF_FILE, SOCK_DGRAM|SOCK_CLOEXEC, 0) = 3 <- look for socket connection
29  * connect(...)                                    <- important
30  * sendto(...)                                     <- important
31  * exit_group(0)                                   <- finish!
32  */
33 #if defined(__x86_64__)
34 #if defined(__ANDROID__)
35 const char *log_syscalls[] = {"socket", "connect", "fcntl", "writev"};
36 #else
37 const char *log_syscalls[] = {"socket", "connect", "sendto"};
38 #endif
39 #elif defined(__i386__)
40 #if defined(__ANDROID__)
41 const char *log_syscalls[] = {"socketcall", "writev", "fcntl64",
42 			      "clock_gettime"};
43 #else
44 const char *log_syscalls[] = {"socketcall", "time"};
45 #endif
46 #elif defined(__arm__)
47 #if defined(__ANDROID__)
48 const char *log_syscalls[] = {"clock_gettime", "connect", "fcntl64", "socket",
49 			      "writev"};
50 #else
51 const char *log_syscalls[] = {"socket", "connect", "gettimeofday", "send"};
52 #endif
53 #elif defined(__aarch64__)
54 #if defined(__ANDROID__)
55 const char *log_syscalls[] = {"connect", "fcntl", "sendto", "socket", "writev"};
56 #else
57 const char *log_syscalls[] = {"socket", "connect", "send"};
58 #endif
59 #elif defined(__powerpc__) || defined(__ia64__) || defined(__hppa__) ||        \
60       defined(__sparc__) || defined(__mips__)
61 const char *log_syscalls[] = {"socket", "connect", "send"};
62 #else
63 #error "Unsupported platform"
64 #endif
65 
66 const size_t log_syscalls_len = ARRAY_SIZE(log_syscalls);
67 
68 /* clang-format off */
69 static struct logging_config_t {
70 	/* The logging system to use. The default is syslog. */
71 	enum logging_system_t logger;
72 
73 	/* File descriptor to log to. Only used when logger is LOG_TO_FD. */
74 	int fd;
75 
76 	/* Minimum priority to log. Only used when logger is LOG_TO_FD. */
77 	int min_priority;
78 } logging_config = {
79 	.logger = LOG_TO_SYSLOG,
80 };
81 /* clang-format on */
82 
do_log(int priority,const char * format,...)83 void do_log(int priority, const char *format, ...)
84 {
85 	if (logging_config.logger == LOG_TO_SYSLOG) {
86 		va_list args;
87 		va_start(args, format);
88 		vsyslog(priority, format, args);
89 		va_end(args);
90 		return;
91 	}
92 
93 	if (logging_config.min_priority < priority)
94 		return;
95 
96 	va_list args;
97 	va_start(args, format);
98 	vdprintf(logging_config.fd, format, args);
99 	va_end(args);
100 	dprintf(logging_config.fd, "\n");
101 }
102 
lookup_syscall(const char * name)103 int lookup_syscall(const char *name)
104 {
105 	const struct syscall_entry *entry = syscall_table;
106 	for (; entry->name && entry->nr >= 0; ++entry)
107 		if (!strcmp(entry->name, name))
108 			return entry->nr;
109 	return -1;
110 }
111 
lookup_syscall_name(int nr)112 const char *lookup_syscall_name(int nr)
113 {
114 	const struct syscall_entry *entry = syscall_table;
115 	for (; entry->name && entry->nr >= 0; ++entry)
116 		if (entry->nr == nr)
117 			return entry->name;
118 	return NULL;
119 }
120 
parse_single_constant(char * constant_str,char ** endptr)121 long int parse_single_constant(char *constant_str, char **endptr)
122 {
123 	const struct constant_entry *entry = constant_table;
124 	long int res = 0;
125 	for (; entry->name; ++entry) {
126 		if (!strcmp(entry->name, constant_str)) {
127 			if (endptr)
128 				*endptr = constant_str + strlen(constant_str);
129 
130 			return entry->value;
131 		}
132 	}
133 
134 	errno = 0;
135 	res = strtol(constant_str, endptr, 0);
136 	if (errno == ERANGE) {
137 		if (res == LONG_MAX) {
138 			/* See if the constant fits in an unsigned long int. */
139 			errno = 0;
140 			res = strtoul(constant_str, endptr, 0);
141 			if (errno == ERANGE) {
142 				/*
143 				 * On unsigned overflow, use the same convention
144 				 * as when strtol(3) finds no digits: set
145 				 * |*endptr| to |constant_str| and return 0.
146 				 */
147 				warn("unsigned overflow: '%s'", constant_str);
148 				*endptr = constant_str;
149 				res = 0;
150 			}
151 		} else if (res == LONG_MIN) {
152 			/*
153 			 * Same for signed underflow: set |*endptr| to
154 			 * |constant_str| and return 0.
155 			 */
156 			warn("signed underflow: '%s'", constant_str);
157 			*endptr = constant_str;
158 			res = 0;
159 		}
160 	}
161 	return res;
162 }
163 
parse_constant(char * constant_str,char ** endptr)164 long int parse_constant(char *constant_str, char **endptr)
165 {
166 	long int value = 0;
167 	char *group, *lastpos = constant_str;
168 	char *original_constant_str = constant_str;
169 
170 	/*
171 	 * Try to parse constants separated by pipes.  Note that since
172 	 * |constant_str| is an atom, there can be no spaces between the
173 	 * constant and the pipe.  Constants can be either a named constant
174 	 * defined in libconstants.gen.c or a number parsed with strtol(3).
175 	 *
176 	 * If there is an error parsing any of the constants, the whole process
177 	 * fails.
178 	 */
179 	while ((group = tokenize(&constant_str, "|")) != NULL) {
180 		char *end = group;
181 		value |= parse_single_constant(group, &end);
182 		if (end == group) {
183 			lastpos = original_constant_str;
184 			value = 0;
185 			break;
186 		}
187 		lastpos = end;
188 	}
189 	if (endptr)
190 		*endptr = lastpos;
191 	return value;
192 }
193 
194 /*
195  * parse_size, specified as a string with a decimal number in bytes,
196  * possibly with one 1-character suffix like "10K" or "6G".
197  * Assumes both pointers are non-NULL.
198  *
199  * Returns 0 on success, negative errno on failure.
200  * Only writes to result on success.
201  */
parse_size(size_t * result,const char * sizespec)202 int parse_size(size_t *result, const char *sizespec)
203 {
204 	const char prefixes[] = "KMGTPE";
205 	size_t i, multiplier = 1, nsize, size = 0;
206 	unsigned long long parsed;
207 	const size_t len = strlen(sizespec);
208 	char *end;
209 
210 	if (len == 0 || sizespec[0] == '-')
211 		return -EINVAL;
212 
213 	for (i = 0; i < sizeof(prefixes); ++i) {
214 		if (sizespec[len - 1] == prefixes[i]) {
215 #if __WORDSIZE == 32
216 			if (i >= 3)
217 				return -ERANGE;
218 #endif
219 			multiplier = 1024;
220 			while (i-- > 0)
221 				multiplier *= 1024;
222 			break;
223 		}
224 	}
225 
226 	/* We only need size_t but strtoul(3) is too small on IL32P64. */
227 	parsed = strtoull(sizespec, &end, 10);
228 	if (parsed == ULLONG_MAX)
229 		return -errno;
230 	if (parsed >= SIZE_MAX)
231 		return -ERANGE;
232 	if ((multiplier != 1 && end != sizespec + len - 1) ||
233 	    (multiplier == 1 && end != sizespec + len))
234 		return -EINVAL;
235 	size = (size_t)parsed;
236 
237 	nsize = size * multiplier;
238 	if (nsize / multiplier != size)
239 		return -ERANGE;
240 	*result = nsize;
241 	return 0;
242 }
243 
strip(char * s)244 char *strip(char *s)
245 {
246 	char *end;
247 	while (*s && isblank(*s))
248 		s++;
249 	end = s + strlen(s) - 1;
250 	while (end >= s && *end && (isblank(*end) || *end == '\n'))
251 		end--;
252 	*(end + 1) = '\0';
253 	return s;
254 }
255 
tokenize(char ** stringp,const char * delim)256 char *tokenize(char **stringp, const char *delim)
257 {
258 	char *ret = NULL;
259 
260 	/* If the string is NULL, there are no tokens to be found. */
261 	if (stringp == NULL || *stringp == NULL)
262 		return NULL;
263 
264 	/*
265 	 * If the delimiter is NULL or empty,
266 	 * the full string makes up the only token.
267 	 */
268 	if (delim == NULL || *delim == '\0') {
269 		ret = *stringp;
270 		*stringp = NULL;
271 		return ret;
272 	}
273 
274 	char *found = strstr(*stringp, delim);
275 	if (!found) {
276 		/*
277 		 * The delimiter was not found, so the full string
278 		 * makes up the only token, and we're done.
279 		 */
280 		ret = *stringp;
281 		*stringp = NULL;
282 	} else {
283 		/* There's a token here, possibly empty.  That's OK. */
284 		*found = '\0';
285 		ret = *stringp;
286 		*stringp = found + strlen(delim);
287 	}
288 
289 	return ret;
290 }
291 
path_join(const char * external_path,const char * internal_path)292 char *path_join(const char *external_path, const char *internal_path)
293 {
294 	char *path;
295 	size_t pathlen;
296 
297 	/* One extra char for '/' and one for '\0', hence + 2. */
298 	pathlen = strlen(external_path) + strlen(internal_path) + 2;
299 	path = malloc(pathlen);
300 	snprintf(path, pathlen, "%s/%s", external_path, internal_path);
301 
302 	return path;
303 }
304 
consumebytes(size_t length,char ** buf,size_t * buflength)305 void *consumebytes(size_t length, char **buf, size_t *buflength)
306 {
307 	char *p = *buf;
308 	if (length > *buflength)
309 		return NULL;
310 	*buf += length;
311 	*buflength -= length;
312 	return p;
313 }
314 
consumestr(char ** buf,size_t * buflength)315 char *consumestr(char **buf, size_t *buflength)
316 {
317 	size_t len = strnlen(*buf, *buflength);
318 	if (len == *buflength)
319 		/* There's no null-terminator. */
320 		return NULL;
321 	return consumebytes(len + 1, buf, buflength);
322 }
323 
init_logging(enum logging_system_t logger,int fd,int min_priority)324 void init_logging(enum logging_system_t logger, int fd, int min_priority)
325 {
326 	logging_config.logger = logger;
327 	logging_config.fd = fd;
328 	logging_config.min_priority = min_priority;
329 }
330