1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
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
73bool util_is_printable_string(const void *data, int len)
74{
75 const char *s = data;
76 const char *ss, *se;
77
78
79 if (len == 0)
80 return 0;
81
82
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((unsigned char)*s))
91 s++;
92
93
94 if (*s != '\0' || s == ss)
95 return 0;
96
97 s++;
98 }
99
100 return 1;
101}
102
103
104
105
106
107
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
128
129
130
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--;
187
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;
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
216 buf = xmalloc(bufsize);
217 do {
218
219 if (offset == bufsize) {
220 bufsize *= 2;
221 buf = xrealloc(buf, bufsize);
222 }
223
224 ret = read(fd, &buf[offset], bufsize - offset);
225 if (ret < 0) {
226 ret = errno;
227 break;
228 }
229 offset += ret;
230 } while (ret != 0);
231
232
233 close(fd);
234 if (ret)
235 free(buf);
236 else
237 *buffp = buf;
238 *len = bufsize;
239 return ret;
240}
241
242int utilfdt_read_err(const char *filename, char **buffp)
243{
244 off_t len;
245 return utilfdt_read_err_len(filename, buffp, &len);
246}
247
248char *utilfdt_read_len(const char *filename, off_t *len)
249{
250 char *buff;
251 int ret = utilfdt_read_err_len(filename, &buff, len);
252
253 if (ret) {
254 fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
255 strerror(ret));
256 return NULL;
257 }
258
259 return buff;
260}
261
262char *utilfdt_read(const char *filename)
263{
264 off_t len;
265 return utilfdt_read_len(filename, &len);
266}
267
268int utilfdt_write_err(const char *filename, const void *blob)
269{
270 int fd = 1;
271 int totalsize;
272 int offset;
273 int ret = 0;
274 const char *ptr = blob;
275
276 if (strcmp(filename, "-") != 0) {
277 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
278 if (fd < 0)
279 return errno;
280 }
281
282 totalsize = fdt_totalsize(blob);
283 offset = 0;
284
285 while (offset < totalsize) {
286 ret = write(fd, ptr + offset, totalsize - offset);
287 if (ret < 0) {
288 ret = -errno;
289 break;
290 }
291 offset += ret;
292 }
293
294 if (fd != 1)
295 close(fd);
296 return ret < 0 ? -ret : 0;
297}
298
299
300int utilfdt_write(const char *filename, const void *blob)
301{
302 int ret = utilfdt_write_err(filename, blob);
303
304 if (ret) {
305 fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
306 strerror(ret));
307 }
308 return ret ? -1 : 0;
309}
310
311int utilfdt_decode_type(const char *fmt, int *type, int *size)
312{
313 int qualifier = 0;
314
315 if (!*fmt)
316 return -1;
317
318
319 *size = -1;
320 if (strchr("hlLb", *fmt)) {
321 qualifier = *fmt++;
322 if (qualifier == *fmt) {
323 switch (*fmt++) {
324
325 case 'h':
326 qualifier = 'b';
327 break;
328 }
329 }
330 }
331
332
333 if ((*fmt == '\0') || !strchr("iuxs", *fmt))
334 return -1;
335
336
337 if (*fmt != 's')
338 *size = qualifier == 'b' ? 1 :
339 qualifier == 'h' ? 2 :
340 qualifier == 'l' ? 4 : -1;
341 *type = *fmt++;
342
343
344 if (*fmt)
345 return -1;
346 return 0;
347}
348
349void utilfdt_print_data(const char *data, int len)
350{
351 int i;
352 const char *p = data;
353 const char *s;
354
355
356 if (len == 0)
357 return;
358
359 if (util_is_printable_string(data, len)) {
360 printf(" = ");
361
362 s = data;
363 do {
364 printf("\"%s\"", s);
365 s += strlen(s) + 1;
366 if (s < data + len)
367 printf(", ");
368 } while (s < data + len);
369
370 } else if ((len % 4) == 0) {
371 const uint32_t *cell = (const uint32_t *)data;
372
373 printf(" = <");
374 for (i = 0, len /= 4; i < len; i++)
375 printf("0x%08x%s", fdt32_to_cpu(cell[i]),
376 i < (len - 1) ? " " : "");
377 printf(">");
378 } else {
379 printf(" = [");
380 for (i = 0; i < len; i++)
381 printf("%02x%s", *p++, i < len - 1 ? " " : "");
382 printf("]");
383 }
384}
385
386void util_version(void)
387{
388 printf("Version: %s\n", DTC_VERSION);
389 exit(0);
390}
391
392void util_usage(const char *errmsg, const char *synopsis,
393 const char *short_opts, struct option const long_opts[],
394 const char * const opts_help[])
395{
396 FILE *fp = errmsg ? stderr : stdout;
397 const char a_arg[] = "<arg>";
398 size_t a_arg_len = strlen(a_arg) + 1;
399 size_t i;
400 int optlen;
401
402 fprintf(fp,
403 "Usage: %s\n"
404 "\n"
405 "Options: -[%s]\n", synopsis, short_opts);
406
407
408 optlen = 0;
409 for (i = 0; long_opts[i].name; ++i) {
410
411 int l = strlen(long_opts[i].name) + 1;
412 if (long_opts[i].has_arg == a_argument)
413 l += a_arg_len;
414 if (optlen < l)
415 optlen = l;
416 }
417
418 for (i = 0; long_opts[i].name; ++i) {
419
420 assert(opts_help[i] != NULL);
421
422
423 if (long_opts[i].val > '~')
424 fprintf(fp, " ");
425 else
426 fprintf(fp, " -%c, ", long_opts[i].val);
427
428
429 if (long_opts[i].has_arg == no_argument)
430 fprintf(fp, "--%-*s", optlen, long_opts[i].name);
431 else
432 fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
433 (int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");
434
435
436 fprintf(fp, "%s\n", opts_help[i]);
437 }
438
439 if (errmsg) {
440 fprintf(fp, "\nError: %s\n", errmsg);
441 exit(EXIT_FAILURE);
442 } else
443 exit(EXIT_SUCCESS);
444}
445