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