projects/linux·blob master · refs

495 lines · 8.9 KiB

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