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