Annotation of embedaddon/php/ext/fileinfo/libmagic/softmagic.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: * softmagic - interpret variable magic from MAGIC
! 30: */
! 31:
! 32: #include "file.h"
! 33:
! 34: #ifndef lint
! 35: FILE_RCSID("@(#)$File: softmagic.c,v 1.135 2009/03/27 22:42:49 christos Exp $")
! 36: #endif /* lint */
! 37:
! 38: #include "magic.h"
! 39: #include <string.h>
! 40: #include <ctype.h>
! 41: #include <stdlib.h>
! 42: #include <time.h>
! 43:
! 44: #ifndef PREG_OFFSET_CAPTURE
! 45: # define PREG_OFFSET_CAPTURE (1<<8)
! 46: #endif
! 47:
! 48:
! 49:
! 50: private int match(struct magic_set *, struct magic *, uint32_t,
! 51: const unsigned char *, size_t, int);
! 52: private int mget(struct magic_set *, const unsigned char *,
! 53: struct magic *, size_t, unsigned int);
! 54: private int magiccheck(struct magic_set *, struct magic *);
! 55: private int32_t mprint(struct magic_set *, struct magic *);
! 56: private int32_t moffset(struct magic_set *, struct magic *);
! 57: private void mdebug(uint32_t, const char *, size_t);
! 58: private int mcopy(struct magic_set *, union VALUETYPE *, int, int,
! 59: const unsigned char *, uint32_t, size_t, size_t);
! 60: private int mconvert(struct magic_set *, struct magic *);
! 61: private int print_sep(struct magic_set *, int);
! 62: private int handle_annotation(struct magic_set *, struct magic *);
! 63: private void cvt_8(union VALUETYPE *, const struct magic *);
! 64: private void cvt_16(union VALUETYPE *, const struct magic *);
! 65: private void cvt_32(union VALUETYPE *, const struct magic *);
! 66: private void cvt_64(union VALUETYPE *, const struct magic *);
! 67:
! 68: /*
! 69: * softmagic - lookup one file in parsed, in-memory copy of database
! 70: * Passed the name and FILE * of one file to be typed.
! 71: */
! 72: /*ARGSUSED1*/ /* nbytes passed for regularity, maybe need later */
! 73: protected int
! 74: file_softmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes, int mode)
! 75: {
! 76: struct mlist *ml;
! 77: int rv;
! 78: for (ml = ms->mlist->next; ml != ms->mlist; ml = ml->next)
! 79: if ((rv = match(ms, ml->magic, ml->nmagic, buf, nbytes, mode)) != 0)
! 80: return rv;
! 81:
! 82: return 0;
! 83: }
! 84:
! 85: /*
! 86: * Go through the whole list, stopping if you find a match. Process all
! 87: * the continuations of that match before returning.
! 88: *
! 89: * We support multi-level continuations:
! 90: *
! 91: * At any time when processing a successful top-level match, there is a
! 92: * current continuation level; it represents the level of the last
! 93: * successfully matched continuation.
! 94: *
! 95: * Continuations above that level are skipped as, if we see one, it
! 96: * means that the continuation that controls them - i.e, the
! 97: * lower-level continuation preceding them - failed to match.
! 98: *
! 99: * Continuations below that level are processed as, if we see one,
! 100: * it means we've finished processing or skipping higher-level
! 101: * continuations under the control of a successful or unsuccessful
! 102: * lower-level continuation, and are now seeing the next lower-level
! 103: * continuation and should process it. The current continuation
! 104: * level reverts to the level of the one we're seeing.
! 105: *
! 106: * Continuations at the current level are processed as, if we see
! 107: * one, there's no lower-level continuation that may have failed.
! 108: *
! 109: * If a continuation matches, we bump the current continuation level
! 110: * so that higher-level continuations are processed.
! 111: */
! 112: private int
! 113: match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
! 114: const unsigned char *s, size_t nbytes, int mode)
! 115: {
! 116: uint32_t magindex = 0;
! 117: unsigned int cont_level = 0;
! 118: int need_separator = 0;
! 119: int returnval = 0, e; /* if a match is found it is set to 1*/
! 120: int firstline = 1; /* a flag to print X\n X\n- X */
! 121: int printed_something = 0;
! 122: int print = (ms->flags & (MAGIC_MIME|MAGIC_APPLE)) == 0;
! 123:
! 124: if (file_check_mem(ms, cont_level) == -1)
! 125: return -1;
! 126:
! 127: for (magindex = 0; magindex < nmagic; magindex++) {
! 128: int flush = 0;
! 129: struct magic *m = &magic[magindex];
! 130:
! 131: if ((m->flag & BINTEST) != mode) {
! 132: /* Skip sub-tests */
! 133: while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 134: magindex++;
! 135: }
! 136: continue; /* Skip to next top-level test*/
! 137: }
! 138:
! 139: ms->offset = m->offset;
! 140: ms->line = m->lineno;
! 141:
! 142: /* if main entry matches, print it... */
! 143: switch (mget(ms, s, m, nbytes, cont_level)) {
! 144: case -1:
! 145: return -1;
! 146: case 0:
! 147: flush = m->reln != '!';
! 148: break;
! 149: default:
! 150: if (m->type == FILE_INDIRECT)
! 151: returnval = 1;
! 152:
! 153: switch (magiccheck(ms, m)) {
! 154: case -1:
! 155: return -1;
! 156: case 0:
! 157: flush++;
! 158: break;
! 159: default:
! 160: flush = 0;
! 161: break;
! 162: }
! 163: break;
! 164: }
! 165: if (flush) {
! 166: /*
! 167: * main entry didn't match,
! 168: * flush its continuations
! 169: */
! 170: while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 171: magindex++;
! 172: }
! 173: continue;
! 174: }
! 175:
! 176: /*
! 177: * If we are going to print something, we'll need to print
! 178: * a blank before we print something else.
! 179: */
! 180: if (*m->desc) {
! 181: need_separator = 1;
! 182: printed_something = 1;
! 183: if ((e = handle_annotation(ms, m)) != 0)
! 184: return e;
! 185: if (print_sep(ms, firstline) == -1)
! 186: return -1;
! 187: }
! 188:
! 189:
! 190: if (print && mprint(ms, m) == -1)
! 191: return -1;
! 192:
! 193: ms->c.li[cont_level].off = moffset(ms, m);
! 194:
! 195: /* and any continuations that match */
! 196: if (file_check_mem(ms, ++cont_level) == -1)
! 197: return -1;
! 198:
! 199: while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 200: magindex++;
! 201: m = &magic[magindex];
! 202: ms->line = m->lineno; /* for messages */
! 203:
! 204: if (cont_level < m->cont_level)
! 205: continue;
! 206: if (cont_level > m->cont_level) {
! 207: /*
! 208: * We're at the end of the level
! 209: * "cont_level" continuations.
! 210: */
! 211: cont_level = m->cont_level;
! 212: }
! 213: ms->offset = m->offset;
! 214: if (m->flag & OFFADD) {
! 215: ms->offset += ms->c.li[cont_level - 1].off;
! 216: }
! 217:
! 218: #ifdef ENABLE_CONDITIONALS
! 219: if (m->cond == COND_ELSE ||
! 220: m->cond == COND_ELIF) {
! 221: if (ms->c.li[cont_level].last_match == 1)
! 222: continue;
! 223: }
! 224: #endif
! 225: switch (mget(ms, s, m, nbytes, cont_level)) {
! 226: case -1:
! 227: return -1;
! 228: case 0:
! 229: if (m->reln != '!')
! 230: continue;
! 231: flush = 1;
! 232: break;
! 233: default:
! 234: if (m->type == FILE_INDIRECT)
! 235: returnval = 1;
! 236: flush = 0;
! 237: break;
! 238: }
! 239:
! 240: switch (flush ? 1 : magiccheck(ms, m)) {
! 241: case -1:
! 242: return -1;
! 243: case 0:
! 244: #ifdef ENABLE_CONDITIONALS
! 245: ms->c.li[cont_level].last_match = 0;
! 246: #endif
! 247: break;
! 248: default:
! 249: #ifdef ENABLE_CONDITIONALS
! 250: ms->c.li[cont_level].last_match = 1;
! 251: #endif
! 252: if (m->type != FILE_DEFAULT)
! 253: ms->c.li[cont_level].got_match = 1;
! 254: else if (ms->c.li[cont_level].got_match) {
! 255: ms->c.li[cont_level].got_match = 0;
! 256: break;
! 257: }
! 258: /*
! 259: * If we are going to print something,
! 260: * make sure that we have a separator first.
! 261: */
! 262: if (*m->desc) {
! 263: if ((e = handle_annotation(ms, m)) != 0)
! 264: return e;
! 265: if (!printed_something) {
! 266: printed_something = 1;
! 267: if (print_sep(ms, firstline)
! 268: == -1)
! 269: return -1;
! 270: }
! 271: }
! 272: /*
! 273: * This continuation matched. Print
! 274: * its message, with a blank before it
! 275: * if the previous item printed and
! 276: * this item isn't empty.
! 277: */
! 278: /* space if previous printed */
! 279: if (need_separator
! 280: && ((m->flag & NOSPACE) == 0)
! 281: && *m->desc) {
! 282: if (print &&
! 283: file_printf(ms, " ") == -1)
! 284: return -1;
! 285: need_separator = 0;
! 286: }
! 287: if (print && mprint(ms, m) == -1)
! 288: return -1;
! 289:
! 290: ms->c.li[cont_level].off = moffset(ms, m);
! 291:
! 292: if (*m->desc)
! 293: need_separator = 1;
! 294:
! 295: /*
! 296: * If we see any continuations
! 297: * at a higher level,
! 298: * process them.
! 299: */
! 300: if (file_check_mem(ms, ++cont_level) == -1)
! 301: return -1;
! 302: break;
! 303: }
! 304: }
! 305: if (printed_something) {
! 306: firstline = 0;
! 307: if (print)
! 308: returnval = 1;
! 309: }
! 310: if ((ms->flags & MAGIC_CONTINUE) == 0 && printed_something) {
! 311: return returnval; /* don't keep searching */
! 312: }
! 313: }
! 314: return returnval; /* This is hit if -k is set or there is no match */
! 315: }
! 316:
! 317: private int
! 318: check_fmt(struct magic_set *ms, struct magic *m)
! 319: {
! 320: pcre *pce;
! 321: int re_options;
! 322: pcre_extra *re_extra;
! 323: TSRMLS_FETCH();
! 324:
! 325: if (strchr(m->desc, '%') == NULL) {
! 326: return 0;
! 327: }
! 328:
! 329: if ((pce = pcre_get_compiled_regex("~%[-0-9.]*s~", &re_extra, &re_options TSRMLS_CC)) == NULL) {
! 330: return -1;
! 331: } else {
! 332: return !pcre_exec(pce, re_extra, m->desc, strlen(m->desc), 0, re_options, NULL, 0);
! 333: }
! 334: }
! 335:
! 336: private int32_t
! 337: mprint(struct magic_set *ms, struct magic *m)
! 338: {
! 339: uint64_t v;
! 340: float vf;
! 341: double vd;
! 342: int64_t t = 0;
! 343: char buf[128];
! 344: union VALUETYPE *p = &ms->ms_value;
! 345:
! 346: switch (m->type) {
! 347: case FILE_BYTE:
! 348: v = file_signextend(ms, m, (uint64_t)p->b);
! 349: switch (check_fmt(ms, m)) {
! 350: case -1:
! 351: return -1;
! 352: case 1:
! 353: (void)snprintf(buf, sizeof(buf), "%c",
! 354: (unsigned char)v);
! 355: if (file_printf(ms, m->desc, buf) == -1)
! 356: return -1;
! 357: break;
! 358: default:
! 359: if (file_printf(ms, m->desc, (unsigned char) v) == -1)
! 360: return -1;
! 361: break;
! 362: }
! 363: t = ms->offset + sizeof(char);
! 364: break;
! 365:
! 366: case FILE_SHORT:
! 367: case FILE_BESHORT:
! 368: case FILE_LESHORT:
! 369: v = file_signextend(ms, m, (uint64_t)p->h);
! 370: switch (check_fmt(ms, m)) {
! 371: case -1:
! 372: return -1;
! 373: case 1:
! 374: (void)snprintf(buf, sizeof(buf), "%hu",
! 375: (unsigned short)v);
! 376: if (file_printf(ms, m->desc, buf) == -1)
! 377: return -1;
! 378: break;
! 379: default:
! 380: if (
! 381: file_printf(ms, m->desc, (unsigned short) v) == -1)
! 382: return -1;
! 383: break;
! 384: }
! 385: t = ms->offset + sizeof(short);
! 386: break;
! 387:
! 388: case FILE_LONG:
! 389: case FILE_BELONG:
! 390: case FILE_LELONG:
! 391: case FILE_MELONG:
! 392: v = file_signextend(ms, m, (uint64_t)p->l);
! 393: switch (check_fmt(ms, m)) {
! 394: case -1:
! 395: return -1;
! 396: case 1:
! 397: (void)snprintf(buf, sizeof(buf), "%u", (uint32_t)v);
! 398: if (file_printf(ms, m->desc, buf) == -1)
! 399: return -1;
! 400: break;
! 401: default:
! 402: if (file_printf(ms, m->desc, (uint32_t) v) == -1)
! 403: return -1;
! 404: break;
! 405: }
! 406: t = ms->offset + sizeof(int32_t);
! 407: break;
! 408:
! 409: case FILE_QUAD:
! 410: case FILE_BEQUAD:
! 411: case FILE_LEQUAD:
! 412: v = file_signextend(ms, m, p->q);
! 413: if (file_printf(ms, m->desc, (uint64_t) v) == -1)
! 414: return -1;
! 415: t = ms->offset + sizeof(int64_t);
! 416: break;
! 417:
! 418: case FILE_STRING:
! 419: case FILE_PSTRING:
! 420: case FILE_BESTRING16:
! 421: case FILE_LESTRING16:
! 422: if (m->reln == '=' || m->reln == '!') {
! 423: if (file_printf(ms, m->desc, m->value.s) == -1)
! 424: return -1;
! 425: t = ms->offset + m->vallen;
! 426: }
! 427: else {
! 428: if (*m->value.s == '\0')
! 429: p->s[strcspn(p->s, "\n")] = '\0';
! 430: if (file_printf(ms, m->desc, p->s) == -1)
! 431: return -1;
! 432: t = ms->offset + strlen(p->s);
! 433: if (m->type == FILE_PSTRING)
! 434: t++;
! 435: }
! 436: break;
! 437:
! 438: case FILE_DATE:
! 439: case FILE_BEDATE:
! 440: case FILE_LEDATE:
! 441: case FILE_MEDATE:
! 442: if (file_printf(ms, m->desc, file_fmttime(p->l, 1)) == -1)
! 443: return -1;
! 444: t = ms->offset + sizeof(time_t);
! 445: break;
! 446:
! 447: case FILE_LDATE:
! 448: case FILE_BELDATE:
! 449: case FILE_LELDATE:
! 450: case FILE_MELDATE:
! 451: if (file_printf(ms, m->desc, file_fmttime(p->l, 0)) == -1)
! 452: return -1;
! 453: t = ms->offset + sizeof(time_t);
! 454: break;
! 455:
! 456: case FILE_QDATE:
! 457: case FILE_BEQDATE:
! 458: case FILE_LEQDATE:
! 459: if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q,
! 460: 1)) == -1)
! 461: return -1;
! 462: t = ms->offset + sizeof(uint64_t);
! 463: break;
! 464:
! 465: case FILE_QLDATE:
! 466: case FILE_BEQLDATE:
! 467: case FILE_LEQLDATE:
! 468: if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q,
! 469: 0)) == -1)
! 470: return -1;
! 471: t = ms->offset + sizeof(uint64_t);
! 472: break;
! 473:
! 474: case FILE_FLOAT:
! 475: case FILE_BEFLOAT:
! 476: case FILE_LEFLOAT:
! 477: vf = p->f;
! 478: switch (check_fmt(ms, m)) {
! 479: case -1:
! 480: return -1;
! 481: case 1:
! 482: (void)snprintf(buf, sizeof(buf), "%g", vf);
! 483: if (file_printf(ms, m->desc, buf) == -1)
! 484: return -1;
! 485: break;
! 486: default:
! 487: if (file_printf(ms, m->desc, vf) == -1)
! 488: return -1;
! 489: break;
! 490: }
! 491: t = ms->offset + sizeof(float);
! 492: break;
! 493:
! 494: case FILE_DOUBLE:
! 495: case FILE_BEDOUBLE:
! 496: case FILE_LEDOUBLE:
! 497: vd = p->d;
! 498: switch (check_fmt(ms, m)) {
! 499: case -1:
! 500: return -1;
! 501: case 1:
! 502: (void)snprintf(buf, sizeof(buf), "%g", vd);
! 503: if (file_printf(ms, m->desc, buf) == -1)
! 504: return -1;
! 505: break;
! 506: default:
! 507: if (file_printf(ms, m->desc, vd) == -1)
! 508: return -1;
! 509: break;
! 510: }
! 511: t = ms->offset + sizeof(double);
! 512: break;
! 513:
! 514: case FILE_REGEX: {
! 515: char *cp;
! 516: int rval;
! 517:
! 518: cp = estrndup((const char *)ms->search.s, ms->search.rm_len);
! 519:
! 520: rval = file_printf(ms, m->desc, cp);
! 521: efree(cp);
! 522:
! 523: if (rval == -1)
! 524: return -1;
! 525:
! 526: if ((m->str_flags & REGEX_OFFSET_START))
! 527: t = ms->search.offset;
! 528: else
! 529: t = ms->search.offset + ms->search.rm_len;
! 530: break;
! 531: }
! 532:
! 533: case FILE_SEARCH:
! 534: if (file_printf(ms, m->desc, m->value.s) == -1)
! 535: return -1;
! 536: if ((m->str_flags & REGEX_OFFSET_START))
! 537: t = ms->search.offset;
! 538: else
! 539: t = ms->search.offset + m->vallen;
! 540: break;
! 541:
! 542: case FILE_DEFAULT:
! 543: if (file_printf(ms, m->desc, m->value.s) == -1)
! 544: return -1;
! 545: t = ms->offset;
! 546: break;
! 547:
! 548: case FILE_INDIRECT:
! 549: t = ms->offset;
! 550: break;
! 551:
! 552: default:
! 553: file_magerror(ms, "invalid m->type (%d) in mprint()", m->type);
! 554: return -1;
! 555: }
! 556: return (int32_t)t;
! 557: }
! 558:
! 559: private int32_t
! 560: moffset(struct magic_set *ms, struct magic *m)
! 561: {
! 562: switch (m->type) {
! 563: case FILE_BYTE:
! 564: return ms->offset + sizeof(char);
! 565:
! 566: case FILE_SHORT:
! 567: case FILE_BESHORT:
! 568: case FILE_LESHORT:
! 569: return ms->offset + sizeof(short);
! 570:
! 571: case FILE_LONG:
! 572: case FILE_BELONG:
! 573: case FILE_LELONG:
! 574: case FILE_MELONG:
! 575: return ms->offset + sizeof(int32_t);
! 576:
! 577: case FILE_QUAD:
! 578: case FILE_BEQUAD:
! 579: case FILE_LEQUAD:
! 580: return ms->offset + sizeof(int64_t);
! 581:
! 582: case FILE_STRING:
! 583: case FILE_PSTRING:
! 584: case FILE_BESTRING16:
! 585: case FILE_LESTRING16:
! 586: if (m->reln == '=' || m->reln == '!')
! 587: return ms->offset + m->vallen;
! 588: else {
! 589: union VALUETYPE *p = &ms->ms_value;
! 590: uint32_t t;
! 591:
! 592: if (*m->value.s == '\0')
! 593: p->s[strcspn(p->s, "\n")] = '\0';
! 594: t = ms->offset + strlen(p->s);
! 595: if (m->type == FILE_PSTRING)
! 596: t++;
! 597: return t;
! 598: }
! 599:
! 600: case FILE_DATE:
! 601: case FILE_BEDATE:
! 602: case FILE_LEDATE:
! 603: case FILE_MEDATE:
! 604: return ms->offset + sizeof(time_t);
! 605:
! 606: case FILE_LDATE:
! 607: case FILE_BELDATE:
! 608: case FILE_LELDATE:
! 609: case FILE_MELDATE:
! 610: return ms->offset + sizeof(time_t);
! 611:
! 612: case FILE_QDATE:
! 613: case FILE_BEQDATE:
! 614: case FILE_LEQDATE:
! 615: return ms->offset + sizeof(uint64_t);
! 616:
! 617: case FILE_QLDATE:
! 618: case FILE_BEQLDATE:
! 619: case FILE_LEQLDATE:
! 620: return ms->offset + sizeof(uint64_t);
! 621:
! 622: case FILE_FLOAT:
! 623: case FILE_BEFLOAT:
! 624: case FILE_LEFLOAT:
! 625: return ms->offset + sizeof(float);
! 626:
! 627: case FILE_DOUBLE:
! 628: case FILE_BEDOUBLE:
! 629: case FILE_LEDOUBLE:
! 630: return ms->offset + sizeof(double);
! 631: break;
! 632:
! 633: case FILE_REGEX:
! 634: if ((m->str_flags & REGEX_OFFSET_START) != 0)
! 635: return ms->search.offset;
! 636: else
! 637: return ms->search.offset + ms->search.rm_len;
! 638:
! 639: case FILE_SEARCH:
! 640: if ((m->str_flags & REGEX_OFFSET_START) != 0)
! 641: return ms->search.offset;
! 642: else
! 643: return ms->search.offset + m->vallen;
! 644:
! 645: case FILE_DEFAULT:
! 646: return ms->offset;
! 647:
! 648: case FILE_INDIRECT:
! 649: return ms->offset;
! 650:
! 651: default:
! 652: return 0;
! 653: }
! 654: }
! 655:
! 656: #define DO_CVT(fld, cast) \
! 657: if (m->num_mask) \
! 658: switch (m->mask_op & FILE_OPS_MASK) { \
! 659: case FILE_OPAND: \
! 660: p->fld &= cast m->num_mask; \
! 661: break; \
! 662: case FILE_OPOR: \
! 663: p->fld |= cast m->num_mask; \
! 664: break; \
! 665: case FILE_OPXOR: \
! 666: p->fld ^= cast m->num_mask; \
! 667: break; \
! 668: case FILE_OPADD: \
! 669: p->fld += cast m->num_mask; \
! 670: break; \
! 671: case FILE_OPMINUS: \
! 672: p->fld -= cast m->num_mask; \
! 673: break; \
! 674: case FILE_OPMULTIPLY: \
! 675: p->fld *= cast m->num_mask; \
! 676: break; \
! 677: case FILE_OPDIVIDE: \
! 678: p->fld /= cast m->num_mask; \
! 679: break; \
! 680: case FILE_OPMODULO: \
! 681: p->fld %= cast m->num_mask; \
! 682: break; \
! 683: } \
! 684: if (m->mask_op & FILE_OPINVERSE) \
! 685: p->fld = ~p->fld \
! 686:
! 687: private void
! 688: cvt_8(union VALUETYPE *p, const struct magic *m)
! 689: {
! 690: DO_CVT(b, (uint8_t));
! 691: }
! 692:
! 693: private void
! 694: cvt_16(union VALUETYPE *p, const struct magic *m)
! 695: {
! 696: DO_CVT(h, (uint16_t));
! 697: }
! 698:
! 699: private void
! 700: cvt_32(union VALUETYPE *p, const struct magic *m)
! 701: {
! 702: DO_CVT(l, (uint32_t));
! 703: }
! 704:
! 705: private void
! 706: cvt_64(union VALUETYPE *p, const struct magic *m)
! 707: {
! 708: DO_CVT(q, (uint64_t));
! 709: }
! 710:
! 711: #define DO_CVT2(fld, cast) \
! 712: if (m->num_mask) \
! 713: switch (m->mask_op & FILE_OPS_MASK) { \
! 714: case FILE_OPADD: \
! 715: p->fld += cast (int64_t)m->num_mask; \
! 716: break; \
! 717: case FILE_OPMINUS: \
! 718: p->fld -= cast (int64_t)m->num_mask; \
! 719: break; \
! 720: case FILE_OPMULTIPLY: \
! 721: p->fld *= cast (int64_t)m->num_mask; \
! 722: break; \
! 723: case FILE_OPDIVIDE: \
! 724: p->fld /= cast (int64_t)m->num_mask; \
! 725: break; \
! 726: } \
! 727:
! 728: private void
! 729: cvt_float(union VALUETYPE *p, const struct magic *m)
! 730: {
! 731: DO_CVT2(f, (float));
! 732: }
! 733:
! 734: private void
! 735: cvt_double(union VALUETYPE *p, const struct magic *m)
! 736: {
! 737: DO_CVT2(d, (double));
! 738: }
! 739:
! 740: /*
! 741: * Convert the byte order of the data we are looking at
! 742: * While we're here, let's apply the mask operation
! 743: * (unless you have a better idea)
! 744: */
! 745: private int
! 746: mconvert(struct magic_set *ms, struct magic *m)
! 747: {
! 748: union VALUETYPE *p = &ms->ms_value;
! 749:
! 750: switch (m->type) {
! 751: case FILE_BYTE:
! 752: cvt_8(p, m);
! 753: return 1;
! 754: case FILE_SHORT:
! 755: cvt_16(p, m);
! 756: return 1;
! 757: case FILE_LONG:
! 758: case FILE_DATE:
! 759: case FILE_LDATE:
! 760: cvt_32(p, m);
! 761: return 1;
! 762: case FILE_QUAD:
! 763: case FILE_QDATE:
! 764: case FILE_QLDATE:
! 765: cvt_64(p, m);
! 766: return 1;
! 767: case FILE_STRING:
! 768: case FILE_BESTRING16:
! 769: case FILE_LESTRING16: {
! 770: /* Null terminate and eat *trailing* return */
! 771: p->s[sizeof(p->s) - 1] = '\0';
! 772: #if 0
! 773: /* Why? breaks magic numbers that end with \xa */
! 774: len = strlen(p->s);
! 775: if (len-- && p->s[len] == '\n')
! 776: p->s[len] = '\0';
! 777: #endif
! 778: return 1;
! 779: }
! 780: case FILE_PSTRING: {
! 781: char *ptr1 = p->s, *ptr2 = ptr1 + 1;
! 782: size_t len = *p->s;
! 783: if (len >= sizeof(p->s))
! 784: len = sizeof(p->s) - 1;
! 785: while (len--)
! 786: *ptr1++ = *ptr2++;
! 787: *ptr1 = '\0';
! 788: #if 0
! 789: /* Why? breaks magic numbers that end with \xa */
! 790: len = strlen(p->s);
! 791: if (len-- && p->s[len] == '\n')
! 792: p->s[len] = '\0';
! 793: #endif
! 794: return 1;
! 795: }
! 796: case FILE_BESHORT:
! 797: p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
! 798: cvt_16(p, m);
! 799: return 1;
! 800: case FILE_BELONG:
! 801: case FILE_BEDATE:
! 802: case FILE_BELDATE:
! 803: p->l = (int32_t)
! 804: ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
! 805: cvt_32(p, m);
! 806: return 1;
! 807: case FILE_BEQUAD:
! 808: case FILE_BEQDATE:
! 809: case FILE_BEQLDATE:
! 810: p->q = (uint64_t)
! 811: (((uint64_t)p->hq[0]<<56)|((uint64_t)p->hq[1]<<48)|
! 812: ((uint64_t)p->hq[2]<<40)|((uint64_t)p->hq[3]<<32)|
! 813: ((uint64_t)p->hq[4]<<24)|((uint64_t)p->hq[5]<<16)|
! 814: ((uint64_t)p->hq[6]<<8)|((uint64_t)p->hq[7]));
! 815: cvt_64(p, m);
! 816: return 1;
! 817: case FILE_LESHORT:
! 818: p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
! 819: cvt_16(p, m);
! 820: return 1;
! 821: case FILE_LELONG:
! 822: case FILE_LEDATE:
! 823: case FILE_LELDATE:
! 824: p->l = (int32_t)
! 825: ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
! 826: cvt_32(p, m);
! 827: return 1;
! 828: case FILE_LEQUAD:
! 829: case FILE_LEQDATE:
! 830: case FILE_LEQLDATE:
! 831: p->q = (uint64_t)
! 832: (((uint64_t)p->hq[7]<<56)|((uint64_t)p->hq[6]<<48)|
! 833: ((uint64_t)p->hq[5]<<40)|((uint64_t)p->hq[4]<<32)|
! 834: ((uint64_t)p->hq[3]<<24)|((uint64_t)p->hq[2]<<16)|
! 835: ((uint64_t)p->hq[1]<<8)|((uint64_t)p->hq[0]));
! 836: cvt_64(p, m);
! 837: return 1;
! 838: case FILE_MELONG:
! 839: case FILE_MEDATE:
! 840: case FILE_MELDATE:
! 841: p->l = (int32_t)
! 842: ((p->hl[1]<<24)|(p->hl[0]<<16)|(p->hl[3]<<8)|(p->hl[2]));
! 843: cvt_32(p, m);
! 844: return 1;
! 845: case FILE_FLOAT:
! 846: cvt_float(p, m);
! 847: return 1;
! 848: case FILE_BEFLOAT:
! 849: p->l = ((uint32_t)p->hl[0]<<24)|((uint32_t)p->hl[1]<<16)|
! 850: ((uint32_t)p->hl[2]<<8) |((uint32_t)p->hl[3]);
! 851: cvt_float(p, m);
! 852: return 1;
! 853: case FILE_LEFLOAT:
! 854: p->l = ((uint32_t)p->hl[3]<<24)|((uint32_t)p->hl[2]<<16)|
! 855: ((uint32_t)p->hl[1]<<8) |((uint32_t)p->hl[0]);
! 856: cvt_float(p, m);
! 857: return 1;
! 858: case FILE_DOUBLE:
! 859: cvt_double(p, m);
! 860: return 1;
! 861: case FILE_BEDOUBLE:
! 862: p->q = ((uint64_t)p->hq[0]<<56)|((uint64_t)p->hq[1]<<48)|
! 863: ((uint64_t)p->hq[2]<<40)|((uint64_t)p->hq[3]<<32)|
! 864: ((uint64_t)p->hq[4]<<24)|((uint64_t)p->hq[5]<<16)|
! 865: ((uint64_t)p->hq[6]<<8) |((uint64_t)p->hq[7]);
! 866: cvt_double(p, m);
! 867: return 1;
! 868: case FILE_LEDOUBLE:
! 869: p->q = ((uint64_t)p->hq[7]<<56)|((uint64_t)p->hq[6]<<48)|
! 870: ((uint64_t)p->hq[5]<<40)|((uint64_t)p->hq[4]<<32)|
! 871: ((uint64_t)p->hq[3]<<24)|((uint64_t)p->hq[2]<<16)|
! 872: ((uint64_t)p->hq[1]<<8) |((uint64_t)p->hq[0]);
! 873: cvt_double(p, m);
! 874: return 1;
! 875: case FILE_REGEX:
! 876: case FILE_SEARCH:
! 877: case FILE_DEFAULT:
! 878: return 1;
! 879: default:
! 880: file_magerror(ms, "invalid type %d in mconvert()", m->type);
! 881: return 0;
! 882: }
! 883: }
! 884:
! 885:
! 886: private void
! 887: mdebug(uint32_t offset, const char *str, size_t len)
! 888: {
! 889: (void) fprintf(stderr, "mget @%d: ", offset);
! 890: file_showstr(stderr, str, len);
! 891: (void) fputc('\n', stderr);
! 892: (void) fputc('\n', stderr);
! 893: }
! 894:
! 895: private int
! 896: mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
! 897: const unsigned char *s, uint32_t offset, size_t nbytes, size_t linecnt)
! 898: {
! 899: /*
! 900: * Note: FILE_SEARCH and FILE_REGEX do not actually copy
! 901: * anything, but setup pointers into the source
! 902: */
! 903: if (indir == 0) {
! 904: switch (type) {
! 905: case FILE_SEARCH:
! 906: ms->search.s = (const char *)s + offset;
! 907: ms->search.s_len = nbytes - offset;
! 908: ms->search.offset = offset;
! 909: return 0;
! 910:
! 911: case FILE_REGEX: {
! 912: const char *b;
! 913: const char *c;
! 914: const char *last; /* end of search region */
! 915: const char *buf; /* start of search region */
! 916: const char *end;
! 917: size_t lines;
! 918:
! 919: if (s == NULL) {
! 920: ms->search.s_len = 0;
! 921: ms->search.s = NULL;
! 922: return 0;
! 923: }
! 924: buf = (const char *)s + offset;
! 925: end = last = (const char *)s + nbytes;
! 926: /* mget() guarantees buf <= last */
! 927: for (lines = linecnt, b = buf;
! 928: lines && ((b = memchr(c = b, '\n', end - b)) || (b = memchr(c, '\r', end - c)));
! 929: lines--, b++) {
! 930: last = b;
! 931: if (b[0] == '\r' && b[1] == '\n')
! 932: b++;
! 933: }
! 934: if (lines)
! 935: last = (const char *)s + nbytes;
! 936:
! 937: ms->search.s = buf;
! 938: ms->search.s_len = last - buf;
! 939: ms->search.offset = offset;
! 940: ms->search.rm_len = 0;
! 941: return 0;
! 942: }
! 943: case FILE_BESTRING16:
! 944: case FILE_LESTRING16: {
! 945: const unsigned char *src = s + offset;
! 946: const unsigned char *esrc = s + nbytes;
! 947: char *dst = p->s;
! 948: char *edst = &p->s[sizeof(p->s) - 1];
! 949:
! 950: if (type == FILE_BESTRING16)
! 951: src++;
! 952:
! 953: /* check for pointer overflow */
! 954: if (src < s) {
! 955: file_magerror(ms, "invalid offset %u in mcopy()",
! 956: offset);
! 957: return -1;
! 958: }
! 959: for (/*EMPTY*/; src < esrc; src += 2, dst++) {
! 960: if (dst < edst)
! 961: *dst = *src;
! 962: else
! 963: break;
! 964: if (*dst == '\0') {
! 965: if (type == FILE_BESTRING16 ?
! 966: *(src - 1) != '\0' :
! 967: *(src + 1) != '\0')
! 968: *dst = ' ';
! 969: }
! 970: }
! 971: *edst = '\0';
! 972: return 0;
! 973: }
! 974: case FILE_STRING: /* XXX - these two should not need */
! 975: case FILE_PSTRING: /* to copy anything, but do anyway. */
! 976: default:
! 977: break;
! 978: }
! 979: }
! 980:
! 981: if (offset >= nbytes) {
! 982: (void)memset(p, '\0', sizeof(*p));
! 983: return 0;
! 984: }
! 985: if (nbytes - offset < sizeof(*p))
! 986: nbytes = nbytes - offset;
! 987: else
! 988: nbytes = sizeof(*p);
! 989:
! 990: (void)memcpy(p, s + offset, nbytes);
! 991:
! 992: /*
! 993: * the usefulness of padding with zeroes eludes me, it
! 994: * might even cause problems
! 995: */
! 996: if (nbytes < sizeof(*p))
! 997: (void)memset(((char *)(void *)p) + nbytes, '\0',
! 998: sizeof(*p) - nbytes);
! 999: return 0;
! 1000: }
! 1001:
! 1002: private int
! 1003: mget(struct magic_set *ms, const unsigned char *s,
! 1004: struct magic *m, size_t nbytes, unsigned int cont_level)
! 1005: {
! 1006: uint32_t offset = ms->offset;
! 1007: uint32_t count = m->str_range;
! 1008: union VALUETYPE *p = &ms->ms_value;
! 1009:
! 1010: if (mcopy(ms, p, m->type, m->flag & INDIR, s, offset, nbytes, count) == -1)
! 1011: return -1;
! 1012:
! 1013: if ((ms->flags & MAGIC_DEBUG) != 0) {
! 1014: mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE));
! 1015: }
! 1016:
! 1017: if (m->flag & INDIR) {
! 1018: int off = m->in_offset;
! 1019: if (m->in_op & FILE_OPINDIRECT) {
! 1020: const union VALUETYPE *q =
! 1021: ((const void *)(s + offset + off));
! 1022: switch (m->in_type) {
! 1023: case FILE_BYTE:
! 1024: off = q->b;
! 1025: break;
! 1026: case FILE_SHORT:
! 1027: off = q->h;
! 1028: break;
! 1029: case FILE_BESHORT:
! 1030: off = (short)((q->hs[0]<<8)|(q->hs[1]));
! 1031: break;
! 1032: case FILE_LESHORT:
! 1033: off = (short)((q->hs[1]<<8)|(q->hs[0]));
! 1034: break;
! 1035: case FILE_LONG:
! 1036: off = q->l;
! 1037: break;
! 1038: case FILE_BELONG:
! 1039: case FILE_BEID3:
! 1040: off = (int32_t)((q->hl[0]<<24)|(q->hl[1]<<16)|
! 1041: (q->hl[2]<<8)|(q->hl[3]));
! 1042: break;
! 1043: case FILE_LEID3:
! 1044: case FILE_LELONG:
! 1045: off = (int32_t)((q->hl[3]<<24)|(q->hl[2]<<16)|
! 1046: (q->hl[1]<<8)|(q->hl[0]));
! 1047: break;
! 1048: case FILE_MELONG:
! 1049: off = (int32_t)((q->hl[1]<<24)|(q->hl[0]<<16)|
! 1050: (q->hl[3]<<8)|(q->hl[2]));
! 1051: break;
! 1052: }
! 1053: }
! 1054: switch (m->in_type) {
! 1055: case FILE_BYTE:
! 1056: if (nbytes < (offset + 1))
! 1057: return 0;
! 1058: if (off) {
! 1059: switch (m->in_op & FILE_OPS_MASK) {
! 1060: case FILE_OPAND:
! 1061: offset = p->b & off;
! 1062: break;
! 1063: case FILE_OPOR:
! 1064: offset = p->b | off;
! 1065: break;
! 1066: case FILE_OPXOR:
! 1067: offset = p->b ^ off;
! 1068: break;
! 1069: case FILE_OPADD:
! 1070: offset = p->b + off;
! 1071: break;
! 1072: case FILE_OPMINUS:
! 1073: offset = p->b - off;
! 1074: break;
! 1075: case FILE_OPMULTIPLY:
! 1076: offset = p->b * off;
! 1077: break;
! 1078: case FILE_OPDIVIDE:
! 1079: offset = p->b / off;
! 1080: break;
! 1081: case FILE_OPMODULO:
! 1082: offset = p->b % off;
! 1083: break;
! 1084: }
! 1085: } else
! 1086: offset = p->b;
! 1087: if (m->in_op & FILE_OPINVERSE)
! 1088: offset = ~offset;
! 1089: break;
! 1090: case FILE_BESHORT:
! 1091: if (nbytes < (offset + 2))
! 1092: return 0;
! 1093: if (off) {
! 1094: switch (m->in_op & FILE_OPS_MASK) {
! 1095: case FILE_OPAND:
! 1096: offset = (short)((p->hs[0]<<8)|
! 1097: (p->hs[1])) &
! 1098: off;
! 1099: break;
! 1100: case FILE_OPOR:
! 1101: offset = (short)((p->hs[0]<<8)|
! 1102: (p->hs[1])) |
! 1103: off;
! 1104: break;
! 1105: case FILE_OPXOR:
! 1106: offset = (short)((p->hs[0]<<8)|
! 1107: (p->hs[1])) ^
! 1108: off;
! 1109: break;
! 1110: case FILE_OPADD:
! 1111: offset = (short)((p->hs[0]<<8)|
! 1112: (p->hs[1])) +
! 1113: off;
! 1114: break;
! 1115: case FILE_OPMINUS:
! 1116: offset = (short)((p->hs[0]<<8)|
! 1117: (p->hs[1])) -
! 1118: off;
! 1119: break;
! 1120: case FILE_OPMULTIPLY:
! 1121: offset = (short)((p->hs[0]<<8)|
! 1122: (p->hs[1])) *
! 1123: off;
! 1124: break;
! 1125: case FILE_OPDIVIDE:
! 1126: offset = (short)((p->hs[0]<<8)|
! 1127: (p->hs[1])) /
! 1128: off;
! 1129: break;
! 1130: case FILE_OPMODULO:
! 1131: offset = (short)((p->hs[0]<<8)|
! 1132: (p->hs[1])) %
! 1133: off;
! 1134: break;
! 1135: }
! 1136: } else
! 1137: offset = (short)((p->hs[0]<<8)|
! 1138: (p->hs[1]));
! 1139: if (m->in_op & FILE_OPINVERSE)
! 1140: offset = ~offset;
! 1141: break;
! 1142: case FILE_LESHORT:
! 1143: if (nbytes < (offset + 2))
! 1144: return 0;
! 1145: if (off) {
! 1146: switch (m->in_op & FILE_OPS_MASK) {
! 1147: case FILE_OPAND:
! 1148: offset = (short)((p->hs[1]<<8)|
! 1149: (p->hs[0])) &
! 1150: off;
! 1151: break;
! 1152: case FILE_OPOR:
! 1153: offset = (short)((p->hs[1]<<8)|
! 1154: (p->hs[0])) |
! 1155: off;
! 1156: break;
! 1157: case FILE_OPXOR:
! 1158: offset = (short)((p->hs[1]<<8)|
! 1159: (p->hs[0])) ^
! 1160: off;
! 1161: break;
! 1162: case FILE_OPADD:
! 1163: offset = (short)((p->hs[1]<<8)|
! 1164: (p->hs[0])) +
! 1165: off;
! 1166: break;
! 1167: case FILE_OPMINUS:
! 1168: offset = (short)((p->hs[1]<<8)|
! 1169: (p->hs[0])) -
! 1170: off;
! 1171: break;
! 1172: case FILE_OPMULTIPLY:
! 1173: offset = (short)((p->hs[1]<<8)|
! 1174: (p->hs[0])) *
! 1175: off;
! 1176: break;
! 1177: case FILE_OPDIVIDE:
! 1178: offset = (short)((p->hs[1]<<8)|
! 1179: (p->hs[0])) /
! 1180: off;
! 1181: break;
! 1182: case FILE_OPMODULO:
! 1183: offset = (short)((p->hs[1]<<8)|
! 1184: (p->hs[0])) %
! 1185: off;
! 1186: break;
! 1187: }
! 1188: } else
! 1189: offset = (short)((p->hs[1]<<8)|
! 1190: (p->hs[0]));
! 1191: if (m->in_op & FILE_OPINVERSE)
! 1192: offset = ~offset;
! 1193: break;
! 1194: case FILE_SHORT:
! 1195: if (nbytes < (offset + 2))
! 1196: return 0;
! 1197: if (off) {
! 1198: switch (m->in_op & FILE_OPS_MASK) {
! 1199: case FILE_OPAND:
! 1200: offset = p->h & off;
! 1201: break;
! 1202: case FILE_OPOR:
! 1203: offset = p->h | off;
! 1204: break;
! 1205: case FILE_OPXOR:
! 1206: offset = p->h ^ off;
! 1207: break;
! 1208: case FILE_OPADD:
! 1209: offset = p->h + off;
! 1210: break;
! 1211: case FILE_OPMINUS:
! 1212: offset = p->h - off;
! 1213: break;
! 1214: case FILE_OPMULTIPLY:
! 1215: offset = p->h * off;
! 1216: break;
! 1217: case FILE_OPDIVIDE:
! 1218: offset = p->h / off;
! 1219: break;
! 1220: case FILE_OPMODULO:
! 1221: offset = p->h % off;
! 1222: break;
! 1223: }
! 1224: }
! 1225: else
! 1226: offset = p->h;
! 1227: if (m->in_op & FILE_OPINVERSE)
! 1228: offset = ~offset;
! 1229: break;
! 1230: case FILE_BELONG:
! 1231: case FILE_BEID3:
! 1232: if (nbytes < (offset + 4))
! 1233: return 0;
! 1234: if (off) {
! 1235: switch (m->in_op & FILE_OPS_MASK) {
! 1236: case FILE_OPAND:
! 1237: offset = (int32_t)((p->hl[0]<<24)|
! 1238: (p->hl[1]<<16)|
! 1239: (p->hl[2]<<8)|
! 1240: (p->hl[3])) &
! 1241: off;
! 1242: break;
! 1243: case FILE_OPOR:
! 1244: offset = (int32_t)((p->hl[0]<<24)|
! 1245: (p->hl[1]<<16)|
! 1246: (p->hl[2]<<8)|
! 1247: (p->hl[3])) |
! 1248: off;
! 1249: break;
! 1250: case FILE_OPXOR:
! 1251: offset = (int32_t)((p->hl[0]<<24)|
! 1252: (p->hl[1]<<16)|
! 1253: (p->hl[2]<<8)|
! 1254: (p->hl[3])) ^
! 1255: off;
! 1256: break;
! 1257: case FILE_OPADD:
! 1258: offset = (int32_t)((p->hl[0]<<24)|
! 1259: (p->hl[1]<<16)|
! 1260: (p->hl[2]<<8)|
! 1261: (p->hl[3])) +
! 1262: off;
! 1263: break;
! 1264: case FILE_OPMINUS:
! 1265: offset = (int32_t)((p->hl[0]<<24)|
! 1266: (p->hl[1]<<16)|
! 1267: (p->hl[2]<<8)|
! 1268: (p->hl[3])) -
! 1269: off;
! 1270: break;
! 1271: case FILE_OPMULTIPLY:
! 1272: offset = (int32_t)((p->hl[0]<<24)|
! 1273: (p->hl[1]<<16)|
! 1274: (p->hl[2]<<8)|
! 1275: (p->hl[3])) *
! 1276: off;
! 1277: break;
! 1278: case FILE_OPDIVIDE:
! 1279: offset = (int32_t)((p->hl[0]<<24)|
! 1280: (p->hl[1]<<16)|
! 1281: (p->hl[2]<<8)|
! 1282: (p->hl[3])) /
! 1283: off;
! 1284: break;
! 1285: case FILE_OPMODULO:
! 1286: offset = (int32_t)((p->hl[0]<<24)|
! 1287: (p->hl[1]<<16)|
! 1288: (p->hl[2]<<8)|
! 1289: (p->hl[3])) %
! 1290: off;
! 1291: break;
! 1292: }
! 1293: } else
! 1294: offset = (int32_t)((p->hl[0]<<24)|
! 1295: (p->hl[1]<<16)|
! 1296: (p->hl[2]<<8)|
! 1297: (p->hl[3]));
! 1298: if (m->in_op & FILE_OPINVERSE)
! 1299: offset = ~offset;
! 1300: break;
! 1301: case FILE_LELONG:
! 1302: case FILE_LEID3:
! 1303: if (nbytes < (offset + 4))
! 1304: return 0;
! 1305: if (off) {
! 1306: switch (m->in_op & FILE_OPS_MASK) {
! 1307: case FILE_OPAND:
! 1308: offset = (int32_t)((p->hl[3]<<24)|
! 1309: (p->hl[2]<<16)|
! 1310: (p->hl[1]<<8)|
! 1311: (p->hl[0])) &
! 1312: off;
! 1313: break;
! 1314: case FILE_OPOR:
! 1315: offset = (int32_t)((p->hl[3]<<24)|
! 1316: (p->hl[2]<<16)|
! 1317: (p->hl[1]<<8)|
! 1318: (p->hl[0])) |
! 1319: off;
! 1320: break;
! 1321: case FILE_OPXOR:
! 1322: offset = (int32_t)((p->hl[3]<<24)|
! 1323: (p->hl[2]<<16)|
! 1324: (p->hl[1]<<8)|
! 1325: (p->hl[0])) ^
! 1326: off;
! 1327: break;
! 1328: case FILE_OPADD:
! 1329: offset = (int32_t)((p->hl[3]<<24)|
! 1330: (p->hl[2]<<16)|
! 1331: (p->hl[1]<<8)|
! 1332: (p->hl[0])) +
! 1333: off;
! 1334: break;
! 1335: case FILE_OPMINUS:
! 1336: offset = (int32_t)((p->hl[3]<<24)|
! 1337: (p->hl[2]<<16)|
! 1338: (p->hl[1]<<8)|
! 1339: (p->hl[0])) -
! 1340: off;
! 1341: break;
! 1342: case FILE_OPMULTIPLY:
! 1343: offset = (int32_t)((p->hl[3]<<24)|
! 1344: (p->hl[2]<<16)|
! 1345: (p->hl[1]<<8)|
! 1346: (p->hl[0])) *
! 1347: off;
! 1348: break;
! 1349: case FILE_OPDIVIDE:
! 1350: offset = (int32_t)((p->hl[3]<<24)|
! 1351: (p->hl[2]<<16)|
! 1352: (p->hl[1]<<8)|
! 1353: (p->hl[0])) /
! 1354: off;
! 1355: break;
! 1356: case FILE_OPMODULO:
! 1357: offset = (int32_t)((p->hl[3]<<24)|
! 1358: (p->hl[2]<<16)|
! 1359: (p->hl[1]<<8)|
! 1360: (p->hl[0])) %
! 1361: off;
! 1362: break;
! 1363: }
! 1364: } else
! 1365: offset = (int32_t)((p->hl[3]<<24)|
! 1366: (p->hl[2]<<16)|
! 1367: (p->hl[1]<<8)|
! 1368: (p->hl[0]));
! 1369: if (m->in_op & FILE_OPINVERSE)
! 1370: offset = ~offset;
! 1371: break;
! 1372: case FILE_MELONG:
! 1373: if (nbytes < (offset + 4))
! 1374: return 0;
! 1375: if (off) {
! 1376: switch (m->in_op & FILE_OPS_MASK) {
! 1377: case FILE_OPAND:
! 1378: offset = (int32_t)((p->hl[1]<<24)|
! 1379: (p->hl[0]<<16)|
! 1380: (p->hl[3]<<8)|
! 1381: (p->hl[2])) &
! 1382: off;
! 1383: break;
! 1384: case FILE_OPOR:
! 1385: offset = (int32_t)((p->hl[1]<<24)|
! 1386: (p->hl[0]<<16)|
! 1387: (p->hl[3]<<8)|
! 1388: (p->hl[2])) |
! 1389: off;
! 1390: break;
! 1391: case FILE_OPXOR:
! 1392: offset = (int32_t)((p->hl[1]<<24)|
! 1393: (p->hl[0]<<16)|
! 1394: (p->hl[3]<<8)|
! 1395: (p->hl[2])) ^
! 1396: off;
! 1397: break;
! 1398: case FILE_OPADD:
! 1399: offset = (int32_t)((p->hl[1]<<24)|
! 1400: (p->hl[0]<<16)|
! 1401: (p->hl[3]<<8)|
! 1402: (p->hl[2])) +
! 1403: off;
! 1404: break;
! 1405: case FILE_OPMINUS:
! 1406: offset = (int32_t)((p->hl[1]<<24)|
! 1407: (p->hl[0]<<16)|
! 1408: (p->hl[3]<<8)|
! 1409: (p->hl[2])) -
! 1410: off;
! 1411: break;
! 1412: case FILE_OPMULTIPLY:
! 1413: offset = (int32_t)((p->hl[1]<<24)|
! 1414: (p->hl[0]<<16)|
! 1415: (p->hl[3]<<8)|
! 1416: (p->hl[2])) *
! 1417: off;
! 1418: break;
! 1419: case FILE_OPDIVIDE:
! 1420: offset = (int32_t)((p->hl[1]<<24)|
! 1421: (p->hl[0]<<16)|
! 1422: (p->hl[3]<<8)|
! 1423: (p->hl[2])) /
! 1424: off;
! 1425: break;
! 1426: case FILE_OPMODULO:
! 1427: offset = (int32_t)((p->hl[1]<<24)|
! 1428: (p->hl[0]<<16)|
! 1429: (p->hl[3]<<8)|
! 1430: (p->hl[2])) %
! 1431: off;
! 1432: break;
! 1433: }
! 1434: } else
! 1435: offset = (int32_t)((p->hl[1]<<24)|
! 1436: (p->hl[0]<<16)|
! 1437: (p->hl[3]<<8)|
! 1438: (p->hl[2]));
! 1439: if (m->in_op & FILE_OPINVERSE)
! 1440: offset = ~offset;
! 1441: break;
! 1442: case FILE_LONG:
! 1443: if (nbytes < (offset + 4))
! 1444: return 0;
! 1445: if (off) {
! 1446: switch (m->in_op & FILE_OPS_MASK) {
! 1447: case FILE_OPAND:
! 1448: offset = p->l & off;
! 1449: break;
! 1450: case FILE_OPOR:
! 1451: offset = p->l | off;
! 1452: break;
! 1453: case FILE_OPXOR:
! 1454: offset = p->l ^ off;
! 1455: break;
! 1456: case FILE_OPADD:
! 1457: offset = p->l + off;
! 1458: break;
! 1459: case FILE_OPMINUS:
! 1460: offset = p->l - off;
! 1461: break;
! 1462: case FILE_OPMULTIPLY:
! 1463: offset = p->l * off;
! 1464: break;
! 1465: case FILE_OPDIVIDE:
! 1466: offset = p->l / off;
! 1467: break;
! 1468: case FILE_OPMODULO:
! 1469: offset = p->l % off;
! 1470: break;
! 1471: }
! 1472: } else
! 1473: offset = p->l;
! 1474: if (m->in_op & FILE_OPINVERSE)
! 1475: offset = ~offset;
! 1476: break;
! 1477: }
! 1478:
! 1479: switch (m->in_type) {
! 1480: case FILE_LEID3:
! 1481: case FILE_BEID3:
! 1482: offset = ((((offset >> 0) & 0x7f) << 0) |
! 1483: (((offset >> 8) & 0x7f) << 7) |
! 1484: (((offset >> 16) & 0x7f) << 14) |
! 1485: (((offset >> 24) & 0x7f) << 21)) + 10;
! 1486: break;
! 1487: default:
! 1488: break;
! 1489: }
! 1490:
! 1491: if (m->flag & INDIROFFADD) {
! 1492: offset += ms->c.li[cont_level-1].off;
! 1493: }
! 1494: if (mcopy(ms, p, m->type, 0, s, offset, nbytes, count) == -1)
! 1495: return -1;
! 1496: ms->offset = offset;
! 1497:
! 1498: if ((ms->flags & MAGIC_DEBUG) != 0) {
! 1499: mdebug(offset, (char *)(void *)p,
! 1500: sizeof(union VALUETYPE));
! 1501: }
! 1502: }
! 1503:
! 1504: /* Verify we have enough data to match magic type */
! 1505: switch (m->type) {
! 1506: case FILE_BYTE:
! 1507: if (nbytes < (offset + 1)) /* should alway be true */
! 1508: return 0;
! 1509: break;
! 1510:
! 1511: case FILE_SHORT:
! 1512: case FILE_BESHORT:
! 1513: case FILE_LESHORT:
! 1514: if (nbytes < (offset + 2))
! 1515: return 0;
! 1516: break;
! 1517:
! 1518: case FILE_LONG:
! 1519: case FILE_BELONG:
! 1520: case FILE_LELONG:
! 1521: case FILE_MELONG:
! 1522: case FILE_DATE:
! 1523: case FILE_BEDATE:
! 1524: case FILE_LEDATE:
! 1525: case FILE_MEDATE:
! 1526: case FILE_LDATE:
! 1527: case FILE_BELDATE:
! 1528: case FILE_LELDATE:
! 1529: case FILE_MELDATE:
! 1530: case FILE_FLOAT:
! 1531: case FILE_BEFLOAT:
! 1532: case FILE_LEFLOAT:
! 1533: if (nbytes < (offset + 4))
! 1534: return 0;
! 1535: break;
! 1536:
! 1537: case FILE_DOUBLE:
! 1538: case FILE_BEDOUBLE:
! 1539: case FILE_LEDOUBLE:
! 1540: if (nbytes < (offset + 8))
! 1541: return 0;
! 1542: break;
! 1543:
! 1544: case FILE_STRING:
! 1545: case FILE_PSTRING:
! 1546: case FILE_SEARCH:
! 1547: if (nbytes < (offset + m->vallen))
! 1548: return 0;
! 1549: break;
! 1550:
! 1551: case FILE_REGEX:
! 1552: if (nbytes < offset)
! 1553: return 0;
! 1554: break;
! 1555:
! 1556: case FILE_INDIRECT:
! 1557: if ((ms->flags & (MAGIC_MIME|MAGIC_APPLE)) == 0 &&
! 1558: file_printf(ms, m->desc) == -1)
! 1559: return -1;
! 1560: if (nbytes < offset)
! 1561: return 0;
! 1562: return file_softmagic(ms, s + offset, nbytes - offset,
! 1563: BINTEST);
! 1564:
! 1565: case FILE_DEFAULT: /* nothing to check */
! 1566: default:
! 1567: break;
! 1568: }
! 1569: if (!mconvert(ms, m))
! 1570: return 0;
! 1571: return 1;
! 1572: }
! 1573:
! 1574: private uint64_t
! 1575: file_strncmp(const char *s1, const char *s2, size_t len, uint32_t flags)
! 1576: {
! 1577: /*
! 1578: * Convert the source args to unsigned here so that (1) the
! 1579: * compare will be unsigned as it is in strncmp() and (2) so
! 1580: * the ctype functions will work correctly without extra
! 1581: * casting.
! 1582: */
! 1583: const unsigned char *a = (const unsigned char *)s1;
! 1584: const unsigned char *b = (const unsigned char *)s2;
! 1585: uint64_t v;
! 1586:
! 1587: /*
! 1588: * What we want here is v = strncmp(s1, s2, len),
! 1589: * but ignoring any nulls.
! 1590: */
! 1591: v = 0;
! 1592: if (0L == flags) { /* normal string: do it fast */
! 1593: while (len-- > 0)
! 1594: if ((v = *b++ - *a++) != '\0')
! 1595: break;
! 1596: }
! 1597: else { /* combine the others */
! 1598: while (len-- > 0) {
! 1599: if ((flags & STRING_IGNORE_LOWERCASE) &&
! 1600: islower(*a)) {
! 1601: if ((v = tolower(*b++) - *a++) != '\0')
! 1602: break;
! 1603: }
! 1604: else if ((flags & STRING_IGNORE_UPPERCASE) &&
! 1605: isupper(*a)) {
! 1606: if ((v = toupper(*b++) - *a++) != '\0')
! 1607: break;
! 1608: }
! 1609: else if ((flags & STRING_COMPACT_BLANK) &&
! 1610: isspace(*a)) {
! 1611: a++;
! 1612: if (isspace(*b++)) {
! 1613: while (isspace(*b))
! 1614: b++;
! 1615: }
! 1616: else {
! 1617: v = 1;
! 1618: break;
! 1619: }
! 1620: }
! 1621: else if ((flags & STRING_COMPACT_OPTIONAL_BLANK) &&
! 1622: isspace(*a)) {
! 1623: a++;
! 1624: while (isspace(*b))
! 1625: b++;
! 1626: }
! 1627: else {
! 1628: if ((v = *b++ - *a++) != '\0')
! 1629: break;
! 1630: }
! 1631: }
! 1632: }
! 1633: return v;
! 1634: }
! 1635:
! 1636: private uint64_t
! 1637: file_strncmp16(const char *a, const char *b, size_t len, uint32_t flags)
! 1638: {
! 1639: /*
! 1640: * XXX - The 16-bit string compare probably needs to be done
! 1641: * differently, especially if the flags are to be supported.
! 1642: * At the moment, I am unsure.
! 1643: */
! 1644: flags = 0;
! 1645: return file_strncmp(a, b, len, flags);
! 1646: }
! 1647:
! 1648: private void
! 1649: convert_libmagic_pattern(zval *pattern, int options)
! 1650: {
! 1651: int i, j=0;
! 1652: char *t;
! 1653:
! 1654: t = (char *) safe_emalloc(Z_STRLEN_P(pattern), 2, 5);
! 1655:
! 1656: t[j++] = '~';
! 1657:
! 1658: for (i=0; i<Z_STRLEN_P(pattern); i++, j++) {
! 1659: switch (Z_STRVAL_P(pattern)[i]) {
! 1660: case '?':
! 1661: t[j] = '.';
! 1662: break;
! 1663: case '*':
! 1664: t[j++] = '.';
! 1665: t[j] = '*';
! 1666: break;
! 1667: case '.':
! 1668: t[j++] = '\\';
! 1669: t[j] = '.';
! 1670: break;
! 1671: case '\\':
! 1672: t[j++] = '\\';
! 1673: t[j] = '\\';
! 1674: break;
! 1675: case '(':
! 1676: t[j++] = '\\';
! 1677: t[j] = '(';
! 1678: break;
! 1679: case ')':
! 1680: t[j++] = '\\';
! 1681: t[j] = ')';
! 1682: break;
! 1683: case '~':
! 1684: t[j++] = '\\';
! 1685: t[j] = '~';
! 1686: break;
! 1687: default:
! 1688: t[j] = Z_STRVAL_P(pattern)[i];
! 1689: break;
! 1690: }
! 1691: }
! 1692: t[j++] = '~';
! 1693:
! 1694: if (options & PCRE_CASELESS)
! 1695: t[j++] = 'm';
! 1696:
! 1697: if (options & PCRE_MULTILINE)
! 1698: t[j++] = 'i';
! 1699:
! 1700: t[j]=0;
! 1701:
! 1702: Z_STRVAL_P(pattern) = t;
! 1703: Z_STRLEN_P(pattern) = j;
! 1704:
! 1705: }
! 1706:
! 1707: private int
! 1708: magiccheck(struct magic_set *ms, struct magic *m)
! 1709: {
! 1710: uint64_t l = m->value.q;
! 1711: uint64_t v;
! 1712: float fl, fv;
! 1713: double dl, dv;
! 1714: int matched;
! 1715: union VALUETYPE *p = &ms->ms_value;
! 1716:
! 1717: switch (m->type) {
! 1718: case FILE_BYTE:
! 1719: v = p->b;
! 1720: break;
! 1721:
! 1722: case FILE_SHORT:
! 1723: case FILE_BESHORT:
! 1724: case FILE_LESHORT:
! 1725: v = p->h;
! 1726: break;
! 1727:
! 1728: case FILE_LONG:
! 1729: case FILE_BELONG:
! 1730: case FILE_LELONG:
! 1731: case FILE_MELONG:
! 1732: case FILE_DATE:
! 1733: case FILE_BEDATE:
! 1734: case FILE_LEDATE:
! 1735: case FILE_MEDATE:
! 1736: case FILE_LDATE:
! 1737: case FILE_BELDATE:
! 1738: case FILE_LELDATE:
! 1739: case FILE_MELDATE:
! 1740: v = p->l;
! 1741: break;
! 1742:
! 1743: case FILE_QUAD:
! 1744: case FILE_LEQUAD:
! 1745: case FILE_BEQUAD:
! 1746: case FILE_QDATE:
! 1747: case FILE_BEQDATE:
! 1748: case FILE_LEQDATE:
! 1749: case FILE_QLDATE:
! 1750: case FILE_BEQLDATE:
! 1751: case FILE_LEQLDATE:
! 1752: v = p->q;
! 1753: break;
! 1754:
! 1755: case FILE_FLOAT:
! 1756: case FILE_BEFLOAT:
! 1757: case FILE_LEFLOAT:
! 1758: fl = m->value.f;
! 1759: fv = p->f;
! 1760: switch (m->reln) {
! 1761: case 'x':
! 1762: matched = 1;
! 1763: break;
! 1764:
! 1765: case '!':
! 1766: matched = fv != fl;
! 1767: break;
! 1768:
! 1769: case '=':
! 1770: matched = fv == fl;
! 1771: break;
! 1772:
! 1773: case '>':
! 1774: matched = fv > fl;
! 1775: break;
! 1776:
! 1777: case '<':
! 1778: matched = fv < fl;
! 1779: break;
! 1780:
! 1781: default:
! 1782: matched = 0;
! 1783: file_magerror(ms, "cannot happen with float: invalid relation `%c'",
! 1784: m->reln);
! 1785: return -1;
! 1786: }
! 1787: return matched;
! 1788:
! 1789: case FILE_DOUBLE:
! 1790: case FILE_BEDOUBLE:
! 1791: case FILE_LEDOUBLE:
! 1792: dl = m->value.d;
! 1793: dv = p->d;
! 1794: switch (m->reln) {
! 1795: case 'x':
! 1796: matched = 1;
! 1797: break;
! 1798:
! 1799: case '!':
! 1800: matched = dv != dl;
! 1801: break;
! 1802:
! 1803: case '=':
! 1804: matched = dv == dl;
! 1805: break;
! 1806:
! 1807: case '>':
! 1808: matched = dv > dl;
! 1809: break;
! 1810:
! 1811: case '<':
! 1812: matched = dv < dl;
! 1813: break;
! 1814:
! 1815: default:
! 1816: matched = 0;
! 1817: file_magerror(ms, "cannot happen with double: invalid relation `%c'", m->reln);
! 1818: return -1;
! 1819: }
! 1820: return matched;
! 1821:
! 1822: case FILE_DEFAULT:
! 1823: l = 0;
! 1824: v = 0;
! 1825: break;
! 1826:
! 1827: case FILE_STRING:
! 1828: case FILE_PSTRING:
! 1829: l = 0;
! 1830: v = file_strncmp(m->value.s, p->s, (size_t)m->vallen, m->str_flags);
! 1831: break;
! 1832:
! 1833: case FILE_BESTRING16:
! 1834: case FILE_LESTRING16:
! 1835: l = 0;
! 1836: v = file_strncmp16(m->value.s, p->s, (size_t)m->vallen, m->str_flags);
! 1837: break;
! 1838:
! 1839: case FILE_SEARCH: { /* search ms->search.s for the string m->value.s */
! 1840: size_t slen;
! 1841: size_t idx;
! 1842:
! 1843: if (ms->search.s == NULL)
! 1844: return 0;
! 1845:
! 1846: slen = MIN(m->vallen, sizeof(m->value.s));
! 1847: l = 0;
! 1848: v = 0;
! 1849:
! 1850: for (idx = 0; m->str_range == 0 || idx < m->str_range; idx++) {
! 1851: if (slen + idx > ms->search.s_len)
! 1852: break;
! 1853:
! 1854: v = file_strncmp(m->value.s, ms->search.s + idx, slen, m->str_flags);
! 1855: if (v == 0) { /* found match */
! 1856: ms->search.offset += idx;
! 1857: break;
! 1858: }
! 1859: }
! 1860: break;
! 1861: }
! 1862: case FILE_REGEX: {
! 1863: zval *pattern;
! 1864: int options = 0;
! 1865: pcre_cache_entry *pce;
! 1866: TSRMLS_FETCH();
! 1867:
! 1868: MAKE_STD_ZVAL(pattern);
! 1869: ZVAL_STRINGL(pattern, (char *)m->value.s, m->vallen, 0);
! 1870:
! 1871: options |= PCRE_MULTILINE;
! 1872:
! 1873: if (m->str_flags & STRING_IGNORE_CASE) {
! 1874: options |= PCRE_CASELESS;
! 1875: }
! 1876:
! 1877: convert_libmagic_pattern(pattern, options);
! 1878:
! 1879: #if (PHP_MAJOR_VERSION < 6)
! 1880: if ((pce = pcre_get_compiled_regex_cache(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
! 1881: #else
! 1882: if ((pce = pcre_get_compiled_regex_cache(IS_STRING, Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
! 1883: #endif
! 1884: zval_dtor(pattern);
! 1885: FREE_ZVAL(pattern);
! 1886: return -1;
! 1887: } else {
! 1888: /* pce now contains the compiled regex */
! 1889: zval *retval;
! 1890: zval *subpats;
! 1891: char *haystack;
! 1892:
! 1893: MAKE_STD_ZVAL(retval);
! 1894: ALLOC_INIT_ZVAL(subpats);
! 1895:
! 1896: /* Cut the search len from haystack, equals to REG_STARTEND */
! 1897: haystack = estrndup(ms->search.s, ms->search.s_len);
! 1898:
! 1899: /* match v = 0, no match v = 1 */
! 1900: #if (PHP_MAJOR_VERSION < 6)
! 1901: php_pcre_match_impl(pce, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
! 1902: #else
! 1903: php_pcre_match_impl(pce, IS_STRING, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
! 1904: #endif
! 1905: /* Free haystack */
! 1906: efree(haystack);
! 1907:
! 1908: if (Z_LVAL_P(retval) < 0) {
! 1909: zval_ptr_dtor(&subpats);
! 1910: FREE_ZVAL(retval);
! 1911: zval_dtor(pattern);
! 1912: FREE_ZVAL(pattern);
! 1913: return -1;
! 1914: } else if ((Z_LVAL_P(retval) > 0) && (Z_TYPE_P(subpats) == IS_ARRAY)) {
! 1915:
! 1916: /* Need to fetch global match which equals pmatch[0] */
! 1917: HashTable *ht = Z_ARRVAL_P(subpats);
! 1918: HashPosition outer_pos;
! 1919: zval *pattern_match = NULL, *pattern_offset = NULL;
! 1920:
! 1921: zend_hash_internal_pointer_reset_ex(ht, &outer_pos);
! 1922:
! 1923: if (zend_hash_has_more_elements_ex(ht, &outer_pos) == SUCCESS &&
! 1924: zend_hash_move_forward_ex(ht, &outer_pos)) {
! 1925:
! 1926: zval **ppzval;
! 1927:
! 1928: /* The first element (should be) is the global match
! 1929: Need to move to the inner array to get the global match */
! 1930:
! 1931: if (zend_hash_get_current_data_ex(ht, (void**)&ppzval, &outer_pos) != FAILURE) {
! 1932:
! 1933: HashTable *inner_ht;
! 1934: HashPosition inner_pos;
! 1935: zval **match, **offset;
! 1936: zval tmpcopy = **ppzval, matchcopy, offsetcopy;
! 1937:
! 1938: zval_copy_ctor(&tmpcopy);
! 1939: INIT_PZVAL(&tmpcopy);
! 1940:
! 1941: inner_ht = Z_ARRVAL(tmpcopy);
! 1942:
! 1943: /* If everything goes according to the master plan
! 1944: tmpcopy now contains two elements:
! 1945: 0 = the match
! 1946: 1 = starting position of the match */
! 1947: zend_hash_internal_pointer_reset_ex(inner_ht, &inner_pos);
! 1948:
! 1949: if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
! 1950: zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
! 1951:
! 1952: if (zend_hash_get_current_data_ex(inner_ht, (void**)&match, &inner_pos) != FAILURE) {
! 1953:
! 1954: matchcopy = **match;
! 1955: zval_copy_ctor(&matchcopy);
! 1956: INIT_PZVAL(&matchcopy);
! 1957: convert_to_string(&matchcopy);
! 1958:
! 1959: MAKE_STD_ZVAL(pattern_match);
! 1960: Z_STRVAL_P(pattern_match) = (char *)Z_STRVAL(matchcopy);
! 1961: Z_STRLEN_P(pattern_match) = Z_STRLEN(matchcopy);
! 1962: Z_TYPE_P(pattern_match) = IS_STRING;
! 1963:
! 1964: zval_dtor(&matchcopy);
! 1965: }
! 1966: }
! 1967:
! 1968: if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
! 1969: zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
! 1970:
! 1971: if (zend_hash_get_current_data_ex(inner_ht, (void**)&offset, &inner_pos) != FAILURE) {
! 1972:
! 1973: offsetcopy = **offset;
! 1974: zval_copy_ctor(&offsetcopy);
! 1975: INIT_PZVAL(&offsetcopy);
! 1976: convert_to_long(&offsetcopy);
! 1977:
! 1978: MAKE_STD_ZVAL(pattern_offset);
! 1979: Z_LVAL_P(pattern_offset) = Z_LVAL(offsetcopy);
! 1980: Z_TYPE_P(pattern_offset) = IS_LONG;
! 1981:
! 1982: zval_dtor(&offsetcopy);
! 1983: }
! 1984: }
! 1985: zval_dtor(&tmpcopy);
! 1986: }
! 1987:
! 1988: if ((pattern_match != NULL) && (pattern_offset != NULL)) {
! 1989: ms->search.s += (int)Z_LVAL_P(pattern_offset); /* this is where the match starts */
! 1990: ms->search.offset += (size_t)Z_LVAL_P(pattern_offset); /* this is where the match starts as size_t */
! 1991: ms->search.rm_len = Z_STRLEN_P(pattern_match) /* This is the length of the matched pattern */;
! 1992: v = 0;
! 1993:
! 1994: efree(pattern_match);
! 1995: efree(pattern_offset);
! 1996:
! 1997: } else {
! 1998: zval_ptr_dtor(&subpats);
! 1999: FREE_ZVAL(retval);
! 2000: zval_dtor(pattern);
! 2001: FREE_ZVAL(pattern);
! 2002: return -1;
! 2003: }
! 2004: }
! 2005:
! 2006:
! 2007: } else {
! 2008: v = 1;
! 2009: }
! 2010: zval_ptr_dtor(&subpats);
! 2011: FREE_ZVAL(retval);
! 2012: }
! 2013: zval_dtor(pattern);
! 2014: FREE_ZVAL(pattern);
! 2015: break;
! 2016: }
! 2017: case FILE_INDIRECT:
! 2018: return 1;
! 2019: default:
! 2020: file_magerror(ms, "invalid type %d in magiccheck()", m->type);
! 2021: return -1;
! 2022: }
! 2023:
! 2024: v = file_signextend(ms, m, v);
! 2025:
! 2026: switch (m->reln) {
! 2027: case 'x':
! 2028: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2029: (void) fprintf(stderr, "%llu == *any* = 1\n",
! 2030: (uint64_t)v);
! 2031: matched = 1;
! 2032: break;
! 2033:
! 2034: case '!':
! 2035: matched = v != l;
! 2036: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2037: (void) fprintf(stderr, "%llu != %llu = %d\n",
! 2038: (uint64_t)v, (uint64_t)l,
! 2039: matched);
! 2040: break;
! 2041:
! 2042: case '=':
! 2043: matched = v == l;
! 2044: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2045: (void) fprintf(stderr, "%llu == %llu = %d\n",
! 2046: (uint64_t)v, (uint64_t)l,
! 2047: matched);
! 2048: break;
! 2049:
! 2050: case '>':
! 2051: if (m->flag & UNSIGNED) {
! 2052: matched = v > l;
! 2053: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2054: (void) fprintf(stderr, "%llu > %llu = %d\n",
! 2055: (uint64_t)v,
! 2056: (uint64_t)l, matched);
! 2057: }
! 2058: else {
! 2059: matched = (int64_t) v > (int64_t) l;
! 2060: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2061: (void) fprintf(stderr, "%lld > %lld = %d\n",
! 2062: (uint64_t)v, (uint64_t)l, matched);
! 2063: }
! 2064: break;
! 2065:
! 2066: case '<':
! 2067: if (m->flag & UNSIGNED) {
! 2068: matched = v < l;
! 2069: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2070: (void) fprintf(stderr, "%llu < %llu = %d\n",
! 2071: (uint64_t)v,
! 2072: (uint64_t)l, matched);
! 2073: }
! 2074: else {
! 2075: matched = (int64_t) v < (int64_t) l;
! 2076: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2077: (void) fprintf(stderr, "%lld < %lld = %d\n",
! 2078: (int64_t)v, (int64_t)l, matched);
! 2079: }
! 2080: break;
! 2081:
! 2082: case '&':
! 2083: matched = (v & l) == l;
! 2084: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2085: (void) fprintf(stderr, "((%llx & %llx) == %llx) = %d\n",
! 2086: (uint64_t)v, (uint64_t)l,
! 2087: (uint64_t)l, matched);
! 2088: break;
! 2089:
! 2090: case '^':
! 2091: matched = (v & l) != l;
! 2092: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2093: (void) fprintf(stderr, "((%llx & %llx) != %llx) = %d\n",
! 2094: (uint64_t)v, (uint64_t)l,
! 2095: (uint64_t)l, matched);
! 2096: break;
! 2097:
! 2098: default:
! 2099: matched = 0;
! 2100: file_magerror(ms, "cannot happen: invalid relation `%c'",
! 2101: m->reln);
! 2102: return -1;
! 2103: }
! 2104:
! 2105: return matched;
! 2106: }
! 2107:
! 2108: private int
! 2109: handle_annotation(struct magic_set *ms, struct magic *m)
! 2110: {
! 2111: if (ms->flags & MAGIC_APPLE) {
! 2112: if (file_printf(ms, "%.8s", m->apple) == -1)
! 2113: return -1;
! 2114: return 1;
! 2115: }
! 2116: if ((ms->flags & MAGIC_MIME_TYPE) && m->mimetype[0]) {
! 2117: if (file_printf(ms, "%s", m->mimetype) == -1)
! 2118: return -1;
! 2119: return 1;
! 2120: }
! 2121: return 0;
! 2122: }
! 2123:
! 2124: private int
! 2125: print_sep(struct magic_set *ms, int firstline)
! 2126: {
! 2127: if (ms->flags & MAGIC_MIME)
! 2128: return 0;
! 2129: if (firstline)
! 2130: return 0;
! 2131: /*
! 2132: * we found another match
! 2133: * put a newline and '-' to do some simple formatting
! 2134: */
! 2135: return file_printf(ms, "\n- ");
! 2136: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to softmagic.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