scripts/dtc/util.c

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