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
26char *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
36char *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
47int 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
69int 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
81int 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
95char *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
119bool 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 */
155static 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 */
178static 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
195char 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
246int 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
288char *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
302int 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
334int 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
345int 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
383void 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
420void NORETURN util_version(void)
421{
422	printf("Version: %s\n", DTC_VERSION);
423	exit(0);
424}
425
426void 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