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 *dup = xmalloc(len); 43 44 memcpy(dup, s, len); 45 46 return dup; 47 } 48 49 char *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 73 int util_is_printable_string(const void *data, int len) 74 { 75 const char *s = data; 76 const char *ss, *se; 77 78 /* zero length is not */ 79 if (len == 0) 80 return 0; 81 82 /* must terminate with zero */ 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(*s)) 91 s++; 92 93 /* not zero, or not done yet */ 94 if (*s != '\0' || s == ss) 95 return 0; 96 97 s++; 98 } 99 100 return 1; 101 } 102 103 /* 104 * Parse a octal encoded character starting at index i in string s. The 105 * resulting character will be returned and the index i will be updated to 106 * point at the character directly after the end of the encoding, this may be 107 * the '\0' terminator of the string. 108 */ 109 static 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 * Parse a hexadecimal encoded character starting at index i in string s. The 128 * resulting character will be returned and the index i will be updated to 129 * point at the character directly after the end of the encoding, this may be 130 * the '\0' terminator of the string. 131 */ 132 static 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 149 char 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--; /* need to re-read the first digit as 187 * part of the octal value */ 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 201 int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len) 202 { 203 int fd = 0; /* assume stdin */ 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 /* Loop until we have read everything */ 216 buf = xmalloc(bufsize); 217 do { 218 /* Expand the buffer to hold the next chunk */ 219 if (offset == bufsize) { 220 bufsize *= 2; 221 buf = xrealloc(buf, bufsize); 222 if (!buf) { 223 ret = ENOMEM; 224 break; 225 } 226 } 227 228 ret = read(fd, &buf[offset], bufsize - offset); 229 if (ret < 0) { 230 ret = errno; 231 break; 232 } 233 offset += ret; 234 } while (ret != 0); 235 236 /* Clean up, including closing stdin; return errno on error */ 237 close(fd); 238 if (ret) 239 free(buf); 240 else 241 *buffp = buf; 242 *len = bufsize; 243 return ret; 244 } 245 246 int utilfdt_read_err(const char *filename, char **buffp) 247 { 248 off_t len; 249 return utilfdt_read_err_len(filename, buffp, &len); 250 } 251 252 char *utilfdt_read_len(const char *filename, off_t *len) 253 { 254 char *buff; 255 int ret = utilfdt_read_err_len(filename, &buff, len); 256 257 if (ret) { 258 fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename, 259 strerror(ret)); 260 return NULL; 261 } 262 /* Successful read */ 263 return buff; 264 } 265 266 char *utilfdt_read(const char *filename) 267 { 268 off_t len; 269 return utilfdt_read_len(filename, &len); 270 } 271 272 int utilfdt_write_err(const char *filename, const void *blob) 273 { 274 int fd = 1; /* assume stdout */ 275 int totalsize; 276 int offset; 277 int ret = 0; 278 const char *ptr = blob; 279 280 if (strcmp(filename, "-") != 0) { 281 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 282 if (fd < 0) 283 return errno; 284 } 285 286 totalsize = fdt_totalsize(blob); 287 offset = 0; 288 289 while (offset < totalsize) { 290 ret = write(fd, ptr + offset, totalsize - offset); 291 if (ret < 0) { 292 ret = -errno; 293 break; 294 } 295 offset += ret; 296 } 297 /* Close the file/stdin; return errno on error */ 298 if (fd != 1) 299 close(fd); 300 return ret < 0 ? -ret : 0; 301 } 302 303 304 int utilfdt_write(const char *filename, const void *blob) 305 { 306 int ret = utilfdt_write_err(filename, blob); 307 308 if (ret) { 309 fprintf(stderr, "Couldn't write blob to '%s': %s\n", filename, 310 strerror(ret)); 311 } 312 return ret ? -1 : 0; 313 } 314 315 int utilfdt_decode_type(const char *fmt, int *type, int *size) 316 { 317 int qualifier = 0; 318 319 if (!*fmt) 320 return -1; 321 322 /* get the conversion qualifier */ 323 *size = -1; 324 if (strchr("hlLb", *fmt)) { 325 qualifier = *fmt++; 326 if (qualifier == *fmt) { 327 switch (*fmt++) { 328 /* TODO: case 'l': qualifier = 'L'; break;*/ 329 case 'h': 330 qualifier = 'b'; 331 break; 332 } 333 } 334 } 335 336 /* we should now have a type */ 337 if ((*fmt == '\0') || !strchr("iuxs", *fmt)) 338 return -1; 339 340 /* convert qualifier (bhL) to byte size */ 341 if (*fmt != 's') 342 *size = qualifier == 'b' ? 1 : 343 qualifier == 'h' ? 2 : 344 qualifier == 'l' ? 4 : -1; 345 *type = *fmt++; 346 347 /* that should be it! */ 348 if (*fmt) 349 return -1; 350 return 0; 351 } 352 353 void utilfdt_print_data(const char *data, int len) 354 { 355 int i; 356 const char *p = data; 357 const char *s; 358 359 /* no data, don't print */ 360 if (len == 0) 361 return; 362 363 if (util_is_printable_string(data, len)) { 364 printf(" = "); 365 366 s = data; 367 do { 368 printf("\"%s\"", s); 369 s += strlen(s) + 1; 370 if (s < data + len) 371 printf(", "); 372 } while (s < data + len); 373 374 } else if ((len % 4) == 0) { 375 const uint32_t *cell = (const uint32_t *)data; 376 377 printf(" = <"); 378 for (i = 0; i < len; i += 4) 379 printf("0x%08x%s", fdt32_to_cpu(cell[i]), 380 i < (len - 4) ? " " : ""); 381 printf(">"); 382 } else { 383 printf(" = ["); 384 for (i = 0; i < len; i++) 385 printf("%02x%s", *p++, i < len - 1 ? " " : ""); 386 printf("]"); 387 } 388 } 389 390 void util_version(void) 391 { 392 printf("Version: %s\n", DTC_VERSION); 393 exit(0); 394 } 395 396 void util_usage(const char *errmsg, const char *synopsis, 397 const char *short_opts, struct option const long_opts[], 398 const char * const opts_help[]) 399 { 400 FILE *fp = errmsg ? stderr : stdout; 401 const char a_arg[] = "<arg>"; 402 size_t a_arg_len = strlen(a_arg) + 1; 403 size_t i; 404 int optlen; 405 406 fprintf(fp, 407 "Usage: %s\n" 408 "\n" 409 "Options: -[%s]\n", synopsis, short_opts); 410 411 /* prescan the --long opt length to auto-align */ 412 optlen = 0; 413 for (i = 0; long_opts[i].name; ++i) { 414 /* +1 is for space between --opt and help text */ 415 int l = strlen(long_opts[i].name) + 1; 416 if (long_opts[i].has_arg == a_argument) 417 l += a_arg_len; 418 if (optlen < l) 419 optlen = l; 420 } 421 422 for (i = 0; long_opts[i].name; ++i) { 423 /* helps when adding new applets or options */ 424 assert(opts_help[i] != NULL); 425 426 /* first output the short flag if it has one */ 427 if (long_opts[i].val > '~') 428 fprintf(fp, " "); 429 else 430 fprintf(fp, " -%c, ", long_opts[i].val); 431 432 /* then the long flag */ 433 if (long_opts[i].has_arg == no_argument) 434 fprintf(fp, "--%-*s", optlen, long_opts[i].name); 435 else 436 fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg, 437 (int)(optlen - strlen(long_opts[i].name) - a_arg_len), ""); 438 439 /* finally the help text */ 440 fprintf(fp, "%s\n", opts_help[i]); 441 } 442 443 if (errmsg) { 444 fprintf(fp, "\nError: %s\n", errmsg); 445 exit(EXIT_FAILURE); 446 } else 447 exit(EXIT_SUCCESS); 448 } 449