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