Loading...
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}
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
39char *xstrdup(const char *s)
40{
41 int len = strlen(s) + 1;
42 char *dup = xmalloc(len);
43
44 memcpy(dup, s, len);
45
46 return dup;
47}
48
49char *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}
72
73int util_is_printable_string(const void *data, int len)
74{
75 const char *s = data;
76 const char *ss, *se;
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
86 se = s + len;
87
88 while (s < se) {
89 ss = s;
90 while (s < se && *s && isprint(*s))
91 s++;
92
93 /* not zero, or not done yet */
94 if (*s != '\0' || s == ss)
95 return 0;
96
97 s++;
98 }
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 */
109static 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 */
132static 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
149char get_escape_char(const char *s, int *i)
150{
151 char c = s[*i];
152 int j = *i + 1;
153 char val;
154
155 assert(c);
156 switch (c) {
157 case 'a':
158 val = '\a';
159 break;
160 case 'b':
161 val = '\b';
162 break;
163 case 't':
164 val = '\t';
165 break;
166 case 'n':
167 val = '\n';
168 break;
169 case 'v':
170 val = '\v';
171 break;
172 case 'f':
173 val = '\f';
174 break;
175 case 'r':
176 val = '\r';
177 break;
178 case '0':
179 case '1':
180 case '2':
181 case '3':
182 case '4':
183 case '5':
184 case '6':
185 case '7':
186 j--; /* need to re-read the first digit as
187 * part of the octal value */
188 val = get_oct_char(s, &j);
189 break;
190 case 'x':
191 val = get_hex_char(s, &j);
192 break;
193 default:
194 val = c;
195 }
196
197 (*i) = j;
198 return val;
199}
200
201int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len)
202{
203 int fd = 0; /* assume stdin */
204 char *buf = NULL;
205 off_t bufsize = 1024, offset = 0;
206 int ret = 0;
207
208 *buffp = NULL;
209 if (strcmp(filename, "-") != 0) {
210 fd = open(filename, O_RDONLY);
211 if (fd < 0)
212 return errno;
213 }
214
215 /* Loop until we have read everything */
216 buf = xmalloc(bufsize);
217 do {
218 /* Expand the buffer to hold the next chunk */
219 if (offset == bufsize) {
220 bufsize *= 2;
221 buf = xrealloc(buf, bufsize);
222 if (!buf) {
223 ret = ENOMEM;
224 break;
225 }
226 }
227
228 ret = read(fd, &buf[offset], bufsize - offset);
229 if (ret < 0) {
230 ret = errno;
231 break;
232 }
233 offset += ret;
234 } while (ret != 0);
235
236 /* Clean up, including closing stdin; return errno on error */
237 close(fd);
238 if (ret)
239 free(buf);
240 else
241 *buffp = buf;
242 *len = bufsize;
243 return ret;
244}
245
246int utilfdt_read_err(const char *filename, char **buffp)
247{
248 off_t len;
249 return utilfdt_read_err_len(filename, buffp, &len);
250}
251
252char *utilfdt_read_len(const char *filename, off_t *len)
253{
254 char *buff;
255 int ret = utilfdt_read_err_len(filename, &buff, len);
256
257 if (ret) {
258 fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
259 strerror(ret));
260 return NULL;
261 }
262 /* Successful read */
263 return buff;
264}
265
266char *utilfdt_read(const char *filename)
267{
268 off_t len;
269 return utilfdt_read_len(filename, &len);
270}
271
272int utilfdt_write_err(const char *filename, const void *blob)
273{
274 int fd = 1; /* assume stdout */
275 int totalsize;
276 int offset;
277 int ret = 0;
278 const char *ptr = blob;
279
280 if (strcmp(filename, "-") != 0) {
281 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
282 if (fd < 0)
283 return errno;
284 }
285
286 totalsize = fdt_totalsize(blob);
287 offset = 0;
288
289 while (offset < totalsize) {
290 ret = write(fd, ptr + offset, totalsize - offset);
291 if (ret < 0) {
292 ret = -errno;
293 break;
294 }
295 offset += ret;
296 }
297 /* Close the file/stdin; return errno on error */
298 if (fd != 1)
299 close(fd);
300 return ret < 0 ? -ret : 0;
301}
302
303
304int utilfdt_write(const char *filename, const void *blob)
305{
306 int ret = utilfdt_write_err(filename, blob);
307
308 if (ret) {
309 fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
310 strerror(ret));
311 }
312 return ret ? -1 : 0;
313}
314
315int utilfdt_decode_type(const char *fmt, int *type, int *size)
316{
317 int qualifier = 0;
318
319 if (!*fmt)
320 return -1;
321
322 /* get the conversion qualifier */
323 *size = -1;
324 if (strchr("hlLb", *fmt)) {
325 qualifier = *fmt++;
326 if (qualifier == *fmt) {
327 switch (*fmt++) {
328/* TODO: case 'l': qualifier = 'L'; break;*/
329 case 'h':
330 qualifier = 'b';
331 break;
332 }
333 }
334 }
335
336 /* we should now have a type */
337 if ((*fmt == '\0') || !strchr("iuxs", *fmt))
338 return -1;
339
340 /* convert qualifier (bhL) to byte size */
341 if (*fmt != 's')
342 *size = qualifier == 'b' ? 1 :
343 qualifier == 'h' ? 2 :
344 qualifier == 'l' ? 4 : -1;
345 *type = *fmt++;
346
347 /* that should be it! */
348 if (*fmt)
349 return -1;
350 return 0;
351}
352
353void utilfdt_print_data(const char *data, int len)
354{
355 int i;
356 const char *p = data;
357 const char *s;
358
359 /* no data, don't print */
360 if (len == 0)
361 return;
362
363 if (util_is_printable_string(data, len)) {
364 printf(" = ");
365
366 s = data;
367 do {
368 printf("\"%s\"", s);
369 s += strlen(s) + 1;
370 if (s < data + len)
371 printf(", ");
372 } while (s < data + len);
373
374 } else if ((len % 4) == 0) {
375 const uint32_t *cell = (const uint32_t *)data;
376
377 printf(" = <");
378 for (i = 0; i < len; i += 4)
379 printf("0x%08x%s", fdt32_to_cpu(cell[i]),
380 i < (len - 4) ? " " : "");
381 printf(">");
382 } else {
383 printf(" = [");
384 for (i = 0; i < len; i++)
385 printf("%02x%s", *p++, i < len - 1 ? " " : "");
386 printf("]");
387 }
388}
389
390void util_version(void)
391{
392 printf("Version: %s\n", DTC_VERSION);
393 exit(0);
394}
395
396void util_usage(const char *errmsg, const char *synopsis,
397 const char *short_opts, struct option const long_opts[],
398 const char * const opts_help[])
399{
400 FILE *fp = errmsg ? stderr : stdout;
401 const char a_arg[] = "<arg>";
402 size_t a_arg_len = strlen(a_arg) + 1;
403 size_t i;
404 int optlen;
405
406 fprintf(fp,
407 "Usage: %s\n"
408 "\n"
409 "Options: -[%s]\n", synopsis, short_opts);
410
411 /* prescan the --long opt length to auto-align */
412 optlen = 0;
413 for (i = 0; long_opts[i].name; ++i) {
414 /* +1 is for space between --opt and help text */
415 int l = strlen(long_opts[i].name) + 1;
416 if (long_opts[i].has_arg == a_argument)
417 l += a_arg_len;
418 if (optlen < l)
419 optlen = l;
420 }
421
422 for (i = 0; long_opts[i].name; ++i) {
423 /* helps when adding new applets or options */
424 assert(opts_help[i] != NULL);
425
426 /* first output the short flag if it has one */
427 if (long_opts[i].val > '~')
428 fprintf(fp, " ");
429 else
430 fprintf(fp, " -%c, ", long_opts[i].val);
431
432 /* then the long flag */
433 if (long_opts[i].has_arg == no_argument)
434 fprintf(fp, "--%-*s", optlen, long_opts[i].name);
435 else
436 fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
437 (int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");
438
439 /* finally the help text */
440 fprintf(fp, "%s\n", opts_help[i]);
441 }
442
443 if (errmsg) {
444 fprintf(fp, "\nError: %s\n", errmsg);
445 exit(EXIT_FAILURE);
446 } else
447 exit(EXIT_SUCCESS);
448}