[J-u-boot.git] / scripts / dtc / util.c

/*
 * Copyright 2011 The Chromium Authors, All Rights Reserved.
 * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
 *
 * util_is_printable_string contributed by
 *	Pantelis Antoniou <pantelis.antoniou AT gmail.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *                                                                   USA
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>

#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

#include "libfdt.h"
#include "util.h"
#include "version_gen.h"

char *xstrdup(const char *s)
{
	int len = strlen(s) + 1;
	char *d = xmalloc(len);

	memcpy(d, s, len);

	return d;
}

/* based in part from (3) vsnprintf */
int xasprintf(char **strp, const char *fmt, ...)
{
	int n, size = 128;	/* start with 128 bytes */
	char *p;
	va_list ap;

	/* initial pointer is NULL making the fist realloc to be malloc */
	p = NULL;
	while (1) {
		p = xrealloc(p, size);

		/* Try to print in the allocated space. */
		va_start(ap, fmt);
		n = vsnprintf(p, size, fmt, ap);
		va_end(ap);

		/* If that worked, return the string. */
		if (n > -1 && n < size)
			break;
		/* Else try again with more space. */
		if (n > -1)	/* glibc 2.1 */
			size = n + 1; /* precisely what is needed */
		else		/* glibc 2.0 */
			size *= 2; /* twice the old size */
	}
	*strp = p;
	return strlen(p);
}

char *join_path(const char *path, const char *name)
{
	int lenp = strlen(path);
	int lenn = strlen(name);
	int len;
	int needslash = 1;
	char *str;

	len = lenp + lenn + 2;
	if ((lenp > 0) && (path[lenp-1] == '/')) {
		needslash = 0;
		len--;
	}

	str = xmalloc(len);
	memcpy(str, path, lenp);
	if (needslash) {
		str[lenp] = '/';
		lenp++;
	}
	memcpy(str+lenp, name, lenn+1);
	return str;
}

bool util_is_printable_string(const void *data, int len)
{
	const char *s = data;
	const char *ss, *se;

	/* zero length is not */
	if (len == 0)
		return 0;

	/* must terminate with zero */
	if (s[len - 1] != '\0')
		return 0;

	se = s + len;

	while (s < se) {
		ss = s;
		while (s < se && *s && isprint((unsigned char)*s))
			s++;

		/* not zero, or not done yet */
		if (*s != '\0' || s == ss)
			return 0;

		s++;
	}

	return 1;
}

/*
 * Parse a octal encoded character starting at index i in string s.  The
 * resulting character will be returned and the index i will be updated to
 * point at the character directly after the end of the encoding, this may be
 * the '\0' terminator of the string.
 */
static char get_oct_char(const char *s, int *i)
{
	char x[4];
	char *endx;
	long val;

	x[3] = '\0';
	strncpy(x, s + *i, 3);

	val = strtol(x, &endx, 8);

	assert(endx > x);

	(*i) += endx - x;
	return val;
}

/*
 * Parse a hexadecimal encoded character starting at index i in string s.  The
 * resulting character will be returned and the index i will be updated to
 * point at the character directly after the end of the encoding, this may be
 * the '\0' terminator of the string.
 */
static char get_hex_char(const char *s, int *i)
{
	char x[3];
	char *endx;
	long val;

	x[2] = '\0';
	strncpy(x, s + *i, 2);

	val = strtol(x, &endx, 16);
	if (!(endx  > x))
		die("\\x used with no following hex digits\n");

	(*i) += endx - x;
	return val;
}

char get_escape_char(const char *s, int *i)
{
	char	c = s[*i];
	int	j = *i + 1;
	char	val;

	switch (c) {
	case 'a':
		val = '\a';
		break;
	case 'b':
		val = '\b';
		break;
	case 't':
		val = '\t';
		break;
	case 'n':
		val = '\n';
		break;
	case 'v':
		val = '\v';
		break;
	case 'f':
		val = '\f';
		break;
	case 'r':
		val = '\r';
		break;
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
		j--; /* need to re-read the first digit as
		      * part of the octal value */
		val = get_oct_char(s, &j);
		break;
	case 'x':
		val = get_hex_char(s, &j);
		break;
	default:
		val = c;
	}

	(*i) = j;
	return val;
}

int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len)
{
	int fd = 0;	/* assume stdin */
	char *buf = NULL;
	off_t bufsize = 1024, offset = 0;
	int ret = 0;

	*buffp = NULL;
	if (strcmp(filename, "-") != 0) {
		fd = open(filename, O_RDONLY);
		if (fd < 0)
			return errno;
	}

	/* Loop until we have read everything */
	buf = xmalloc(bufsize);
	do {
		/* Expand the buffer to hold the next chunk */
		if (offset == bufsize) {
			bufsize *= 2;
			buf = xrealloc(buf, bufsize);
		}

		ret = read(fd, &buf[offset], bufsize - offset);
		if (ret < 0) {
			ret = errno;
			break;
		}
		offset += ret;
	} while (ret != 0);

	/* Clean up, including closing stdin; return errno on error */
	close(fd);
	if (ret)
		free(buf);
	else
		*buffp = buf;
	*len = bufsize;
	return ret;
}

int utilfdt_read_err(const char *filename, char **buffp)
{
	off_t len;
	return utilfdt_read_err_len(filename, buffp, &len);
}

char *utilfdt_read_len(const char *filename, off_t *len)
{
	char *buff;
	int ret = utilfdt_read_err_len(filename, &buff, len);

	if (ret) {
		fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
			strerror(ret));
		return NULL;
	}
	/* Successful read */
	return buff;
}

char *utilfdt_read(const char *filename)
{
	off_t len;
	return utilfdt_read_len(filename, &len);
}

int utilfdt_write_err(const char *filename, const void *blob)
{
	int fd = 1;	/* assume stdout */
	int totalsize;
	int offset;
	int ret = 0;
	const char *ptr = blob;

	if (strcmp(filename, "-") != 0) {
		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
		if (fd < 0)
			return errno;
	}

	totalsize = fdt_totalsize(blob);
	offset = 0;

	while (offset < totalsize) {
		ret = write(fd, ptr + offset, totalsize - offset);
		if (ret < 0) {
			ret = -errno;
			break;
		}
		offset += ret;
	}
	/* Close the file/stdin; return errno on error */
	if (fd != 1)
		close(fd);
	return ret < 0 ? -ret : 0;
}


int utilfdt_write(const char *filename, const void *blob)
{
	int ret = utilfdt_write_err(filename, blob);

	if (ret) {
		fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
			strerror(ret));
	}
	return ret ? -1 : 0;
}

int utilfdt_decode_type(const char *fmt, int *type, int *size)
{
	int qualifier = 0;

	if (!*fmt)
		return -1;

	/* get the conversion qualifier */
	*size = -1;
	if (strchr("hlLb", *fmt)) {
		qualifier = *fmt++;
		if (qualifier == *fmt) {
			switch (*fmt++) {
/* TODO:		case 'l': qualifier = 'L'; break;*/
			case 'h':
				qualifier = 'b';
				break;
			}
		}
	}

	/* we should now have a type */
	if ((*fmt == '\0') || !strchr("iuxs", *fmt))
		return -1;

	/* convert qualifier (bhL) to byte size */
	if (*fmt != 's')
		*size = qualifier == 'b' ? 1 :
				qualifier == 'h' ? 2 :
				qualifier == 'l' ? 4 : -1;
	*type = *fmt++;

	/* that should be it! */
	if (*fmt)
		return -1;
	return 0;
}

void utilfdt_print_data(const char *data, int len)
{
	int i;
	const char *s;

	/* no data, don't print */
	if (len == 0)
		return;

	if (util_is_printable_string(data, len)) {
		printf(" = ");

		s = data;
		do {
			printf("\"%s\"", s);
			s += strlen(s) + 1;
			if (s < data + len)
				printf(", ");
		} while (s < data + len);

	} else if ((len % 4) == 0) {
		const fdt32_t *cell = (const fdt32_t *)data;

		printf(" = <");
		for (i = 0, len /= 4; i < len; i++)
			printf("0x%08x%s", fdt32_to_cpu(cell[i]),
			       i < (len - 1) ? " " : "");
		printf(">");
	} else {
		const unsigned char *p = (const unsigned char *)data;
		printf(" = [");
		for (i = 0; i < len; i++)
			printf("%02x%s", *p++, i < len - 1 ? " " : "");
		printf("]");
	}
}

void NORETURN util_version(void)
{
	printf("Version: %s\n", DTC_VERSION);
	exit(0);
}

void NORETURN util_usage(const char *errmsg, const char *synopsis,
			 const char *short_opts,
			 struct option const long_opts[],
			 const char * const opts_help[])
{
	FILE *fp = errmsg ? stderr : stdout;
	const char a_arg[] = "<arg>";
	size_t a_arg_len = strlen(a_arg) + 1;
	size_t i;
	int optlen;

	fprintf(fp,
		"Usage: %s\n"
		"\n"
		"Options: -[%s]\n", synopsis, short_opts);

	/* prescan the --long opt length to auto-align */
	optlen = 0;
	for (i = 0; long_opts[i].name; ++i) {
		/* +1 is for space between --opt and help text */
		int l = strlen(long_opts[i].name) + 1;
		if (long_opts[i].has_arg == a_argument)
			l += a_arg_len;
		if (optlen < l)
			optlen = l;
	}

	for (i = 0; long_opts[i].name; ++i) {
		/* helps when adding new applets or options */
		assert(opts_help[i] != NULL);

		/* first output the short flag if it has one */
		if (long_opts[i].val > '~')
			fprintf(fp, "      ");
		else
			fprintf(fp, "  -%c, ", long_opts[i].val);

		/* then the long flag */
		if (long_opts[i].has_arg == no_argument)
			fprintf(fp, "--%-*s", optlen, long_opts[i].name);
		else
			fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
				(int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");

		/* finally the help text */
		fprintf(fp, "%s\n", opts_help[i]);
	}

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