1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright 2011 The Chromium Authors, All Rights Reserved.
4  * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
5  *
6  * util_is_printable_string contributed by
7  *	Pantelis Antoniou <pantelis.antoniou AT gmail.com>
8  */
9 
10 #include <ctype.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <stdarg.h>
14 #include <string.h>
15 #include <assert.h>
16 #include <inttypes.h>
17 
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <unistd.h>
21 
22 #include "libfdt.h"
23 #include "util.h"
24 #include "version_gen.h"
25 
xstrdup(const char * s)26 char *xstrdup(const char *s)
27 {
28 	int len = strlen(s) + 1;
29 	char *d = xmalloc(len);
30 
31 	memcpy(d, s, len);
32 
33 	return d;
34 }
35 
xstrndup(const char * s,size_t n)36 char *xstrndup(const char *s, size_t n)
37 {
38 	size_t len = strnlen(s, n) + 1;
39 	char *d = xmalloc(len);
40 
41 	memcpy(d, s, len - 1);
42 	d[len - 1] = '\0';
43 
44 	return d;
45 }
46 
xavsprintf_append(char ** strp,const char * fmt,va_list ap)47 int xavsprintf_append(char **strp, const char *fmt, va_list ap)
48 {
49 	int n, size = 0;	/* start with 128 bytes */
50 	char *p;
51 	va_list ap_copy;
52 
53 	p = *strp;
54 	if (p)
55 		size = strlen(p);
56 
57 	va_copy(ap_copy, ap);
58 	n = vsnprintf(NULL, 0, fmt, ap_copy) + 1;
59 	va_end(ap_copy);
60 
61 	p = xrealloc(p, size + n);
62 
63 	n = vsnprintf(p + size, n, fmt, ap);
64 
65 	*strp = p;
66 	return strlen(p);
67 }
68 
xasprintf_append(char ** strp,const char * fmt,...)69 int xasprintf_append(char **strp, const char *fmt, ...)
70 {
71 	int n;
72 	va_list ap;
73 
74 	va_start(ap, fmt);
75 	n = xavsprintf_append(strp, fmt, ap);
76 	va_end(ap);
77 
78 	return n;
79 }
80 
xasprintf(char ** strp,const char * fmt,...)81 int xasprintf(char **strp, const char *fmt, ...)
82 {
83 	int n;
84 	va_list ap;
85 
86 	*strp = NULL;
87 
88 	va_start(ap, fmt);
89 	n = xavsprintf_append(strp, fmt, ap);
90 	va_end(ap);
91 
92 	return n;
93 }
94 
join_path(const char * path,const char * name)95 char *join_path(const char *path, const char *name)
96 {
97 	int lenp = strlen(path);
98 	int lenn = strlen(name);
99 	int len;
100 	int needslash = 1;
101 	char *str;
102 
103 	len = lenp + lenn + 2;
104 	if ((lenp > 0) && (path[lenp-1] == '/')) {
105 		needslash = 0;
106 		len--;
107 	}
108 
109 	str = xmalloc(len);
110 	memcpy(str, path, lenp);
111 	if (needslash) {
112 		str[lenp] = '/';
113 		lenp++;
114 	}
115 	memcpy(str+lenp, name, lenn+1);
116 	return str;
117 }
118 
util_is_printable_string(const void * data,int len)119 bool util_is_printable_string(const void *data, int len)
120 {
121 	const char *s = data;
122 	const char *ss, *se;
123 
124 	/* zero length is not */
125 	if (len == 0)
126 		return 0;
127 
128 	/* must terminate with zero */
129 	if (s[len - 1] != '\0')
130 		return 0;
131 
132 	se = s + len;
133 
134 	while (s < se) {
135 		ss = s;
136 		while (s < se && *s && isprint((unsigned char)*s))
137 			s++;
138 
139 		/* not zero, or not done yet */
140 		if (*s != '\0' || s == ss)
141 			return 0;
142 
143 		s++;
144 	}
145 
146 	return 1;
147 }
148 
149 /*
150  * Parse a octal encoded character starting at index i in string s.  The
151  * resulting character will be returned and the index i will be updated to
152  * point at the character directly after the end of the encoding, this may be
153  * the '\0' terminator of the string.
154  */
get_oct_char(const char * s,int * i)155 static char get_oct_char(const char *s, int *i)
156 {
157 	char x[4];
158 	char *endx;
159 	long val;
160 
161 	x[3] = '\0';
162 	strncpy(x, s + *i, 3);
163 
164 	val = strtol(x, &endx, 8);
165 
166 	assert(endx > x);
167 
168 	(*i) += endx - x;
169 	return val;
170 }
171 
172 /*
173  * Parse a hexadecimal encoded character starting at index i in string s.  The
174  * resulting character will be returned and the index i will be updated to
175  * point at the character directly after the end of the encoding, this may be
176  * the '\0' terminator of the string.
177  */
get_hex_char(const char * s,int * i)178 static char get_hex_char(const char *s, int *i)
179 {
180 	char x[3];
181 	char *endx;
182 	long val;
183 
184 	x[2] = '\0';
185 	strncpy(x, s + *i, 2);
186 
187 	val = strtol(x, &endx, 16);
188 	if (!(endx  > x))
189 		die("\\x used with no following hex digits\n");
190 
191 	(*i) += endx - x;
192 	return val;
193 }
194 
get_escape_char(const char * s,int * i)195 char get_escape_char(const char *s, int *i)
196 {
197 	char	c = s[*i];
198 	int	j = *i + 1;
199 	char	val;
200 
201 	switch (c) {
202 	case 'a':
203 		val = '\a';
204 		break;
205 	case 'b':
206 		val = '\b';
207 		break;
208 	case 't':
209 		val = '\t';
210 		break;
211 	case 'n':
212 		val = '\n';
213 		break;
214 	case 'v':
215 		val = '\v';
216 		break;
217 	case 'f':
218 		val = '\f';
219 		break;
220 	case 'r':
221 		val = '\r';
222 		break;
223 	case '0':
224 	case '1':
225 	case '2':
226 	case '3':
227 	case '4':
228 	case '5':
229 	case '6':
230 	case '7':
231 		j--; /* need to re-read the first digit as
232 		      * part of the octal value */
233 		val = get_oct_char(s, &j);
234 		break;
235 	case 'x':
236 		val = get_hex_char(s, &j);
237 		break;
238 	default:
239 		val = c;
240 	}
241 
242 	(*i) = j;
243 	return val;
244 }
245 
utilfdt_read_err(const char * filename,char ** buffp,size_t * len)246 int utilfdt_read_err(const char *filename, char **buffp, size_t *len)
247 {
248 	int fd = 0;	/* assume stdin */
249 	char *buf = NULL;
250 	size_t bufsize = 1024, offset = 0;
251 	int ret = 0;
252 
253 	*buffp = NULL;
254 	if (strcmp(filename, "-") != 0) {
255 		fd = open(filename, O_RDONLY);
256 		if (fd < 0)
257 			return errno;
258 	}
259 
260 	/* Loop until we have read everything */
261 	buf = xmalloc(bufsize);
262 	do {
263 		/* Expand the buffer to hold the next chunk */
264 		if (offset == bufsize) {
265 			bufsize *= 2;
266 			buf = xrealloc(buf, bufsize);
267 		}
268 
269 		ret = read(fd, &buf[offset], bufsize - offset);
270 		if (ret < 0) {
271 			ret = errno;
272 			break;
273 		}
274 		offset += ret;
275 	} while (ret != 0);
276 
277 	/* Clean up, including closing stdin; return errno on error */
278 	close(fd);
279 	if (ret)
280 		free(buf);
281 	else
282 		*buffp = buf;
283 	if (len)
284 		*len = bufsize;
285 	return ret;
286 }
287 
utilfdt_read(const char * filename,size_t * len)288 char *utilfdt_read(const char *filename, size_t *len)
289 {
290 	char *buff;
291 	int ret = utilfdt_read_err(filename, &buff, len);
292 
293 	if (ret) {
294 		fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
295 			strerror(ret));
296 		return NULL;
297 	}
298 	/* Successful read */
299 	return buff;
300 }
301 
utilfdt_write_err(const char * filename,const void * blob)302 int utilfdt_write_err(const char *filename, const void *blob)
303 {
304 	int fd = 1;	/* assume stdout */
305 	int totalsize;
306 	int offset;
307 	int ret = 0;
308 	const char *ptr = blob;
309 
310 	if (strcmp(filename, "-") != 0) {
311 		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
312 		if (fd < 0)
313 			return errno;
314 	}
315 
316 	totalsize = fdt_totalsize(blob);
317 	offset = 0;
318 
319 	while (offset < totalsize) {
320 		ret = write(fd, ptr + offset, totalsize - offset);
321 		if (ret < 0) {
322 			ret = -errno;
323 			break;
324 		}
325 		offset += ret;
326 	}
327 	/* Close the file/stdin; return errno on error */
328 	if (fd != 1)
329 		close(fd);
330 	return ret < 0 ? -ret : 0;
331 }
332 
333 
utilfdt_write(const char * filename,const void * blob)334 int utilfdt_write(const char *filename, const void *blob)
335 {
336 	int ret = utilfdt_write_err(filename, blob);
337 
338 	if (ret) {
339 		fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
340 			strerror(ret));
341 	}
342 	return ret ? -1 : 0;
343 }
344 
utilfdt_decode_type(const char * fmt,int * type,int * size)345 int utilfdt_decode_type(const char *fmt, int *type, int *size)
346 {
347 	int qualifier = 0;
348 
349 	if (!*fmt)
350 		return -1;
351 
352 	/* get the conversion qualifier */
353 	*size = -1;
354 	if (strchr("hlLb", *fmt)) {
355 		qualifier = *fmt++;
356 		if (qualifier == *fmt) {
357 			switch (*fmt++) {
358 /* TODO:		case 'l': qualifier = 'L'; break;*/
359 			case 'h':
360 				qualifier = 'b';
361 				break;
362 			}
363 		}
364 	}
365 
366 	/* we should now have a type */
367 	if ((*fmt == '\0') || !strchr("iuxsr", *fmt))
368 		return -1;
369 
370 	/* convert qualifier (bhL) to byte size */
371 	if (*fmt != 's' && *fmt != 'r')
372 		*size = qualifier == 'b' ? 1 :
373 				qualifier == 'h' ? 2 :
374 				qualifier == 'l' ? 4 : -1;
375 	*type = *fmt++;
376 
377 	/* that should be it! */
378 	if (*fmt)
379 		return -1;
380 	return 0;
381 }
382 
utilfdt_print_data(const char * data,int len)383 void utilfdt_print_data(const char *data, int len)
384 {
385 	int i;
386 	const char *s;
387 
388 	/* no data, don't print */
389 	if (len == 0)
390 		return;
391 
392 	if (util_is_printable_string(data, len)) {
393 		printf(" = ");
394 
395 		s = data;
396 		do {
397 			printf("\"%s\"", s);
398 			s += strlen(s) + 1;
399 			if (s < data + len)
400 				printf(", ");
401 		} while (s < data + len);
402 
403 	} else if ((len % 4) == 0) {
404 		const fdt32_t *cell = (const fdt32_t *)data;
405 
406 		printf(" = <");
407 		for (i = 0, len /= 4; i < len; i++)
408 			printf("0x%08" PRIx32 "%s", fdt32_to_cpu(cell[i]),
409 			       i < (len - 1) ? " " : "");
410 		printf(">");
411 	} else {
412 		const unsigned char *p = (const unsigned char *)data;
413 		printf(" = [");
414 		for (i = 0; i < len; i++)
415 			printf("%02x%s", *p++, i < len - 1 ? " " : "");
416 		printf("]");
417 	}
418 }
419 
util_version(void)420 void NORETURN util_version(void)
421 {
422 	printf("Version: %s\n", DTC_VERSION);
423 	exit(0);
424 }
425 
util_usage(const char * errmsg,const char * synopsis,const char * short_opts,struct option const long_opts[],const char * const opts_help[])426 void NORETURN util_usage(const char *errmsg, const char *synopsis,
427 			 const char *short_opts,
428 			 struct option const long_opts[],
429 			 const char * const opts_help[])
430 {
431 	FILE *fp = errmsg ? stderr : stdout;
432 	const char a_arg[] = "<arg>";
433 	size_t a_arg_len = strlen(a_arg) + 1;
434 	size_t i;
435 	int optlen;
436 
437 	fprintf(fp,
438 		"Usage: %s\n"
439 		"\n"
440 		"Options: -[%s]\n", synopsis, short_opts);
441 
442 	/* prescan the --long opt length to auto-align */
443 	optlen = 0;
444 	for (i = 0; long_opts[i].name; ++i) {
445 		/* +1 is for space between --opt and help text */
446 		int l = strlen(long_opts[i].name) + 1;
447 		if (long_opts[i].has_arg == a_argument)
448 			l += a_arg_len;
449 		if (optlen < l)
450 			optlen = l;
451 	}
452 
453 	for (i = 0; long_opts[i].name; ++i) {
454 		/* helps when adding new applets or options */
455 		assert(opts_help[i] != NULL);
456 
457 		/* first output the short flag if it has one */
458 		if (long_opts[i].val > '~')
459 			fprintf(fp, "      ");
460 		else
461 			fprintf(fp, "  -%c, ", long_opts[i].val);
462 
463 		/* then the long flag */
464 		if (long_opts[i].has_arg == no_argument)
465 			fprintf(fp, "--%-*s", optlen, long_opts[i].name);
466 		else
467 			fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
468 				(int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");
469 
470 		/* finally the help text */
471 		fprintf(fp, "%s\n", opts_help[i]);
472 	}
473 
474 	if (errmsg) {
475 		fprintf(fp, "\nError: %s\n", errmsg);
476 		exit(EXIT_FAILURE);
477 	} else
478 		exit(EXIT_SUCCESS);
479 }
480