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 void 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 42 char *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 52 char *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 63 int 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 85 int 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 97 int 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 111 char *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 135 bool 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 */ 171 static 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 */ 194 static 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 211 char 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 262 int 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 304 char *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 318 int 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 350 int 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 361 int 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 399 void 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 436 void NORETURN util_version(void) 437 { 438 printf("Version: %s\n", DTC_VERSION); 439 exit(0); 440 } 441 442 void 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 } 496