[mirror_ubuntu-zesty-kernel.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;
}

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 uint32_t *cell = (const uint32_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 util_version(void)
{
	printf("Version: %s\n", DTC_VERSION);
	exit(0);
}

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