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 | |
26 | char *xstrdup(const char *s) |
27 | { |
28 | int len = strlen(s: s) + 1; |
29 | char *d = xmalloc(len); |
30 | |
31 | memcpy(dest: d, src: s, n: len); |
32 | |
33 | return d; |
34 | } |
35 | |
36 | char *xstrndup(const char *s, size_t n) |
37 | { |
38 | size_t len = strnlen(string: s, maxlen: n) + 1; |
39 | char *d = xmalloc(len); |
40 | |
41 | memcpy(dest: d, src: s, n: len - 1); |
42 | d[len - 1] = '\0'; |
43 | |
44 | return d; |
45 | } |
46 | |
47 | int 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(s: p); |
56 | |
57 | va_copy(ap_copy, ap); |
58 | n = vsnprintf(NULL, maxlen: 0, format: fmt, arg: ap_copy) + 1; |
59 | va_end(ap_copy); |
60 | |
61 | p = xrealloc(p, len: size + n); |
62 | |
63 | n = vsnprintf(s: p + size, maxlen: n, format: fmt, arg: ap); |
64 | |
65 | *strp = p; |
66 | return strlen(s: p); |
67 | } |
68 | |
69 | int 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 | |
81 | int 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 | |
95 | char *join_path(const char *path, const char *name) |
96 | { |
97 | int lenp = strlen(s: path); |
98 | int lenn = strlen(s: 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(dest: str, src: path, n: lenp); |
111 | if (needslash) { |
112 | str[lenp] = '/'; |
113 | lenp++; |
114 | } |
115 | memcpy(dest: str+lenp, src: name, n: lenn+1); |
116 | return str; |
117 | } |
118 | |
119 | bool 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 | */ |
155 | static 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(dest: x, src: s + *i, n: 3); |
163 | |
164 | val = strtol(nptr: x, endptr: &endx, base: 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 | */ |
178 | static 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(dest: x, src: s + *i, n: 2); |
186 | |
187 | val = strtol(nptr: x, endptr: &endx, base: 16); |
188 | if (!(endx > x)) |
189 | die(str: "\\x used with no following hex digits\n" ); |
190 | |
191 | (*i) += endx - x; |
192 | return val; |
193 | } |
194 | |
195 | char 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, i: &j); |
234 | break; |
235 | case 'x': |
236 | val = get_hex_char(s, i: &j); |
237 | break; |
238 | default: |
239 | val = c; |
240 | } |
241 | |
242 | (*i) = j; |
243 | return val; |
244 | } |
245 | |
246 | int 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(s1: filename, s2: "-" ) != 0) { |
255 | fd = open(file: filename, O_RDONLY); |
256 | if (fd < 0) |
257 | return errno; |
258 | } |
259 | |
260 | /* Loop until we have read everything */ |
261 | buf = xmalloc(len: bufsize); |
262 | do { |
263 | /* Expand the buffer to hold the next chunk */ |
264 | if (offset == bufsize) { |
265 | bufsize *= 2; |
266 | buf = xrealloc(p: buf, len: bufsize); |
267 | } |
268 | |
269 | ret = read(fd: fd, buf: &buf[offset], nbytes: 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: fd); |
279 | if (ret) |
280 | free(ptr: buf); |
281 | else |
282 | *buffp = buf; |
283 | if (len) |
284 | *len = bufsize; |
285 | return ret; |
286 | } |
287 | |
288 | char *utilfdt_read(const char *filename, size_t *len) |
289 | { |
290 | char *buff; |
291 | int ret = utilfdt_read_err(filename, buffp: &buff, len); |
292 | |
293 | if (ret) { |
294 | fprintf(stderr, format: "Couldn't open blob from '%s': %s\n" , filename, |
295 | strerror(errnum: ret)); |
296 | return NULL; |
297 | } |
298 | /* Successful read */ |
299 | return buff; |
300 | } |
301 | |
302 | int 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(s1: filename, s2: "-" ) != 0) { |
311 | fd = open(file: 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: fd, buf: ptr + offset, n: 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: fd); |
330 | return ret < 0 ? -ret : 0; |
331 | } |
332 | |
333 | |
334 | int utilfdt_write(const char *filename, const void *blob) |
335 | { |
336 | int ret = utilfdt_write_err(filename, blob); |
337 | |
338 | if (ret) { |
339 | fprintf(stderr, format: "Couldn't write blob to '%s': %s\n" , filename, |
340 | strerror(errnum: ret)); |
341 | } |
342 | return ret ? -1 : 0; |
343 | } |
344 | |
345 | int 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(s: "hlLb" , c: *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(s: "iuxsr" , c: *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 | |
383 | void 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(format: " = " ); |
394 | |
395 | s = data; |
396 | do { |
397 | printf(format: "\"%s\"" , s); |
398 | s += strlen(s: s) + 1; |
399 | if (s < data + len) |
400 | printf(format: ", " ); |
401 | } while (s < data + len); |
402 | |
403 | } else if ((len % 4) == 0) { |
404 | const fdt32_t *cell = (const fdt32_t *)data; |
405 | |
406 | printf(format: " = <" ); |
407 | for (i = 0, len /= 4; i < len; i++) |
408 | printf(format: "0x%08" PRIx32 "%s" , fdt32_to_cpu(cell[i]), |
409 | i < (len - 1) ? " " : "" ); |
410 | printf(format: ">" ); |
411 | } else { |
412 | const unsigned char *p = (const unsigned char *)data; |
413 | printf(format: " = [" ); |
414 | for (i = 0; i < len; i++) |
415 | printf(format: "%02x%s" , *p++, i < len - 1 ? " " : "" ); |
416 | printf(format: "]" ); |
417 | } |
418 | } |
419 | |
420 | void NORETURN util_version(void) |
421 | { |
422 | printf(format: "Version: %s\n" , DTC_VERSION); |
423 | exit(status: 0); |
424 | } |
425 | |
426 | void 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(s: a_arg) + 1; |
434 | size_t i; |
435 | int optlen; |
436 | |
437 | fprintf(stream: fp, |
438 | format: "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(s: 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(stream: fp, format: " " ); |
460 | else |
461 | fprintf(stream: fp, format: " -%c, " , long_opts[i].val); |
462 | |
463 | /* then the long flag */ |
464 | if (long_opts[i].has_arg == no_argument) |
465 | fprintf(stream: fp, format: "--%-*s" , optlen, long_opts[i].name); |
466 | else |
467 | fprintf(stream: fp, format: "--%s %s%*s" , long_opts[i].name, a_arg, |
468 | (int)(optlen - strlen(s: long_opts[i].name) - a_arg_len), "" ); |
469 | |
470 | /* finally the help text */ |
471 | fprintf(stream: fp, format: "%s\n" , opts_help[i]); |
472 | } |
473 | |
474 | if (errmsg) { |
475 | fprintf(stream: fp, format: "\nError: %s\n" , errmsg); |
476 | exit(EXIT_FAILURE); |
477 | } else |
478 | exit(EXIT_SUCCESS); |
479 | } |
480 | |