Annotation of embedaddon/php/ext/fileinfo/libmagic.patch, revision 1.1
1.1 ! misho 1: diff -u libmagic.orig/apprentice.c libmagic/apprentice.c
! 2: --- libmagic.orig/apprentice.c 2011-09-15 23:28:13.000000000 +0800
! 3: +++ libmagic/apprentice.c 2011-09-15 23:29:29.000000000 +0800
! 4: @@ -29,6 +29,8 @@
! 5: * apprentice - make one pass through /etc/magic, learning its secrets.
! 6: */
! 7:
! 8: +#include "php.h"
! 9: +
! 10: #include "file.h"
! 11:
! 12: #ifndef lint
! 13: @@ -38,17 +40,32 @@
! 14: #include "magic.h"
! 15: #include "patchlevel.h"
! 16: #include <stdlib.h>
! 17: -#ifdef HAVE_UNISTD_H
! 18: +
! 19: +#if defined(__hpux) && !defined(HAVE_STRTOULL)
! 20: +#if SIZEOF_LONG == 8
! 21: +# define strtoull strtoul
! 22: +#else
! 23: +# define strtoull __strtoull
! 24: +#endif
! 25: +#endif
! 26: +
! 27: +#ifdef PHP_WIN32
! 28: +#include "win32/unistd.h"
! 29: +#if _MSC_VER <= 1300
! 30: +# include "win32/php_strtoi64.h"
! 31: +#endif
! 32: +#define strtoull _strtoui64
! 33: +#else
! 34: #include <unistd.h>
! 35: #endif
! 36: +
! 37: #include <string.h>
! 38: #include <assert.h>
! 39: #include <ctype.h>
! 40: #include <fcntl.h>
! 41: -#ifdef QUICK
! 42: -#include <sys/mman.h>
! 43: -#endif
! 44: +#ifndef PHP_WIN32
! 45: #include <dirent.h>
! 46: +#endif
! 47:
! 48: #define EATAB {while (isascii((unsigned char) *l) && \
! 49: isspace((unsigned char) *l)) ++l;}
! 50: @@ -116,12 +133,10 @@
! 51: private int parse_strength(struct magic_set *, struct magic_entry *, const char *);
! 52: private int parse_apple(struct magic_set *, struct magic_entry *, const char *);
! 53:
! 54: -
! 55: private size_t maxmagic = 0;
! 56: private size_t magicsize = sizeof(struct magic);
! 57:
! 58: private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
! 59: -
! 60: private struct {
! 61: const char *name;
! 62: size_t len;
! 63: @@ -135,38 +150,7 @@
! 64: { NULL, 0, NULL }
! 65: };
! 66:
! 67: -#ifdef COMPILE_ONLY
! 68: -
! 69: -int main(int, char *[]);
! 70: -
! 71: -int
! 72: -main(int argc, char *argv[])
! 73: -{
! 74: - int ret;
! 75: - struct magic_set *ms;
! 76: - char *progname;
! 77: -
! 78: - if ((progname = strrchr(argv[0], '/')) != NULL)
! 79: - progname++;
! 80: - else
! 81: - progname = argv[0];
! 82: -
! 83: - if (argc != 2) {
! 84: - (void)fprintf(stderr, "Usage: %s file\n", progname);
! 85: - return 1;
! 86: - }
! 87: -
! 88: - if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
! 89: - (void)fprintf(stderr, "%s: %s\n", progname, strerror(errno));
! 90: - return 1;
! 91: - }
! 92: - ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
! 93: - if (ret == 1)
! 94: - (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
! 95: - magic_close(ms);
! 96: - return ret;
! 97: -}
! 98: -#endif /* COMPILE_ONLY */
! 99: +#include "../data_file.c"
! 100:
! 101: static const struct type_tbl_s {
! 102: const char name[16];
! 103: @@ -222,6 +206,10 @@
! 104: # undef XX_NULL
! 105: };
! 106:
! 107: +#ifndef S_ISDIR
! 108: +#define S_ISDIR(mode) ((mode) & _S_IFDIR)
! 109: +#endif
! 110: +
! 111: private int
! 112: get_type(const char *l, const char **t)
! 113: {
! 114: @@ -279,15 +267,17 @@
! 115: if (rv != 0)
! 116: return -1;
! 117: rv = apprentice_compile(ms, &magic, &nmagic, fn);
! 118: - free(magic);
! 119: + efree(magic);
! 120: return rv;
! 121: }
! 122:
! 123: -#ifndef COMPILE_ONLY
! 124: if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {
! 125: - if (ms->flags & MAGIC_CHECK)
! 126: - file_magwarn(ms, "using regular magic file `%s'", fn);
! 127: - rv = apprentice_load(ms, &magic, &nmagic, fn, action);
! 128: + if (fn) {
! 129: + if (ms->flags & MAGIC_CHECK)
! 130: + file_magwarn(ms, "using regular magic file `%s'", fn);
! 131: + rv = apprentice_load(ms, &magic, &nmagic, fn, action);
! 132: + }
! 133: +
! 134: if (rv != 0)
! 135: return -1;
! 136: }
! 137: @@ -299,11 +289,7 @@
! 138: return -1;
! 139: }
! 140:
! 141: - if ((ml = CAST(struct mlist *, malloc(sizeof(*ml)))) == NULL) {
! 142: - file_delmagic(magic, mapped, nmagic);
! 143: - file_oomem(ms, sizeof(*ml));
! 144: - return -1;
! 145: - }
! 146: + ml = emalloc(sizeof(*ml));
! 147:
! 148: ml->magic = magic;
! 149: ml->nmagic = nmagic;
! 150: @@ -315,7 +301,6 @@
! 151: mlist->prev = ml;
! 152:
! 153: return 0;
! 154: -#endif /* COMPILE_ONLY */
! 155: }
! 156:
! 157: protected void
! 158: @@ -324,22 +309,18 @@
! 159: if (p == NULL)
! 160: return;
! 161: switch (type) {
! 162: - case 2:
! 163: -#ifdef QUICK
! 164: - p--;
! 165: - (void)munmap((void *)p, sizeof(*p) * (entries + 1));
! 166: + case 3:
! 167: + /* Do nothing, it's part of the code segment */
! 168: break;
! 169: -#else
! 170: - (void)&entries;
! 171: - abort();
! 172: - /*NOTREACHED*/
! 173: -#endif
! 174: +
! 175: case 1:
! 176: p--;
! 177: /*FALLTHROUGH*/
! 178: +
! 179: case 0:
! 180: - free(p);
! 181: + efree(p);
! 182: break;
! 183: +
! 184: default:
! 185: abort();
! 186: }
! 187: @@ -357,20 +338,17 @@
! 188:
! 189: if (fn == NULL)
! 190: fn = getenv("MAGIC");
! 191: - if (fn == NULL)
! 192: - fn = MAGIC;
! 193: -
! 194: - if ((mfn = strdup(fn)) == NULL) {
! 195: - file_oomem(ms, strlen(fn));
! 196: - return NULL;
! 197: + if (fn == NULL) {
! 198: + mlist = emalloc(sizeof(*mlist));
! 199: + mlist->next = mlist->prev = mlist;
! 200: + apprentice_1(ms, fn, action, mlist);
! 201: + return mlist;
! 202: }
! 203: +
! 204: + mfn = estrdup(fn);
! 205: fn = mfn;
! 206:
! 207: - if ((mlist = CAST(struct mlist *, malloc(sizeof(*mlist)))) == NULL) {
! 208: - free(mfn);
! 209: - file_oomem(ms, sizeof(*mlist));
! 210: - return NULL;
! 211: - }
! 212: + mlist = emalloc(sizeof(*mlist));
! 213: mlist->next = mlist->prev = mlist;
! 214:
! 215: while (fn) {
! 216: @@ -384,13 +362,13 @@
! 217: fn = p;
! 218: }
! 219: if (errs == -1) {
! 220: - free(mfn);
! 221: - free(mlist);
! 222: + efree(mfn);
! 223: + efree(mlist);
! 224: mlist = NULL;
! 225: file_error(ms, 0, "could not find any magic files!");
! 226: return NULL;
! 227: }
! 228: - free(mfn);
! 229: + efree(mfn);
! 230: return mlist;
! 231: }
! 232:
! 233: @@ -523,6 +501,7 @@
! 234: abort();
! 235: }
! 236:
! 237: +
! 238: /*
! 239: * Magic entries with no description get a bonus because they depend
! 240: * on subsequent magic entries to print something.
! 241: @@ -538,8 +517,8 @@
! 242: private int
! 243: apprentice_sort(const void *a, const void *b)
! 244: {
! 245: - const struct magic_entry *ma = CAST(const struct magic_entry *, a);
! 246: - const struct magic_entry *mb = CAST(const struct magic_entry *, b);
! 247: + const struct magic_entry *ma = a;
! 248: + const struct magic_entry *mb = b;
! 249: size_t sa = apprentice_magic_strength(ma->mp);
! 250: size_t sb = apprentice_magic_strength(mb->mp);
! 251: if (sa == sb)
! 252: @@ -617,34 +596,51 @@
! 253: load_1(struct magic_set *ms, int action, const char *fn, int *errs,
! 254: struct magic_entry **marray, uint32_t *marraycount)
! 255: {
! 256: - char line[BUFSIZ];
! 257: + char buffer[BUFSIZ + 1];
! 258: + char *line;
! 259: + size_t line_len;
! 260: size_t lineno = 0;
! 261: - FILE *f = fopen(ms->file = fn, "r");
! 262: - if (f == NULL) {
! 263: +
! 264: + php_stream *stream;
! 265: +
! 266: + TSRMLS_FETCH();
! 267: +
! 268: +#if PHP_API_VERSION < 20100412
! 269: + stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
! 270: +#else
! 271: + stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
! 272: +#endif
! 273: +
! 274: + if (stream == NULL) {
! 275: if (errno != ENOENT)
! 276: file_error(ms, errno, "cannot read magic file `%s'",
! 277: fn);
! 278: (*errs)++;
! 279: } else {
! 280: +
! 281: /* read and parse this file */
! 282: - for (ms->line = 1; fgets(line, sizeof(line), f) != NULL; ms->line++) {
! 283: - size_t len;
! 284: - len = strlen(line);
! 285: - if (len == 0) /* null line, garbage, etc */
! 286: +#if (PHP_MAJOR_VERSION < 6)
! 287: + for (ms->line = 1; (line = php_stream_get_line(stream, buffer , BUFSIZ, &line_len)) != NULL; ms->line++) {
! 288: +#else
! 289: + for (ms->line = 1; (line = php_stream_get_line(stream, ZSTR(buffer), BUFSIZ, &line_len)) != NULL; ms->line++) {
! 290: +#endif
! 291: + if (line_len == 0) /* null line, garbage, etc */
! 292: continue;
! 293: - if (line[len - 1] == '\n') {
! 294: +
! 295: + if (line[line_len - 1] == '\n') {
! 296: lineno++;
! 297: - line[len - 1] = '\0'; /* delete newline */
! 298: + line[line_len - 1] = '\0'; /* delete newline */
! 299: }
! 300: if (line[0] == '\0') /* empty, do not parse */
! 301: continue;
! 302: if (line[0] == '#') /* comment, do not parse */
! 303: continue;
! 304: +
! 305: if (line[0] == '!' && line[1] == ':') {
! 306: size_t i;
! 307:
! 308: for (i = 0; bang[i].name != NULL; i++) {
! 309: - if (len - 2 > bang[i].len &&
! 310: + if (line_len - 2 > bang[i].len &&
! 311: memcmp(bang[i].name, line + 2,
! 312: bang[i].len) == 0)
! 313: break;
! 314: @@ -670,12 +666,11 @@
! 315: }
! 316: continue;
! 317: }
! 318: - if (parse(ms, marray, marraycount, line, lineno,
! 319: - action) != 0)
! 320: + if (parse(ms, marray, marraycount, line, lineno, action) != 0)
! 321: (*errs)++;
! 322: }
! 323:
! 324: - (void)fclose(f);
! 325: + php_stream_close(stream);
! 326: }
! 327: }
! 328:
! 329: @@ -690,7 +685,6 @@
! 330: int errs = 0;
! 331: struct magic_entry *marray;
! 332: uint32_t marraycount, i, mentrycount = 0, starttest;
! 333: - size_t slen;
! 334: char subfn[MAXPATHLEN];
! 335: struct stat st;
! 336: DIR *dir;
! 337: @@ -698,12 +692,8 @@
! 338:
! 339: ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
! 340:
! 341: - maxmagic = MAXMAGIS;
! 342: - if ((marray = CAST(struct magic_entry *, calloc(maxmagic,
! 343: - sizeof(*marray)))) == NULL) {
! 344: - file_oomem(ms, maxmagic * sizeof(*marray));
! 345: - return -1;
! 346: - }
! 347: + maxmagic = MAXMAGIS;
! 348: + marray = ecalloc(maxmagic, sizeof(*marray));
! 349: marraycount = 0;
! 350:
! 351: /* print silly verbose header for USG compat. */
! 352: @@ -713,14 +703,14 @@
! 353: /* load directory or file */
! 354: /* FIXME: Read file names and sort them to prevent
! 355: non-determinism. See Debian bug #488562. */
! 356: - if (stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
! 357: + if (php_sys_stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
! 358: dir = opendir(fn);
! 359: if (dir) {
! 360: while ((d = readdir(dir)) != NULL) {
! 361: snprintf(subfn, sizeof(subfn), "%s/%s",
! 362: fn, d->d_name);
! 363: if (stat(subfn, &st) == 0 &&
! 364: - S_ISREG(st.st_mode)) {
! 365: + S_ISREG(st.st_mode)) {
! 366: load_1(ms, action, subfn, &errs,
! 367: &marray, &marraycount);
! 368: }
! 369: @@ -790,12 +780,7 @@
! 370: for (i = 0; i < marraycount; i++)
! 371: mentrycount += marray[i].cont_count;
! 372:
! 373: - slen = sizeof(**magicp) * mentrycount;
! 374: - if ((*magicp = CAST(struct magic *, malloc(slen))) == NULL) {
! 375: - file_oomem(ms, slen);
! 376: - errs++;
! 377: - goto out;
! 378: - }
! 379: + *magicp = emalloc(sizeof(**magicp) * mentrycount);
! 380:
! 381: mentrycount = 0;
! 382: for (i = 0; i < marraycount; i++) {
! 383: @@ -805,8 +790,8 @@
! 384: }
! 385: out:
! 386: for (i = 0; i < marraycount; i++)
! 387: - free(marray[i].mp);
! 388: - free(marray);
! 389: + efree(marray[i].mp);
! 390: + efree(marray);
! 391: if (errs) {
! 392: *magicp = NULL;
! 393: *nmagicp = 0;
! 394: @@ -1081,11 +1066,7 @@
! 395: if (me->cont_count == me->max_count) {
! 396: struct magic *nm;
! 397: size_t cnt = me->max_count + ALLOC_CHUNK;
! 398: - if ((nm = CAST(struct magic *, realloc(me->mp,
! 399: - sizeof(*nm) * cnt))) == NULL) {
! 400: - file_oomem(ms, sizeof(*nm) * cnt);
! 401: - return -1;
! 402: - }
! 403: + nm = erealloc(me->mp, sizeof(*nm) * cnt);
! 404: me->mp = m = nm;
! 405: me->max_count = cnt;
! 406: }
! 407: @@ -1097,23 +1078,13 @@
! 408: struct magic_entry *mp;
! 409:
! 410: maxmagic += ALLOC_INCR;
! 411: - if ((mp = CAST(struct magic_entry *,
! 412: - realloc(*mentryp, sizeof(*mp) * maxmagic))) ==
! 413: - NULL) {
! 414: - file_oomem(ms, sizeof(*mp) * maxmagic);
! 415: - return -1;
! 416: - }
! 417: - (void)memset(&mp[*nmentryp], 0, sizeof(*mp) *
! 418: - ALLOC_INCR);
! 419: + mp = erealloc(*mentryp, sizeof(*mp) * maxmagic);
! 420: + (void)memset(&mp[*nmentryp], 0, sizeof(*mp) * ALLOC_INCR);
! 421: *mentryp = mp;
! 422: }
! 423: me = &(*mentryp)[*nmentryp];
! 424: if (me->mp == NULL) {
! 425: - size_t len = sizeof(*m) * ALLOC_CHUNK;
! 426: - if ((m = CAST(struct magic *, malloc(len))) == NULL) {
! 427: - file_oomem(ms, len);
! 428: - return -1;
! 429: - }
! 430: + m = safe_emalloc(sizeof(*m), ALLOC_CHUNK, 0);
! 431: me->mp = m;
! 432: me->max_count = ALLOC_CHUNK;
! 433: } else
! 434: @@ -1264,7 +1235,7 @@
! 435:
! 436: m->mask_op = 0;
! 437: if (*l == '~') {
! 438: - if (!IS_STRING(m->type))
! 439: + if (!IS_LIBMAGIC_STRING(m->type))
! 440: m->mask_op |= FILE_OPINVERSE;
! 441: else if (ms->flags & MAGIC_CHECK)
! 442: file_magwarn(ms, "'~' invalid for string types");
! 443: @@ -1274,7 +1245,7 @@
! 444: m->str_flags = 0;
! 445: m->num_mask = 0;
! 446: if ((op = get_op(*l)) != -1) {
! 447: - if (!IS_STRING(m->type)) {
! 448: + if (!IS_LIBMAGIC_STRING(m->type)) {
! 449: uint64_t val;
! 450: ++l;
! 451: m->mask_op |= op;
! 452: @@ -1423,11 +1394,6 @@
! 453: if (check_format(ms, m) == -1)
! 454: return -1;
! 455: }
! 456: -#ifndef COMPILE_ONLY
! 457: - if (action == FILE_CHECK) {
! 458: - file_mdump(m);
! 459: - }
! 460: -#endif
! 461: m->mimetype[0] = '\0'; /* initialise MIME type to none */
! 462: if (m->cont_level == 0)
! 463: ++(*nmentryp); /* make room for next */
! 464: @@ -2053,56 +2019,68 @@
! 465:
! 466: /*
! 467: * handle a compiled file.
! 468: + * return -1 = error
! 469: + * return 1 = memory structure you can free
! 470: + * return 3 = bundled library from PHP
! 471: */
! 472: private int
! 473: apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
! 474: const char *fn)
! 475: {
! 476: - int fd;
! 477: - struct stat st;
! 478: uint32_t *ptr;
! 479: uint32_t version;
! 480: int needsbyteswap;
! 481: char *dbname = NULL;
! 482: void *mm = NULL;
! 483: + int ret = 0;
! 484: + php_stream *stream = NULL;
! 485: + php_stream_statbuf st;
! 486: +
! 487: +
! 488: + TSRMLS_FETCH();
! 489: +
! 490: + if (fn == NULL) {
! 491: + mm = (void *)&php_magic_database;
! 492: + ret = 3;
! 493: + goto internal_loaded;
! 494: + }
! 495:
! 496: dbname = mkdbname(ms, fn, 0);
! 497: if (dbname == NULL)
! 498: goto error2;
! 499:
! 500: - if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
! 501: +#if PHP_API_VERSION < 20100412
! 502: + stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
! 503: +#else
! 504: + stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
! 505: +#endif
! 506: +
! 507: + if (!stream) {
! 508: goto error2;
! 509: + }
! 510:
! 511: - if (fstat(fd, &st) == -1) {
! 512: + if (php_stream_stat(stream, &st) < 0) {
! 513: file_error(ms, errno, "cannot stat `%s'", dbname);
! 514: goto error1;
! 515: }
! 516: - if (st.st_size < 8) {
! 517: +
! 518: + if (st.sb.st_size < 8) {
! 519: file_error(ms, 0, "file `%s' is too small", dbname);
! 520: goto error1;
! 521: }
! 522:
! 523: -#ifdef QUICK
! 524: - if ((mm = mmap(0, (size_t)st.st_size, PROT_READ|PROT_WRITE,
! 525: - MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) {
! 526: - file_error(ms, errno, "cannot map `%s'", dbname);
! 527: - goto error1;
! 528: - }
! 529: -#define RET 2
! 530: -#else
! 531: - if ((mm = CAST(void *, malloc((size_t)st.st_size))) == NULL) {
! 532: - file_oomem(ms, (size_t)st.st_size);
! 533: - goto error1;
! 534: - }
! 535: - if (read(fd, mm, (size_t)st.st_size) != (ssize_t)st.st_size) {
! 536: + mm = emalloc((size_t)st.sb.st_size);
! 537: + if (php_stream_read(stream, mm, (size_t)st.sb.st_size) != (size_t)st.sb.st_size) {
! 538: file_badread(ms);
! 539: goto error1;
! 540: }
! 541: -#define RET 1
! 542: -#endif
! 543: - *magicp = CAST(struct magic *, mm);
! 544: - (void)close(fd);
! 545: - fd = -1;
! 546: + ret = 1;
! 547: +
! 548: + php_stream_close(stream);
! 549: + stream = NULL;
! 550: +
! 551: +internal_loaded:
! 552: + *magicp = mm;
! 553: ptr = (uint32_t *)(void *)*magicp;
! 554: if (*ptr != MAGICNO) {
! 555: if (swap4(*ptr) != MAGICNO) {
! 556: @@ -2110,42 +2088,65 @@
! 557: goto error1;
! 558: }
! 559: needsbyteswap = 1;
! 560: - } else
! 561: + } else {
! 562: needsbyteswap = 0;
! 563: + }
! 564: +
! 565: if (needsbyteswap)
! 566: version = swap4(ptr[1]);
! 567: else
! 568: version = ptr[1];
! 569: +
! 570: if (version != VERSIONNO) {
! 571: file_error(ms, 0, "File %d.%d supports only version %d magic "
! 572: "files. `%s' is version %d", FILE_VERSION_MAJOR, patchlevel,
! 573: VERSIONNO, dbname, version);
! 574: goto error1;
! 575: }
! 576: - *nmagicp = (uint32_t)(st.st_size / sizeof(struct magic));
! 577: - if (*nmagicp > 0)
! 578: +
! 579: + /* php_magic_database is a const, performing writes will segfault. This is for big-endian
! 580: + machines only, PPC and Sparc specifically. Consider static variable or MINIT in
! 581: + future. */
! 582: + if (needsbyteswap && fn == NULL) {
! 583: + mm = emalloc(sizeof(php_magic_database));
! 584: + mm = memcpy(mm, php_magic_database, sizeof(php_magic_database));
! 585: + *magicp = mm;
! 586: + ret = 1;
! 587: + }
! 588: +
! 589: + if (fn == NULL) {
! 590: + *nmagicp = (sizeof(php_magic_database) / sizeof(struct magic));
! 591: + } else {
! 592: + *nmagicp = (uint32_t)(st.sb.st_size / sizeof(struct magic));
! 593: + }
! 594: + if (*nmagicp > 0) {
! 595: (*nmagicp)--;
! 596: + }
! 597: (*magicp)++;
! 598: - if (needsbyteswap)
! 599: + if (needsbyteswap) {
! 600: byteswap(*magicp, *nmagicp);
! 601: - free(dbname);
! 602: - return RET;
! 603: + }
! 604: +
! 605: + if (dbname) {
! 606: + efree(dbname);
! 607: + }
! 608: + return ret;
! 609:
! 610: error1:
! 611: - if (fd != -1)
! 612: - (void)close(fd);
! 613: - if (mm) {
! 614: -#ifdef QUICK
! 615: - (void)munmap((void *)mm, (size_t)st.st_size);
! 616: -#else
! 617: - free(mm);
! 618: -#endif
! 619: + if (stream) {
! 620: + php_stream_close(stream);
! 621: + }
! 622: +
! 623: + if (mm && ret == 1) {
! 624: + efree(mm);
! 625: } else {
! 626: *magicp = NULL;
! 627: *nmagicp = 0;
! 628: }
! 629: error2:
! 630: - free(dbname);
! 631: + if (dbname) {
! 632: + efree(dbname);
! 633: + }
! 634: return -1;
! 635: }
! 636:
! 637: @@ -2159,41 +2160,50 @@
! 638: apprentice_compile(struct magic_set *ms, struct magic **magicp,
! 639: uint32_t *nmagicp, const char *fn)
! 640: {
! 641: - int fd;
! 642: char *dbname;
! 643: int rv = -1;
! 644: + php_stream *stream;
! 645:
! 646: - dbname = mkdbname(ms, fn, 1);
! 647: + TSRMLS_FETCH();
! 648:
! 649: - if (dbname == NULL)
! 650: + dbname = mkdbname(ms, fn, 0);
! 651: +
! 652: + if (dbname == NULL) {
! 653: goto out;
! 654: + }
! 655:
! 656: - if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1) {
! 657: +/* wb+ == O_WRONLY|O_CREAT|O_TRUNC|O_BINARY */
! 658: +#if PHP_API_VERSION < 20100412
! 659: + stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
! 660: +#else
! 661: + stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS, NULL);
! 662: +#endif
! 663: +
! 664: + if (!stream) {
! 665: file_error(ms, errno, "cannot open `%s'", dbname);
! 666: goto out;
! 667: }
! 668:
! 669: - if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
! 670: + if (php_stream_write(stream, (char *)ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
! 671: file_error(ms, errno, "error writing `%s'", dbname);
! 672: goto out;
! 673: }
! 674:
! 675: - if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET)
! 676: - != sizeof(struct magic)) {
! 677: + if (php_stream_seek(stream,(off_t)sizeof(struct magic), SEEK_SET) != sizeof(struct magic)) {
! 678: file_error(ms, errno, "error seeking `%s'", dbname);
! 679: goto out;
! 680: }
! 681:
! 682: - if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp))
! 683: - != (ssize_t)(sizeof(struct magic) * *nmagicp)) {
! 684: + if (php_stream_write(stream, (char *)*magicp, (sizeof(struct magic) * *nmagicp) != (ssize_t)(sizeof(struct magic) * *nmagicp))) {
! 685: file_error(ms, errno, "error writing `%s'", dbname);
! 686: goto out;
! 687: }
! 688:
! 689: - (void)close(fd);
! 690: + php_stream_close(stream);
! 691: +
! 692: rv = 0;
! 693: out:
! 694: - free(dbname);
! 695: + efree(dbname);
! 696: return rv;
! 697: }
! 698:
! 699: @@ -2206,6 +2216,7 @@
! 700: {
! 701: const char *p, *q;
! 702: char *buf;
! 703: + TSRMLS_FETCH();
! 704:
! 705: if (strip) {
! 706: if ((p = strrchr(fn, '/')) != NULL)
! 707: @@ -2227,14 +2238,14 @@
! 708: q++;
! 709: /* Compatibility with old code that looked in .mime */
! 710: if (ms->flags & MAGIC_MIME) {
! 711: - asprintf(&buf, "%.*s.mime%s", (int)(q - fn), fn, ext);
! 712: - if (access(buf, R_OK) != -1) {
! 713: + spprintf(&buf, MAXPATHLEN, "%.*s.mime%s", (int)(q - fn), fn, ext);
! 714: + if (VCWD_ACCESS(buf, R_OK) != -1) {
! 715: ms->flags &= MAGIC_MIME_TYPE;
! 716: return buf;
! 717: }
! 718: - free(buf);
! 719: + efree(buf);
! 720: }
! 721: - asprintf(&buf, "%.*s%s", (int)(q - fn), fn, ext);
! 722: + spprintf(&buf, MAXPATHLEN, "%.*s%s", (int)(q - fn), fn, ext);
! 723:
! 724: /* Compatibility with old code that looked in .mime */
! 725: if (strstr(p, ".mime") != NULL)
! 726: @@ -2324,7 +2335,7 @@
! 727: m->offset = swap4((uint32_t)m->offset);
! 728: m->in_offset = swap4((uint32_t)m->in_offset);
! 729: m->lineno = swap4((uint32_t)m->lineno);
! 730: - if (IS_STRING(m->type)) {
! 731: + if (IS_LIBMAGIC_STRING(m->type)) {
! 732: m->str_range = swap4(m->str_range);
! 733: m->str_flags = swap4(m->str_flags);
! 734: }
! 735: diff -u libmagic.orig/ascmagic.c libmagic/ascmagic.c
! 736: --- libmagic.orig/ascmagic.c 2011-09-15 23:28:13.000000000 +0800
! 737: +++ libmagic/ascmagic.c 2011-09-15 23:28:26.000000000 +0800
! 738: @@ -144,10 +144,8 @@
! 739: /* malloc size is a conservative overestimate; could be
! 740: improved, or at least realloced after conversion. */
! 741: mlen = ulen * 6;
! 742: - if ((utf8_buf = CAST(unsigned char *, malloc(mlen))) == NULL) {
! 743: - file_oomem(ms, mlen);
! 744: - goto done;
! 745: - }
! 746: + utf8_buf = emalloc(mlen);
! 747: +
! 748: if ((utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen)) == NULL)
! 749: goto done;
! 750: if ((rv = file_softmagic(ms, utf8_buf, (size_t)(utf8_end - utf8_buf),
! 751: @@ -310,7 +308,7 @@
! 752: rv = 1;
! 753: done:
! 754: if (utf8_buf)
! 755: - free(utf8_buf);
! 756: + efree(utf8_buf);
! 757:
! 758: return rv;
! 759: }
! 760: diff -u libmagic.orig/cdf.c libmagic/cdf.c
! 761: --- libmagic.orig/cdf.c 2011-09-15 23:28:13.000000000 +0800
! 762: +++ libmagic/cdf.c 2011-09-15 23:29:29.000000000 +0800
! 763: @@ -40,7 +40,17 @@
! 764: #include <err.h>
! 765: #endif
! 766: #include <stdlib.h>
! 767: +
! 768: +#ifdef PHP_WIN32
! 769: +#include "win32/unistd.h"
! 770: +#else
! 771: #include <unistd.h>
! 772: +#endif
! 773: +
! 774: +#ifndef UINT32_MAX
! 775: +# define UINT32_MAX (0xffffffff)
! 776: +#endif
! 777: +
! 778: #include <string.h>
! 779: #include <time.h>
! 780: #include <ctype.h>
! 781: @@ -1042,7 +1052,7 @@
! 782: cdf_directory_t *d;
! 783: char name[__arraycount(d->d_name)];
! 784: cdf_stream_t scn;
! 785: - struct timespec ts;
! 786: + struct timeval ts;
! 787:
! 788: static const char *types[] = { "empty", "user storage",
! 789: "user stream", "lockbytes", "property", "root storage" };
! 790: @@ -1094,13 +1104,13 @@
! 791: cdf_dump_property_info(const cdf_property_info_t *info, size_t count)
! 792: {
! 793: cdf_timestamp_t tp;
! 794: - struct timespec ts;
! 795: + struct timeval ts;
! 796: char buf[64];
! 797: size_t i;
! 798:
! 799: for (i = 0; i < count; i++) {
! 800: cdf_print_property_name(buf, sizeof(buf), info[i].pi_id);
! 801: - (void)fprintf(stderr, "%zu) %s: ", i, buf);
! 802: + (void)fprintf(stderr, "%zu) %s: ", i, buf);
! 803: switch (info[i].pi_type) {
! 804: case CDF_SIGNED16:
! 805: (void)fprintf(stderr, "signed 16 [%hd]\n",
! 806: @@ -1121,13 +1131,17 @@
! 807: break;
! 808: case CDF_FILETIME:
! 809: tp = info[i].pi_tp;
! 810: +#if defined(PHP_WIN32) && _MSC_VER <= 1500
! 811: + if (tp < 1000000000000000i64) {
! 812: +#else
! 813: if (tp < 1000000000000000LL) {
! 814: +#endif
! 815: cdf_print_elapsed_time(buf, sizeof(buf), tp);
! 816: (void)fprintf(stderr, "timestamp %s\n", buf);
! 817: } else {
! 818: cdf_timestamp_to_timespec(&ts, tp);
! 819: (void)fprintf(stderr, "timestamp %s",
! 820: - ctime(&ts.tv_sec));
! 821: + ctime(&ts.tv_sec));
! 822: }
! 823: break;
! 824: case CDF_CLIPBOARD:
! 825: diff -u libmagic.orig/cdf.h libmagic/cdf.h
! 826: --- libmagic.orig/cdf.h 2011-09-15 23:28:13.000000000 +0800
! 827: +++ libmagic/cdf.h 2011-09-15 23:29:29.000000000 +0800
! 828: @@ -42,7 +42,11 @@
! 829:
! 830: typedef struct {
! 831: uint64_t h_magic;
! 832: -#define CDF_MAGIC 0xE11AB1A1E011CFD0LL
! 833: +#if defined(PHP_WIN32) && _MSC_VER <= 1500
! 834: +# define CDF_MAGIC 0xE11AB1A1E011CFD0i64
! 835: +#else
! 836: +# define CDF_MAGIC 0xE11AB1A1E011CFD0LL
! 837: +#endif
! 838: uint64_t h_uuid[2];
! 839: uint16_t h_revision;
! 840: uint16_t h_version;
! 841: @@ -248,9 +252,9 @@
! 842: size_t i_len;
! 843: } cdf_info_t;
! 844:
! 845: -struct timespec;
! 846: -int cdf_timestamp_to_timespec(struct timespec *, cdf_timestamp_t);
! 847: -int cdf_timespec_to_timestamp(cdf_timestamp_t *, const struct timespec *);
! 848: +struct timeval;
! 849: +int cdf_timestamp_to_timespec(struct timeval *, cdf_timestamp_t);
! 850: +int cdf_timespec_to_timestamp(cdf_timestamp_t *, const struct timeval *);
! 851: int cdf_read_header(const cdf_info_t *, cdf_header_t *);
! 852: void cdf_swap_header(cdf_header_t *);
! 853: void cdf_unpack_header(cdf_header_t *, char *);
! 854: diff -u libmagic.orig/cdf_time.c libmagic/cdf_time.c
! 855: --- libmagic.orig/cdf_time.c 2011-09-15 23:28:13.000000000 +0800
! 856: +++ libmagic/cdf_time.c 2011-10-19 22:51:40.000000000 +0800
! 857: @@ -96,7 +96,7 @@
! 858: }
! 859:
! 860: int
! 861: -cdf_timestamp_to_timespec(struct timespec *ts, cdf_timestamp_t t)
! 862: +cdf_timestamp_to_timespec(struct timeval *ts, cdf_timestamp_t t)
! 863: {
! 864: struct tm tm;
! 865: #ifdef HAVE_STRUCT_TM_TM_ZONE
! 866: @@ -104,8 +104,8 @@
! 867: #endif
! 868: int rdays;
! 869:
! 870: - /* Unit is 100's of nanoseconds */
! 871: - ts->tv_nsec = (t % CDF_TIME_PREC) * 100;
! 872: + /* Time interval, in microseconds */
! 873: + ts->tv_usec = (t % CDF_TIME_PREC) * CDF_TIME_PREC;
! 874:
! 875: t /= CDF_TIME_PREC;
! 876: tm.tm_sec = t % 60;
! 877: @@ -117,7 +117,7 @@
! 878: tm.tm_hour = t % 24;
! 879: t /= 24;
! 880:
! 881: - // XXX: Approx
! 882: + /* XXX: Approx */
! 883: tm.tm_year = CDF_BASE_YEAR + (t / 365);
! 884:
! 885: rdays = cdf_getdays(tm.tm_year);
! 886: @@ -143,7 +143,7 @@
! 887: }
! 888:
! 889: int
! 890: -cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timespec *ts)
! 891: +cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timeval *ts)
! 892: {
! 893: (void)&t;
! 894: (void)&ts;
! 895: @@ -153,7 +153,7 @@
! 896: errno = EINVAL;
! 897: return -1;
! 898: }
! 899: - *t = (ts->ts_nsec / 100) * CDF_TIME_PREC;
! 900: + *t = (ts->ts_usec / CDF_TIME_PREC) * CDF_TIME_PREC;
! 901: *t = tm.tm_sec;
! 902: *t += tm.tm_min * 60;
! 903: *t += tm.tm_hour * 60 * 60;
! 904: @@ -167,7 +167,7 @@
! 905: int
! 906: main(int argc, char *argv[])
! 907: {
! 908: - struct timespec ts;
! 909: + struct timeval ts;
! 910: static const cdf_timestamp_t tst = 0x01A5E403C2D59C00ULL;
! 911: static const char *ref = "Sat Apr 23 01:30:00 1977";
! 912: char *p, *q;
! 913: diff -u libmagic.orig/compress.c libmagic/compress.c
! 914: --- libmagic.orig/compress.c 2011-09-15 23:28:13.000000000 +0800
! 915: +++ libmagic/compress.c 2011-09-15 23:28:26.000000000 +0800
! 916: @@ -32,6 +32,7 @@
! 917: * uncompress(method, old, n, newch) - uncompress old into new,
! 918: * using method, return sizeof new
! 919: */
! 920: +#include "config.h"
! 921: #include "file.h"
! 922:
! 923: #ifndef lint
! 924: @@ -45,7 +46,10 @@
! 925: #endif
! 926: #include <string.h>
! 927: #include <errno.h>
! 928: +#include <sys/types.h>
! 929: +#ifndef PHP_WIN32
! 930: #include <sys/ioctl.h>
! 931: +#endif
! 932: #ifdef HAVE_SYS_WAIT_H
! 933: #include <sys/wait.h>
! 934: #endif
! 935: @@ -57,6 +61,9 @@
! 936: #include <zlib.h>
! 937: #endif
! 938:
! 939: +#undef FIONREAD
! 940: +
! 941: +
! 942: private const struct {
! 943: const char magic[8];
! 944: size_t maglen;
! 945: @@ -79,12 +86,10 @@
! 946: { "\3757zXZ\0",6,{ "xz", "-cd", NULL }, 1 }, /* XZ Utils */
! 947: };
! 948:
! 949: -private size_t ncompr = sizeof(compr) / sizeof(compr[0]);
! 950: -
! 951: #define NODATA ((size_t)~0)
! 952:
! 953: -
! 954: private ssize_t swrite(int, const void *, size_t);
! 955: +#ifdef PHP_FILEINFO_UNCOMPRESS
! 956: private size_t uncompressbuf(struct magic_set *, int, size_t,
! 957: const unsigned char *, unsigned char **, size_t);
! 958: #ifdef BUILTIN_DECOMPRESS
! 959: @@ -100,10 +105,13 @@
! 960: size_t i, nsz;
! 961: int rv = 0;
! 962: int mime = ms->flags & MAGIC_MIME;
! 963: + size_t ncompr;
! 964:
! 965: if ((ms->flags & MAGIC_COMPRESS) == 0)
! 966: return 0;
! 967:
! 968: + ncompr = sizeof(compr) / sizeof(compr[0]);
! 969: +
! 970: for (i = 0; i < ncompr; i++) {
! 971: if (nbytes < compr[i].maglen)
! 972: continue;
! 973: @@ -133,10 +141,11 @@
! 974: }
! 975: error:
! 976: if (newbuf)
! 977: - free(newbuf);
! 978: + efree(newbuf);
! 979: ms->flags |= MAGIC_COMPRESS;
! 980: return rv;
! 981: }
! 982: +#endif
! 983:
! 984: /*
! 985: * `safe' write for sockets and pipes.
! 986: @@ -169,7 +178,7 @@
! 987: protected ssize_t
! 988: sread(int fd, void *buf, size_t n, int canbepipe)
! 989: {
! 990: - int rv, cnt;
! 991: + int rv;
! 992: #ifdef FIONREAD
! 993: int t = 0;
! 994: #endif
! 995: @@ -181,6 +190,7 @@
! 996: #ifdef FIONREAD
! 997: if ((canbepipe && (ioctl(fd, FIONREAD, &t) == -1)) || (t == 0)) {
! 998: #ifdef FD_ZERO
! 999: + int cnt;
! 1000: for (cnt = 0;; cnt++) {
! 1001: fd_set check;
! 1002: struct timeval tout = {0, 100 * 1000};
! 1003: @@ -294,6 +304,7 @@
! 1004: return fd;
! 1005: }
! 1006:
! 1007: +#ifdef PHP_FILEINFO_UNCOMPRESS
! 1008: #ifdef BUILTIN_DECOMPRESS
! 1009:
! 1010: #define FHCRC (1 << 1)
! 1011: @@ -301,6 +312,7 @@
! 1012: #define FNAME (1 << 3)
! 1013: #define FCOMMENT (1 << 4)
! 1014:
! 1015: +
! 1016: private size_t
! 1017: uncompressgzipped(struct magic_set *ms, const unsigned char *old,
! 1018: unsigned char **newch, size_t n)
! 1019: @@ -330,9 +342,7 @@
! 1020:
! 1021: if (data_start >= n)
! 1022: return 0;
! 1023: - if ((*newch = CAST(unsigned char *, malloc(HOWMANY + 1))) == NULL) {
! 1024: - return 0;
! 1025: - }
! 1026: + *newch = (unsigned char *)emalloc(HOWMANY + 1));
! 1027:
! 1028: /* XXX: const castaway, via strchr */
! 1029: z.next_in = (Bytef *)strchr((const char *)old + data_start,
! 1030: @@ -455,20 +465,14 @@
! 1031: fdin[1] = -1;
! 1032: }
! 1033:
! 1034: - if ((*newch = (unsigned char *) malloc(HOWMANY + 1)) == NULL) {
! 1035: -#ifdef DEBUG
! 1036: - (void)fprintf(stderr, "Malloc failed (%s)\n",
! 1037: - strerror(errno));
! 1038: -#endif
! 1039: - n = 0;
! 1040: - goto err;
! 1041: - }
! 1042: + *newch = (unsigned char *) emalloc(HOWMANY + 1);
! 1043: +
! 1044: if ((r = sread(fdout[0], *newch, HOWMANY, 0)) <= 0) {
! 1045: #ifdef DEBUG
! 1046: (void)fprintf(stderr, "Read failed (%s)\n",
! 1047: strerror(errno));
! 1048: #endif
! 1049: - free(*newch);
! 1050: + efree(*newch);
! 1051: n = 0;
! 1052: newch[0] = '\0';
! 1053: goto err;
! 1054: @@ -492,3 +496,4 @@
! 1055: return n;
! 1056: }
! 1057: }
! 1058: +#endif /* if PHP_FILEINFO_UNCOMPRESS */
! 1059: diff -u libmagic.orig/file.h libmagic/file.h
! 1060: --- libmagic.orig/file.h 2011-09-15 23:28:13.000000000 +0800
! 1061: +++ libmagic/file.h 2011-09-15 23:28:26.000000000 +0800
! 1062: @@ -33,9 +33,7 @@
! 1063: #ifndef __file_h__
! 1064: #define __file_h__
! 1065:
! 1066: -#ifdef HAVE_CONFIG_H
! 1067: -#include <config.h>
! 1068: -#endif
! 1069: +#include "config.h"
! 1070:
! 1071: #include <stdio.h> /* Include that here, to make sure __P gets defined */
! 1072: #include <errno.h>
! 1073: @@ -46,9 +44,20 @@
! 1074: #ifdef HAVE_INTTYPES_H
! 1075: #include <inttypes.h>
! 1076: #endif
! 1077: -#include <regex.h>
! 1078: +#ifdef PHP_WIN32
! 1079: +#include "win32/php_stdint.h"
! 1080: +#endif
! 1081: +
! 1082: +#include "php.h"
! 1083: +#include "ext/standard/php_string.h"
! 1084: +#include "ext/pcre/php_pcre.h"
! 1085: +
! 1086: #include <sys/types.h>
! 1087: +#ifdef PHP_WIN32
! 1088: +#include "win32/param.h"
! 1089: +#else
! 1090: #include <sys/param.h>
! 1091: +#endif
! 1092: /* Do this here and now, because struct stat gets re-defined on solaris */
! 1093: #include <sys/stat.h>
! 1094: #include <stdarg.h>
! 1095: @@ -59,7 +68,7 @@
! 1096: #define MAGIC "/etc/magic"
! 1097: #endif
! 1098:
! 1099: -#ifdef __EMX__
! 1100: +#if defined(__EMX__) || defined(PHP_WIN32)
! 1101: #define PATHSEP ';'
! 1102: #else
! 1103: #define PATHSEP ':'
! 1104: @@ -81,12 +90,6 @@
! 1105: #endif
! 1106: #endif
! 1107:
! 1108: -#ifndef __GNUC__
! 1109: -#ifndef __attribute__
! 1110: -#define __attribute__(a)
! 1111: -#endif
! 1112: -#endif
! 1113: -
! 1114: #ifndef MIN
! 1115: #define MIN(a,b) (((a) < (b)) ? (a) : (b))
! 1116: #endif
! 1117: @@ -189,7 +192,7 @@
! 1118: #define FILE_INDIRECT 41
! 1119: #define FILE_NAMES_SIZE 42/* size of array to contain all names */
! 1120:
! 1121: -#define IS_STRING(t) \
! 1122: +#define IS_LIBMAGIC_STRING(t) \
! 1123: ((t) == FILE_STRING || \
! 1124: (t) == FILE_PSTRING || \
! 1125: (t) == FILE_BESTRING16 || \
! 1126: @@ -211,7 +214,7 @@
! 1127: #ifdef ENABLE_CONDITIONALS
! 1128: uint8_t cond; /* conditional type */
! 1129: #else
! 1130: - uint8_t dummy;
! 1131: + uint8_t dummy;
! 1132: #endif
! 1133: uint8_t factor_op;
! 1134: #define FILE_FACTOR_OP_PLUS '+'
! 1135: @@ -345,20 +348,20 @@
! 1136:
! 1137: struct stat;
! 1138: protected const char *file_fmttime(uint32_t, int);
! 1139: -protected int file_buffer(struct magic_set *, int, const char *, const void *,
! 1140: +protected int file_buffer(struct magic_set *, php_stream *, const char *, const void *,
! 1141: size_t);
! 1142: -protected int file_fsmagic(struct magic_set *, const char *, struct stat *);
! 1143: +protected int file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb, php_stream *stream);
! 1144: protected int file_pipe2file(struct magic_set *, int, const void *, size_t);
! 1145: -protected int file_vprintf(struct magic_set *, const char *, va_list);
! 1146: -protected int file_printf(struct magic_set *, const char *, ...)
! 1147: - __attribute__((__format__(__printf__, 2, 3)));
! 1148: +protected int file_printf(struct magic_set *, const char *, ...);
! 1149: protected int file_reset(struct magic_set *);
! 1150: protected int file_tryelf(struct magic_set *, int, const unsigned char *,
! 1151: size_t);
! 1152: protected int file_trycdf(struct magic_set *, int, const unsigned char *,
! 1153: size_t);
! 1154: +#ifdef PHP_FILEINFO_UNCOMPRESS
! 1155: protected int file_zmagic(struct magic_set *, int, const char *,
! 1156: const unsigned char *, size_t);
! 1157: +#endif
! 1158: protected int file_ascmagic(struct magic_set *, const unsigned char *, size_t);
! 1159: protected int file_ascmagic_with_encoding(struct magic_set *,
! 1160: const unsigned char *, size_t, unichar *, size_t, const char *,
! 1161: @@ -375,13 +378,9 @@
! 1162: protected void file_badread(struct magic_set *);
! 1163: protected void file_badseek(struct magic_set *);
! 1164: protected void file_oomem(struct magic_set *, size_t);
! 1165: -protected void file_error(struct magic_set *, int, const char *, ...)
! 1166: - __attribute__((__format__(__printf__, 3, 4)));
! 1167: -protected void file_magerror(struct magic_set *, const char *, ...)
! 1168: - __attribute__((__format__(__printf__, 2, 3)));
! 1169: -protected void file_magwarn(struct magic_set *, const char *, ...)
! 1170: - __attribute__((__format__(__printf__, 2, 3)));
! 1171: -protected void file_mdump(struct magic *);
! 1172: +protected void file_error(struct magic_set *, int, const char *, ...);
! 1173: +protected void file_magerror(struct magic_set *, const char *, ...);
! 1174: +protected void file_magwarn(struct magic_set *, const char *, ...);
! 1175: protected void file_showstr(FILE *, const char *, size_t);
! 1176: protected size_t file_mbswidth(const char *);
! 1177: protected const char *file_getbuffer(struct magic_set *);
! 1178: @@ -394,11 +393,8 @@
! 1179: size_t);
! 1180: #endif /* __EMX__ */
! 1181:
! 1182: -
! 1183: -#ifndef COMPILE_ONLY
! 1184: extern const char *file_names[];
! 1185: extern const size_t file_nnames;
! 1186: -#endif
! 1187:
! 1188: #ifndef HAVE_STRERROR
! 1189: extern int sys_nerr;
! 1190: @@ -411,20 +407,14 @@
! 1191: #define strtoul(a, b, c) strtol(a, b, c)
! 1192: #endif
! 1193:
! 1194: -#ifndef HAVE_VASPRINTF
! 1195: -int vasprintf(char **, const char *, va_list);
! 1196: -#endif
! 1197: -#ifndef HAVE_ASPRINTF
! 1198: -int asprintf(char **ptr, const char *format_string, ...);
! 1199: -#endif
! 1200: -
! 1201: -#ifndef HAVE_STRLCPY
! 1202: +#ifndef strlcpy
! 1203: size_t strlcpy(char *dst, const char *src, size_t siz);
! 1204: #endif
! 1205: -#ifndef HAVE_STRLCAT
! 1206: +#ifndef strlcat
! 1207: size_t strlcat(char *dst, const char *src, size_t siz);
! 1208: #endif
! 1209:
! 1210: +
! 1211: #if defined(HAVE_MMAP) && defined(HAVE_SYS_MMAN_H) && !defined(QUICK)
! 1212: #define QUICK
! 1213: #endif
! 1214: diff -u libmagic.orig/fsmagic.c libmagic/fsmagic.c
! 1215: --- libmagic.orig/fsmagic.c 2011-09-15 23:28:13.000000000 +0800
! 1216: +++ libmagic/fsmagic.c 2011-09-15 23:28:26.000000000 +0800
! 1217: @@ -60,29 +60,19 @@
! 1218: #endif
! 1219: #undef HAVE_MAJOR
! 1220:
! 1221: -private int
! 1222: -bad_link(struct magic_set *ms, int err, char *buf)
! 1223: -{
! 1224: - const char *errfmt;
! 1225: - int mime = ms->flags & MAGIC_MIME;
! 1226: - if ((mime & MAGIC_MIME_TYPE) &&
! 1227: - file_printf(ms, "application/x-symlink")
! 1228: - == -1)
! 1229: - return -1;
! 1230: - else if (!mime) {
! 1231: - if (err == ELOOP)
! 1232: - errfmt = "symbolic link in a loop";
! 1233: - else
! 1234: - errfmt = "broken symbolic link to `%s'";
! 1235: - if (ms->flags & MAGIC_ERROR) {
! 1236: - file_error(ms, err, errfmt, buf);
! 1237: - return -1;
! 1238: - }
! 1239: - if (file_printf(ms, errfmt, buf) == -1)
! 1240: - return -1;
! 1241: - }
! 1242: - return 1;
! 1243: -}
! 1244: +#ifdef PHP_WIN32
! 1245: +
! 1246: +# undef S_IFIFO
! 1247: +#endif
! 1248: +
! 1249: +
! 1250: +#ifndef S_ISDIR
! 1251: +#define S_ISDIR(mode) ((mode) & _S_IFDIR)
! 1252: +#endif
! 1253: +
! 1254: +#ifndef S_ISREG
! 1255: +#define S_ISREG(mode) ((mode) & _S_IFREG)
! 1256: +#endif
! 1257:
! 1258: private int
! 1259: handle_mime(struct magic_set *ms, int mime, const char *str)
! 1260: @@ -100,41 +90,36 @@
! 1261: }
! 1262:
! 1263: protected int
! 1264: -file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
! 1265: +file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb, php_stream *stream)
! 1266: {
! 1267: - int ret = 0;
! 1268: int mime = ms->flags & MAGIC_MIME;
! 1269: -#ifdef S_IFLNK
! 1270: - char buf[BUFSIZ+4];
! 1271: - int nch;
! 1272: - struct stat tstatbuf;
! 1273: -#endif
! 1274: + TSRMLS_FETCH();
! 1275:
! 1276: if (ms->flags & MAGIC_APPLE)
! 1277: return 0;
! 1278: - if (fn == NULL)
! 1279: +
! 1280: + if (!fn && !stream) {
! 1281: return 0;
! 1282: + }
! 1283:
! 1284: - /*
! 1285: - * Fstat is cheaper but fails for files you don't have read perms on.
! 1286: - * On 4.2BSD and similar systems, use lstat() to identify symlinks.
! 1287: - */
! 1288: -#ifdef S_IFLNK
! 1289: - if ((ms->flags & MAGIC_SYMLINK) == 0)
! 1290: - ret = lstat(fn, sb);
! 1291: - else
! 1292: -#endif
! 1293: - ret = stat(fn, sb); /* don't merge into if; see "ret =" above */
! 1294: -
! 1295: - if (ret) {
! 1296: - if (ms->flags & MAGIC_ERROR) {
! 1297: - file_error(ms, errno, "cannot stat `%s'", fn);
! 1298: - return -1;
! 1299: + if (stream) {
! 1300: + php_stream_statbuf ssb;
! 1301: + if (php_stream_stat(stream, &ssb) < 0) {
! 1302: + if (ms->flags & MAGIC_ERROR) {
! 1303: + file_error(ms, errno, "cannot stat `%s'", fn);
! 1304: + return -1;
! 1305: + }
! 1306: + return 1;
! 1307: + }
! 1308: + memcpy(sb, &ssb.sb, sizeof(struct stat));
! 1309: + } else {
! 1310: + if (php_sys_stat(fn, sb) != 0) {
! 1311: + if (ms->flags & MAGIC_ERROR) {
! 1312: + file_error(ms, errno, "cannot stat `%s'", fn);
! 1313: + return -1;
! 1314: + }
! 1315: + return 1;
! 1316: }
! 1317: - if (file_printf(ms, "cannot open `%s' (%s)",
! 1318: - fn, strerror(errno)) == -1)
! 1319: - return -1;
! 1320: - return 1;
! 1321: }
! 1322:
! 1323: if (!mime) {
! 1324: @@ -154,172 +139,75 @@
! 1325: return -1;
! 1326: #endif
! 1327: }
! 1328: -
! 1329: +
! 1330: switch (sb->st_mode & S_IFMT) {
! 1331: - case S_IFDIR:
! 1332: - if (mime) {
! 1333: - if (handle_mime(ms, mime, "x-directory") == -1)
! 1334: - return -1;
! 1335: - } else if (file_printf(ms, "directory") == -1)
! 1336: - return -1;
! 1337: - return 1;
! 1338: -#ifdef S_IFCHR
! 1339: - case S_IFCHR:
! 1340: - /*
! 1341: - * If -s has been specified, treat character special files
! 1342: - * like ordinary files. Otherwise, just report that they
! 1343: - * are block special files and go on to the next file.
! 1344: - */
! 1345: - if ((ms->flags & MAGIC_DEVICES) != 0)
! 1346: - break;
! 1347: - if (mime) {
! 1348: - if (handle_mime(ms, mime, "x-character-device") == -1)
! 1349: - return -1;
! 1350: - } else {
! 1351: -#ifdef HAVE_STAT_ST_RDEV
! 1352: -# ifdef dv_unit
! 1353: - if (file_printf(ms, "character special (%d/%d/%d)",
! 1354: - major(sb->st_rdev), dv_unit(sb->st_rdev),
! 1355: - dv_subunit(sb->st_rdev)) == -1)
! 1356: - return -1;
! 1357: -# else
! 1358: - if (file_printf(ms, "character special (%ld/%ld)",
! 1359: - (long)major(sb->st_rdev), (long)minor(sb->st_rdev))
! 1360: - == -1)
! 1361: - return -1;
! 1362: -# endif
! 1363: -#else
! 1364: - if (file_printf(ms, "character special") == -1)
! 1365: - return -1;
! 1366: -#endif
! 1367: - }
! 1368: - return 1;
! 1369: -#endif
! 1370: -#ifdef S_IFBLK
! 1371: - case S_IFBLK:
! 1372: - /*
! 1373: - * If -s has been specified, treat block special files
! 1374: - * like ordinary files. Otherwise, just report that they
! 1375: - * are block special files and go on to the next file.
! 1376: - */
! 1377: - if ((ms->flags & MAGIC_DEVICES) != 0)
! 1378: - break;
! 1379: - if (mime) {
! 1380: - if (handle_mime(ms, mime, "x-block-device") == -1)
! 1381: - return -1;
! 1382: - } else {
! 1383: -#ifdef HAVE_STAT_ST_RDEV
! 1384: -# ifdef dv_unit
! 1385: - if (file_printf(ms, "block special (%d/%d/%d)",
! 1386: - major(sb->st_rdev), dv_unit(sb->st_rdev),
! 1387: - dv_subunit(sb->st_rdev)) == -1)
! 1388: - return -1;
! 1389: -# else
! 1390: - if (file_printf(ms, "block special (%ld/%ld)",
! 1391: - (long)major(sb->st_rdev), (long)minor(sb->st_rdev)) == -1)
! 1392: - return -1;
! 1393: -# endif
! 1394: -#else
! 1395: - if (file_printf(ms, "block special") == -1)
! 1396: - return -1;
! 1397: -#endif
! 1398: - }
! 1399: - return 1;
! 1400: -#endif
! 1401: - /* TODO add code to handle V7 MUX and Blit MUX files */
! 1402: -#ifdef S_IFIFO
! 1403: - case S_IFIFO:
! 1404: - if((ms->flags & MAGIC_DEVICES) != 0)
! 1405: - break;
! 1406: - if (mime) {
! 1407: - if (handle_mime(ms, mime, "x-fifo") == -1)
! 1408: - return -1;
! 1409: - } else if (file_printf(ms, "fifo (named pipe)") == -1)
! 1410: - return -1;
! 1411: - return 1;
! 1412: -#endif
! 1413: -#ifdef S_IFDOOR
! 1414: - case S_IFDOOR:
! 1415: - if (mime) {
! 1416: - if (handle_mime(ms, mime, "x-door") == -1)
! 1417: - return -1;
! 1418: - } else if (file_printf(ms, "door") == -1)
! 1419: - return -1;
! 1420: - return 1;
! 1421: -#endif
! 1422: -#ifdef S_IFLNK
! 1423: - case S_IFLNK:
! 1424: - if ((nch = readlink(fn, buf, BUFSIZ-1)) <= 0) {
! 1425: - if (ms->flags & MAGIC_ERROR) {
! 1426: - file_error(ms, errno, "unreadable symlink `%s'",
! 1427: - fn);
! 1428: - return -1;
! 1429: +#ifndef PHP_WIN32
! 1430: +# ifdef S_IFCHR
! 1431: + case S_IFCHR:
! 1432: + /*
! 1433: + * If -s has been specified, treat character special files
! 1434: + * like ordinary files. Otherwise, just report that they
! 1435: + * are block special files and go on to the next file.
! 1436: + */
! 1437: + if ((ms->flags & MAGIC_DEVICES) != 0) {
! 1438: + break;
! 1439: }
! 1440: if (mime) {
! 1441: - if (handle_mime(ms, mime, "x-symlink") == -1)
! 1442: + if (handle_mime(ms, mime, "x-character-device") == -1)
! 1443: return -1;
! 1444: - } else if (file_printf(ms,
! 1445: - "unreadable symlink `%s' (%s)", fn,
! 1446: - strerror(errno)) == -1)
! 1447: - return -1;
! 1448: + } else {
! 1449: +# ifdef HAVE_STAT_ST_RDEV
! 1450: +# ifdef dv_unit
! 1451: + if (file_printf(ms, "character special (%d/%d/%d)",
! 1452: + major(sb->st_rdev), dv_unit(sb->st_rdev),
! 1453: + dv_subunit(sb->st_rdev)) == -1)
! 1454: + return -1;
! 1455: +# else
! 1456: + if (file_printf(ms, "character special (%ld/%ld)",
! 1457: + (long)major(sb->st_rdev), (long)minor(sb->st_rdev))
! 1458: + == -1)
! 1459: + return -1;
! 1460: +# endif
! 1461: +# else
! 1462: + if (file_printf(ms, "character special") == -1)
! 1463: + return -1;
! 1464: +# endif
! 1465: + }
! 1466: return 1;
! 1467: - }
! 1468: - buf[nch] = '\0'; /* readlink(2) does not do this */
! 1469: -
! 1470: - /* If broken symlink, say so and quit early. */
! 1471: - if (*buf == '/') {
! 1472: - if (stat(buf, &tstatbuf) < 0)
! 1473: - return bad_link(ms, errno, buf);
! 1474: - } else {
! 1475: - char *tmp;
! 1476: - char buf2[BUFSIZ+BUFSIZ+4];
! 1477: +# endif
! 1478: +#endif
! 1479:
! 1480: - if ((tmp = strrchr(fn, '/')) == NULL) {
! 1481: - tmp = buf; /* in current directory anyway */
! 1482: - } else {
! 1483: - if (tmp - fn + 1 > BUFSIZ) {
! 1484: - if (ms->flags & MAGIC_ERROR) {
! 1485: - file_error(ms, 0,
! 1486: - "path too long: `%s'", buf);
! 1487: +#ifdef S_IFIFO
! 1488: + case S_IFIFO:
! 1489: + if((ms->flags & MAGIC_DEVICES) != 0)
! 1490: + break;
! 1491: + if (mime) {
! 1492: + if (handle_mime(ms, mime, "x-fifo") == -1)
! 1493: return -1;
! 1494: - }
! 1495: + } else if (file_printf(ms, "fifo (named pipe)") == -1)
! 1496: + return -1;
! 1497: + return 1;
! 1498: +#endif
! 1499: +#ifdef S_IFDOOR
! 1500: + case S_IFDOOR:
! 1501: if (mime) {
! 1502: - if (handle_mime(ms, mime,
! 1503: - "x-path-too-long") == -1)
! 1504: + if (handle_mime(ms, mime, "x-door") == -1)
! 1505: return -1;
! 1506: - } else if (file_printf(ms,
! 1507: - "path too long: `%s'", fn) == -1)
! 1508: + } else if (file_printf(ms, "door") == -1)
! 1509: return -1;
! 1510: return 1;
! 1511: - }
! 1512: - /* take dir part */
! 1513: - (void)strlcpy(buf2, fn, sizeof buf2);
! 1514: - buf2[tmp - fn + 1] = '\0';
! 1515: - /* plus (rel) link */
! 1516: - (void)strlcat(buf2, buf, sizeof buf2);
! 1517: - tmp = buf2;
! 1518: - }
! 1519: - if (stat(tmp, &tstatbuf) < 0)
! 1520: - return bad_link(ms, errno, buf);
! 1521: - }
! 1522: +#endif
! 1523:
! 1524: - /* Otherwise, handle it. */
! 1525: - if ((ms->flags & MAGIC_SYMLINK) != 0) {
! 1526: - const char *p;
! 1527: - ms->flags &= MAGIC_SYMLINK;
! 1528: - p = magic_file(ms, buf);
! 1529: - ms->flags |= MAGIC_SYMLINK;
! 1530: - return p != NULL ? 1 : -1;
! 1531: - } else { /* just print what it points to */
! 1532: - if (mime) {
! 1533: - if (handle_mime(ms, mime, "x-symlink") == -1)
! 1534: - return -1;
! 1535: - } else if (file_printf(ms, "symbolic link to `%s'",
! 1536: - buf) == -1)
! 1537: - return -1;
! 1538: - }
! 1539: - return 1;
! 1540: +#ifdef S_IFLNK
! 1541: + case S_IFLNK:
! 1542: + /* stat is used, if it made here then the link is broken */
! 1543: + if (ms->flags & MAGIC_ERROR) {
! 1544: + file_error(ms, errno, "unreadable symlink `%s'", fn);
! 1545: + return -1;
! 1546: + }
! 1547: + return 1;
! 1548: #endif
! 1549: +
! 1550: #ifdef S_IFSOCK
! 1551: #ifndef __COHERENT__
! 1552: case S_IFSOCK:
! 1553: @@ -331,12 +219,14 @@
! 1554: return 1;
! 1555: #endif
! 1556: #endif
! 1557: - case S_IFREG:
! 1558: - break;
! 1559: - default:
! 1560: - file_error(ms, 0, "invalid mode 0%o", sb->st_mode);
! 1561: - return -1;
! 1562: - /*NOTREACHED*/
! 1563: +
! 1564: + case S_IFREG:
! 1565: + break;
! 1566: +
! 1567: + default:
! 1568: + file_error(ms, 0, "invalid mode 0%o", sb->st_mode);
! 1569: + return -1;
! 1570: + /*NOTREACHED*/
! 1571: }
! 1572:
! 1573: /*
! 1574: diff -u libmagic.orig/funcs.c libmagic/funcs.c
! 1575: --- libmagic.orig/funcs.c 2011-09-15 23:28:13.000000000 +0800
! 1576: +++ libmagic/funcs.c 2011-09-15 23:28:26.000000000 +0800
! 1577: @@ -41,52 +41,36 @@
! 1578: #if defined(HAVE_WCTYPE_H)
! 1579: #include <wctype.h>
! 1580: #endif
! 1581: -#if defined(HAVE_LIMITS_H)
! 1582: -#include <limits.h>
! 1583: -#endif
! 1584:
! 1585: -#ifndef SIZE_MAX
! 1586: -#define SIZE_MAX ((size_t)~0)
! 1587: +#ifndef SIZE_MAX
! 1588: +# define SIZE_MAX ((size_t) -1)
! 1589: #endif
! 1590:
! 1591: /*
! 1592: * Like printf, only we append to a buffer.
! 1593: */
! 1594: protected int
! 1595: -file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
! 1596: +file_printf(struct magic_set *ms, const char *fmt, ...)
! 1597: {
! 1598: + va_list ap;
! 1599: int len;
! 1600: - char *buf, *newstr;
! 1601: + char *buf = NULL, *newstr;
! 1602:
! 1603: - len = vasprintf(&buf, fmt, ap);
! 1604: - if (len < 0)
! 1605: - goto out;
! 1606: + va_start(ap, fmt);
! 1607: + len = vspprintf(&buf, 0, fmt, ap);
! 1608: + va_end(ap);
! 1609:
! 1610: if (ms->o.buf != NULL) {
! 1611: - len = asprintf(&newstr, "%s%s", ms->o.buf, buf);
! 1612: - free(buf);
! 1613: - if (len < 0)
! 1614: - goto out;
! 1615: - free(ms->o.buf);
! 1616: - buf = newstr;
! 1617: + len = spprintf(&newstr, 0, "%s%s", ms->o.buf, (buf ? buf : ""));
! 1618: + if (buf) {
! 1619: + efree(buf);
! 1620: + }
! 1621: + efree(ms->o.buf);
! 1622: + ms->o.buf = newstr;
! 1623: + } else {
! 1624: + ms->o.buf = buf;
! 1625: }
! 1626: - ms->o.buf = buf;
! 1627: return 0;
! 1628: -out:
! 1629: - file_error(ms, errno, "vasprintf failed");
! 1630: - return -1;
! 1631: -}
! 1632: -
! 1633: -protected int
! 1634: -file_printf(struct magic_set *ms, const char *fmt, ...)
! 1635: -{
! 1636: - int rv;
! 1637: - va_list ap;
! 1638: -
! 1639: - va_start(ap, fmt);
! 1640: - rv = file_vprintf(ms, fmt, ap);
! 1641: - va_end(ap);
! 1642: - return rv;
! 1643: }
! 1644:
! 1645: /*
! 1646: @@ -97,17 +81,32 @@
! 1647: file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
! 1648: uint32_t lineno)
! 1649: {
! 1650: + char *buf = NULL;
! 1651: +
! 1652: /* Only the first error is ok */
! 1653: - if (ms->event_flags & EVENT_HAD_ERR)
! 1654: + if (ms->event_flags & EVENT_HAD_ERR) {
! 1655: return;
! 1656: + }
! 1657: +
! 1658: if (lineno != 0) {
! 1659: - free(ms->o.buf);
! 1660: + efree(ms->o.buf);
! 1661: ms->o.buf = NULL;
! 1662: file_printf(ms, "line %u: ", lineno);
! 1663: }
! 1664: - file_vprintf(ms, f, va);
! 1665: - if (error > 0)
! 1666: - file_printf(ms, " (%s)", strerror(error));
! 1667: +
! 1668: + vspprintf(&buf, 0, f, va);
! 1669: + va_end(va);
! 1670: +
! 1671: + if (error > 0) {
! 1672: + file_printf(ms, "%s (%s)", (*buf ? buf : ""), strerror(error));
! 1673: + } else if (*buf) {
! 1674: + file_printf(ms, "%s", buf);
! 1675: + }
! 1676: +
! 1677: + if (buf) {
! 1678: + efree(buf);
! 1679: + }
! 1680: +
! 1681: ms->event_flags |= EVENT_HAD_ERR;
! 1682: ms->error = error;
! 1683: }
! 1684: @@ -153,14 +152,13 @@
! 1685: file_error(ms, errno, "error reading");
! 1686: }
! 1687:
! 1688: -#ifndef COMPILE_ONLY
! 1689: protected int
! 1690: -file_buffer(struct magic_set *ms, int fd, const char *inname, const void *buf,
! 1691: +file_buffer(struct magic_set *ms, php_stream *stream, const char *inname, const void *buf,
! 1692: size_t nb)
! 1693: {
! 1694: int m = 0, rv = 0, looks_text = 0;
! 1695: int mime = ms->flags & MAGIC_MIME;
! 1696: - const unsigned char *ubuf = CAST(const unsigned char *, buf);
! 1697: + const unsigned char *ubuf = buf;
! 1698: unichar *u8buf = NULL;
! 1699: size_t ulen;
! 1700: const char *code = NULL;
! 1701: @@ -188,7 +186,7 @@
! 1702: &code, &code_mime, &type);
! 1703: }
! 1704:
! 1705: -#ifdef __EMX__
! 1706: +#if defined(__EMX__)
! 1707: if ((ms->flags & MAGIC_NO_CHECK_APPTYPE) == 0 && inname) {
! 1708: switch (file_os2_apptype(ms, inname, buf, nb)) {
! 1709: case -1:
! 1710: @@ -201,13 +199,14 @@
! 1711: }
! 1712: #endif
! 1713:
! 1714: - /* try compression stuff */
! 1715: +#if PHP_FILEINFO_UNCOMPRESS
! 1716: if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) == 0)
! 1717: - if ((m = file_zmagic(ms, fd, inname, ubuf, nb)) != 0) {
! 1718: + if ((m = file_zmagic(ms, stream, inname, ubuf, nb)) != 0) {
! 1719: if ((ms->flags & MAGIC_DEBUG) != 0)
! 1720: (void)fprintf(stderr, "zmagic %d\n", m);
! 1721: goto done;
! 1722: - }
! 1723: + }
! 1724: +#endif
! 1725:
! 1726: /* Check if we have a tar file */
! 1727: if ((ms->flags & MAGIC_NO_CHECK_TAR) == 0)
! 1728: @@ -218,12 +217,17 @@
! 1729: }
! 1730:
! 1731: /* Check if we have a CDF file */
! 1732: - if ((ms->flags & MAGIC_NO_CHECK_CDF) == 0)
! 1733: - if ((m = file_trycdf(ms, fd, ubuf, nb)) != 0) {
! 1734: - if ((ms->flags & MAGIC_DEBUG) != 0)
! 1735: - (void)fprintf(stderr, "cdf %d\n", m);
! 1736: - goto done;
! 1737: + if ((ms->flags & MAGIC_NO_CHECK_CDF) == 0) {
! 1738: + int fd;
! 1739: + TSRMLS_FETCH();
! 1740: + if (stream && SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&fd, 0)) {
! 1741: + if ((m = file_trycdf(ms, fd, ubuf, nb)) != 0) {
! 1742: + if ((ms->flags & MAGIC_DEBUG) != 0)
! 1743: + (void)fprintf(stderr, "cdf %d\n", m);
! 1744: + goto done;
! 1745: + }
! 1746: }
! 1747: + }
! 1748:
! 1749: /* try soft magic tests */
! 1750: if ((ms->flags & MAGIC_NO_CHECK_SOFT) == 0)
! 1751: @@ -294,7 +298,6 @@
! 1752:
! 1753: return m;
! 1754: }
! 1755: -#endif
! 1756:
! 1757: protected int
! 1758: file_reset(struct magic_set *ms)
! 1759: @@ -304,11 +307,11 @@
! 1760: return -1;
! 1761: }
! 1762: if (ms->o.buf) {
! 1763: - free(ms->o.buf);
! 1764: + efree(ms->o.buf);
! 1765: ms->o.buf = NULL;
! 1766: }
! 1767: if (ms->o.pbuf) {
! 1768: - free(ms->o.pbuf);
! 1769: + efree(ms->o.pbuf);
! 1770: ms->o.pbuf = NULL;
! 1771: }
! 1772: ms->event_flags &= ~EVENT_HAD_ERR;
! 1773: @@ -342,14 +345,10 @@
! 1774: /* * 4 is for octal representation, + 1 is for NUL */
! 1775: len = strlen(ms->o.buf);
! 1776: if (len > (SIZE_MAX - 1) / 4) {
! 1777: - file_oomem(ms, len);
! 1778: return NULL;
! 1779: }
! 1780: psize = len * 4 + 1;
! 1781: - if ((pbuf = CAST(char *, realloc(ms->o.pbuf, psize))) == NULL) {
! 1782: - file_oomem(ms, psize);
! 1783: - return NULL;
! 1784: - }
! 1785: + pbuf = erealloc(ms->o.pbuf, psize);
! 1786: ms->o.pbuf = pbuf;
! 1787:
! 1788: #if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
! 1789: @@ -409,13 +408,7 @@
! 1790:
! 1791: if (level >= ms->c.len) {
! 1792: len = (ms->c.len += 20) * sizeof(*ms->c.li);
! 1793: - ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
! 1794: - malloc(len) :
! 1795: - realloc(ms->c.li, len));
! 1796: - if (ms->c.li == NULL) {
! 1797: - file_oomem(ms, len);
! 1798: - return -1;
! 1799: - }
! 1800: + ms->c.li = (ms->c.li == NULL) ? emalloc(len) : erealloc(ms->c.li, len);
! 1801: }
! 1802: ms->c.li[level].got_match = 0;
! 1803: #ifdef ENABLE_CONDITIONALS
! 1804: diff -u libmagic.orig/magic.c libmagic/magic.c
! 1805: --- libmagic.orig/magic.c 2011-09-15 23:28:13.000000000 +0800
! 1806: +++ libmagic/magic.c 2011-09-15 23:29:29.000000000 +0800
! 1807: @@ -34,14 +34,19 @@
! 1808: #include "magic.h"
! 1809:
! 1810: #include <stdlib.h>
! 1811: +#ifdef PHP_WIN32
! 1812: +#include "win32/unistd.h"
! 1813: +#else
! 1814: #include <unistd.h>
! 1815: +#endif
! 1816: #include <string.h>
! 1817: -#ifdef QUICK
! 1818: -#include <sys/mman.h>
! 1819: +#ifdef PHP_WIN32
! 1820: +# include "config.w32.h"
! 1821: +#else
! 1822: +# include "php_config.h"
! 1823: #endif
! 1824: -#ifdef HAVE_LIMITS_H
! 1825: +
! 1826: #include <limits.h> /* for PIPE_BUF */
! 1827: -#endif
! 1828:
! 1829: #if defined(HAVE_UTIMES)
! 1830: # include <sys/time.h>
! 1831: @@ -57,7 +62,9 @@
! 1832: #include <unistd.h> /* for read() */
! 1833: #endif
! 1834:
! 1835: -#include <netinet/in.h> /* for byte swapping */
! 1836: +#ifndef PHP_WIN32
! 1837: +# include <netinet/in.h> /* for byte swapping */
! 1838: +#endif
! 1839:
! 1840: #include "patchlevel.h"
! 1841:
! 1842: @@ -70,13 +77,16 @@
! 1843: #endif
! 1844: #endif
! 1845:
! 1846: +#ifdef PHP_WIN32
! 1847: +# undef S_IFLNK
! 1848: +# undef S_IFIFO
! 1849: +#endif
! 1850: +
! 1851: private void free_mlist(struct mlist *);
! 1852: private void close_and_restore(const struct magic_set *, const char *, int,
! 1853: const struct stat *);
! 1854: private int unreadable_info(struct magic_set *, mode_t, const char *);
! 1855: -#ifndef COMPILE_ONLY
! 1856: -private const char *file_or_fd(struct magic_set *, const char *, int);
! 1857: -#endif
! 1858: +private const char *file_or_stream(struct magic_set *, const char *, php_stream *);
! 1859:
! 1860: #ifndef STDIN_FILENO
! 1861: #define STDIN_FILENO 0
! 1862: @@ -86,11 +96,8 @@
! 1863: magic_open(int flags)
! 1864: {
! 1865: struct magic_set *ms;
! 1866: - size_t len;
! 1867:
! 1868: - if ((ms = CAST(magic_set *, calloc((size_t)1,
! 1869: - sizeof(struct magic_set)))) == NULL)
! 1870: - return NULL;
! 1871: + ms = ecalloc((size_t)1, sizeof(struct magic_set));
! 1872:
! 1873: if (magic_setflags(ms, flags) == -1) {
! 1874: errno = EINVAL;
! 1875: @@ -98,11 +105,9 @@
! 1876: }
! 1877:
! 1878: ms->o.buf = ms->o.pbuf = NULL;
! 1879: - len = (ms->c.len = 10) * sizeof(*ms->c.li);
! 1880: -
! 1881: - if ((ms->c.li = CAST(struct level_info *, malloc(len))) == NULL)
! 1882: - goto free;
! 1883:
! 1884: + ms->c.li = emalloc((ms->c.len = 10) * sizeof(*ms->c.li));
! 1885: +
! 1886: ms->event_flags = 0;
! 1887: ms->error = -1;
! 1888: ms->mlist = NULL;
! 1889: @@ -110,7 +115,7 @@
! 1890: ms->line = 0;
! 1891: return ms;
! 1892: free:
! 1893: - free(ms);
! 1894: + efree(ms);
! 1895: return NULL;
! 1896: }
! 1897:
! 1898: @@ -126,10 +131,10 @@
! 1899: struct mlist *next = ml->next;
! 1900: struct magic *mg = ml->magic;
! 1901: file_delmagic(mg, ml->mapped, ml->nmagic);
! 1902: - free(ml);
! 1903: + efree(ml);
! 1904: ml = next;
! 1905: }
! 1906: - free(ml);
! 1907: + efree(ml);
! 1908: }
! 1909:
! 1910: private int
! 1911: @@ -153,11 +158,19 @@
! 1912: public void
! 1913: magic_close(struct magic_set *ms)
! 1914: {
! 1915: - free_mlist(ms->mlist);
! 1916: - free(ms->o.pbuf);
! 1917: - free(ms->o.buf);
! 1918: - free(ms->c.li);
! 1919: - free(ms);
! 1920: + if (ms->mlist) {
! 1921: + free_mlist(ms->mlist);
! 1922: + }
! 1923: + if (ms->o.pbuf) {
! 1924: + efree(ms->o.pbuf);
! 1925: + }
! 1926: + if (ms->o.buf) {
! 1927: + efree(ms->o.buf);
! 1928: + }
! 1929: + if (ms->c.li) {
! 1930: + efree(ms->c.li);
! 1931: + }
! 1932: + efree(ms);
! 1933: }
! 1934:
! 1935: /*
! 1936: @@ -183,21 +196,10 @@
! 1937: return ml ? 0 : -1;
! 1938: }
! 1939:
! 1940: -public int
! 1941: -magic_check(struct magic_set *ms, const char *magicfile)
! 1942: -{
! 1943: - struct mlist *ml = file_apprentice(ms, magicfile, FILE_CHECK);
! 1944: - free_mlist(ml);
! 1945: - return ml ? 0 : -1;
! 1946: -}
! 1947: -
! 1948: private void
! 1949: close_and_restore(const struct magic_set *ms, const char *name, int fd,
! 1950: const struct stat *sb)
! 1951: {
! 1952: - if (fd == STDIN_FILENO)
! 1953: - return;
! 1954: - (void) close(fd);
! 1955:
! 1956: if ((ms->flags & MAGIC_PRESERVE_ATIME) != 0) {
! 1957: /*
! 1958: @@ -224,7 +226,6 @@
! 1959: }
! 1960: }
! 1961:
! 1962: -#ifndef COMPILE_ONLY
! 1963:
! 1964: /*
! 1965: * find type of descriptor
! 1966: @@ -232,7 +233,7 @@
! 1967: public const char *
! 1968: magic_descriptor(struct magic_set *ms, int fd)
! 1969: {
! 1970: - return file_or_fd(ms, NULL, fd);
! 1971: + return file_or_stream(ms, NULL, NULL);
! 1972: }
! 1973:
! 1974: /*
! 1975: @@ -241,103 +242,95 @@
! 1976: public const char *
! 1977: magic_file(struct magic_set *ms, const char *inname)
! 1978: {
! 1979: - return file_or_fd(ms, inname, STDIN_FILENO);
! 1980: + return file_or_stream(ms, inname, NULL);
! 1981: +}
! 1982: +
! 1983: +public const char *
! 1984: +magic_stream(struct magic_set *ms, php_stream *stream)
! 1985: +{
! 1986: + return file_or_stream(ms, NULL, stream);
! 1987: }
! 1988:
! 1989: private const char *
! 1990: -file_or_fd(struct magic_set *ms, const char *inname, int fd)
! 1991: +file_or_stream(struct magic_set *ms, const char *inname, php_stream *stream)
! 1992: {
! 1993: int rv = -1;
! 1994: unsigned char *buf;
! 1995: struct stat sb;
! 1996: ssize_t nbytes = 0; /* number of bytes read from a datafile */
! 1997: - int ispipe = 0;
! 1998: + int no_in_stream = 0;
! 1999: + TSRMLS_FETCH();
! 2000: +
! 2001: + if (!inname && !stream) {
! 2002: + return NULL;
! 2003: + }
! 2004:
! 2005: /*
! 2006: * one extra for terminating '\0', and
! 2007: * some overlapping space for matches near EOF
! 2008: */
! 2009: #define SLOP (1 + sizeof(union VALUETYPE))
! 2010: - if ((buf = CAST(unsigned char *, malloc(HOWMANY + SLOP))) == NULL)
! 2011: - return NULL;
! 2012: + buf = emalloc(HOWMANY + SLOP);
! 2013:
! 2014: - if (file_reset(ms) == -1)
! 2015: + if (file_reset(ms) == -1) {
! 2016: goto done;
! 2017: + }
! 2018:
! 2019: - switch (file_fsmagic(ms, inname, &sb)) {
! 2020: - case -1: /* error */
! 2021: - goto done;
! 2022: - case 0: /* nothing found */
! 2023: - break;
! 2024: - default: /* matched it and printed type */
! 2025: + switch (file_fsmagic(ms, inname, &sb, stream)) {
! 2026: + case -1: /* error */
! 2027: + goto done;
! 2028: + case 0: /* nothing found */
! 2029: + break;
! 2030: + default: /* matched it and printed type */
! 2031: + rv = 0;
! 2032: + goto done;
! 2033: + }
! 2034: +
! 2035: + errno = 0;
! 2036: +
! 2037: + if (!stream && inname) {
! 2038: + no_in_stream = 1;
! 2039: +#if PHP_API_VERSION < 20100412
! 2040: + stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
! 2041: +#else
! 2042: + stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS, NULL);
! 2043: +#endif
! 2044: + }
! 2045: +
! 2046: + if (!stream) {
! 2047: + if (unreadable_info(ms, sb.st_mode, inname) == -1)
! 2048: + goto done;
! 2049: rv = 0;
! 2050: goto done;
! 2051: }
! 2052:
! 2053: - if (inname == NULL) {
! 2054: - if (fstat(fd, &sb) == 0 && S_ISFIFO(sb.st_mode))
! 2055: - ispipe = 1;
! 2056: - } else {
! 2057: - int flags = O_RDONLY|O_BINARY;
! 2058: -
! 2059: - if (stat(inname, &sb) == 0 && S_ISFIFO(sb.st_mode)) {
! 2060: - flags |= O_NONBLOCK;
! 2061: - ispipe = 1;
! 2062: - }
! 2063: -
! 2064: - errno = 0;
! 2065: - if ((fd = open(inname, flags)) < 0) {
! 2066: - if (unreadable_info(ms, sb.st_mode, inname) == -1)
! 2067: - goto done;
! 2068: - rv = 0;
! 2069: - goto done;
! 2070: - }
! 2071: #ifdef O_NONBLOCK
! 2072: - if ((flags = fcntl(fd, F_GETFL)) != -1) {
! 2073: - flags &= ~O_NONBLOCK;
! 2074: - (void)fcntl(fd, F_SETFL, flags);
! 2075: - }
! 2076: +/* we should be already be in non blocking mode for network socket */
! 2077: #endif
! 2078: - }
! 2079:
! 2080: /*
! 2081: * try looking at the first HOWMANY bytes
! 2082: */
! 2083: - if (ispipe) {
! 2084: - ssize_t r = 0;
! 2085: -
! 2086: - while ((r = sread(fd, (void *)&buf[nbytes],
! 2087: - (size_t)(HOWMANY - nbytes), 1)) > 0) {
! 2088: - nbytes += r;
! 2089: - if (r < PIPE_BUF) break;
! 2090: - }
! 2091: -
! 2092: - if (nbytes == 0) {
! 2093: - /* We can not read it, but we were able to stat it. */
! 2094: - if (unreadable_info(ms, sb.st_mode, inname) == -1)
! 2095: - goto done;
! 2096: - rv = 0;
! 2097: - goto done;
! 2098: - }
! 2099: -
! 2100: - } else {
! 2101: - if ((nbytes = read(fd, (char *)buf, HOWMANY)) == -1) {
! 2102: - file_error(ms, errno, "cannot read `%s'", inname);
! 2103: - goto done;
! 2104: - }
! 2105: + if ((nbytes = php_stream_read(stream, (char *)buf, HOWMANY)) < 0) {
! 2106: + file_error(ms, errno, "cannot read `%s'", inname);
! 2107: + goto done;
! 2108: }
! 2109:
! 2110: (void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
! 2111: - if (file_buffer(ms, fd, inname, buf, (size_t)nbytes) == -1)
! 2112: + if (file_buffer(ms, stream, inname, buf, (size_t)nbytes) == -1)
! 2113: goto done;
! 2114: rv = 0;
! 2115: done:
! 2116: - free(buf);
! 2117: - close_and_restore(ms, inname, fd, &sb);
! 2118: + efree(buf);
! 2119: +
! 2120: + if (no_in_stream && stream) {
! 2121: + php_stream_close(stream);
! 2122: + }
! 2123: +
! 2124: + close_and_restore(ms, inname, 0, &sb);
! 2125: return rv == 0 ? file_getbuffer(ms) : NULL;
! 2126: }
! 2127:
! 2128: -
! 2129: public const char *
! 2130: magic_buffer(struct magic_set *ms, const void *buf, size_t nb)
! 2131: {
! 2132: @@ -345,14 +338,13 @@
! 2133: return NULL;
! 2134: /*
! 2135: * The main work is done here!
! 2136: - * We have the file name and/or the data buffer to be identified.
! 2137: + * We have the file name and/or the data buffer to be identified.
! 2138: */
! 2139: - if (file_buffer(ms, -1, NULL, buf, nb) == -1) {
! 2140: + if (file_buffer(ms, NULL, NULL, buf, nb) == -1) {
! 2141: return NULL;
! 2142: }
! 2143: return file_getbuffer(ms);
! 2144: }
! 2145: -#endif
! 2146:
! 2147: public const char *
! 2148: magic_error(struct magic_set *ms)
! 2149: diff -u libmagic.orig/magic.h libmagic/magic.h
! 2150: --- libmagic.orig/magic.h 2011-09-15 23:28:13.000000000 +0800
! 2151: +++ libmagic/magic.h 2011-09-15 23:28:26.000000000 +0800
! 2152: @@ -70,6 +70,7 @@
! 2153: void magic_close(magic_t);
! 2154:
! 2155: const char *magic_file(magic_t, const char *);
! 2156: +const char *magic_stream(magic_t, php_stream *);
! 2157: const char *magic_descriptor(magic_t, int);
! 2158: const char *magic_buffer(magic_t, const void *, size_t);
! 2159:
! 2160: @@ -78,7 +79,6 @@
! 2161:
! 2162: int magic_load(magic_t, const char *);
! 2163: int magic_compile(magic_t, const char *);
! 2164: -int magic_check(magic_t, const char *);
! 2165: int magic_errno(magic_t);
! 2166:
! 2167: #ifdef __cplusplus
! 2168: diff -u libmagic.orig/patchlevel.h libmagic/patchlevel.h
! 2169: --- libmagic.orig/patchlevel.h 2011-09-15 23:28:13.000000000 +0800
! 2170: +++ libmagic/patchlevel.h 2011-09-15 23:28:26.000000000 +0800
! 2171: @@ -3,23 +3,23 @@
! 2172:
! 2173: /*
! 2174: * Patchlevel file for Ian Darwin's MAGIC command.
! 2175: - * $File: patchlevel.h,v 1.74 2009/05/06 20:32:48 christos Exp $
! 2176: + * $File: patchlevel.h,v 1.68 2008/03/22 21:39:43 christos Exp $
! 2177: *
! 2178: - * $Log: patchlevel.h,v $
! 2179: - * Revision 1.74 2009/05/06 20:32:48 christos
! 2180: - * welcome to 5.03
! 2181: + * $Log$
! 2182: + * Revision 1.4 2009/05/04 20:52:43 scottmac
! 2183: + * Update libmagic to 5.02
! 2184: *
! 2185: - * Revision 1.73 2009/05/04 15:15:13 christos
! 2186: - * 5.02...
! 2187: + * Revision 1.3 2009/03/15 23:02:35 scottmac
! 2188: + * Update fileinfo to libmagic 5.00 and remove dependency on dirent.h on Windows
! 2189: *
! 2190: - * Revision 1.72 2009/04/30 21:20:15 christos
! 2191: - * 5.01 we are almost here.
! 2192: + * Revision 1.2 2008/11/02 16:09:27 scottmac
! 2193: + * Update libmagic to 4.26 and add support for v6 of the magic file format.
! 2194: *
! 2195: - * Revision 1.71 2009/01/21 19:09:42 christos
! 2196: - * file 5.0
! 2197: + * Revision 1.1 2008/07/11 14:13:50 derick
! 2198: + * - Move lib to libmagic
! 2199: *
! 2200: - * Revision 1.70 2008/08/30 10:01:01 christos
! 2201: - * file 4.26
! 2202: + * Revision 1.1 2008/07/11 14:10:50 derick
! 2203: + * - Step one for bundling the libmagic library. Some config.m4 issues left.
! 2204: *
! 2205: * Revision 1.69 2008/07/02 15:27:05 christos
! 2206: * welcome to 4.25
! 2207: diff -u libmagic.orig/print.c libmagic/print.c
! 2208: --- libmagic.orig/print.c 2011-09-15 23:28:13.000000000 +0800
! 2209: +++ libmagic/print.c 2011-09-15 23:29:29.000000000 +0800
! 2210: @@ -28,6 +28,8 @@
! 2211: /*
! 2212: * print.c - debugging printout routines
! 2213: */
! 2214: +#define _GNU_SOURCE
! 2215: +#include "php.h"
! 2216:
! 2217: #include "file.h"
! 2218:
! 2219: @@ -35,6 +37,7 @@
! 2220: FILE_RCSID("@(#)$File: print.c,v 1.66 2009/02/03 20:27:51 christos Exp $")
! 2221: #endif /* lint */
! 2222:
! 2223: +#include <stdio.h>
! 2224: #include <string.h>
! 2225: #include <stdarg.h>
! 2226: #include <stdlib.h>
! 2227: @@ -45,157 +48,21 @@
! 2228:
! 2229: #define SZOF(a) (sizeof(a) / sizeof(a[0]))
! 2230:
! 2231: -#ifndef COMPILE_ONLY
! 2232: -protected void
! 2233: -file_mdump(struct magic *m)
! 2234: -{
! 2235: - private const char optyp[] = { FILE_OPS };
! 2236: -
! 2237: - (void) fprintf(stderr, "[%u", m->lineno);
! 2238: - (void) fprintf(stderr, ">>>>>>>> %u" + 8 - (m->cont_level & 7),
! 2239: - m->offset);
! 2240: -
! 2241: - if (m->flag & INDIR) {
! 2242: - (void) fprintf(stderr, "(%s,",
! 2243: - /* Note: type is unsigned */
! 2244: - (m->in_type < file_nnames) ?
! 2245: - file_names[m->in_type] : "*bad*");
! 2246: - if (m->in_op & FILE_OPINVERSE)
! 2247: - (void) fputc('~', stderr);
! 2248: - (void) fprintf(stderr, "%c%u),",
! 2249: - ((size_t)(m->in_op & FILE_OPS_MASK) <
! 2250: - SZOF(optyp)) ?
! 2251: - optyp[m->in_op & FILE_OPS_MASK] : '?',
! 2252: - m->in_offset);
! 2253: - }
! 2254: - (void) fprintf(stderr, " %s%s", (m->flag & UNSIGNED) ? "u" : "",
! 2255: - /* Note: type is unsigned */
! 2256: - (m->type < file_nnames) ? file_names[m->type] : "*bad*");
! 2257: - if (m->mask_op & FILE_OPINVERSE)
! 2258: - (void) fputc('~', stderr);
! 2259: -
! 2260: - if (IS_STRING(m->type)) {
! 2261: - if (m->str_flags) {
! 2262: - (void) fputc('/', stderr);
! 2263: - if (m->str_flags & STRING_COMPACT_BLANK)
! 2264: - (void) fputc(CHAR_COMPACT_BLANK, stderr);
! 2265: - if (m->str_flags & STRING_COMPACT_OPTIONAL_BLANK)
! 2266: - (void) fputc(CHAR_COMPACT_OPTIONAL_BLANK,
! 2267: - stderr);
! 2268: - if (m->str_flags & STRING_IGNORE_LOWERCASE)
! 2269: - (void) fputc(CHAR_IGNORE_LOWERCASE, stderr);
! 2270: - if (m->str_flags & STRING_IGNORE_UPPERCASE)
! 2271: - (void) fputc(CHAR_IGNORE_UPPERCASE, stderr);
! 2272: - if (m->str_flags & REGEX_OFFSET_START)
! 2273: - (void) fputc(CHAR_REGEX_OFFSET_START, stderr);
! 2274: - }
! 2275: - if (m->str_range)
! 2276: - (void) fprintf(stderr, "/%u", m->str_range);
! 2277: - }
! 2278: - else {
! 2279: - if ((size_t)(m->mask_op & FILE_OPS_MASK) < SZOF(optyp))
! 2280: - (void) fputc(optyp[m->mask_op & FILE_OPS_MASK], stderr);
! 2281: - else
! 2282: - (void) fputc('?', stderr);
! 2283: -
! 2284: - if (m->num_mask) {
! 2285: - (void) fprintf(stderr, "%.8llx",
! 2286: - (unsigned long long)m->num_mask);
! 2287: - }
! 2288: - }
! 2289: - (void) fprintf(stderr, ",%c", m->reln);
! 2290: -
! 2291: - if (m->reln != 'x') {
! 2292: - switch (m->type) {
! 2293: - case FILE_BYTE:
! 2294: - case FILE_SHORT:
! 2295: - case FILE_LONG:
! 2296: - case FILE_LESHORT:
! 2297: - case FILE_LELONG:
! 2298: - case FILE_MELONG:
! 2299: - case FILE_BESHORT:
! 2300: - case FILE_BELONG:
! 2301: - (void) fprintf(stderr, "%d", m->value.l);
! 2302: - break;
! 2303: - case FILE_BEQUAD:
! 2304: - case FILE_LEQUAD:
! 2305: - case FILE_QUAD:
! 2306: - (void) fprintf(stderr, "%lld",
! 2307: - (unsigned long long)m->value.q);
! 2308: - break;
! 2309: - case FILE_PSTRING:
! 2310: - case FILE_STRING:
! 2311: - case FILE_REGEX:
! 2312: - case FILE_BESTRING16:
! 2313: - case FILE_LESTRING16:
! 2314: - case FILE_SEARCH:
! 2315: - file_showstr(stderr, m->value.s, (size_t)m->vallen);
! 2316: - break;
! 2317: - case FILE_DATE:
! 2318: - case FILE_LEDATE:
! 2319: - case FILE_BEDATE:
! 2320: - case FILE_MEDATE:
! 2321: - (void)fprintf(stderr, "%s,",
! 2322: - file_fmttime(m->value.l, 1));
! 2323: - break;
! 2324: - case FILE_LDATE:
! 2325: - case FILE_LELDATE:
! 2326: - case FILE_BELDATE:
! 2327: - case FILE_MELDATE:
! 2328: - (void)fprintf(stderr, "%s,",
! 2329: - file_fmttime(m->value.l, 0));
! 2330: - break;
! 2331: - case FILE_QDATE:
! 2332: - case FILE_LEQDATE:
! 2333: - case FILE_BEQDATE:
! 2334: - (void)fprintf(stderr, "%s,",
! 2335: - file_fmttime((uint32_t)m->value.q, 1));
! 2336: - break;
! 2337: - case FILE_QLDATE:
! 2338: - case FILE_LEQLDATE:
! 2339: - case FILE_BEQLDATE:
! 2340: - (void)fprintf(stderr, "%s,",
! 2341: - file_fmttime((uint32_t)m->value.q, 0));
! 2342: - break;
! 2343: - case FILE_FLOAT:
! 2344: - case FILE_BEFLOAT:
! 2345: - case FILE_LEFLOAT:
! 2346: - (void) fprintf(stderr, "%G", m->value.f);
! 2347: - break;
! 2348: - case FILE_DOUBLE:
! 2349: - case FILE_BEDOUBLE:
! 2350: - case FILE_LEDOUBLE:
! 2351: - (void) fprintf(stderr, "%G", m->value.d);
! 2352: - break;
! 2353: - case FILE_DEFAULT:
! 2354: - /* XXX - do anything here? */
! 2355: - break;
! 2356: - default:
! 2357: - (void) fputs("*bad*", stderr);
! 2358: - break;
! 2359: - }
! 2360: - }
! 2361: - (void) fprintf(stderr, ",\"%s\"]\n", m->desc);
! 2362: -}
! 2363: -#endif
! 2364: -
! 2365: /*VARARGS*/
! 2366: protected void
! 2367: file_magwarn(struct magic_set *ms, const char *f, ...)
! 2368: {
! 2369: va_list va;
! 2370: + char *expanded_format;
! 2371: + TSRMLS_FETCH();
! 2372:
! 2373: - /* cuz we use stdout for most, stderr here */
! 2374: - (void) fflush(stdout);
! 2375: -
! 2376: - if (ms->file)
! 2377: - (void) fprintf(stderr, "%s, %lu: ", ms->file,
! 2378: - (unsigned long)ms->line);
! 2379: - (void) fprintf(stderr, "Warning: ");
! 2380: va_start(va, f);
! 2381: - (void) vfprintf(stderr, f, va);
! 2382: + vasprintf(&expanded_format, f, va);
! 2383: va_end(va);
! 2384: - (void) fputc('\n', stderr);
! 2385: +
! 2386: + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Warning: %s", expanded_format);
! 2387: +
! 2388: + free(expanded_format);
! 2389: }
! 2390:
! 2391: protected const char *
! 2392: diff -u libmagic.orig/readcdf.c libmagic/readcdf.c
! 2393: --- libmagic.orig/readcdf.c 2011-09-15 23:28:13.000000000 +0800
! 2394: +++ libmagic/readcdf.c 2011-09-15 23:29:29.000000000 +0800
! 2395: @@ -30,7 +30,11 @@
! 2396: #endif
! 2397:
! 2398: #include <stdlib.h>
! 2399: +#ifdef PHP_WIN32
! 2400: +#include "win32/unistd.h"
! 2401: +#else
! 2402: #include <unistd.h>
! 2403: +#endif
! 2404: #include <string.h>
! 2405: #include <time.h>
! 2406: #include <ctype.h>
! 2407: @@ -46,7 +50,7 @@
! 2408: {
! 2409: size_t i;
! 2410: cdf_timestamp_t tp;
! 2411: - struct timespec ts;
! 2412: + struct timeval ts;
! 2413: char buf[64];
! 2414: const char *str = "vnd.ms-office";
! 2415: const char *s;
! 2416: @@ -106,7 +110,11 @@
! 2417: case CDF_FILETIME:
! 2418: tp = info[i].pi_tp;
! 2419: if (tp != 0) {
! 2420: +#if defined(PHP_WIN32) && _MSC_VER <= 1500
! 2421: + if (tp < 1000000000000000i64) {
! 2422: +#else
! 2423: if (tp < 1000000000000000LL) {
! 2424: +#endif
! 2425: char tbuf[64];
! 2426: cdf_print_elapsed_time(tbuf,
! 2427: sizeof(tbuf), tp);
! 2428: @@ -115,7 +123,10 @@
! 2429: return -1;
! 2430: } else {
! 2431: char *c, *ec;
! 2432: - cdf_timestamp_to_timespec(&ts, tp);
! 2433: +
! 2434: + if (cdf_timestamp_to_timespec(&ts, tp) == -1) {
! 2435: + return -1;
! 2436: + }
! 2437: c = ctime(&ts.tv_sec);
! 2438: if ((ec = strchr(c, '\n')) != NULL)
! 2439: *ec = '\0';
! 2440: diff -u libmagic.orig/readelf.c libmagic/readelf.c
! 2441: --- libmagic.orig/readelf.c 2011-09-15 23:28:13.000000000 +0800
! 2442: +++ libmagic/readelf.c 2011-09-15 23:28:26.000000000 +0800
! 2443: @@ -49,7 +49,7 @@
! 2444: off_t, int *, int);
! 2445: private int doshn(struct magic_set *, int, int, int, off_t, int, size_t, int *,
! 2446: int);
! 2447: -private size_t donote(struct magic_set *, void *, size_t, size_t, int,
! 2448: +private size_t donote(struct magic_set *, unsigned char *, size_t, size_t, int,
! 2449: int, size_t, int *);
! 2450:
! 2451: #define ELF_ALIGN(a) ((((a) + align - 1) / align) * align)
! 2452: @@ -364,7 +364,7 @@
! 2453: #endif
! 2454:
! 2455: private size_t
! 2456: -donote(struct magic_set *ms, void *vbuf, size_t offset, size_t size,
! 2457: +donote(struct magic_set *ms, unsigned char *nbuf, size_t offset, size_t size,
! 2458: int clazz, int swap, size_t align, int *flags)
! 2459: {
! 2460: Elf32_Nhdr nh32;
! 2461: @@ -374,7 +374,6 @@
! 2462: int os_style = -1;
! 2463: #endif
! 2464: uint32_t namesz, descsz;
! 2465: - unsigned char *nbuf = CAST(unsigned char *, vbuf);
! 2466:
! 2467: (void)memcpy(xnh_addr, &nbuf[offset], xnh_sizeof);
! 2468: offset += xnh_sizeof;
! 2469: @@ -855,20 +854,16 @@
! 2470: file_badread(ms);
! 2471: return -1;
! 2472: }
! 2473: - if ((nbuf = malloc((size_t)xsh_size)) == NULL) {
! 2474: - file_error(ms, errno, "Cannot allocate memory"
! 2475: - " for note");
! 2476: - return -1;
! 2477: - }
! 2478: + nbuf = emalloc((size_t)xsh_size);
! 2479: if ((noff = lseek(fd, (off_t)xsh_offset, SEEK_SET)) ==
! 2480: (off_t)-1) {
! 2481: file_badread(ms);
! 2482: - free(nbuf);
! 2483: + efree(nbuf);
! 2484: return -1;
! 2485: }
! 2486: if (read(fd, nbuf, (size_t)xsh_size) !=
! 2487: (ssize_t)xsh_size) {
! 2488: - free(nbuf);
! 2489: + efree(nbuf);
! 2490: file_badread(ms);
! 2491: return -1;
! 2492: }
! 2493: @@ -884,11 +879,11 @@
! 2494: break;
! 2495: }
! 2496: if ((lseek(fd, off, SEEK_SET)) == (off_t)-1) {
! 2497: - free(nbuf);
! 2498: + efree(nbuf);
! 2499: file_badread(ms);
! 2500: return -1;
! 2501: }
! 2502: - free(nbuf);
! 2503: + efree(nbuf);
! 2504: break;
! 2505: case SHT_SUNW_cap:
! 2506: {
! 2507: diff -u libmagic.orig/softmagic.c libmagic/softmagic.c
! 2508: --- libmagic.orig/softmagic.c 2011-09-15 23:28:13.000000000 +0800
! 2509: +++ libmagic/softmagic.c 2011-09-15 23:29:29.000000000 +0800
! 2510: @@ -41,6 +41,11 @@
! 2511: #include <stdlib.h>
! 2512: #include <time.h>
! 2513:
! 2514: +#ifndef PREG_OFFSET_CAPTURE
! 2515: +# define PREG_OFFSET_CAPTURE (1<<8)
! 2516: +#endif
! 2517: +
! 2518: +
! 2519:
! 2520: private int match(struct magic_set *, struct magic *, uint32_t,
! 2521: const unsigned char *, size_t, int);
! 2522: @@ -125,9 +130,9 @@
! 2523:
! 2524: if ((m->flag & BINTEST) != mode) {
! 2525: /* Skip sub-tests */
! 2526: - while (magic[magindex + 1].cont_level != 0 &&
! 2527: - ++magindex < nmagic)
! 2528: - continue;
! 2529: + while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 2530: + magindex++;
! 2531: + }
! 2532: continue; /* Skip to next top-level test*/
! 2533: }
! 2534:
! 2535: @@ -162,9 +167,9 @@
! 2536: * main entry didn't match,
! 2537: * flush its continuations
! 2538: */
! 2539: - while (magindex < nmagic - 1 &&
! 2540: - magic[magindex + 1].cont_level != 0)
! 2541: + while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 2542: magindex++;
! 2543: + }
! 2544: continue;
! 2545: }
! 2546:
! 2547: @@ -191,8 +196,8 @@
! 2548: if (file_check_mem(ms, ++cont_level) == -1)
! 2549: return -1;
! 2550:
! 2551: - while (magic[magindex+1].cont_level != 0 &&
! 2552: - ++magindex < nmagic) {
! 2553: + while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
! 2554: + magindex++;
! 2555: m = &magic[magindex];
! 2556: ms->line = m->lineno; /* for messages */
! 2557:
! 2558: @@ -207,8 +212,7 @@
! 2559: }
! 2560: ms->offset = m->offset;
! 2561: if (m->flag & OFFADD) {
! 2562: - ms->offset +=
! 2563: - ms->c.li[cont_level - 1].off;
! 2564: + ms->offset += ms->c.li[cont_level - 1].off;
! 2565: }
! 2566:
! 2567: #ifdef ENABLE_CONDITIONALS
! 2568: @@ -313,44 +317,22 @@
! 2569: private int
! 2570: check_fmt(struct magic_set *ms, struct magic *m)
! 2571: {
! 2572: - regex_t rx;
! 2573: - int rc;
! 2574: -
! 2575: - if (strchr(m->desc, '%') == NULL)
! 2576: + pcre *pce;
! 2577: + int re_options;
! 2578: + pcre_extra *re_extra;
! 2579: + TSRMLS_FETCH();
! 2580: +
! 2581: + if (strchr(m->desc, '%') == NULL) {
! 2582: return 0;
! 2583: -
! 2584: - rc = regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB);
! 2585: - if (rc) {
! 2586: - char errmsg[512];
! 2587: - (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
! 2588: - file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
! 2589: + }
! 2590: +
! 2591: + if ((pce = pcre_get_compiled_regex("~%[-0-9.]*s~", &re_extra, &re_options TSRMLS_CC)) == NULL) {
! 2592: return -1;
! 2593: } else {
! 2594: - rc = regexec(&rx, m->desc, 0, 0, 0);
! 2595: - regfree(&rx);
! 2596: - return !rc;
! 2597: + return !pcre_exec(pce, re_extra, m->desc, strlen(m->desc), 0, re_options, NULL, 0);
! 2598: }
! 2599: }
! 2600:
! 2601: -#ifndef HAVE_STRNDUP
! 2602: -char * strndup(const char *, size_t);
! 2603: -
! 2604: -char *
! 2605: -strndup(const char *str, size_t n)
! 2606: -{
! 2607: - size_t len;
! 2608: - char *copy;
! 2609: -
! 2610: - for (len = 0; len < n && str[len]; len++)
! 2611: - continue;
! 2612: - if ((copy = malloc(len + 1)) == NULL)
! 2613: - return NULL;
! 2614: - (void)memcpy(copy, str, len);
! 2615: - copy[len] = '\0';
! 2616: - return copy;
! 2617: -}
! 2618: -#endif /* HAVE_STRNDUP */
! 2619: -
! 2620: private int32_t
! 2621: mprint(struct magic_set *ms, struct magic *m)
! 2622: {
! 2623: @@ -533,13 +515,10 @@
! 2624: char *cp;
! 2625: int rval;
! 2626:
! 2627: - cp = strndup((const char *)ms->search.s, ms->search.rm_len);
! 2628: - if (cp == NULL) {
! 2629: - file_oomem(ms, ms->search.rm_len);
! 2630: - return -1;
! 2631: - }
! 2632: + cp = estrndup((const char *)ms->search.s, ms->search.rm_len);
! 2633: +
! 2634: rval = file_printf(ms, m->desc, cp);
! 2635: - free(cp);
! 2636: + efree(cp);
! 2637:
! 2638: if (rval == -1)
! 2639: return -1;
! 2640: @@ -733,16 +712,16 @@
! 2641: if (m->num_mask) \
! 2642: switch (m->mask_op & FILE_OPS_MASK) { \
! 2643: case FILE_OPADD: \
! 2644: - p->fld += cast m->num_mask; \
! 2645: + p->fld += cast (int64_t)m->num_mask; \
! 2646: break; \
! 2647: case FILE_OPMINUS: \
! 2648: - p->fld -= cast m->num_mask; \
! 2649: + p->fld -= cast (int64_t)m->num_mask; \
! 2650: break; \
! 2651: case FILE_OPMULTIPLY: \
! 2652: - p->fld *= cast m->num_mask; \
! 2653: + p->fld *= cast (int64_t)m->num_mask; \
! 2654: break; \
! 2655: case FILE_OPDIVIDE: \
! 2656: - p->fld /= cast m->num_mask; \
! 2657: + p->fld /= cast (int64_t)m->num_mask; \
! 2658: break; \
! 2659: } \
! 2660:
! 2661: @@ -1033,16 +1012,13 @@
! 2662:
! 2663: if ((ms->flags & MAGIC_DEBUG) != 0) {
! 2664: mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE));
! 2665: -#ifndef COMPILE_ONLY
! 2666: - file_mdump(m);
! 2667: -#endif
! 2668: }
! 2669:
! 2670: if (m->flag & INDIR) {
! 2671: int off = m->in_offset;
! 2672: if (m->in_op & FILE_OPINDIRECT) {
! 2673: - const union VALUETYPE *q = CAST(const union VALUETYPE *,
! 2674: - ((const void *)(s + offset + off)));
! 2675: + const union VALUETYPE *q =
! 2676: + ((const void *)(s + offset + off));
! 2677: switch (m->in_type) {
! 2678: case FILE_BYTE:
! 2679: off = q->b;
! 2680: @@ -1522,9 +1498,6 @@
! 2681: if ((ms->flags & MAGIC_DEBUG) != 0) {
! 2682: mdebug(offset, (char *)(void *)p,
! 2683: sizeof(union VALUETYPE));
! 2684: -#ifndef COMPILE_ONLY
! 2685: - file_mdump(m);
! 2686: -#endif
! 2687: }
! 2688: }
! 2689:
! 2690: @@ -1672,6 +1645,65 @@
! 2691: return file_strncmp(a, b, len, flags);
! 2692: }
! 2693:
! 2694: +private void
! 2695: +convert_libmagic_pattern(zval *pattern, int options)
! 2696: +{
! 2697: + int i, j=0;
! 2698: + char *t;
! 2699: +
! 2700: + t = (char *) safe_emalloc(Z_STRLEN_P(pattern), 2, 5);
! 2701: +
! 2702: + t[j++] = '~';
! 2703: +
! 2704: + for (i=0; i<Z_STRLEN_P(pattern); i++, j++) {
! 2705: + switch (Z_STRVAL_P(pattern)[i]) {
! 2706: + case '?':
! 2707: + t[j] = '.';
! 2708: + break;
! 2709: + case '*':
! 2710: + t[j++] = '.';
! 2711: + t[j] = '*';
! 2712: + break;
! 2713: + case '.':
! 2714: + t[j++] = '\\';
! 2715: + t[j] = '.';
! 2716: + break;
! 2717: + case '\\':
! 2718: + t[j++] = '\\';
! 2719: + t[j] = '\\';
! 2720: + break;
! 2721: + case '(':
! 2722: + t[j++] = '\\';
! 2723: + t[j] = '(';
! 2724: + break;
! 2725: + case ')':
! 2726: + t[j++] = '\\';
! 2727: + t[j] = ')';
! 2728: + break;
! 2729: + case '~':
! 2730: + t[j++] = '\\';
! 2731: + t[j] = '~';
! 2732: + break;
! 2733: + default:
! 2734: + t[j] = Z_STRVAL_P(pattern)[i];
! 2735: + break;
! 2736: + }
! 2737: + }
! 2738: + t[j++] = '~';
! 2739: +
! 2740: + if (options & PCRE_CASELESS)
! 2741: + t[j++] = 'm';
! 2742: +
! 2743: + if (options & PCRE_MULTILINE)
! 2744: + t[j++] = 'i';
! 2745: +
! 2746: + t[j]=0;
! 2747: +
! 2748: + Z_STRVAL_P(pattern) = t;
! 2749: + Z_STRLEN_P(pattern) = j;
! 2750: +
! 2751: +}
! 2752: +
! 2753: private int
! 2754: magiccheck(struct magic_set *ms, struct magic *m)
! 2755: {
! 2756: @@ -1828,67 +1860,162 @@
! 2757: break;
! 2758: }
! 2759: case FILE_REGEX: {
! 2760: - int rc;
! 2761: - regex_t rx;
! 2762: - char errmsg[512];
! 2763: -
! 2764: - if (ms->search.s == NULL)
! 2765: - return 0;
! 2766: -
! 2767: - l = 0;
! 2768: - rc = regcomp(&rx, m->value.s,
! 2769: - REG_EXTENDED|REG_NEWLINE|
! 2770: - ((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0));
! 2771: - if (rc) {
! 2772: - (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
! 2773: - file_magerror(ms, "regex error %d, (%s)",
! 2774: - rc, errmsg);
! 2775: - v = (uint64_t)-1;
! 2776: - }
! 2777: - else {
! 2778: - regmatch_t pmatch[1];
! 2779: -#ifndef REG_STARTEND
! 2780: -#define REG_STARTEND 0
! 2781: - size_t l = ms->search.s_len - 1;
! 2782: - char c = ms->search.s[l];
! 2783: - ((char *)(intptr_t)ms->search.s)[l] = '\0';
! 2784: + zval *pattern;
! 2785: + int options = 0;
! 2786: + pcre_cache_entry *pce;
! 2787: + TSRMLS_FETCH();
! 2788: +
! 2789: + MAKE_STD_ZVAL(pattern);
! 2790: + ZVAL_STRINGL(pattern, (char *)m->value.s, m->vallen, 0);
! 2791: +
! 2792: + options |= PCRE_MULTILINE;
! 2793: +
! 2794: + if (m->str_flags & STRING_IGNORE_CASE) {
! 2795: + options |= PCRE_CASELESS;
! 2796: + }
! 2797: +
! 2798: + convert_libmagic_pattern(pattern, options);
! 2799: +
! 2800: +#if (PHP_MAJOR_VERSION < 6)
! 2801: + if ((pce = pcre_get_compiled_regex_cache(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
! 2802: #else
! 2803: - pmatch[0].rm_so = 0;
! 2804: - pmatch[0].rm_eo = ms->search.s_len;
! 2805: + if ((pce = pcre_get_compiled_regex_cache(IS_STRING, Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
! 2806: #endif
! 2807: - rc = regexec(&rx, (const char *)ms->search.s,
! 2808: - 1, pmatch, REG_STARTEND);
! 2809: -#if REG_STARTEND == 0
! 2810: - ((char *)(intptr_t)ms->search.s)[l] = c;
! 2811: + zval_dtor(pattern);
! 2812: + FREE_ZVAL(pattern);
! 2813: + return -1;
! 2814: + } else {
! 2815: + /* pce now contains the compiled regex */
! 2816: + zval *retval;
! 2817: + zval *subpats;
! 2818: + char *haystack;
! 2819: +
! 2820: + MAKE_STD_ZVAL(retval);
! 2821: + ALLOC_INIT_ZVAL(subpats);
! 2822: +
! 2823: + /* Cut the search len from haystack, equals to REG_STARTEND */
! 2824: + haystack = estrndup(ms->search.s, ms->search.s_len);
! 2825: +
! 2826: + /* match v = 0, no match v = 1 */
! 2827: +#if (PHP_MAJOR_VERSION < 6)
! 2828: + php_pcre_match_impl(pce, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
! 2829: +#else
! 2830: + php_pcre_match_impl(pce, IS_STRING, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
! 2831: #endif
! 2832: - switch (rc) {
! 2833: - case 0:
! 2834: - ms->search.s += (int)pmatch[0].rm_so;
! 2835: - ms->search.offset += (size_t)pmatch[0].rm_so;
! 2836: - ms->search.rm_len =
! 2837: - (size_t)(pmatch[0].rm_eo - pmatch[0].rm_so);
! 2838: - v = 0;
! 2839: - break;
! 2840: + /* Free haystack */
! 2841: + efree(haystack);
! 2842: +
! 2843: + if (Z_LVAL_P(retval) < 0) {
! 2844: + zval_ptr_dtor(&subpats);
! 2845: + FREE_ZVAL(retval);
! 2846: + zval_dtor(pattern);
! 2847: + FREE_ZVAL(pattern);
! 2848: + return -1;
! 2849: + } else if ((Z_LVAL_P(retval) > 0) && (Z_TYPE_P(subpats) == IS_ARRAY)) {
! 2850: +
! 2851: + /* Need to fetch global match which equals pmatch[0] */
! 2852: + HashTable *ht = Z_ARRVAL_P(subpats);
! 2853: + HashPosition outer_pos;
! 2854: + zval *pattern_match = NULL, *pattern_offset = NULL;
! 2855: +
! 2856: + zend_hash_internal_pointer_reset_ex(ht, &outer_pos);
! 2857: +
! 2858: + if (zend_hash_has_more_elements_ex(ht, &outer_pos) == SUCCESS &&
! 2859: + zend_hash_move_forward_ex(ht, &outer_pos)) {
! 2860: +
! 2861: + zval **ppzval;
! 2862: +
! 2863: + /* The first element (should be) is the global match
! 2864: + Need to move to the inner array to get the global match */
! 2865: +
! 2866: + if (zend_hash_get_current_data_ex(ht, (void**)&ppzval, &outer_pos) != FAILURE) {
! 2867: +
! 2868: + HashTable *inner_ht;
! 2869: + HashPosition inner_pos;
! 2870: + zval **match, **offset;
! 2871: + zval tmpcopy = **ppzval, matchcopy, offsetcopy;
! 2872: +
! 2873: + zval_copy_ctor(&tmpcopy);
! 2874: + INIT_PZVAL(&tmpcopy);
! 2875: +
! 2876: + inner_ht = Z_ARRVAL(tmpcopy);
! 2877: +
! 2878: + /* If everything goes according to the master plan
! 2879: + tmpcopy now contains two elements:
! 2880: + 0 = the match
! 2881: + 1 = starting position of the match */
! 2882: + zend_hash_internal_pointer_reset_ex(inner_ht, &inner_pos);
! 2883: +
! 2884: + if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
! 2885: + zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
! 2886: +
! 2887: + if (zend_hash_get_current_data_ex(inner_ht, (void**)&match, &inner_pos) != FAILURE) {
! 2888: +
! 2889: + matchcopy = **match;
! 2890: + zval_copy_ctor(&matchcopy);
! 2891: + INIT_PZVAL(&matchcopy);
! 2892: + convert_to_string(&matchcopy);
! 2893: +
! 2894: + MAKE_STD_ZVAL(pattern_match);
! 2895: + Z_STRVAL_P(pattern_match) = (char *)Z_STRVAL(matchcopy);
! 2896: + Z_STRLEN_P(pattern_match) = Z_STRLEN(matchcopy);
! 2897: + Z_TYPE_P(pattern_match) = IS_STRING;
! 2898: +
! 2899: + zval_dtor(&matchcopy);
! 2900: + }
! 2901: + }
! 2902: +
! 2903: + if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
! 2904: + zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
! 2905: +
! 2906: + if (zend_hash_get_current_data_ex(inner_ht, (void**)&offset, &inner_pos) != FAILURE) {
! 2907: +
! 2908: + offsetcopy = **offset;
! 2909: + zval_copy_ctor(&offsetcopy);
! 2910: + INIT_PZVAL(&offsetcopy);
! 2911: + convert_to_long(&offsetcopy);
! 2912: +
! 2913: + MAKE_STD_ZVAL(pattern_offset);
! 2914: + Z_LVAL_P(pattern_offset) = Z_LVAL(offsetcopy);
! 2915: + Z_TYPE_P(pattern_offset) = IS_LONG;
! 2916: +
! 2917: + zval_dtor(&offsetcopy);
! 2918: + }
! 2919: + }
! 2920: + zval_dtor(&tmpcopy);
! 2921: + }
! 2922: +
! 2923: + if ((pattern_match != NULL) && (pattern_offset != NULL)) {
! 2924: + ms->search.s += (int)Z_LVAL_P(pattern_offset); /* this is where the match starts */
! 2925: + ms->search.offset += (size_t)Z_LVAL_P(pattern_offset); /* this is where the match starts as size_t */
! 2926: + ms->search.rm_len = Z_STRLEN_P(pattern_match) /* This is the length of the matched pattern */;
! 2927: + v = 0;
! 2928: +
! 2929: + efree(pattern_match);
! 2930: + efree(pattern_offset);
! 2931: +
! 2932: + } else {
! 2933: + zval_ptr_dtor(&subpats);
! 2934: + FREE_ZVAL(retval);
! 2935: + zval_dtor(pattern);
! 2936: + FREE_ZVAL(pattern);
! 2937: + return -1;
! 2938: + }
! 2939: + }
! 2940:
! 2941: - case REG_NOMATCH:
! 2942: +
! 2943: + } else {
! 2944: v = 1;
! 2945: - break;
! 2946: -
! 2947: - default:
! 2948: - (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
! 2949: - file_magerror(ms, "regexec error %d, (%s)",
! 2950: - rc, errmsg);
! 2951: - v = (uint64_t)-1;
! 2952: - break;
! 2953: }
! 2954: - regfree(&rx);
! 2955: + zval_ptr_dtor(&subpats);
! 2956: + FREE_ZVAL(retval);
! 2957: }
! 2958: - if (v == (uint64_t)-1)
! 2959: - return -1;
! 2960: - break;
! 2961: + zval_dtor(pattern);
! 2962: + FREE_ZVAL(pattern);
! 2963: + break;
! 2964: }
! 2965: case FILE_INDIRECT:
! 2966: - return 1;
! 2967: + return 1;
! 2968: default:
! 2969: file_magerror(ms, "invalid type %d in magiccheck()", m->type);
! 2970: return -1;
! 2971: @@ -1900,7 +2027,7 @@
! 2972: case 'x':
! 2973: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2974: (void) fprintf(stderr, "%llu == *any* = 1\n",
! 2975: - (unsigned long long)v);
! 2976: + (uint64_t)v);
! 2977: matched = 1;
! 2978: break;
! 2979:
! 2980: @@ -1908,7 +2035,7 @@
! 2981: matched = v != l;
! 2982: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2983: (void) fprintf(stderr, "%llu != %llu = %d\n",
! 2984: - (unsigned long long)v, (unsigned long long)l,
! 2985: + (uint64_t)v, (uint64_t)l,
! 2986: matched);
! 2987: break;
! 2988:
! 2989: @@ -1916,7 +2043,7 @@
! 2990: matched = v == l;
! 2991: if ((ms->flags & MAGIC_DEBUG) != 0)
! 2992: (void) fprintf(stderr, "%llu == %llu = %d\n",
! 2993: - (unsigned long long)v, (unsigned long long)l,
! 2994: + (uint64_t)v, (uint64_t)l,
! 2995: matched);
! 2996: break;
! 2997:
! 2998: @@ -1925,14 +2052,14 @@
! 2999: matched = v > l;
! 3000: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3001: (void) fprintf(stderr, "%llu > %llu = %d\n",
! 3002: - (unsigned long long)v,
! 3003: - (unsigned long long)l, matched);
! 3004: + (uint64_t)v,
! 3005: + (uint64_t)l, matched);
! 3006: }
! 3007: else {
! 3008: matched = (int64_t) v > (int64_t) l;
! 3009: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3010: (void) fprintf(stderr, "%lld > %lld = %d\n",
! 3011: - (long long)v, (long long)l, matched);
! 3012: + (uint64_t)v, (uint64_t)l, matched);
! 3013: }
! 3014: break;
! 3015:
! 3016: @@ -1941,14 +2068,14 @@
! 3017: matched = v < l;
! 3018: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3019: (void) fprintf(stderr, "%llu < %llu = %d\n",
! 3020: - (unsigned long long)v,
! 3021: - (unsigned long long)l, matched);
! 3022: + (uint64_t)v,
! 3023: + (uint64_t)l, matched);
! 3024: }
! 3025: else {
! 3026: matched = (int64_t) v < (int64_t) l;
! 3027: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3028: (void) fprintf(stderr, "%lld < %lld = %d\n",
! 3029: - (long long)v, (long long)l, matched);
! 3030: + (int64_t)v, (int64_t)l, matched);
! 3031: }
! 3032: break;
! 3033:
! 3034: @@ -1956,16 +2083,16 @@
! 3035: matched = (v & l) == l;
! 3036: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3037: (void) fprintf(stderr, "((%llx & %llx) == %llx) = %d\n",
! 3038: - (unsigned long long)v, (unsigned long long)l,
! 3039: - (unsigned long long)l, matched);
! 3040: + (uint64_t)v, (uint64_t)l,
! 3041: + (uint64_t)l, matched);
! 3042: break;
! 3043:
! 3044: case '^':
! 3045: matched = (v & l) != l;
! 3046: if ((ms->flags & MAGIC_DEBUG) != 0)
! 3047: (void) fprintf(stderr, "((%llx & %llx) != %llx) = %d\n",
! 3048: - (unsigned long long)v, (unsigned long long)l,
! 3049: - (unsigned long long)l, matched);
! 3050: + (uint64_t)v, (uint64_t)l,
! 3051: + (uint64_t)l, matched);
! 3052: break;
! 3053:
! 3054: default:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libmagic.patch 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