scripts/dtc/util.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright 2011 The Chromium Authors, All Rights Reserved.
0004  * Copyright 2008 Jon Loeliger, Freescale Semiconductor, Inc.
0005  *
0006  * util_is_printable_string contributed by
0007  *  Pantelis Antoniou <pantelis.antoniou AT gmail.com>
0008  */
0009
0010 #include <ctype.h>
0011 #include <stdio.h>
0012 #include <stdlib.h>
0013 #include <stdarg.h>
0014 #include <string.h>
0015 #include <assert.h>
0016 #include <inttypes.h>
0017
0018 #include <errno.h>
0019 #include <fcntl.h>
0020 #include <unistd.h>
0021
0022 #include "libfdt.h"
0023 #include "util.h"
0024 #include "version_gen.h"
0025
0026 char *xstrdup(const char *s)
0027 {
0028     int len = strlen(s) + 1;
0029     char *d = xmalloc(len);
0030
0031     memcpy(d, s, len);
0032
0033     return d;
0034 }
0035
0036 int xavsprintf_append(char **strp, const char *fmt, va_list ap)
0037 {
0038     int n, size = 0;    /* start with 128 bytes */
0039     char *p;
0040     va_list ap_copy;
0041
0042     p = *strp;
0043     if (p)
0044         size = strlen(p);
0045
0046     va_copy(ap_copy, ap);
0047     n = vsnprintf(NULL, 0, fmt, ap_copy) + 1;
0048     va_end(ap_copy);
0049
0050     p = xrealloc(p, size + n);
0051
0052     n = vsnprintf(p + size, n, fmt, ap);
0053
0054     *strp = p;
0055     return strlen(p);
0056 }
0057
0058 int xasprintf_append(char **strp, const char *fmt, ...)
0059 {
0060     int n;
0061     va_list ap;
0062
0063     va_start(ap, fmt);
0064     n = xavsprintf_append(strp, fmt, ap);
0065     va_end(ap);
0066
0067     return n;
0068 }
0069
0070 int xasprintf(char **strp, const char *fmt, ...)
0071 {
0072     int n;
0073     va_list ap;
0074
0075     *strp = NULL;
0076
0077     va_start(ap, fmt);
0078     n = xavsprintf_append(strp, fmt, ap);
0079     va_end(ap);
0080
0081     return n;
0082 }
0083
0084 char *join_path(const char *path, const char *name)
0085 {
0086     int lenp = strlen(path);
0087     int lenn = strlen(name);
0088     int len;
0089     int needslash = 1;
0090     char *str;
0091
0092     len = lenp + lenn + 2;
0093     if ((lenp > 0) && (path[lenp-1] == '/')) {
0094         needslash = 0;
0095         len--;
0096     }
0097
0098     str = xmalloc(len);
0099     memcpy(str, path, lenp);
0100     if (needslash) {
0101         str[lenp] = '/';
0102         lenp++;
0103     }
0104     memcpy(str+lenp, name, lenn+1);
0105     return str;
0106 }
0107
0108 bool util_is_printable_string(const void *data, int len)
0109 {
0110     const char *s = data;
0111     const char *ss, *se;
0112
0113     /* zero length is not */
0114     if (len == 0)
0115         return 0;
0116
0117     /* must terminate with zero */
0118     if (s[len - 1] != '\0')
0119         return 0;
0120
0121     se = s + len;
0122
0123     while (s < se) {
0124         ss = s;
0125         while (s < se && *s && isprint((unsigned char)*s))
0126             s++;
0127
0128         /* not zero, or not done yet */
0129         if (*s != '\0' || s == ss)
0130             return 0;
0131
0132         s++;
0133     }
0134
0135     return 1;
0136 }
0137
0138 /*
0139  * Parse a octal encoded character starting at index i in string s.  The
0140  * resulting character will be returned and the index i will be updated to
0141  * point at the character directly after the end of the encoding, this may be
0142  * the '\0' terminator of the string.
0143  */
0144 static char get_oct_char(const char *s, int *i)
0145 {
0146     char x[4];
0147     char *endx;
0148     long val;
0149
0150     x[3] = '\0';
0151     strncpy(x, s + *i, 3);
0152
0153     val = strtol(x, &endx, 8);
0154
0155     assert(endx > x);
0156
0157     (*i) += endx - x;
0158     return val;
0159 }
0160
0161 /*
0162  * Parse a hexadecimal encoded character starting at index i in string s.  The
0163  * resulting character will be returned and the index i will be updated to
0164  * point at the character directly after the end of the encoding, this may be
0165  * the '\0' terminator of the string.
0166  */
0167 static char get_hex_char(const char *s, int *i)
0168 {
0169     char x[3];
0170     char *endx;
0171     long val;
0172
0173     x[2] = '\0';
0174     strncpy(x, s + *i, 2);
0175
0176     val = strtol(x, &endx, 16);
0177     if (!(endx  > x))
0178         die("\\x used with no following hex digits\n");
0179
0180     (*i) += endx - x;
0181     return val;
0182 }
0183
0184 char get_escape_char(const char *s, int *i)
0185 {
0186     char    c = s[*i];
0187     int j = *i + 1;
0188     char    val;
0189
0190     switch (c) {
0191     case 'a':
0192         val = '\a';
0193         break;
0194     case 'b':
0195         val = '\b';
0196         break;
0197     case 't':
0198         val = '\t';
0199         break;
0200     case 'n':
0201         val = '\n';
0202         break;
0203     case 'v':
0204         val = '\v';
0205         break;
0206     case 'f':
0207         val = '\f';
0208         break;
0209     case 'r':
0210         val = '\r';
0211         break;
0212     case '0':
0213     case '1':
0214     case '2':
0215     case '3':
0216     case '4':
0217     case '5':
0218     case '6':
0219     case '7':
0220         j--; /* need to re-read the first digit as
0221               * part of the octal value */
0222         val = get_oct_char(s, &j);
0223         break;
0224     case 'x':
0225         val = get_hex_char(s, &j);
0226         break;
0227     default:
0228         val = c;
0229     }
0230
0231     (*i) = j;
0232     return val;
0233 }
0234
0235 int utilfdt_read_err(const char *filename, char **buffp, size_t *len)
0236 {
0237     int fd = 0; /* assume stdin */
0238     char *buf = NULL;
0239     size_t bufsize = 1024, offset = 0;
0240     int ret = 0;
0241
0242     *buffp = NULL;
0243     if (strcmp(filename, "-") != 0) {
0244         fd = open(filename, O_RDONLY);
0245         if (fd < 0)
0246             return errno;
0247     }
0248
0249     /* Loop until we have read everything */
0250     buf = xmalloc(bufsize);
0251     do {
0252         /* Expand the buffer to hold the next chunk */
0253         if (offset == bufsize) {
0254             bufsize *= 2;
0255             buf = xrealloc(buf, bufsize);
0256         }
0257
0258         ret = read(fd, &buf[offset], bufsize - offset);
0259         if (ret < 0) {
0260             ret = errno;
0261             break;
0262         }
0263         offset += ret;
0264     } while (ret != 0);
0265
0266     /* Clean up, including closing stdin; return errno on error */
0267     close(fd);
0268     if (ret)
0269         free(buf);
0270     else
0271         *buffp = buf;
0272     if (len)
0273         *len = bufsize;
0274     return ret;
0275 }
0276
0277 char *utilfdt_read(const char *filename, size_t *len)
0278 {
0279     char *buff;
0280     int ret = utilfdt_read_err(filename, &buff, len);
0281
0282     if (ret) {
0283         fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
0284             strerror(ret));
0285         return NULL;
0286     }
0287     /* Successful read */
0288     return buff;
0289 }
0290
0291 int utilfdt_write_err(const char *filename, const void *blob)
0292 {
0293     int fd = 1; /* assume stdout */
0294     int totalsize;
0295     int offset;
0296     int ret = 0;
0297     const char *ptr = blob;
0298
0299     if (strcmp(filename, "-") != 0) {
0300         fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
0301         if (fd < 0)
0302             return errno;
0303     }
0304
0305     totalsize = fdt_totalsize(blob);
0306     offset = 0;
0307
0308     while (offset < totalsize) {
0309         ret = write(fd, ptr + offset, totalsize - offset);
0310         if (ret < 0) {
0311             ret = -errno;
0312             break;
0313         }
0314         offset += ret;
0315     }
0316     /* Close the file/stdin; return errno on error */
0317     if (fd != 1)
0318         close(fd);
0319     return ret < 0 ? -ret : 0;
0320 }
0321
0322
0323 int utilfdt_write(const char *filename, const void *blob)
0324 {
0325     int ret = utilfdt_write_err(filename, blob);
0326
0327     if (ret) {
0328         fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename,
0329             strerror(ret));
0330     }
0331     return ret ? -1 : 0;
0332 }
0333
0334 int utilfdt_decode_type(const char *fmt, int *type, int *size)
0335 {
0336     int qualifier = 0;
0337
0338     if (!*fmt)
0339         return -1;
0340
0341     /* get the conversion qualifier */
0342     *size = -1;
0343     if (strchr("hlLb", *fmt)) {
0344         qualifier = *fmt++;
0345         if (qualifier == *fmt) {
0346             switch (*fmt++) {
0347 /* TODO:        case 'l': qualifier = 'L'; break;*/
0348             case 'h':
0349                 qualifier = 'b';
0350                 break;
0351             }
0352         }
0353     }
0354
0355     /* we should now have a type */
0356     if ((*fmt == '\0') || !strchr("iuxs", *fmt))
0357         return -1;
0358
0359     /* convert qualifier (bhL) to byte size */
0360     if (*fmt != 's')
0361         *size = qualifier == 'b' ? 1 :
0362                 qualifier == 'h' ? 2 :
0363                 qualifier == 'l' ? 4 : -1;
0364     *type = *fmt++;
0365
0366     /* that should be it! */
0367     if (*fmt)
0368         return -1;
0369     return 0;
0370 }
0371
0372 void utilfdt_print_data(const char *data, int len)
0373 {
0374     int i;
0375     const char *s;
0376
0377     /* no data, don't print */
0378     if (len == 0)
0379         return;
0380
0381     if (util_is_printable_string(data, len)) {
0382         printf(" = ");
0383
0384         s = data;
0385         do {
0386             printf("\"%s\"", s);
0387             s += strlen(s) + 1;
0388             if (s < data + len)
0389                 printf(", ");
0390         } while (s < data + len);
0391
0392     } else if ((len % 4) == 0) {
0393         const fdt32_t *cell = (const fdt32_t *)data;
0394
0395         printf(" = <");
0396         for (i = 0, len /= 4; i < len; i++)
0397             printf("0x%08" PRIx32 "%s", fdt32_to_cpu(cell[i]),
0398                    i < (len - 1) ? " " : "");
0399         printf(">");
0400     } else {
0401         const unsigned char *p = (const unsigned char *)data;
0402         printf(" = [");
0403         for (i = 0; i < len; i++)
0404             printf("%02x%s", *p++, i < len - 1 ? " " : "");
0405         printf("]");
0406     }
0407 }
0408
0409 void NORETURN util_version(void)
0410 {
0411     printf("Version: %s\n", DTC_VERSION);
0412     exit(0);
0413 }
0414
0415 void NORETURN util_usage(const char *errmsg, const char *synopsis,
0416              const char *short_opts,
0417              struct option const long_opts[],
0418              const char * const opts_help[])
0419 {
0420     FILE *fp = errmsg ? stderr : stdout;
0421     const char a_arg[] = "<arg>";
0422     size_t a_arg_len = strlen(a_arg) + 1;
0423     size_t i;
0424     int optlen;
0425
0426     fprintf(fp,
0427         "Usage: %s\n"
0428         "\n"
0429         "Options: -[%s]\n", synopsis, short_opts);
0430
0431     /* prescan the --long opt length to auto-align */
0432     optlen = 0;
0433     for (i = 0; long_opts[i].name; ++i) {
0434         /* +1 is for space between --opt and help text */
0435         int l = strlen(long_opts[i].name) + 1;
0436         if (long_opts[i].has_arg == a_argument)
0437             l += a_arg_len;
0438         if (optlen < l)
0439             optlen = l;
0440     }
0441
0442     for (i = 0; long_opts[i].name; ++i) {
0443         /* helps when adding new applets or options */
0444         assert(opts_help[i] != NULL);
0445
0446         /* first output the short flag if it has one */
0447         if (long_opts[i].val > '~')
0448             fprintf(fp, "      ");
0449         else
0450             fprintf(fp, "  -%c, ", long_opts[i].val);
0451
0452         /* then the long flag */
0453         if (long_opts[i].has_arg == no_argument)
0454             fprintf(fp, "--%-*s", optlen, long_opts[i].name);
0455         else
0456             fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
0457                 (int)(optlen - strlen(long_opts[i].name) - a_arg_len), "");
0458
0459         /* finally the help text */
0460         fprintf(fp, "%s\n", opts_help[i]);
0461     }
0462
0463     if (errmsg) {
0464         fprintf(fp, "\nError: %s\n", errmsg);
0465         exit(EXIT_FAILURE);
0466     } else
0467         exit(EXIT_SUCCESS);
0468 }