1 /* $NetBSD: apprentice.c,v 1.7 2012/04/07 17:30:55 christos Exp $ */ 2 3 /* 4 * Copyright (c) Ian F. Darwin 1986-1995. 5 * Software written by Ian F. Darwin and others; 6 * maintained 1995-present by Christos Zoulas and others. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice immediately at the beginning of the file, without modification, 13 * this list of conditions, and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 22 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 /* 31 * apprentice - make one pass through /etc/magic, learning its secrets. 32 */ 33 34 #include "file.h" 35 36 #ifndef lint 37 #if 0 38 FILE_RCSID("@(#)$File: apprentice.c,v 1.173 2011/12/08 12:38:24 rrt Exp $") 39 #else 40 __RCSID("$NetBSD: apprentice.c,v 1.7 2012/04/07 17:30:55 christos Exp $"); 41 #endif 42 #endif /* lint */ 43 44 #include "magic.h" 45 #include <stdlib.h> 46 #ifdef HAVE_UNISTD_H 47 #include <unistd.h> 48 #endif 49 #include <string.h> 50 #include <assert.h> 51 #include <ctype.h> 52 #include <fcntl.h> 53 #ifdef QUICK 54 #include <sys/mman.h> 55 #endif 56 #include <dirent.h> 57 58 #define EATAB {while (isascii((unsigned char) *l) && \ 59 isspace((unsigned char) *l)) ++l;} 60 #define LOWCASE(l) (isupper((unsigned char) (l)) ? \ 61 tolower((unsigned char) (l)) : (l)) 62 /* 63 * Work around a bug in headers on Digital Unix. 64 * At least confirmed for: OSF1 V4.0 878 65 */ 66 #if defined(__osf__) && defined(__DECC) 67 #ifdef MAP_FAILED 68 #undef MAP_FAILED 69 #endif 70 #endif 71 72 #ifndef MAP_FAILED 73 #define MAP_FAILED (void *) -1 74 #endif 75 76 #ifndef MAP_FILE 77 #define MAP_FILE 0 78 #endif 79 80 struct magic_entry { 81 struct magic *mp; 82 uint32_t cont_count; 83 uint32_t max_count; 84 }; 85 86 int file_formats[FILE_NAMES_SIZE]; 87 const size_t file_nformats = FILE_NAMES_SIZE; 88 const char *file_names[FILE_NAMES_SIZE]; 89 const size_t file_nnames = FILE_NAMES_SIZE; 90 91 private int getvalue(struct magic_set *ms, struct magic *, const char **, int); 92 private int hextoint(int); 93 private const char *getstr(struct magic_set *, struct magic *, const char *, 94 int); 95 private int parse(struct magic_set *, struct magic_entry **, uint32_t *, 96 const char *, size_t, int); 97 private void eatsize(const char **); 98 private int apprentice_1(struct magic_set *, const char *, int, struct mlist *); 99 private size_t apprentice_magic_strength(const struct magic *); 100 private int apprentice_sort(const void *, const void *); 101 private void apprentice_list(struct mlist *, int ); 102 private int apprentice_load(struct magic_set *, struct magic **, uint32_t *, 103 const char *, int); 104 private void byteswap(struct magic *, uint32_t); 105 private void bs1(struct magic *); 106 private uint16_t swap2(uint16_t); 107 private uint32_t swap4(uint32_t); 108 private uint64_t swap8(uint64_t); 109 private char *mkdbname(struct magic_set *, const char *, int); 110 private int apprentice_map(struct magic_set *, struct magic **, uint32_t *, 111 const char *); 112 private int apprentice_compile(struct magic_set *, struct magic **, uint32_t *, 113 const char *); 114 private int check_format_type(const char *, int); 115 private int check_format(struct magic_set *, struct magic *); 116 private int get_op(char); 117 private int parse_mime(struct magic_set *, struct magic_entry *, const char *); 118 private int parse_strength(struct magic_set *, struct magic_entry *, const char *); 119 private int parse_apple(struct magic_set *, struct magic_entry *, const char *); 120 121 122 private size_t maxmagic = 0; 123 private size_t magicsize = sizeof(struct magic); 124 125 private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc"; 126 127 private struct { 128 const char *name; 129 size_t len; 130 int (*fun)(struct magic_set *, struct magic_entry *, const char *); 131 } bang[] = { 132 #define DECLARE_FIELD(name) { # name, sizeof(# name) - 1, parse_ ## name } 133 DECLARE_FIELD(mime), 134 DECLARE_FIELD(apple), 135 DECLARE_FIELD(strength), 136 #undef DECLARE_FIELD 137 { NULL, 0, NULL } 138 }; 139 140 #ifdef COMPILE_ONLY 141 142 int main(int, char *[]); 143 144 int 145 main(int argc, char *argv[]) 146 { 147 int ret; 148 struct magic_set *ms; 149 char *progname; 150 151 if ((progname = strrchr(argv[0], '/')) != NULL) 152 progname++; 153 else 154 progname = argv[0]; 155 156 if (argc != 2) { 157 (void)fprintf(stderr, "Usage: %s file\n", progname); 158 return 1; 159 } 160 161 if ((ms = magic_open(MAGIC_CHECK)) == NULL) { 162 (void)fprintf(stderr, "%s: %s\n", progname, strerror(errno)); 163 return 1; 164 } 165 ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0; 166 if (ret == 1) 167 (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms)); 168 magic_close(ms); 169 return ret; 170 } 171 #endif /* COMPILE_ONLY */ 172 173 static const struct type_tbl_s { 174 const char name[16]; 175 const size_t len; 176 const int type; 177 const int format; 178 } type_tbl[] = { 179 # define XX(s) s, (sizeof(s) - 1) 180 # define XX_NULL "", 0 181 { XX("byte"), FILE_BYTE, FILE_FMT_NUM }, 182 { XX("short"), FILE_SHORT, FILE_FMT_NUM }, 183 { XX("default"), FILE_DEFAULT, FILE_FMT_STR }, 184 { XX("long"), FILE_LONG, FILE_FMT_NUM }, 185 { XX("string"), FILE_STRING, FILE_FMT_STR }, 186 { XX("date"), FILE_DATE, FILE_FMT_STR }, 187 { XX("beshort"), FILE_BESHORT, FILE_FMT_NUM }, 188 { XX("belong"), FILE_BELONG, FILE_FMT_NUM }, 189 { XX("bedate"), FILE_BEDATE, FILE_FMT_STR }, 190 { XX("leshort"), FILE_LESHORT, FILE_FMT_NUM }, 191 { XX("lelong"), FILE_LELONG, FILE_FMT_NUM }, 192 { XX("ledate"), FILE_LEDATE, FILE_FMT_STR }, 193 { XX("pstring"), FILE_PSTRING, FILE_FMT_STR }, 194 { XX("ldate"), FILE_LDATE, FILE_FMT_STR }, 195 { XX("beldate"), FILE_BELDATE, FILE_FMT_STR }, 196 { XX("leldate"), FILE_LELDATE, FILE_FMT_STR }, 197 { XX("regex"), FILE_REGEX, FILE_FMT_STR }, 198 { XX("bestring16"), FILE_BESTRING16, FILE_FMT_STR }, 199 { XX("lestring16"), FILE_LESTRING16, FILE_FMT_STR }, 200 { XX("search"), FILE_SEARCH, FILE_FMT_STR }, 201 { XX("medate"), FILE_MEDATE, FILE_FMT_STR }, 202 { XX("meldate"), FILE_MELDATE, FILE_FMT_STR }, 203 { XX("melong"), FILE_MELONG, FILE_FMT_NUM }, 204 { XX("quad"), FILE_QUAD, FILE_FMT_QUAD }, 205 { XX("lequad"), FILE_LEQUAD, FILE_FMT_QUAD }, 206 { XX("bequad"), FILE_BEQUAD, FILE_FMT_QUAD }, 207 { XX("qdate"), FILE_QDATE, FILE_FMT_STR }, 208 { XX("leqdate"), FILE_LEQDATE, FILE_FMT_STR }, 209 { XX("beqdate"), FILE_BEQDATE, FILE_FMT_STR }, 210 { XX("qldate"), FILE_QLDATE, FILE_FMT_STR }, 211 { XX("leqldate"), FILE_LEQLDATE, FILE_FMT_STR }, 212 { XX("beqldate"), FILE_BEQLDATE, FILE_FMT_STR }, 213 { XX("float"), FILE_FLOAT, FILE_FMT_FLOAT }, 214 { XX("befloat"), FILE_BEFLOAT, FILE_FMT_FLOAT }, 215 { XX("lefloat"), FILE_LEFLOAT, FILE_FMT_FLOAT }, 216 { XX("double"), FILE_DOUBLE, FILE_FMT_DOUBLE }, 217 { XX("bedouble"), FILE_BEDOUBLE, FILE_FMT_DOUBLE }, 218 { XX("ledouble"), FILE_LEDOUBLE, FILE_FMT_DOUBLE }, 219 { XX("leid3"), FILE_LEID3, FILE_FMT_NUM }, 220 { XX("beid3"), FILE_BEID3, FILE_FMT_NUM }, 221 { XX("indirect"), FILE_INDIRECT, FILE_FMT_NUM }, 222 { XX_NULL, FILE_INVALID, FILE_FMT_NONE }, 223 # undef XX 224 # undef XX_NULL 225 }; 226 227 private int 228 get_type(const char *l, const char **t) 229 { 230 const struct type_tbl_s *p; 231 232 for (p = type_tbl; p->len; p++) { 233 if (strncmp(l, p->name, p->len) == 0) { 234 if (t) 235 *t = l + p->len; 236 break; 237 } 238 } 239 return p->type; 240 } 241 242 private void 243 init_file_tables(void) 244 { 245 static int done = 0; 246 const struct type_tbl_s *p; 247 248 if (done) 249 return; 250 done++; 251 252 for (p = type_tbl; p->len; p++) { 253 assert(p->type < FILE_NAMES_SIZE); 254 file_names[p->type] = p->name; 255 file_formats[p->type] = p->format; 256 } 257 } 258 259 /* 260 * Handle one file or directory. 261 */ 262 private int 263 apprentice_1(struct magic_set *ms, const char *fn, int action, 264 struct mlist *mlist) 265 { 266 struct magic *magic = NULL; 267 uint32_t nmagic = 0; 268 struct mlist *ml; 269 int rv = -1; 270 int mapped; 271 272 if (magicsize != FILE_MAGICSIZE) { 273 file_error(ms, 0, "magic element size %lu != %lu", 274 (unsigned long)sizeof(*magic), 275 (unsigned long)FILE_MAGICSIZE); 276 return -1; 277 } 278 279 if (action == FILE_COMPILE) { 280 rv = apprentice_load(ms, &magic, &nmagic, fn, action); 281 if (rv != 0) 282 return -1; 283 rv = apprentice_compile(ms, &magic, &nmagic, fn); 284 free(magic); 285 return rv; 286 } 287 288 #ifndef COMPILE_ONLY 289 if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) { 290 if (ms->flags & MAGIC_CHECK) 291 file_magwarn(ms, "using regular magic file `%s'", fn); 292 rv = apprentice_load(ms, &magic, &nmagic, fn, action); 293 if (rv != 0) 294 return -1; 295 } 296 297 mapped = rv; 298 299 if (magic == NULL) { 300 file_delmagic(magic, mapped, nmagic); 301 return -1; 302 } 303 304 if ((ml = CAST(struct mlist *, malloc(sizeof(*ml)))) == NULL) { 305 file_delmagic(magic, mapped, nmagic); 306 file_oomem(ms, sizeof(*ml)); 307 return -1; 308 } 309 310 ml->magic = magic; 311 ml->nmagic = nmagic; 312 ml->mapped = mapped; 313 314 mlist->prev->next = ml; 315 ml->prev = mlist->prev; 316 ml->next = mlist; 317 mlist->prev = ml; 318 319 if (action == FILE_LIST) { 320 printf("Binary patterns:\n"); 321 apprentice_list(mlist, BINTEST); 322 printf("Text patterns:\n"); 323 apprentice_list(mlist, TEXTTEST); 324 } 325 326 return 0; 327 #endif /* COMPILE_ONLY */ 328 } 329 330 protected void 331 file_delmagic(struct magic *p, int type, size_t entries) 332 { 333 if (p == NULL) 334 return; 335 switch (type) { 336 case 2: 337 #ifdef QUICK 338 p--; 339 (void)munmap((void *)p, sizeof(*p) * (entries + 1)); 340 break; 341 #else 342 (void)&entries; 343 abort(); 344 /*NOTREACHED*/ 345 #endif 346 case 1: 347 p--; 348 /*FALLTHROUGH*/ 349 case 0: 350 free(p); 351 break; 352 default: 353 abort(); 354 } 355 } 356 357 /* const char *fn: list of magic files and directories */ 358 protected struct mlist * 359 file_apprentice(struct magic_set *ms, const char *fn, int action) 360 { 361 char *p, *mfn; 362 int file_err, errs = -1; 363 struct mlist *mlist; 364 365 if ((fn = magic_getpath(fn, action)) == NULL) 366 return NULL; 367 368 init_file_tables(); 369 370 if ((mfn = strdup(fn)) == NULL) { 371 file_oomem(ms, strlen(fn)); 372 return NULL; 373 } 374 fn = mfn; 375 376 if ((mlist = CAST(struct mlist *, malloc(sizeof(*mlist)))) == NULL) { 377 free(mfn); 378 file_oomem(ms, sizeof(*mlist)); 379 return NULL; 380 } 381 mlist->next = mlist->prev = mlist; 382 383 while (fn) { 384 p = strchr(fn, PATHSEP); 385 if (p) 386 *p++ = '\0'; 387 if (*fn == '\0') 388 break; 389 file_err = apprentice_1(ms, fn, action, mlist); 390 errs = MAX(errs, file_err); 391 fn = p; 392 } 393 if (errs == -1) { 394 free(mfn); 395 free(mlist); 396 mlist = NULL; 397 file_error(ms, 0, "could not find any magic files!"); 398 return NULL; 399 } 400 free(mfn); 401 return mlist; 402 } 403 404 /* 405 * Get weight of this magic entry, for sorting purposes. 406 */ 407 private size_t 408 apprentice_magic_strength(const struct magic *m) 409 { 410 #define MULT 10 411 size_t val = 2 * MULT; /* baseline strength */ 412 413 switch (m->type) { 414 case FILE_DEFAULT: /* make sure this sorts last */ 415 if (m->factor_op != FILE_FACTOR_OP_NONE) 416 abort(); 417 return 0; 418 419 case FILE_BYTE: 420 val += 1 * MULT; 421 break; 422 423 case FILE_SHORT: 424 case FILE_LESHORT: 425 case FILE_BESHORT: 426 val += 2 * MULT; 427 break; 428 429 case FILE_LONG: 430 case FILE_LELONG: 431 case FILE_BELONG: 432 case FILE_MELONG: 433 val += 4 * MULT; 434 break; 435 436 case FILE_PSTRING: 437 case FILE_STRING: 438 val += m->vallen * MULT; 439 break; 440 441 case FILE_BESTRING16: 442 case FILE_LESTRING16: 443 val += m->vallen * MULT / 2; 444 break; 445 446 case FILE_SEARCH: 447 case FILE_REGEX: 448 val += m->vallen * MAX(MULT / m->vallen, 1); 449 break; 450 451 case FILE_DATE: 452 case FILE_LEDATE: 453 case FILE_BEDATE: 454 case FILE_MEDATE: 455 case FILE_LDATE: 456 case FILE_LELDATE: 457 case FILE_BELDATE: 458 case FILE_MELDATE: 459 case FILE_FLOAT: 460 case FILE_BEFLOAT: 461 case FILE_LEFLOAT: 462 val += 4 * MULT; 463 break; 464 465 case FILE_QUAD: 466 case FILE_BEQUAD: 467 case FILE_LEQUAD: 468 case FILE_QDATE: 469 case FILE_LEQDATE: 470 case FILE_BEQDATE: 471 case FILE_QLDATE: 472 case FILE_LEQLDATE: 473 case FILE_BEQLDATE: 474 case FILE_DOUBLE: 475 case FILE_BEDOUBLE: 476 case FILE_LEDOUBLE: 477 val += 8 * MULT; 478 break; 479 480 case FILE_INDIRECT: 481 break; 482 483 default: 484 val = 0; 485 (void)fprintf(stderr, "Bad type %d\n", m->type); 486 abort(); 487 } 488 489 switch (m->reln) { 490 case 'x': /* matches anything penalize */ 491 case '!': /* matches almost anything penalize */ 492 val = 0; 493 break; 494 495 case '=': /* Exact match, prefer */ 496 val += MULT; 497 break; 498 499 case '>': 500 case '<': /* comparison match reduce strength */ 501 val -= 2 * MULT; 502 break; 503 504 case '^': 505 case '&': /* masking bits, we could count them too */ 506 val -= MULT; 507 break; 508 509 default: 510 (void)fprintf(stderr, "Bad relation %c\n", m->reln); 511 abort(); 512 } 513 514 if (val == 0) /* ensure we only return 0 for FILE_DEFAULT */ 515 val = 1; 516 517 switch (m->factor_op) { 518 case FILE_FACTOR_OP_NONE: 519 break; 520 case FILE_FACTOR_OP_PLUS: 521 val += m->factor; 522 break; 523 case FILE_FACTOR_OP_MINUS: 524 val -= m->factor; 525 break; 526 case FILE_FACTOR_OP_TIMES: 527 val *= m->factor; 528 break; 529 case FILE_FACTOR_OP_DIV: 530 val /= m->factor; 531 break; 532 default: 533 abort(); 534 } 535 536 /* 537 * Magic entries with no description get a bonus because they depend 538 * on subsequent magic entries to print something. 539 */ 540 if (m->desc[0] == '\0') 541 val++; 542 return val; 543 } 544 545 /* 546 * Sort callback for sorting entries by "strength" (basically length) 547 */ 548 private int 549 apprentice_sort(const void *a, const void *b) 550 { 551 const struct magic_entry *ma = CAST(const struct magic_entry *, a); 552 const struct magic_entry *mb = CAST(const struct magic_entry *, b); 553 size_t sa = apprentice_magic_strength(ma->mp); 554 size_t sb = apprentice_magic_strength(mb->mp); 555 if (sa == sb) 556 return 0; 557 else if (sa > sb) 558 return -1; 559 else 560 return 1; 561 } 562 563 /* 564 * Shows sorted patterns list in the order which is used for the matching 565 */ 566 private void 567 apprentice_list(struct mlist *mlist, int mode) 568 { 569 uint32_t magindex = 0; 570 struct mlist *ml; 571 for (ml = mlist->next; ml != mlist; ml = ml->next) { 572 for (magindex = 0; magindex < ml->nmagic; magindex++) { 573 struct magic *m = &ml->magic[magindex]; 574 if ((m->flag & mode) != mode) { 575 /* Skip sub-tests */ 576 while (magindex + 1 < ml->nmagic && 577 ml->magic[magindex + 1].cont_level != 0) 578 ++magindex; 579 continue; /* Skip to next top-level test*/ 580 } 581 582 /* 583 * Try to iterate over the tree until we find item with 584 * description/mimetype. 585 */ 586 while (magindex + 1 < ml->nmagic && 587 ml->magic[magindex + 1].cont_level != 0 && 588 *ml->magic[magindex].desc == '\0' && 589 *ml->magic[magindex].mimetype == '\0') 590 magindex++; 591 592 printf("Strength = %3" SIZE_T_FORMAT "u : %s [%s]\n", 593 apprentice_magic_strength(m), 594 ml->magic[magindex].desc, 595 ml->magic[magindex].mimetype); 596 } 597 } 598 } 599 600 private void 601 set_test_type(struct magic *mstart, struct magic *m) 602 { 603 switch (m->type) { 604 case FILE_BYTE: 605 case FILE_SHORT: 606 case FILE_LONG: 607 case FILE_DATE: 608 case FILE_BESHORT: 609 case FILE_BELONG: 610 case FILE_BEDATE: 611 case FILE_LESHORT: 612 case FILE_LELONG: 613 case FILE_LEDATE: 614 case FILE_LDATE: 615 case FILE_BELDATE: 616 case FILE_LELDATE: 617 case FILE_MEDATE: 618 case FILE_MELDATE: 619 case FILE_MELONG: 620 case FILE_QUAD: 621 case FILE_LEQUAD: 622 case FILE_BEQUAD: 623 case FILE_QDATE: 624 case FILE_LEQDATE: 625 case FILE_BEQDATE: 626 case FILE_QLDATE: 627 case FILE_LEQLDATE: 628 case FILE_BEQLDATE: 629 case FILE_FLOAT: 630 case FILE_BEFLOAT: 631 case FILE_LEFLOAT: 632 case FILE_DOUBLE: 633 case FILE_BEDOUBLE: 634 case FILE_LEDOUBLE: 635 mstart->flag |= BINTEST; 636 break; 637 case FILE_STRING: 638 case FILE_PSTRING: 639 case FILE_BESTRING16: 640 case FILE_LESTRING16: 641 /* Allow text overrides */ 642 if (mstart->str_flags & STRING_TEXTTEST) 643 mstart->flag |= TEXTTEST; 644 else 645 mstart->flag |= BINTEST; 646 break; 647 case FILE_REGEX: 648 case FILE_SEARCH: 649 /* Check for override */ 650 if (mstart->str_flags & STRING_BINTEST) 651 mstart->flag |= BINTEST; 652 if (mstart->str_flags & STRING_TEXTTEST) 653 mstart->flag |= TEXTTEST; 654 655 if (mstart->flag & (TEXTTEST|BINTEST)) 656 break; 657 658 /* binary test if pattern is not text */ 659 if (file_looks_utf8(m->value.us, (size_t)m->vallen, NULL, 660 NULL) <= 0) 661 mstart->flag |= BINTEST; 662 else 663 mstart->flag |= TEXTTEST; 664 break; 665 case FILE_DEFAULT: 666 /* can't deduce anything; we shouldn't see this at the 667 top level anyway */ 668 break; 669 case FILE_INVALID: 670 default: 671 /* invalid search type, but no need to complain here */ 672 break; 673 } 674 } 675 676 /* 677 * Load and parse one file. 678 */ 679 private void 680 load_1(struct magic_set *ms, int action, const char *fn, int *errs, 681 struct magic_entry **marray, uint32_t *marraycount) 682 { 683 size_t lineno = 0, llen = 0; 684 char *line = NULL; 685 ssize_t len; 686 687 FILE *f = fopen(ms->file = fn, "r"); 688 if (f == NULL) { 689 if (errno != ENOENT) 690 file_error(ms, errno, "cannot read magic file `%s'", 691 fn); 692 (*errs)++; 693 return; 694 } 695 696 /* read and parse this file */ 697 for (ms->line = 1; (len = getline(&line, &llen, f)) != -1; 698 ms->line++) { 699 if (len == 0) /* null line, garbage, etc */ 700 continue; 701 if (line[len - 1] == '\n') { 702 lineno++; 703 line[len - 1] = '\0'; /* delete newline */ 704 } 705 switch (line[0]) { 706 case '\0': /* empty, do not parse */ 707 case '#': /* comment, do not parse */ 708 continue; 709 case '!': 710 if (line[1] == ':') { 711 size_t i; 712 713 for (i = 0; bang[i].name != NULL; i++) { 714 if ((size_t)(len - 2) > bang[i].len && 715 memcmp(bang[i].name, line + 2, 716 bang[i].len) == 0) 717 break; 718 } 719 if (bang[i].name == NULL) { 720 file_error(ms, 0, 721 "Unknown !: entry `%s'", line); 722 (*errs)++; 723 continue; 724 } 725 if (*marraycount == 0) { 726 file_error(ms, 0, 727 "No current entry for :!%s type", 728 bang[i].name); 729 (*errs)++; 730 continue; 731 } 732 if ((*bang[i].fun)(ms, 733 &(*marray)[*marraycount - 1], 734 line + bang[i].len + 2) != 0) { 735 (*errs)++; 736 continue; 737 } 738 continue; 739 } 740 /*FALLTHROUGH*/ 741 default: 742 if (parse(ms, marray, marraycount, line, lineno, 743 action) != 0) 744 (*errs)++; 745 break; 746 } 747 } 748 free(line); 749 (void)fclose(f); 750 } 751 752 /* 753 * parse a file or directory of files 754 * const char *fn: name of magic file or directory 755 */ 756 private int 757 cmpstrp(const void *p1, const void *p2) 758 { 759 return strcmp(*(char *const *)p1, *(char *const *)p2); 760 } 761 762 private int 763 apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, 764 const char *fn, int action) 765 { 766 int errs = 0; 767 struct magic_entry *marray; 768 uint32_t marraycount, i, mentrycount = 0, starttest; 769 size_t slen, files = 0, maxfiles = 0; 770 char **filearr = NULL, *mfn; 771 struct stat st; 772 DIR *dir; 773 struct dirent *d; 774 775 ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */ 776 777 maxmagic = MAXMAGIS; 778 if ((marray = CAST(struct magic_entry *, calloc(maxmagic, 779 sizeof(*marray)))) == NULL) { 780 file_oomem(ms, maxmagic * sizeof(*marray)); 781 return -1; 782 } 783 marraycount = 0; 784 785 /* print silly verbose header for USG compat. */ 786 if (action == FILE_CHECK) 787 (void)fprintf(stderr, "%s\n", usg_hdr); 788 789 /* load directory or file */ 790 if (stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) { 791 dir = opendir(fn); 792 if (!dir) { 793 errs++; 794 goto out; 795 } 796 while ((d = readdir(dir)) != NULL) { 797 if (asprintf(&mfn, "%s/%s", fn, d->d_name) < 0) { 798 file_oomem(ms, 799 strlen(fn) + strlen(d->d_name) + 2); 800 errs++; 801 closedir(dir); 802 goto out; 803 } 804 if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) { 805 free(mfn); 806 continue; 807 } 808 if (files >= maxfiles) { 809 size_t mlen; 810 maxfiles = (maxfiles + 1) * 2; 811 mlen = maxfiles * sizeof(*filearr); 812 if ((filearr = CAST(char **, 813 realloc(filearr, mlen))) == NULL) { 814 file_oomem(ms, mlen); 815 free(mfn); 816 closedir(dir); 817 errs++; 818 goto out; 819 } 820 } 821 filearr[files++] = mfn; 822 } 823 closedir(dir); 824 qsort(filearr, files, sizeof(*filearr), cmpstrp); 825 for (i = 0; i < files; i++) { 826 load_1(ms, action, filearr[i], &errs, &marray, 827 &marraycount); 828 free(filearr[i]); 829 } 830 free(filearr); 831 } else 832 load_1(ms, action, fn, &errs, &marray, &marraycount); 833 if (errs) 834 goto out; 835 836 /* Set types of tests */ 837 for (i = 0; i < marraycount; ) { 838 if (marray[i].mp->cont_level != 0) { 839 i++; 840 continue; 841 } 842 843 starttest = i; 844 do { 845 static const char text[] = "text"; 846 static const char binary[] = "binary"; 847 static const size_t len = sizeof(text); 848 set_test_type(marray[starttest].mp, marray[i].mp); 849 if ((ms->flags & MAGIC_DEBUG) == 0) 850 continue; 851 (void)fprintf(stderr, "%s%s%s: %s\n", 852 marray[i].mp->mimetype, 853 marray[i].mp->mimetype[0] == '\0' ? "" : "; ", 854 marray[i].mp->desc[0] ? marray[i].mp->desc : 855 "(no description)", 856 marray[i].mp->flag & BINTEST ? binary : text); 857 if (marray[i].mp->flag & BINTEST) { 858 char *p = strstr(marray[i].mp->desc, text); 859 if (p && (p == marray[i].mp->desc || 860 isspace((unsigned char)p[-1])) && 861 (p + len - marray[i].mp->desc == 862 MAXstring || (p[len] == '\0' || 863 isspace((unsigned char)p[len])))) 864 (void)fprintf(stderr, "*** Possible " 865 "binary test for text type\n"); 866 } 867 } while (++i < marraycount && marray[i].mp->cont_level != 0); 868 } 869 870 qsort(marray, marraycount, sizeof(*marray), apprentice_sort); 871 872 /* 873 * Make sure that any level 0 "default" line is last (if one exists). 874 */ 875 for (i = 0; i < marraycount; i++) { 876 if (marray[i].mp->cont_level == 0 && 877 marray[i].mp->type == FILE_DEFAULT) { 878 while (++i < marraycount) 879 if (marray[i].mp->cont_level == 0) 880 break; 881 if (i != marraycount) { 882 /* XXX - Ugh! */ 883 ms->line = marray[i].mp->lineno; 884 file_magwarn(ms, 885 "level 0 \"default\" did not sort last"); 886 } 887 break; 888 } 889 } 890 891 for (i = 0; i < marraycount; i++) 892 mentrycount += marray[i].cont_count; 893 894 slen = sizeof(**magicp) * mentrycount; 895 if ((*magicp = CAST(struct magic *, malloc(slen))) == NULL) { 896 file_oomem(ms, slen); 897 errs++; 898 goto out; 899 } 900 901 mentrycount = 0; 902 for (i = 0; i < marraycount; i++) { 903 (void)memcpy(*magicp + mentrycount, marray[i].mp, 904 marray[i].cont_count * sizeof(**magicp)); 905 mentrycount += marray[i].cont_count; 906 } 907 out: 908 for (i = 0; i < marraycount; i++) 909 free(marray[i].mp); 910 free(marray); 911 if (errs) { 912 *magicp = NULL; 913 *nmagicp = 0; 914 return errs; 915 } else { 916 *nmagicp = mentrycount; 917 return 0; 918 } 919 920 } 921 922 /* 923 * extend the sign bit if the comparison is to be signed 924 */ 925 protected uint64_t 926 file_signextend(struct magic_set *ms, struct magic *m, uint64_t v) 927 { 928 if (!(m->flag & UNSIGNED)) { 929 switch(m->type) { 930 /* 931 * Do not remove the casts below. They are 932 * vital. When later compared with the data, 933 * the sign extension must have happened. 934 */ 935 case FILE_BYTE: 936 v = (char) v; 937 break; 938 case FILE_SHORT: 939 case FILE_BESHORT: 940 case FILE_LESHORT: 941 v = (short) v; 942 break; 943 case FILE_DATE: 944 case FILE_BEDATE: 945 case FILE_LEDATE: 946 case FILE_MEDATE: 947 case FILE_LDATE: 948 case FILE_BELDATE: 949 case FILE_LELDATE: 950 case FILE_MELDATE: 951 case FILE_LONG: 952 case FILE_BELONG: 953 case FILE_LELONG: 954 case FILE_MELONG: 955 case FILE_FLOAT: 956 case FILE_BEFLOAT: 957 case FILE_LEFLOAT: 958 v = (int32_t) v; 959 break; 960 case FILE_QUAD: 961 case FILE_BEQUAD: 962 case FILE_LEQUAD: 963 case FILE_QDATE: 964 case FILE_QLDATE: 965 case FILE_BEQDATE: 966 case FILE_BEQLDATE: 967 case FILE_LEQDATE: 968 case FILE_LEQLDATE: 969 case FILE_DOUBLE: 970 case FILE_BEDOUBLE: 971 case FILE_LEDOUBLE: 972 v = (int64_t) v; 973 break; 974 case FILE_STRING: 975 case FILE_PSTRING: 976 case FILE_BESTRING16: 977 case FILE_LESTRING16: 978 case FILE_REGEX: 979 case FILE_SEARCH: 980 case FILE_DEFAULT: 981 case FILE_INDIRECT: 982 break; 983 default: 984 if (ms->flags & MAGIC_CHECK) 985 file_magwarn(ms, "cannot happen: m->type=%d\n", 986 m->type); 987 return ~0U; 988 } 989 } 990 return v; 991 } 992 993 private int 994 string_modifier_check(struct magic_set *ms, struct magic *m) 995 { 996 if ((ms->flags & MAGIC_CHECK) == 0) 997 return 0; 998 999 if (m->type != FILE_PSTRING && (m->str_flags & PSTRING_LEN) != 0) { 1000 file_magwarn(ms, 1001 "'/BHhLl' modifiers are only allowed for pascal strings\n"); 1002 return -1; 1003 } 1004 switch (m->type) { 1005 case FILE_BESTRING16: 1006 case FILE_LESTRING16: 1007 if (m->str_flags != 0) { 1008 file_magwarn(ms, 1009 "no modifiers allowed for 16-bit strings\n"); 1010 return -1; 1011 } 1012 break; 1013 case FILE_STRING: 1014 case FILE_PSTRING: 1015 if ((m->str_flags & REGEX_OFFSET_START) != 0) { 1016 file_magwarn(ms, 1017 "'/%c' only allowed on regex and search\n", 1018 CHAR_REGEX_OFFSET_START); 1019 return -1; 1020 } 1021 break; 1022 case FILE_SEARCH: 1023 if (m->str_range == 0) { 1024 file_magwarn(ms, 1025 "missing range; defaulting to %d\n", 1026 STRING_DEFAULT_RANGE); 1027 m->str_range = STRING_DEFAULT_RANGE; 1028 return -1; 1029 } 1030 break; 1031 case FILE_REGEX: 1032 if ((m->str_flags & STRING_COMPACT_WHITESPACE) != 0) { 1033 file_magwarn(ms, "'/%c' not allowed on regex\n", 1034 CHAR_COMPACT_WHITESPACE); 1035 return -1; 1036 } 1037 if ((m->str_flags & STRING_COMPACT_OPTIONAL_WHITESPACE) != 0) { 1038 file_magwarn(ms, "'/%c' not allowed on regex\n", 1039 CHAR_COMPACT_OPTIONAL_WHITESPACE); 1040 return -1; 1041 } 1042 break; 1043 default: 1044 file_magwarn(ms, "coding error: m->type=%d\n", 1045 m->type); 1046 return -1; 1047 } 1048 return 0; 1049 } 1050 1051 private int 1052 get_op(char c) 1053 { 1054 switch (c) { 1055 case '&': 1056 return FILE_OPAND; 1057 case '|': 1058 return FILE_OPOR; 1059 case '^': 1060 return FILE_OPXOR; 1061 case '+': 1062 return FILE_OPADD; 1063 case '-': 1064 return FILE_OPMINUS; 1065 case '*': 1066 return FILE_OPMULTIPLY; 1067 case '/': 1068 return FILE_OPDIVIDE; 1069 case '%': 1070 return FILE_OPMODULO; 1071 default: 1072 return -1; 1073 } 1074 } 1075 1076 #ifdef ENABLE_CONDITIONALS 1077 private int 1078 get_cond(const char *l, const char **t) 1079 { 1080 static const struct cond_tbl_s { 1081 char name[8]; 1082 size_t len; 1083 int cond; 1084 } cond_tbl[] = { 1085 { "if", 2, COND_IF }, 1086 { "elif", 4, COND_ELIF }, 1087 { "else", 4, COND_ELSE }, 1088 { "", 0, COND_NONE }, 1089 }; 1090 const struct cond_tbl_s *p; 1091 1092 for (p = cond_tbl; p->len; p++) { 1093 if (strncmp(l, p->name, p->len) == 0 && 1094 isspace((unsigned char)l[p->len])) { 1095 if (t) 1096 *t = l + p->len; 1097 break; 1098 } 1099 } 1100 return p->cond; 1101 } 1102 1103 private int 1104 check_cond(struct magic_set *ms, int cond, uint32_t cont_level) 1105 { 1106 int last_cond; 1107 last_cond = ms->c.li[cont_level].last_cond; 1108 1109 switch (cond) { 1110 case COND_IF: 1111 if (last_cond != COND_NONE && last_cond != COND_ELIF) { 1112 if (ms->flags & MAGIC_CHECK) 1113 file_magwarn(ms, "syntax error: `if'"); 1114 return -1; 1115 } 1116 last_cond = COND_IF; 1117 break; 1118 1119 case COND_ELIF: 1120 if (last_cond != COND_IF && last_cond != COND_ELIF) { 1121 if (ms->flags & MAGIC_CHECK) 1122 file_magwarn(ms, "syntax error: `elif'"); 1123 return -1; 1124 } 1125 last_cond = COND_ELIF; 1126 break; 1127 1128 case COND_ELSE: 1129 if (last_cond != COND_IF && last_cond != COND_ELIF) { 1130 if (ms->flags & MAGIC_CHECK) 1131 file_magwarn(ms, "syntax error: `else'"); 1132 return -1; 1133 } 1134 last_cond = COND_NONE; 1135 break; 1136 1137 case COND_NONE: 1138 last_cond = COND_NONE; 1139 break; 1140 } 1141 1142 ms->c.li[cont_level].last_cond = last_cond; 1143 return 0; 1144 } 1145 #endif /* ENABLE_CONDITIONALS */ 1146 1147 /* 1148 * parse one line from magic file, put into magic[index++] if valid 1149 */ 1150 private int 1151 parse(struct magic_set *ms, struct magic_entry **mentryp, uint32_t *nmentryp, 1152 const char *line, size_t lineno, int action) 1153 { 1154 #ifdef ENABLE_CONDITIONALS 1155 static uint32_t last_cont_level = 0; 1156 #endif 1157 size_t i; 1158 struct magic_entry *me; 1159 struct magic *m; 1160 const char *l = line; 1161 char *t; 1162 int op; 1163 uint32_t cont_level; 1164 1165 cont_level = 0; 1166 1167 while (*l == '>') { 1168 ++l; /* step over */ 1169 cont_level++; 1170 } 1171 #ifdef ENABLE_CONDITIONALS 1172 if (cont_level == 0 || cont_level > last_cont_level) 1173 if (file_check_mem(ms, cont_level) == -1) 1174 return -1; 1175 last_cont_level = cont_level; 1176 #endif 1177 1178 #define ALLOC_CHUNK (size_t)10 1179 #define ALLOC_INCR (size_t)200 1180 1181 if (cont_level != 0) { 1182 if (*nmentryp == 0) { 1183 file_error(ms, 0, "No current entry for continuation"); 1184 return -1; 1185 } 1186 me = &(*mentryp)[*nmentryp - 1]; 1187 if (me->cont_count == me->max_count) { 1188 struct magic *nm; 1189 size_t cnt = me->max_count + ALLOC_CHUNK; 1190 if ((nm = CAST(struct magic *, realloc(me->mp, 1191 sizeof(*nm) * cnt))) == NULL) { 1192 file_oomem(ms, sizeof(*nm) * cnt); 1193 return -1; 1194 } 1195 me->mp = m = nm; 1196 me->max_count = CAST(uint32_t, cnt); 1197 } 1198 m = &me->mp[me->cont_count++]; 1199 (void)memset(m, 0, sizeof(*m)); 1200 m->cont_level = cont_level; 1201 } else { 1202 if (*nmentryp == maxmagic) { 1203 struct magic_entry *mp; 1204 1205 maxmagic += ALLOC_INCR; 1206 if ((mp = CAST(struct magic_entry *, 1207 realloc(*mentryp, sizeof(*mp) * maxmagic))) == 1208 NULL) { 1209 file_oomem(ms, sizeof(*mp) * maxmagic); 1210 return -1; 1211 } 1212 (void)memset(&mp[*nmentryp], 0, sizeof(*mp) * 1213 ALLOC_INCR); 1214 *mentryp = mp; 1215 } 1216 me = &(*mentryp)[*nmentryp]; 1217 if (me->mp == NULL) { 1218 size_t len = sizeof(*m) * ALLOC_CHUNK; 1219 if ((m = CAST(struct magic *, malloc(len))) == NULL) { 1220 file_oomem(ms, len); 1221 return -1; 1222 } 1223 me->mp = m; 1224 me->max_count = ALLOC_CHUNK; 1225 } else 1226 m = me->mp; 1227 (void)memset(m, 0, sizeof(*m)); 1228 m->factor_op = FILE_FACTOR_OP_NONE; 1229 m->cont_level = 0; 1230 me->cont_count = 1; 1231 } 1232 m->lineno = CAST(uint32_t, lineno); 1233 1234 if (*l == '&') { /* m->cont_level == 0 checked below. */ 1235 ++l; /* step over */ 1236 m->flag |= OFFADD; 1237 } 1238 if (*l == '(') { 1239 ++l; /* step over */ 1240 m->flag |= INDIR; 1241 if (m->flag & OFFADD) 1242 m->flag = (m->flag & ~OFFADD) | INDIROFFADD; 1243 1244 if (*l == '&') { /* m->cont_level == 0 checked below */ 1245 ++l; /* step over */ 1246 m->flag |= OFFADD; 1247 } 1248 } 1249 /* Indirect offsets are not valid at level 0. */ 1250 if (m->cont_level == 0 && (m->flag & (OFFADD | INDIROFFADD))) 1251 if (ms->flags & MAGIC_CHECK) 1252 file_magwarn(ms, "relative offset at level 0"); 1253 1254 /* get offset, then skip over it */ 1255 m->offset = (uint32_t)strtoul(l, &t, 0); 1256 if (l == t) 1257 if (ms->flags & MAGIC_CHECK) 1258 file_magwarn(ms, "offset `%s' invalid", l); 1259 l = t; 1260 1261 if (m->flag & INDIR) { 1262 m->in_type = FILE_LONG; 1263 m->in_offset = 0; 1264 /* 1265 * read [.lbs][+-]nnnnn) 1266 */ 1267 if (*l == '.') { 1268 l++; 1269 switch (*l) { 1270 case 'l': 1271 m->in_type = FILE_LELONG; 1272 break; 1273 case 'L': 1274 m->in_type = FILE_BELONG; 1275 break; 1276 case 'm': 1277 m->in_type = FILE_MELONG; 1278 break; 1279 case 'h': 1280 case 's': 1281 m->in_type = FILE_LESHORT; 1282 break; 1283 case 'H': 1284 case 'S': 1285 m->in_type = FILE_BESHORT; 1286 break; 1287 case 'c': 1288 case 'b': 1289 case 'C': 1290 case 'B': 1291 m->in_type = FILE_BYTE; 1292 break; 1293 case 'e': 1294 case 'f': 1295 case 'g': 1296 m->in_type = FILE_LEDOUBLE; 1297 break; 1298 case 'E': 1299 case 'F': 1300 case 'G': 1301 m->in_type = FILE_BEDOUBLE; 1302 break; 1303 case 'i': 1304 m->in_type = FILE_LEID3; 1305 break; 1306 case 'I': 1307 m->in_type = FILE_BEID3; 1308 break; 1309 default: 1310 if (ms->flags & MAGIC_CHECK) 1311 file_magwarn(ms, 1312 "indirect offset type `%c' invalid", 1313 *l); 1314 break; 1315 } 1316 l++; 1317 } 1318 1319 m->in_op = 0; 1320 if (*l == '~') { 1321 m->in_op |= FILE_OPINVERSE; 1322 l++; 1323 } 1324 if ((op = get_op(*l)) != -1) { 1325 m->in_op |= op; 1326 l++; 1327 } 1328 if (*l == '(') { 1329 m->in_op |= FILE_OPINDIRECT; 1330 l++; 1331 } 1332 if (isdigit((unsigned char)*l) || *l == '-') { 1333 m->in_offset = (int32_t)strtol(l, &t, 0); 1334 if (l == t) 1335 if (ms->flags & MAGIC_CHECK) 1336 file_magwarn(ms, 1337 "in_offset `%s' invalid", l); 1338 l = t; 1339 } 1340 if (*l++ != ')' || 1341 ((m->in_op & FILE_OPINDIRECT) && *l++ != ')')) 1342 if (ms->flags & MAGIC_CHECK) 1343 file_magwarn(ms, 1344 "missing ')' in indirect offset"); 1345 } 1346 EATAB; 1347 1348 #ifdef ENABLE_CONDITIONALS 1349 m->cond = get_cond(l, &l); 1350 if (check_cond(ms, m->cond, cont_level) == -1) 1351 return -1; 1352 1353 EATAB; 1354 #endif 1355 1356 if (*l == 'u') { 1357 ++l; 1358 m->flag |= UNSIGNED; 1359 } 1360 1361 m->type = get_type(l, &l); 1362 if (m->type == FILE_INVALID) { 1363 if (ms->flags & MAGIC_CHECK) 1364 file_magwarn(ms, "type `%s' invalid", l); 1365 return -1; 1366 } 1367 1368 /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */ 1369 /* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */ 1370 1371 m->mask_op = 0; 1372 if (*l == '~') { 1373 if (!IS_STRING(m->type)) 1374 m->mask_op |= FILE_OPINVERSE; 1375 else if (ms->flags & MAGIC_CHECK) 1376 file_magwarn(ms, "'~' invalid for string types"); 1377 ++l; 1378 } 1379 m->str_range = 0; 1380 m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0; 1381 if ((op = get_op(*l)) != -1) { 1382 if (!IS_STRING(m->type)) { 1383 uint64_t val; 1384 ++l; 1385 m->mask_op |= op; 1386 val = (uint64_t)strtoull(l, &t, 0); 1387 l = t; 1388 m->num_mask = file_signextend(ms, m, val); 1389 eatsize(&l); 1390 } 1391 else if (op == FILE_OPDIVIDE) { 1392 int have_range = 0; 1393 while (!isspace((unsigned char)*++l)) { 1394 switch (*l) { 1395 case '0': case '1': case '2': 1396 case '3': case '4': case '5': 1397 case '6': case '7': case '8': 1398 case '9': 1399 if (have_range && 1400 (ms->flags & MAGIC_CHECK)) 1401 file_magwarn(ms, 1402 "multiple ranges"); 1403 have_range = 1; 1404 m->str_range = CAST(uint32_t, 1405 strtoul(l, &t, 0)); 1406 if (m->str_range == 0) 1407 file_magwarn(ms, 1408 "zero range"); 1409 l = t - 1; 1410 break; 1411 case CHAR_COMPACT_WHITESPACE: 1412 m->str_flags |= 1413 STRING_COMPACT_WHITESPACE; 1414 break; 1415 case CHAR_COMPACT_OPTIONAL_WHITESPACE: 1416 m->str_flags |= 1417 STRING_COMPACT_OPTIONAL_WHITESPACE; 1418 break; 1419 case CHAR_IGNORE_LOWERCASE: 1420 m->str_flags |= STRING_IGNORE_LOWERCASE; 1421 break; 1422 case CHAR_IGNORE_UPPERCASE: 1423 m->str_flags |= STRING_IGNORE_UPPERCASE; 1424 break; 1425 case CHAR_REGEX_OFFSET_START: 1426 m->str_flags |= REGEX_OFFSET_START; 1427 break; 1428 case CHAR_BINTEST: 1429 m->str_flags |= STRING_BINTEST; 1430 break; 1431 case CHAR_TEXTTEST: 1432 m->str_flags |= STRING_TEXTTEST; 1433 break; 1434 case CHAR_PSTRING_1_LE: 1435 if (m->type != FILE_PSTRING) 1436 goto bad; 1437 m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_1_LE; 1438 break; 1439 case CHAR_PSTRING_2_BE: 1440 if (m->type != FILE_PSTRING) 1441 goto bad; 1442 m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_2_BE; 1443 break; 1444 case CHAR_PSTRING_2_LE: 1445 if (m->type != FILE_PSTRING) 1446 goto bad; 1447 m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_2_LE; 1448 break; 1449 case CHAR_PSTRING_4_BE: 1450 if (m->type != FILE_PSTRING) 1451 goto bad; 1452 m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_4_BE; 1453 break; 1454 case CHAR_PSTRING_4_LE: 1455 if (m->type != FILE_PSTRING) 1456 goto bad; 1457 m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_4_LE; 1458 break; 1459 case CHAR_PSTRING_LENGTH_INCLUDES_ITSELF: 1460 if (m->type != FILE_PSTRING) 1461 goto bad; 1462 m->str_flags |= PSTRING_LENGTH_INCLUDES_ITSELF; 1463 break; 1464 default: 1465 bad: 1466 if (ms->flags & MAGIC_CHECK) 1467 file_magwarn(ms, 1468 "string extension `%c' " 1469 "invalid", *l); 1470 return -1; 1471 } 1472 /* allow multiple '/' for readability */ 1473 if (l[1] == '/' && 1474 !isspace((unsigned char)l[2])) 1475 l++; 1476 } 1477 if (string_modifier_check(ms, m) == -1) 1478 return -1; 1479 } 1480 else { 1481 if (ms->flags & MAGIC_CHECK) 1482 file_magwarn(ms, "invalid string op: %c", *t); 1483 return -1; 1484 } 1485 } 1486 /* 1487 * We used to set mask to all 1's here, instead let's just not do 1488 * anything if mask = 0 (unless you have a better idea) 1489 */ 1490 EATAB; 1491 1492 switch (*l) { 1493 case '>': 1494 case '<': 1495 m->reln = *l; 1496 ++l; 1497 if (*l == '=') { 1498 if (ms->flags & MAGIC_CHECK) { 1499 file_magwarn(ms, "%c= not supported", 1500 m->reln); 1501 return -1; 1502 } 1503 ++l; 1504 } 1505 break; 1506 /* Old-style anding: "0 byte &0x80 dynamically linked" */ 1507 case '&': 1508 case '^': 1509 case '=': 1510 m->reln = *l; 1511 ++l; 1512 if (*l == '=') { 1513 /* HP compat: ignore &= etc. */ 1514 ++l; 1515 } 1516 break; 1517 case '!': 1518 m->reln = *l; 1519 ++l; 1520 break; 1521 default: 1522 m->reln = '='; /* the default relation */ 1523 if (*l == 'x' && ((isascii((unsigned char)l[1]) && 1524 isspace((unsigned char)l[1])) || !l[1])) { 1525 m->reln = *l; 1526 ++l; 1527 } 1528 break; 1529 } 1530 /* 1531 * Grab the value part, except for an 'x' reln. 1532 */ 1533 if (m->reln != 'x' && getvalue(ms, m, &l, action)) 1534 return -1; 1535 1536 /* 1537 * TODO finish this macro and start using it! 1538 * #define offsetcheck {if (offset > HOWMANY-1) 1539 * magwarn("offset too big"); } 1540 */ 1541 1542 /* 1543 * Now get last part - the description 1544 */ 1545 EATAB; 1546 if (l[0] == '\b') { 1547 ++l; 1548 m->flag |= NOSPACE; 1549 } else if ((l[0] == '\\') && (l[1] == 'b')) { 1550 ++l; 1551 ++l; 1552 m->flag |= NOSPACE; 1553 } 1554 for (i = 0; (m->desc[i++] = *l++) != '\0' && i < sizeof(m->desc); ) 1555 continue; 1556 if (i == sizeof(m->desc)) { 1557 m->desc[sizeof(m->desc) - 1] = '\0'; 1558 if (ms->flags & MAGIC_CHECK) 1559 file_magwarn(ms, "description `%s' truncated", m->desc); 1560 } 1561 1562 /* 1563 * We only do this check while compiling, or if any of the magic 1564 * files were not compiled. 1565 */ 1566 if (ms->flags & MAGIC_CHECK) { 1567 if (check_format(ms, m) == -1) 1568 return -1; 1569 } 1570 #ifndef COMPILE_ONLY 1571 if (action == FILE_CHECK) { 1572 file_mdump(m); 1573 } 1574 #endif 1575 m->mimetype[0] = '\0'; /* initialise MIME type to none */ 1576 if (m->cont_level == 0) 1577 ++(*nmentryp); /* make room for next */ 1578 return 0; 1579 } 1580 1581 /* 1582 * parse a STRENGTH annotation line from magic file, put into magic[index - 1] 1583 * if valid 1584 */ 1585 private int 1586 parse_strength(struct magic_set *ms, struct magic_entry *me, const char *line) 1587 { 1588 const char *l = line; 1589 char *el; 1590 unsigned long factor; 1591 struct magic *m = &me->mp[0]; 1592 1593 if (m->factor_op != FILE_FACTOR_OP_NONE) { 1594 file_magwarn(ms, 1595 "Current entry already has a strength type: %c %d", 1596 m->factor_op, m->factor); 1597 return -1; 1598 } 1599 EATAB; 1600 switch (*l) { 1601 case FILE_FACTOR_OP_NONE: 1602 case FILE_FACTOR_OP_PLUS: 1603 case FILE_FACTOR_OP_MINUS: 1604 case FILE_FACTOR_OP_TIMES: 1605 case FILE_FACTOR_OP_DIV: 1606 m->factor_op = *l++; 1607 break; 1608 default: 1609 file_magwarn(ms, "Unknown factor op `%c'", *l); 1610 return -1; 1611 } 1612 EATAB; 1613 factor = strtoul(l, &el, 0); 1614 if (factor > 255) { 1615 file_magwarn(ms, "Too large factor `%lu'", factor); 1616 goto out; 1617 } 1618 if (*el && !isspace((unsigned char)*el)) { 1619 file_magwarn(ms, "Bad factor `%s'", l); 1620 goto out; 1621 } 1622 m->factor = (uint8_t)factor; 1623 if (m->factor == 0 && m->factor_op == FILE_FACTOR_OP_DIV) { 1624 file_magwarn(ms, "Cannot have factor op `%c' and factor %u", 1625 m->factor_op, m->factor); 1626 goto out; 1627 } 1628 return 0; 1629 out: 1630 m->factor_op = FILE_FACTOR_OP_NONE; 1631 m->factor = 0; 1632 return -1; 1633 } 1634 1635 /* 1636 * Parse an Apple CREATOR/TYPE annotation from magic file and put it into 1637 * magic[index - 1] 1638 */ 1639 private int 1640 parse_apple(struct magic_set *ms, struct magic_entry *me, const char *line) 1641 { 1642 size_t i; 1643 const char *l = line; 1644 struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1]; 1645 1646 if (m->apple[0] != '\0') { 1647 file_magwarn(ms, "Current entry already has a APPLE type " 1648 "`%.8s', new type `%s'", m->mimetype, l); 1649 return -1; 1650 } 1651 1652 EATAB; 1653 for (i = 0; *l && ((isascii((unsigned char)*l) && 1654 isalnum((unsigned char)*l)) || strchr("-+/.", *l)) && 1655 i < sizeof(m->apple); m->apple[i++] = *l++) 1656 continue; 1657 if (i == sizeof(m->apple) && *l) { 1658 /* We don't need to NUL terminate here, printing handles it */ 1659 if (ms->flags & MAGIC_CHECK) 1660 file_magwarn(ms, "APPLE type `%s' truncated %" 1661 SIZE_T_FORMAT "u", line, i); 1662 } 1663 1664 if (i > 0) 1665 return 0; 1666 else 1667 return -1; 1668 } 1669 1670 /* 1671 * parse a MIME annotation line from magic file, put into magic[index - 1] 1672 * if valid 1673 */ 1674 private int 1675 parse_mime(struct magic_set *ms, struct magic_entry *me, const char *line) 1676 { 1677 size_t i; 1678 const char *l = line; 1679 struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1]; 1680 1681 if (m->mimetype[0] != '\0') { 1682 file_magwarn(ms, "Current entry already has a MIME type `%s'," 1683 " new type `%s'", m->mimetype, l); 1684 return -1; 1685 } 1686 1687 EATAB; 1688 for (i = 0; *l && ((isascii((unsigned char)*l) && 1689 isalnum((unsigned char)*l)) || strchr("-+/.", *l)) && 1690 i < sizeof(m->mimetype); m->mimetype[i++] = *l++) 1691 continue; 1692 if (i == sizeof(m->mimetype)) { 1693 m->mimetype[sizeof(m->mimetype) - 1] = '\0'; 1694 if (ms->flags & MAGIC_CHECK) 1695 file_magwarn(ms, "MIME type `%s' truncated %" 1696 SIZE_T_FORMAT "u", m->mimetype, i); 1697 } else 1698 m->mimetype[i] = '\0'; 1699 1700 if (i > 0) 1701 return 0; 1702 else 1703 return -1; 1704 } 1705 1706 private int 1707 check_format_type(const char *ptr, int type) 1708 { 1709 int quad = 0; 1710 if (*ptr == '\0') { 1711 /* Missing format string; bad */ 1712 return -1; 1713 } 1714 1715 switch (type) { 1716 case FILE_FMT_QUAD: 1717 quad = 1; 1718 /*FALLTHROUGH*/ 1719 case FILE_FMT_NUM: 1720 if (*ptr == '-') 1721 ptr++; 1722 if (*ptr == '.') 1723 ptr++; 1724 while (isdigit((unsigned char)*ptr)) ptr++; 1725 if (*ptr == '.') 1726 ptr++; 1727 while (isdigit((unsigned char)*ptr)) ptr++; 1728 if (quad) { 1729 if (*ptr++ != 'l') 1730 return -1; 1731 if (*ptr++ != 'l') 1732 return -1; 1733 } 1734 1735 switch (*ptr++) { 1736 case 'l': 1737 switch (*ptr++) { 1738 case 'i': 1739 case 'd': 1740 case 'u': 1741 case 'x': 1742 case 'X': 1743 return 0; 1744 default: 1745 return -1; 1746 } 1747 1748 case 'h': 1749 switch (*ptr++) { 1750 case 'h': 1751 switch (*ptr++) { 1752 case 'i': 1753 case 'd': 1754 case 'u': 1755 case 'x': 1756 case 'X': 1757 return 0; 1758 default: 1759 return -1; 1760 } 1761 case 'd': 1762 return 0; 1763 default: 1764 return -1; 1765 } 1766 1767 case 'i': 1768 case 'c': 1769 case 'd': 1770 case 'u': 1771 case 'x': 1772 case 'X': 1773 return 0; 1774 1775 default: 1776 return -1; 1777 } 1778 1779 case FILE_FMT_FLOAT: 1780 case FILE_FMT_DOUBLE: 1781 if (*ptr == '-') 1782 ptr++; 1783 if (*ptr == '.') 1784 ptr++; 1785 while (isdigit((unsigned char)*ptr)) ptr++; 1786 if (*ptr == '.') 1787 ptr++; 1788 while (isdigit((unsigned char)*ptr)) ptr++; 1789 1790 switch (*ptr++) { 1791 case 'e': 1792 case 'E': 1793 case 'f': 1794 case 'F': 1795 case 'g': 1796 case 'G': 1797 return 0; 1798 1799 default: 1800 return -1; 1801 } 1802 1803 1804 case FILE_FMT_STR: 1805 if (*ptr == '-') 1806 ptr++; 1807 while (isdigit((unsigned char )*ptr)) 1808 ptr++; 1809 if (*ptr == '.') { 1810 ptr++; 1811 while (isdigit((unsigned char )*ptr)) 1812 ptr++; 1813 } 1814 1815 switch (*ptr++) { 1816 case 's': 1817 return 0; 1818 default: 1819 return -1; 1820 } 1821 1822 default: 1823 /* internal error */ 1824 abort(); 1825 } 1826 /*NOTREACHED*/ 1827 return -1; 1828 } 1829 1830 /* 1831 * Check that the optional printf format in description matches 1832 * the type of the magic. 1833 */ 1834 private int 1835 check_format(struct magic_set *ms, struct magic *m) 1836 { 1837 char *ptr; 1838 1839 for (ptr = m->desc; *ptr; ptr++) 1840 if (*ptr == '%') 1841 break; 1842 if (*ptr == '\0') { 1843 /* No format string; ok */ 1844 return 1; 1845 } 1846 1847 assert(file_nformats == file_nnames); 1848 1849 if (m->type >= file_nformats) { 1850 file_magwarn(ms, "Internal error inconsistency between " 1851 "m->type and format strings"); 1852 return -1; 1853 } 1854 if (file_formats[m->type] == FILE_FMT_NONE) { 1855 file_magwarn(ms, "No format string for `%s' with description " 1856 "`%s'", m->desc, file_names[m->type]); 1857 return -1; 1858 } 1859 1860 ptr++; 1861 if (check_format_type(ptr, file_formats[m->type]) == -1) { 1862 /* 1863 * TODO: this error message is unhelpful if the format 1864 * string is not one character long 1865 */ 1866 file_magwarn(ms, "Printf format `%c' is not valid for type " 1867 "`%s' in description `%s'", *ptr ? *ptr : '?', 1868 file_names[m->type], m->desc); 1869 return -1; 1870 } 1871 1872 for (; *ptr; ptr++) { 1873 if (*ptr == '%') { 1874 file_magwarn(ms, 1875 "Too many format strings (should have at most one) " 1876 "for `%s' with description `%s'", 1877 file_names[m->type], m->desc); 1878 return -1; 1879 } 1880 } 1881 return 0; 1882 } 1883 1884 /* 1885 * Read a numeric value from a pointer, into the value union of a magic 1886 * pointer, according to the magic type. Update the string pointer to point 1887 * just after the number read. Return 0 for success, non-zero for failure. 1888 */ 1889 private int 1890 getvalue(struct magic_set *ms, struct magic *m, const char **p, int action) 1891 { 1892 switch (m->type) { 1893 case FILE_BESTRING16: 1894 case FILE_LESTRING16: 1895 case FILE_STRING: 1896 case FILE_PSTRING: 1897 case FILE_REGEX: 1898 case FILE_SEARCH: 1899 *p = getstr(ms, m, *p, action == FILE_COMPILE); 1900 if (*p == NULL) { 1901 if (ms->flags & MAGIC_CHECK) 1902 file_magwarn(ms, "cannot get string from `%s'", 1903 m->value.s); 1904 return -1; 1905 } 1906 return 0; 1907 case FILE_FLOAT: 1908 case FILE_BEFLOAT: 1909 case FILE_LEFLOAT: 1910 if (m->reln != 'x') { 1911 char *ep; 1912 #ifdef HAVE_STRTOF 1913 m->value.f = strtof(*p, &ep); 1914 #else 1915 m->value.f = (float)strtod(*p, &ep); 1916 #endif 1917 *p = ep; 1918 } 1919 return 0; 1920 case FILE_DOUBLE: 1921 case FILE_BEDOUBLE: 1922 case FILE_LEDOUBLE: 1923 if (m->reln != 'x') { 1924 char *ep; 1925 m->value.d = strtod(*p, &ep); 1926 *p = ep; 1927 } 1928 return 0; 1929 default: 1930 if (m->reln != 'x') { 1931 char *ep; 1932 m->value.q = file_signextend(ms, m, 1933 (uint64_t)strtoull(*p, &ep, 0)); 1934 *p = ep; 1935 eatsize(p); 1936 } 1937 return 0; 1938 } 1939 } 1940 1941 /* 1942 * Convert a string containing C character escapes. Stop at an unescaped 1943 * space or tab. 1944 * Copy the converted version to "m->value.s", and the length in m->vallen. 1945 * Return updated scan pointer as function result. Warn if set. 1946 */ 1947 private const char * 1948 getstr(struct magic_set *ms, struct magic *m, const char *s, int warn) 1949 { 1950 const char *origs = s; 1951 char *p = m->value.s; 1952 size_t plen = sizeof(m->value.s); 1953 char *origp = p; 1954 char *pmax = p + plen - 1; 1955 int c; 1956 int val; 1957 1958 while ((c = *s++) != '\0') { 1959 if (isspace((unsigned char) c)) 1960 break; 1961 if (p >= pmax) { 1962 file_error(ms, 0, "string too long: `%s'", origs); 1963 return NULL; 1964 } 1965 if (c == '\\') { 1966 switch(c = *s++) { 1967 1968 case '\0': 1969 if (warn) 1970 file_magwarn(ms, "incomplete escape"); 1971 goto out; 1972 1973 case '\t': 1974 if (warn) { 1975 file_magwarn(ms, 1976 "escaped tab found, use \\t instead"); 1977 warn = 0; /* already did */ 1978 } 1979 /*FALLTHROUGH*/ 1980 default: 1981 if (warn) { 1982 if (isprint((unsigned char)c)) { 1983 /* Allow escaping of 1984 * ``relations'' */ 1985 if (strchr("<>&^=!", c) == NULL 1986 && (m->type != FILE_REGEX || 1987 strchr("[]().*?^$|{}", c) 1988 == NULL)) { 1989 file_magwarn(ms, "no " 1990 "need to escape " 1991 "`%c'", c); 1992 } 1993 } else { 1994 file_magwarn(ms, 1995 "unknown escape sequence: " 1996 "\\%03o", c); 1997 } 1998 } 1999 /*FALLTHROUGH*/ 2000 /* space, perhaps force people to use \040? */ 2001 case ' ': 2002 #if 0 2003 /* 2004 * Other things people escape, but shouldn't need to, 2005 * so we disallow them 2006 */ 2007 case '\'': 2008 case '"': 2009 case '?': 2010 #endif 2011 /* Relations */ 2012 case '>': 2013 case '<': 2014 case '&': 2015 case '^': 2016 case '=': 2017 case '!': 2018 /* and baskslash itself */ 2019 case '\\': 2020 *p++ = (char) c; 2021 break; 2022 2023 case 'a': 2024 *p++ = '\a'; 2025 break; 2026 2027 case 'b': 2028 *p++ = '\b'; 2029 break; 2030 2031 case 'f': 2032 *p++ = '\f'; 2033 break; 2034 2035 case 'n': 2036 *p++ = '\n'; 2037 break; 2038 2039 case 'r': 2040 *p++ = '\r'; 2041 break; 2042 2043 case 't': 2044 *p++ = '\t'; 2045 break; 2046 2047 case 'v': 2048 *p++ = '\v'; 2049 break; 2050 2051 /* \ and up to 3 octal digits */ 2052 case '0': 2053 case '1': 2054 case '2': 2055 case '3': 2056 case '4': 2057 case '5': 2058 case '6': 2059 case '7': 2060 val = c - '0'; 2061 c = *s++; /* try for 2 */ 2062 if (c >= '0' && c <= '7') { 2063 val = (val << 3) | (c - '0'); 2064 c = *s++; /* try for 3 */ 2065 if (c >= '0' && c <= '7') 2066 val = (val << 3) | (c-'0'); 2067 else 2068 --s; 2069 } 2070 else 2071 --s; 2072 *p++ = (char)val; 2073 break; 2074 2075 /* \x and up to 2 hex digits */ 2076 case 'x': 2077 val = 'x'; /* Default if no digits */ 2078 c = hextoint(*s++); /* Get next char */ 2079 if (c >= 0) { 2080 val = c; 2081 c = hextoint(*s++); 2082 if (c >= 0) 2083 val = (val << 4) + c; 2084 else 2085 --s; 2086 } else 2087 --s; 2088 *p++ = (char)val; 2089 break; 2090 } 2091 } else 2092 *p++ = (char)c; 2093 } 2094 out: 2095 *p = '\0'; 2096 m->vallen = CAST(unsigned char, (p - origp)); 2097 if (m->type == FILE_PSTRING) 2098 m->vallen += (unsigned char)file_pstring_length_size(m); 2099 return s; 2100 } 2101 2102 2103 /* Single hex char to int; -1 if not a hex char. */ 2104 private int 2105 hextoint(int c) 2106 { 2107 if (!isascii((unsigned char) c)) 2108 return -1; 2109 if (isdigit((unsigned char) c)) 2110 return c - '0'; 2111 if ((c >= 'a') && (c <= 'f')) 2112 return c + 10 - 'a'; 2113 if (( c>= 'A') && (c <= 'F')) 2114 return c + 10 - 'A'; 2115 return -1; 2116 } 2117 2118 2119 /* 2120 * Print a string containing C character escapes. 2121 */ 2122 protected void 2123 file_showstr(FILE *fp, const char *s, size_t len) 2124 { 2125 char c; 2126 2127 for (;;) { 2128 if (len == ~0U) { 2129 c = *s++; 2130 if (c == '\0') 2131 break; 2132 } 2133 else { 2134 if (len-- == 0) 2135 break; 2136 c = *s++; 2137 } 2138 if (c >= 040 && c <= 0176) /* TODO isprint && !iscntrl */ 2139 (void) fputc(c, fp); 2140 else { 2141 (void) fputc('\\', fp); 2142 switch (c) { 2143 case '\a': 2144 (void) fputc('a', fp); 2145 break; 2146 2147 case '\b': 2148 (void) fputc('b', fp); 2149 break; 2150 2151 case '\f': 2152 (void) fputc('f', fp); 2153 break; 2154 2155 case '\n': 2156 (void) fputc('n', fp); 2157 break; 2158 2159 case '\r': 2160 (void) fputc('r', fp); 2161 break; 2162 2163 case '\t': 2164 (void) fputc('t', fp); 2165 break; 2166 2167 case '\v': 2168 (void) fputc('v', fp); 2169 break; 2170 2171 default: 2172 (void) fprintf(fp, "%.3o", c & 0377); 2173 break; 2174 } 2175 } 2176 } 2177 } 2178 2179 /* 2180 * eatsize(): Eat the size spec from a number [eg. 10UL] 2181 */ 2182 private void 2183 eatsize(const char **p) 2184 { 2185 const char *l = *p; 2186 2187 if (LOWCASE(*l) == 'u') 2188 l++; 2189 2190 switch (LOWCASE(*l)) { 2191 case 'l': /* long */ 2192 case 's': /* short */ 2193 case 'h': /* short */ 2194 case 'b': /* char/byte */ 2195 case 'c': /* char/byte */ 2196 l++; 2197 /*FALLTHROUGH*/ 2198 default: 2199 break; 2200 } 2201 2202 *p = l; 2203 } 2204 2205 /* 2206 * handle a compiled file. 2207 */ 2208 private int 2209 apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, 2210 const char *fn) 2211 { 2212 int fd; 2213 struct stat st; 2214 uint32_t *ptr; 2215 uint32_t version; 2216 int needsbyteswap; 2217 char *dbname = NULL; 2218 void *mm = NULL; 2219 2220 dbname = mkdbname(ms, fn, 0); 2221 if (dbname == NULL) 2222 goto error2; 2223 2224 if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1) 2225 goto error2; 2226 2227 if (fstat(fd, &st) == -1) { 2228 file_error(ms, errno, "cannot stat `%s'", dbname); 2229 goto error1; 2230 } 2231 if (st.st_size < 8) { 2232 file_error(ms, 0, "file `%s' is too small", dbname); 2233 goto error1; 2234 } 2235 2236 #ifdef QUICK 2237 if ((mm = mmap(0, (size_t)st.st_size, PROT_READ|PROT_WRITE, 2238 MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) { 2239 file_error(ms, errno, "cannot map `%s'", dbname); 2240 goto error1; 2241 } 2242 #define RET 2 2243 #else 2244 if ((mm = CAST(void *, malloc((size_t)st.st_size))) == NULL) { 2245 file_oomem(ms, (size_t)st.st_size); 2246 goto error1; 2247 } 2248 if (read(fd, mm, (size_t)st.st_size) != (ssize_t)st.st_size) { 2249 file_badread(ms); 2250 goto error1; 2251 } 2252 #define RET 1 2253 #endif 2254 *magicp = CAST(struct magic *, mm); 2255 (void)close(fd); 2256 fd = -1; 2257 ptr = (uint32_t *)(void *)*magicp; 2258 if (*ptr != MAGICNO) { 2259 if (swap4(*ptr) != MAGICNO) { 2260 file_error(ms, 0, "bad magic in `%s'", dbname); 2261 goto error1; 2262 } 2263 needsbyteswap = 1; 2264 } else 2265 needsbyteswap = 0; 2266 if (needsbyteswap) 2267 version = swap4(ptr[1]); 2268 else 2269 version = ptr[1]; 2270 if (version != VERSIONNO) { 2271 file_error(ms, 0, "File %s supports only version %d magic " 2272 "files. `%s' is version %d", VERSION, 2273 VERSIONNO, dbname, version); 2274 goto error1; 2275 } 2276 *nmagicp = (uint32_t)(st.st_size / sizeof(struct magic)); 2277 if (*nmagicp > 0) 2278 (*nmagicp)--; 2279 (*magicp)++; 2280 if (needsbyteswap) 2281 byteswap(*magicp, *nmagicp); 2282 free(dbname); 2283 return RET; 2284 2285 error1: 2286 if (fd != -1) 2287 (void)close(fd); 2288 if (mm) { 2289 #ifdef QUICK 2290 (void)munmap((void *)mm, (size_t)st.st_size); 2291 #else 2292 free(mm); 2293 #endif 2294 } else { 2295 *magicp = NULL; 2296 *nmagicp = 0; 2297 } 2298 error2: 2299 free(dbname); 2300 return -1; 2301 } 2302 2303 private const uint32_t ar[] = { 2304 MAGICNO, VERSIONNO 2305 }; 2306 /* 2307 * handle an mmaped file. 2308 */ 2309 private int 2310 apprentice_compile(struct magic_set *ms, struct magic **magicp, 2311 uint32_t *nmagicp, const char *fn) 2312 { 2313 int fd = -1; 2314 char *dbname; 2315 int rv = -1; 2316 2317 dbname = mkdbname(ms, fn, 1); 2318 2319 if (dbname == NULL) 2320 goto out; 2321 2322 if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1) { 2323 file_error(ms, errno, "cannot open `%s'", dbname); 2324 goto out; 2325 } 2326 2327 if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) { 2328 file_error(ms, errno, "error writing `%s'", dbname); 2329 goto out; 2330 } 2331 2332 if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET) 2333 != sizeof(struct magic)) { 2334 file_error(ms, errno, "error seeking `%s'", dbname); 2335 goto out; 2336 } 2337 2338 if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp)) 2339 != (ssize_t)(sizeof(struct magic) * *nmagicp)) { 2340 file_error(ms, errno, "error writing `%s'", dbname); 2341 goto out; 2342 } 2343 2344 if (fd != -1) 2345 (void)close(fd); 2346 rv = 0; 2347 out: 2348 free(dbname); 2349 return rv; 2350 } 2351 2352 private const char ext[] = ".mgc"; 2353 /* 2354 * make a dbname 2355 */ 2356 private char * 2357 mkdbname(struct magic_set *ms, const char *fn, int strip) 2358 { 2359 const char *p, *q; 2360 char *buf; 2361 2362 if (strip) { 2363 if ((p = strrchr(fn, '/')) != NULL) 2364 fn = ++p; 2365 } 2366 2367 for (q = fn; *q; q++) 2368 continue; 2369 /* Look for .mgc */ 2370 for (p = ext + sizeof(ext) - 1; p >= ext && q >= fn; p--, q--) 2371 if (*p != *q) 2372 break; 2373 2374 /* Did not find .mgc, restore q */ 2375 if (p >= ext) 2376 while (*q) 2377 q++; 2378 2379 q++; 2380 /* Compatibility with old code that looked in .mime */ 2381 if (ms->flags & MAGIC_MIME) { 2382 asprintf(&buf, "%.*s.mime%s", (int)(q - fn), fn, ext); 2383 if (access(buf, R_OK) != -1) { 2384 ms->flags &= MAGIC_MIME_TYPE; 2385 return buf; 2386 } 2387 free(buf); 2388 } 2389 asprintf(&buf, "%.*s%s", (int)(q - fn), fn, ext); 2390 2391 /* Compatibility with old code that looked in .mime */ 2392 if (strstr(p, ".mime") != NULL) 2393 ms->flags &= MAGIC_MIME_TYPE; 2394 return buf; 2395 } 2396 2397 /* 2398 * Byteswap an mmap'ed file if needed 2399 */ 2400 private void 2401 byteswap(struct magic *magic, uint32_t nmagic) 2402 { 2403 uint32_t i; 2404 for (i = 0; i < nmagic; i++) 2405 bs1(&magic[i]); 2406 } 2407 2408 /* 2409 * swap a short 2410 */ 2411 private uint16_t 2412 swap2(uint16_t sv) 2413 { 2414 uint16_t rv; 2415 uint8_t *s = (uint8_t *)(void *)&sv; 2416 uint8_t *d = (uint8_t *)(void *)&rv; 2417 d[0] = s[1]; 2418 d[1] = s[0]; 2419 return rv; 2420 } 2421 2422 /* 2423 * swap an int 2424 */ 2425 private uint32_t 2426 swap4(uint32_t sv) 2427 { 2428 uint32_t rv; 2429 uint8_t *s = (uint8_t *)(void *)&sv; 2430 uint8_t *d = (uint8_t *)(void *)&rv; 2431 d[0] = s[3]; 2432 d[1] = s[2]; 2433 d[2] = s[1]; 2434 d[3] = s[0]; 2435 return rv; 2436 } 2437 2438 /* 2439 * swap a quad 2440 */ 2441 private uint64_t 2442 swap8(uint64_t sv) 2443 { 2444 uint64_t rv; 2445 uint8_t *s = (uint8_t *)(void *)&sv; 2446 uint8_t *d = (uint8_t *)(void *)&rv; 2447 #if 0 2448 d[0] = s[3]; 2449 d[1] = s[2]; 2450 d[2] = s[1]; 2451 d[3] = s[0]; 2452 d[4] = s[7]; 2453 d[5] = s[6]; 2454 d[6] = s[5]; 2455 d[7] = s[4]; 2456 #else 2457 d[0] = s[7]; 2458 d[1] = s[6]; 2459 d[2] = s[5]; 2460 d[3] = s[4]; 2461 d[4] = s[3]; 2462 d[5] = s[2]; 2463 d[6] = s[1]; 2464 d[7] = s[0]; 2465 #endif 2466 return rv; 2467 } 2468 2469 /* 2470 * byteswap a single magic entry 2471 */ 2472 private void 2473 bs1(struct magic *m) 2474 { 2475 m->cont_level = swap2(m->cont_level); 2476 m->offset = swap4((uint32_t)m->offset); 2477 m->in_offset = swap4((uint32_t)m->in_offset); 2478 m->lineno = swap4((uint32_t)m->lineno); 2479 if (IS_STRING(m->type)) { 2480 m->str_range = swap4(m->str_range); 2481 m->str_flags = swap4(m->str_flags); 2482 } 2483 else { 2484 m->value.q = swap8(m->value.q); 2485 m->num_mask = swap8(m->num_mask); 2486 } 2487 } 2488 2489 protected size_t 2490 file_pstring_length_size(const struct magic *m) 2491 { 2492 switch (m->str_flags & PSTRING_LEN) { 2493 case PSTRING_1_LE: 2494 return 1; 2495 case PSTRING_2_LE: 2496 case PSTRING_2_BE: 2497 return 2; 2498 case PSTRING_4_LE: 2499 case PSTRING_4_BE: 2500 return 4; 2501 default: 2502 abort(); /* Impossible */ 2503 return 1; 2504 } 2505 } 2506 protected size_t 2507 file_pstring_get_length(const struct magic *m, const char *s) 2508 { 2509 size_t len = 0; 2510 2511 switch (m->str_flags & PSTRING_LEN) { 2512 case PSTRING_1_LE: 2513 len = *s; 2514 break; 2515 case PSTRING_2_LE: 2516 len = (s[1] << 8) | s[0]; 2517 break; 2518 case PSTRING_2_BE: 2519 len = (s[0] << 8) | s[1]; 2520 break; 2521 case PSTRING_4_LE: 2522 len = (s[3] << 24) | (s[2] << 16) | (s[1] << 8) | s[0]; 2523 break; 2524 case PSTRING_4_BE: 2525 len = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]; 2526 break; 2527 default: 2528 abort(); /* Impossible */ 2529 } 2530 2531 if (m->str_flags & PSTRING_LENGTH_INCLUDES_ITSELF) 2532 len -= file_pstring_length_size(m); 2533 2534 return len; 2535 } 2536