2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/apprentice.c libmagic/apprentice.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/apprentice.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/apprentice.c 2012-04-22 18:57:16.215980866 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -29,6 +29,8 @@
|
|
|
|
* apprentice - make one pass through /etc/magic, learning its secrets.
|
|
|
|
*/
|
|
|
|
|
|
|
|
+#include "php.h"
|
|
|
|
+
|
|
|
|
#include "file.h"
|
|
|
|
|
|
|
|
#ifndef lint
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -36,18 +38,34 @@
|
|
|
|
#endif /* lint */
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
#include "magic.h"
|
2012-03-27 19:34:46 +08:00
|
|
|
+#include "patchlevel.h"
|
2010-02-01 06:54:00 +08:00
|
|
|
#include <stdlib.h>
|
|
|
|
-#ifdef HAVE_UNISTD_H
|
|
|
|
+
|
2011-10-19 23:08:50 +08:00
|
|
|
+#if defined(__hpux) && !defined(HAVE_STRTOULL)
|
|
|
|
+#if SIZEOF_LONG == 8
|
|
|
|
+# define strtoull strtoul
|
|
|
|
+#else
|
|
|
|
+# define strtoull __strtoull
|
|
|
|
+#endif
|
|
|
|
+#endif
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/unistd.h"
|
|
|
|
+#if _MSC_VER <= 1300
|
|
|
|
+# include "win32/php_strtoi64.h"
|
2008-07-25 16:18:35 +08:00
|
|
|
+#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
+#define strtoull _strtoui64
|
|
|
|
+#else
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
2008-07-25 16:18:35 +08:00
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
-#ifdef QUICK
|
|
|
|
-#include <sys/mman.h>
|
|
|
|
-#endif
|
|
|
|
+#ifndef PHP_WIN32
|
|
|
|
#include <dirent.h>
|
|
|
|
+#endif
|
|
|
|
|
|
|
|
#define EATAB {while (isascii((unsigned char) *l) && \
|
|
|
|
isspace((unsigned char) *l)) ++l;}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -112,12 +130,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
private int parse_strength(struct magic_set *, struct magic_entry *, const char *);
|
|
|
|
private int parse_apple(struct magic_set *, struct magic_entry *, const char *);
|
|
|
|
|
|
|
|
-
|
|
|
|
private size_t maxmagic = 0;
|
|
|
|
private size_t magicsize = sizeof(struct magic);
|
|
|
|
|
|
|
|
private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
|
|
|
|
-
|
|
|
|
private struct {
|
|
|
|
const char *name;
|
|
|
|
size_t len;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -131,38 +147,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
{ NULL, 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
-#ifdef COMPILE_ONLY
|
|
|
|
-
|
|
|
|
-int main(int, char *[]);
|
|
|
|
-
|
|
|
|
-int
|
|
|
|
-main(int argc, char *argv[])
|
|
|
|
-{
|
|
|
|
- int ret;
|
|
|
|
- struct magic_set *ms;
|
|
|
|
- char *progname;
|
|
|
|
-
|
|
|
|
- if ((progname = strrchr(argv[0], '/')) != NULL)
|
|
|
|
- progname++;
|
|
|
|
- else
|
|
|
|
- progname = argv[0];
|
|
|
|
-
|
|
|
|
- if (argc != 2) {
|
|
|
|
- (void)fprintf(stderr, "Usage: %s file\n", progname);
|
|
|
|
- return 1;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
|
|
|
|
- (void)fprintf(stderr, "%s: %s\n", progname, strerror(errno));
|
|
|
|
- return 1;
|
|
|
|
- }
|
|
|
|
- ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
|
|
|
|
- if (ret == 1)
|
|
|
|
- (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
|
|
|
|
- magic_close(ms);
|
|
|
|
- return ret;
|
|
|
|
-}
|
|
|
|
-#endif /* COMPILE_ONLY */
|
|
|
|
+#include "../data_file.c"
|
|
|
|
|
2008-07-25 16:18:35 +08:00
|
|
|
static const struct type_tbl_s {
|
|
|
|
const char name[16];
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -218,6 +203,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
# undef XX_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
+#ifndef S_ISDIR
|
|
|
|
+#define S_ISDIR(mode) ((mode) & _S_IFDIR)
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
private int
|
|
|
|
get_type(const char *l, const char **t)
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -275,15 +264,17 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if (rv != 0)
|
|
|
|
return -1;
|
|
|
|
rv = apprentice_compile(ms, &magic, &nmagic, fn);
|
|
|
|
- free(magic);
|
|
|
|
+ efree(magic);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {
|
|
|
|
- if (ms->flags & MAGIC_CHECK)
|
|
|
|
- file_magwarn(ms, "using regular magic file `%s'", fn);
|
|
|
|
- rv = apprentice_load(ms, &magic, &nmagic, fn, action);
|
|
|
|
+ if (fn) {
|
|
|
|
+ if (ms->flags & MAGIC_CHECK)
|
|
|
|
+ file_magwarn(ms, "using regular magic file `%s'", fn);
|
|
|
|
+ rv = apprentice_load(ms, &magic, &nmagic, fn, action);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
if (rv != 0)
|
|
|
|
return -1;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -295,11 +286,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if ((ml = CAST(struct mlist *, malloc(sizeof(*ml)))) == NULL) {
|
|
|
|
- file_delmagic(magic, mapped, nmagic);
|
|
|
|
- file_oomem(ms, sizeof(*ml));
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ ml = emalloc(sizeof(*ml));
|
|
|
|
|
|
|
|
ml->magic = magic;
|
|
|
|
ml->nmagic = nmagic;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -318,7 +305,6 @@
|
|
|
|
}
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
return 0;
|
|
|
|
-#endif /* COMPILE_ONLY */
|
|
|
|
}
|
|
|
|
|
|
|
|
protected void
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -327,22 +313,18 @@
|
2008-07-25 16:18:35 +08:00
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
switch (type) {
|
2010-02-01 06:54:00 +08:00
|
|
|
- case 2:
|
|
|
|
-#ifdef QUICK
|
|
|
|
- p--;
|
|
|
|
- (void)munmap((void *)p, sizeof(*p) * (entries + 1));
|
2008-07-25 16:18:35 +08:00
|
|
|
+ case 3:
|
|
|
|
+ /* Do nothing, it's part of the code segment */
|
2010-02-01 06:54:00 +08:00
|
|
|
break;
|
|
|
|
-#else
|
|
|
|
- (void)&entries;
|
|
|
|
- abort();
|
|
|
|
- /*NOTREACHED*/
|
|
|
|
-#endif
|
|
|
|
+
|
|
|
|
case 1:
|
2008-07-25 16:18:35 +08:00
|
|
|
p--;
|
2010-02-01 06:54:00 +08:00
|
|
|
/*FALLTHROUGH*/
|
|
|
|
+
|
|
|
|
case 0:
|
|
|
|
- free(p);
|
|
|
|
+ efree(p);
|
|
|
|
break;
|
|
|
|
+
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -355,23 +337,27 @@
|
|
|
|
char *p, *mfn;
|
|
|
|
int file_err, errs = -1;
|
|
|
|
struct mlist *mlist;
|
2010-02-01 06:54:00 +08:00
|
|
|
-
|
2012-03-27 19:34:46 +08:00
|
|
|
+/* XXX disabling default magic loading so the compiled in data is used */
|
|
|
|
+#if 0
|
|
|
|
if ((fn = magic_getpath(fn, action)) == NULL)
|
|
|
|
return NULL;
|
|
|
|
+#endif
|
|
|
|
|
|
|
|
init_file_tables();
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
- if ((mfn = strdup(fn)) == NULL) {
|
|
|
|
- file_oomem(ms, strlen(fn));
|
|
|
|
- return NULL;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ if (fn == NULL)
|
|
|
|
+ fn = getenv("MAGIC");
|
2008-07-25 16:18:35 +08:00
|
|
|
+ if (fn == NULL) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+ mlist = emalloc(sizeof(*mlist));
|
2008-07-25 16:18:35 +08:00
|
|
|
+ mlist->next = mlist->prev = mlist;
|
|
|
|
+ apprentice_1(ms, fn, action, mlist);
|
|
|
|
+ return mlist;
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
+
|
|
|
|
+ mfn = estrdup(fn);
|
|
|
|
fn = mfn;
|
|
|
|
|
|
|
|
- if ((mlist = CAST(struct mlist *, malloc(sizeof(*mlist)))) == NULL) {
|
|
|
|
- free(mfn);
|
|
|
|
- file_oomem(ms, sizeof(*mlist));
|
|
|
|
- return NULL;
|
|
|
|
- }
|
|
|
|
+ mlist = emalloc(sizeof(*mlist));
|
|
|
|
mlist->next = mlist->prev = mlist;
|
|
|
|
|
|
|
|
while (fn) {
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -385,13 +371,13 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
fn = p;
|
|
|
|
}
|
|
|
|
if (errs == -1) {
|
|
|
|
- free(mfn);
|
|
|
|
- free(mlist);
|
|
|
|
+ efree(mfn);
|
|
|
|
+ efree(mlist);
|
|
|
|
mlist = NULL;
|
|
|
|
file_error(ms, 0, "could not find any magic files!");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
- free(mfn);
|
|
|
|
+ efree(mfn);
|
|
|
|
return mlist;
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -524,6 +510,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
+
|
|
|
|
/*
|
|
|
|
* Magic entries with no description get a bonus because they depend
|
|
|
|
* on subsequent magic entries to print something.
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -539,8 +526,8 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
private int
|
|
|
|
apprentice_sort(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
- const struct magic_entry *ma = CAST(const struct magic_entry *, a);
|
|
|
|
- const struct magic_entry *mb = CAST(const struct magic_entry *, b);
|
|
|
|
+ const struct magic_entry *ma = a;
|
|
|
|
+ const struct magic_entry *mb = b;
|
|
|
|
size_t sa = apprentice_magic_strength(ma->mp);
|
|
|
|
size_t sb = apprentice_magic_strength(mb->mp);
|
|
|
|
if (sa == sb)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -671,12 +658,22 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
load_1(struct magic_set *ms, int action, const char *fn, int *errs,
|
|
|
|
struct magic_entry **marray, uint32_t *marraycount)
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
- size_t lineno = 0, llen = 0;
|
2010-02-01 06:54:00 +08:00
|
|
|
+ char buffer[BUFSIZ + 1];
|
2012-03-27 19:34:46 +08:00
|
|
|
char *line = NULL;
|
|
|
|
- ssize_t len;
|
|
|
|
+ size_t len;
|
|
|
|
+ size_t lineno = 0;
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
|
|
|
+ php_stream *stream;
|
|
|
|
+
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if PHP_API_VERSION < 20100412
|
2010-02-01 06:54:00 +08:00
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
|
2008-07-25 16:18:35 +08:00
|
|
|
+#else
|
2010-02-01 06:54:00 +08:00
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
|
2008-07-25 16:18:35 +08:00
|
|
|
+#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
|
|
|
|
- FILE *f = fopen(ms->file = fn, "r");
|
|
|
|
- if (f == NULL) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+ if (stream == NULL) {
|
|
|
|
if (errno != ENOENT)
|
|
|
|
file_error(ms, errno, "cannot read magic file `%s'",
|
|
|
|
fn);
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -684,9 +681,12 @@
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
- /* read and parse this file */
|
|
|
|
- for (ms->line = 1; (len = getline(&line, &llen, f)) != -1;
|
|
|
|
- ms->line++) {
|
|
|
|
+ /* read and parse this file */
|
2010-02-01 06:54:00 +08:00
|
|
|
+#if (PHP_MAJOR_VERSION < 6)
|
2012-03-27 19:34:46 +08:00
|
|
|
+ for (ms->line = 1; (line = php_stream_get_line(stream, buffer , BUFSIZ, &len)) != NULL; ms->line++) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+#else
|
2012-03-27 19:34:46 +08:00
|
|
|
+ for (ms->line = 1; (line = php_stream_get_line(stream, ZSTR(buffer), BUFSIZ, &len)) != NULL; ms->line++) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
if (len == 0) /* null line, garbage, etc */
|
|
|
|
continue;
|
|
|
|
if (line[len - 1] == '\n') {
|
|
|
|
@@ -736,8 +736,7 @@
|
|
|
|
break;
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
- free(line);
|
|
|
|
- (void)fclose(f);
|
|
|
|
+ php_stream_close(stream);
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
/*
|
|
|
|
@@ -757,20 +756,16 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
int errs = 0;
|
|
|
|
struct magic_entry *marray;
|
|
|
|
uint32_t marraycount, i, mentrycount = 0, starttest;
|
2012-03-27 19:34:46 +08:00
|
|
|
- size_t slen, files = 0, maxfiles = 0;
|
|
|
|
- char **filearr = NULL, *mfn;
|
|
|
|
+ size_t files = 0, maxfiles = 0;
|
|
|
|
+ char **filearr = NULL, mfn[MAXPATHLEN];
|
2010-02-01 06:54:00 +08:00
|
|
|
struct stat st;
|
|
|
|
DIR *dir;
|
2012-03-27 19:34:46 +08:00
|
|
|
struct dirent *d;
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
|
|
|
|
|
|
|
|
- maxmagic = MAXMAGIS;
|
|
|
|
- if ((marray = CAST(struct magic_entry *, calloc(maxmagic,
|
|
|
|
- sizeof(*marray)))) == NULL) {
|
|
|
|
- file_oomem(ms, maxmagic * sizeof(*marray));
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ maxmagic = MAXMAGIS;
|
|
|
|
+ marray = ecalloc(maxmagic, sizeof(*marray));
|
|
|
|
marraycount = 0;
|
|
|
|
|
|
|
|
/* print silly verbose header for USG compat. */
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -778,14 +773,16 @@
|
|
|
|
(void)fprintf(stderr, "%s\n", usg_hdr);
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
/* load directory or file */
|
|
|
|
- if (stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
|
2012-03-27 19:34:46 +08:00
|
|
|
+ /* FIXME: Read file names and sort them to prevent
|
|
|
|
+ non-determinism. See Debian bug #488562. */
|
2010-02-01 06:54:00 +08:00
|
|
|
+ if (php_sys_stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
|
|
|
|
dir = opendir(fn);
|
2012-03-27 19:34:46 +08:00
|
|
|
if (!dir) {
|
|
|
|
errs++;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
while ((d = readdir(dir)) != NULL) {
|
|
|
|
- if (asprintf(&mfn, "%s/%s", fn, d->d_name) < 0) {
|
|
|
|
+ if (snprintf(mfn, sizeof(mfn), "%s/%s", fn, d->d_name) < 0) {
|
|
|
|
file_oomem(ms,
|
|
|
|
strlen(fn) + strlen(d->d_name) + 2);
|
|
|
|
errs++;
|
|
|
|
@@ -793,7 +790,6 @@
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
|
|
|
|
- free(mfn);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (files >= maxfiles) {
|
|
|
|
@@ -803,7 +799,6 @@
|
|
|
|
if ((filearr = CAST(char **,
|
|
|
|
realloc(filearr, mlen))) == NULL) {
|
|
|
|
file_oomem(ms, mlen);
|
|
|
|
- free(mfn);
|
|
|
|
closedir(dir);
|
|
|
|
errs++;
|
|
|
|
goto out;
|
|
|
|
@@ -882,12 +877,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
for (i = 0; i < marraycount; i++)
|
|
|
|
mentrycount += marray[i].cont_count;
|
|
|
|
|
|
|
|
- slen = sizeof(**magicp) * mentrycount;
|
|
|
|
- if ((*magicp = CAST(struct magic *, malloc(slen))) == NULL) {
|
|
|
|
- file_oomem(ms, slen);
|
|
|
|
- errs++;
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
+ *magicp = emalloc(sizeof(**magicp) * mentrycount);
|
|
|
|
|
|
|
|
mentrycount = 0;
|
|
|
|
for (i = 0; i < marraycount; i++) {
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -897,8 +887,8 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
for (i = 0; i < marraycount; i++)
|
|
|
|
- free(marray[i].mp);
|
|
|
|
- free(marray);
|
|
|
|
+ efree(marray[i].mp);
|
|
|
|
+ efree(marray);
|
|
|
|
if (errs) {
|
|
|
|
*magicp = NULL;
|
|
|
|
*nmagicp = 0;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1178,11 +1168,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if (me->cont_count == me->max_count) {
|
|
|
|
struct magic *nm;
|
|
|
|
size_t cnt = me->max_count + ALLOC_CHUNK;
|
|
|
|
- if ((nm = CAST(struct magic *, realloc(me->mp,
|
|
|
|
- sizeof(*nm) * cnt))) == NULL) {
|
|
|
|
- file_oomem(ms, sizeof(*nm) * cnt);
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ nm = erealloc(me->mp, sizeof(*nm) * cnt);
|
|
|
|
me->mp = m = nm;
|
2012-03-27 19:34:46 +08:00
|
|
|
me->max_count = CAST(uint32_t, cnt);
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1194,23 +1180,13 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
struct magic_entry *mp;
|
|
|
|
|
|
|
|
maxmagic += ALLOC_INCR;
|
|
|
|
- if ((mp = CAST(struct magic_entry *,
|
|
|
|
- realloc(*mentryp, sizeof(*mp) * maxmagic))) ==
|
|
|
|
- NULL) {
|
|
|
|
- file_oomem(ms, sizeof(*mp) * maxmagic);
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
- (void)memset(&mp[*nmentryp], 0, sizeof(*mp) *
|
|
|
|
- ALLOC_INCR);
|
|
|
|
+ mp = erealloc(*mentryp, sizeof(*mp) * maxmagic);
|
|
|
|
+ (void)memset(&mp[*nmentryp], 0, sizeof(*mp) * ALLOC_INCR);
|
|
|
|
*mentryp = mp;
|
|
|
|
}
|
|
|
|
me = &(*mentryp)[*nmentryp];
|
|
|
|
if (me->mp == NULL) {
|
|
|
|
- size_t len = sizeof(*m) * ALLOC_CHUNK;
|
|
|
|
- if ((m = CAST(struct magic *, malloc(len))) == NULL) {
|
|
|
|
- file_oomem(ms, len);
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ m = safe_emalloc(sizeof(*m), ALLOC_CHUNK, 0);
|
|
|
|
me->mp = m;
|
|
|
|
me->max_count = ALLOC_CHUNK;
|
|
|
|
} else
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1361,7 +1337,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
m->mask_op = 0;
|
|
|
|
if (*l == '~') {
|
|
|
|
- if (!IS_STRING(m->type))
|
|
|
|
+ if (!IS_LIBMAGIC_STRING(m->type))
|
|
|
|
m->mask_op |= FILE_OPINVERSE;
|
|
|
|
else if (ms->flags & MAGIC_CHECK)
|
|
|
|
file_magwarn(ms, "'~' invalid for string types");
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1370,7 +1346,7 @@
|
|
|
|
m->str_range = 0;
|
|
|
|
m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0;
|
2010-02-01 06:54:00 +08:00
|
|
|
if ((op = get_op(*l)) != -1) {
|
|
|
|
- if (!IS_STRING(m->type)) {
|
|
|
|
+ if (!IS_LIBMAGIC_STRING(m->type)) {
|
|
|
|
uint64_t val;
|
|
|
|
++l;
|
|
|
|
m->mask_op |= op;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1558,11 +1534,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if (check_format(ms, m) == -1)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
- if (action == FILE_CHECK) {
|
|
|
|
- file_mdump(m);
|
|
|
|
- }
|
|
|
|
-#endif
|
|
|
|
m->mimetype[0] = '\0'; /* initialise MIME type to none */
|
|
|
|
if (m->cont_level == 0)
|
|
|
|
++(*nmentryp); /* make room for next */
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2195,56 +2166,68 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* handle a compiled file.
|
|
|
|
+ * return -1 = error
|
|
|
|
+ * return 1 = memory structure you can free
|
|
|
|
+ * return 3 = bundled library from PHP
|
|
|
|
*/
|
|
|
|
private int
|
|
|
|
apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
|
|
|
const char *fn)
|
|
|
|
{
|
|
|
|
- int fd;
|
|
|
|
- struct stat st;
|
|
|
|
uint32_t *ptr;
|
|
|
|
uint32_t version;
|
2008-07-25 16:18:35 +08:00
|
|
|
int needsbyteswap;
|
|
|
|
char *dbname = NULL;
|
|
|
|
void *mm = NULL;
|
|
|
|
+ int ret = 0;
|
2010-02-01 06:54:00 +08:00
|
|
|
+ php_stream *stream = NULL;
|
|
|
|
+ php_stream_statbuf st;
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+ TSRMLS_FETCH();
|
2008-07-25 16:18:35 +08:00
|
|
|
+
|
|
|
|
+ if (fn == NULL) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+ mm = (void *)&php_magic_database;
|
2008-07-25 16:18:35 +08:00
|
|
|
+ ret = 3;
|
|
|
|
+ goto internal_loaded;
|
|
|
|
+ }
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
dbname = mkdbname(ms, fn, 0);
|
2008-07-25 16:18:35 +08:00
|
|
|
if (dbname == NULL)
|
2010-02-01 06:54:00 +08:00
|
|
|
goto error2;
|
|
|
|
|
|
|
|
- if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if PHP_API_VERSION < 20100412
|
2010-02-01 06:54:00 +08:00
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
|
|
|
|
+#else
|
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+ if (!stream) {
|
|
|
|
goto error2;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
- if (fstat(fd, &st) == -1) {
|
|
|
|
+ if (php_stream_stat(stream, &st) < 0) {
|
|
|
|
file_error(ms, errno, "cannot stat `%s'", dbname);
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
- if (st.st_size < 8) {
|
|
|
|
+
|
|
|
|
+ if (st.sb.st_size < 8) {
|
|
|
|
file_error(ms, 0, "file `%s' is too small", dbname);
|
2008-07-25 16:18:35 +08:00
|
|
|
goto error1;
|
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
-#ifdef QUICK
|
|
|
|
- if ((mm = mmap(0, (size_t)st.st_size, PROT_READ|PROT_WRITE,
|
|
|
|
- MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) {
|
|
|
|
- file_error(ms, errno, "cannot map `%s'", dbname);
|
|
|
|
- goto error1;
|
|
|
|
- }
|
2008-07-25 16:18:35 +08:00
|
|
|
-#define RET 2
|
2010-02-01 06:54:00 +08:00
|
|
|
-#else
|
|
|
|
- if ((mm = CAST(void *, malloc((size_t)st.st_size))) == NULL) {
|
|
|
|
- file_oomem(ms, (size_t)st.st_size);
|
|
|
|
- goto error1;
|
|
|
|
- }
|
|
|
|
- if (read(fd, mm, (size_t)st.st_size) != (ssize_t)st.st_size) {
|
|
|
|
+ mm = emalloc((size_t)st.sb.st_size);
|
|
|
|
+ if (php_stream_read(stream, mm, (size_t)st.sb.st_size) != (size_t)st.sb.st_size) {
|
2008-07-25 16:18:35 +08:00
|
|
|
file_badread(ms);
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
-#define RET 1
|
2010-02-01 06:54:00 +08:00
|
|
|
-#endif
|
|
|
|
- *magicp = CAST(struct magic *, mm);
|
|
|
|
- (void)close(fd);
|
|
|
|
- fd = -1;
|
2008-07-25 16:18:35 +08:00
|
|
|
+ ret = 1;
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
|
|
|
+ php_stream_close(stream);
|
|
|
|
+ stream = NULL;
|
|
|
|
+
|
2008-07-25 16:18:35 +08:00
|
|
|
+internal_loaded:
|
|
|
|
+ *magicp = mm;
|
|
|
|
ptr = (uint32_t *)(void *)*magicp;
|
|
|
|
if (*ptr != MAGICNO) {
|
|
|
|
if (swap4(*ptr) != MAGICNO) {
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2259,35 +2242,55 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
else
|
|
|
|
version = ptr[1];
|
|
|
|
if (version != VERSIONNO) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- file_error(ms, 0, "File %s supports only version %d magic "
|
|
|
|
- "files. `%s' is version %d", VERSION,
|
|
|
|
+ file_error(ms, 0, "File %d.%d supports only version %d magic "
|
|
|
|
+ "files. `%s' is version %d", FILE_VERSION_MAJOR, patchlevel,
|
2008-07-25 16:18:35 +08:00
|
|
|
VERSIONNO, dbname, version);
|
|
|
|
goto error1;
|
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
- *nmagicp = (uint32_t)(st.st_size / sizeof(struct magic));
|
|
|
|
- if (*nmagicp > 0)
|
|
|
|
+
|
|
|
|
+ /* php_magic_database is a const, performing writes will segfault. This is for big-endian
|
|
|
|
+ machines only, PPC and Sparc specifically. Consider static variable or MINIT in
|
|
|
|
+ future. */
|
|
|
|
+ if (needsbyteswap && fn == NULL) {
|
|
|
|
+ mm = emalloc(sizeof(php_magic_database));
|
|
|
|
+ mm = memcpy(mm, php_magic_database, sizeof(php_magic_database));
|
|
|
|
+ *magicp = mm;
|
|
|
|
+ ret = 1;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (fn == NULL) {
|
2008-07-25 16:18:35 +08:00
|
|
|
+ *nmagicp = (sizeof(php_magic_database) / sizeof(struct magic));
|
2010-02-01 06:54:00 +08:00
|
|
|
+ } else {
|
|
|
|
+ *nmagicp = (uint32_t)(st.sb.st_size / sizeof(struct magic));
|
|
|
|
+ }
|
|
|
|
+ if (*nmagicp > 0) {
|
2008-07-25 16:18:35 +08:00
|
|
|
(*nmagicp)--;
|
2010-02-01 06:54:00 +08:00
|
|
|
+ }
|
|
|
|
(*magicp)++;
|
|
|
|
- if (needsbyteswap)
|
|
|
|
+ if (needsbyteswap) {
|
2008-07-25 16:18:35 +08:00
|
|
|
byteswap(*magicp, *nmagicp);
|
2010-02-01 06:54:00 +08:00
|
|
|
- free(dbname);
|
2008-07-25 16:18:35 +08:00
|
|
|
- return RET;
|
2010-02-01 06:54:00 +08:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (dbname) {
|
|
|
|
+ efree(dbname);
|
|
|
|
+ }
|
2008-07-25 16:18:35 +08:00
|
|
|
+ return ret;
|
|
|
|
|
|
|
|
error1:
|
2010-02-01 06:54:00 +08:00
|
|
|
- if (fd != -1)
|
|
|
|
- (void)close(fd);
|
|
|
|
- if (mm) {
|
|
|
|
-#ifdef QUICK
|
|
|
|
- (void)munmap((void *)mm, (size_t)st.st_size);
|
|
|
|
-#else
|
|
|
|
- free(mm);
|
|
|
|
-#endif
|
|
|
|
+ if (stream) {
|
|
|
|
+ php_stream_close(stream);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (mm && ret == 1) {
|
|
|
|
+ efree(mm);
|
|
|
|
} else {
|
|
|
|
*magicp = NULL;
|
|
|
|
*nmagicp = 0;
|
|
|
|
}
|
|
|
|
error2:
|
|
|
|
- free(dbname);
|
|
|
|
+ if (dbname) {
|
|
|
|
+ efree(dbname);
|
|
|
|
+ }
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2301,42 +2304,49 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
apprentice_compile(struct magic_set *ms, struct magic **magicp,
|
|
|
|
uint32_t *nmagicp, const char *fn)
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
- int fd = -1;
|
2010-02-01 06:54:00 +08:00
|
|
|
char *dbname;
|
|
|
|
int rv = -1;
|
|
|
|
+ php_stream *stream;
|
|
|
|
|
|
|
|
- dbname = mkdbname(ms, fn, 1);
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+
|
2012-03-27 19:34:46 +08:00
|
|
|
+ dbname = mkdbname(ms, fn, 0);
|
|
|
|
|
|
|
|
if (dbname == NULL)
|
2010-02-01 06:54:00 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
- if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1) {
|
|
|
|
+/* wb+ == O_WRONLY|O_CREAT|O_TRUNC|O_BINARY */
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if PHP_API_VERSION < 20100412
|
2010-02-01 06:54:00 +08:00
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
|
|
|
|
+#else
|
|
|
|
+ stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS, NULL);
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+ if (!stream) {
|
|
|
|
file_error(ms, errno, "cannot open `%s'", dbname);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
|
|
|
|
+ if (php_stream_write(stream, (char *)ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
|
|
|
|
file_error(ms, errno, "error writing `%s'", dbname);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET)
|
|
|
|
- != sizeof(struct magic)) {
|
|
|
|
+ if (php_stream_seek(stream,(off_t)sizeof(struct magic), SEEK_SET) != sizeof(struct magic)) {
|
|
|
|
file_error(ms, errno, "error seeking `%s'", dbname);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp))
|
|
|
|
- != (ssize_t)(sizeof(struct magic) * *nmagicp)) {
|
|
|
|
+ if (php_stream_write(stream, (char *)*magicp, (sizeof(struct magic) * *nmagicp) != (ssize_t)(sizeof(struct magic) * *nmagicp))) {
|
|
|
|
file_error(ms, errno, "error writing `%s'", dbname);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (fd != -1)
|
|
|
|
- (void)close(fd);
|
2010-02-01 06:54:00 +08:00
|
|
|
+ php_stream_close(stream);
|
|
|
|
+
|
|
|
|
rv = 0;
|
|
|
|
out:
|
|
|
|
- free(dbname);
|
|
|
|
+ efree(dbname);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2349,6 +2359,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
char *buf;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
|
|
|
|
if (strip) {
|
|
|
|
if ((p = strrchr(fn, '/')) != NULL)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2370,14 +2381,14 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
q++;
|
|
|
|
/* Compatibility with old code that looked in .mime */
|
|
|
|
if (ms->flags & MAGIC_MIME) {
|
|
|
|
- asprintf(&buf, "%.*s.mime%s", (int)(q - fn), fn, ext);
|
|
|
|
- if (access(buf, R_OK) != -1) {
|
|
|
|
+ spprintf(&buf, MAXPATHLEN, "%.*s.mime%s", (int)(q - fn), fn, ext);
|
|
|
|
+ if (VCWD_ACCESS(buf, R_OK) != -1) {
|
|
|
|
ms->flags &= MAGIC_MIME_TYPE;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
- free(buf);
|
|
|
|
+ efree(buf);
|
|
|
|
}
|
|
|
|
- asprintf(&buf, "%.*s%s", (int)(q - fn), fn, ext);
|
|
|
|
+ spprintf(&buf, MAXPATHLEN, "%.*s%s", (int)(q - fn), fn, ext);
|
|
|
|
|
|
|
|
/* Compatibility with old code that looked in .mime */
|
|
|
|
if (strstr(p, ".mime") != NULL)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -2467,7 +2478,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
m->offset = swap4((uint32_t)m->offset);
|
|
|
|
m->in_offset = swap4((uint32_t)m->in_offset);
|
|
|
|
m->lineno = swap4((uint32_t)m->lineno);
|
|
|
|
- if (IS_STRING(m->type)) {
|
|
|
|
+ if (IS_LIBMAGIC_STRING(m->type)) {
|
|
|
|
m->str_range = swap4(m->str_range);
|
|
|
|
m->str_flags = swap4(m->str_flags);
|
|
|
|
}
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/ascmagic.c libmagic/ascmagic.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/ascmagic.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/ascmagic.c 2012-04-22 18:57:16.215980866 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -139,10 +139,8 @@
|
|
|
|
/* malloc size is a conservative overestimate; could be
|
|
|
|
improved, or at least realloced after conversion. */
|
|
|
|
mlen = ulen * 6;
|
|
|
|
- if ((utf8_buf = CAST(unsigned char *, malloc(mlen))) == NULL) {
|
|
|
|
- file_oomem(ms, mlen);
|
|
|
|
- goto done;
|
|
|
|
- }
|
|
|
|
+ utf8_buf = emalloc(mlen);
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
2012-03-27 19:34:46 +08:00
|
|
|
if ((utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen))
|
|
|
|
== NULL)
|
|
|
|
goto done;
|
|
|
|
@@ -296,7 +294,8 @@
|
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
rv = 1;
|
|
|
|
done:
|
2012-03-27 19:34:46 +08:00
|
|
|
- free(utf8_buf);
|
|
|
|
+ if (utf8_buf)
|
2010-02-01 06:54:00 +08:00
|
|
|
+ efree(utf8_buf);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/cdf.c libmagic/cdf.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/cdf.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/cdf.c 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -43,7 +43,17 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#include <err.h>
|
|
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
+
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/unistd.h"
|
|
|
|
+#else
|
|
|
|
#include <unistd.h>
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+#ifndef UINT32_MAX
|
|
|
|
+# define UINT32_MAX (0xffffffff)
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <ctype.h>
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -296,10 +306,10 @@
|
|
|
|
if (info->i_fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
- if (lseek(info->i_fd, off, SEEK_SET) == (off_t)-1)
|
|
|
|
+ if (FINFO_LSEEK_FUNC(info->i_fd, off, SEEK_SET) == (off_t)-1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
- if (read(info->i_fd, buf, len) != (ssize_t)len)
|
|
|
|
+ if (FINFO_READ_FUNC(info->i_fd, buf, len) != (ssize_t)len)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return (ssize_t)len;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1135,7 +1145,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
cdf_directory_t *d;
|
|
|
|
char name[__arraycount(d->d_name)];
|
|
|
|
cdf_stream_t scn;
|
|
|
|
- struct timespec ts;
|
|
|
|
+ struct timeval ts;
|
|
|
|
|
|
|
|
static const char *types[] = { "empty", "user storage",
|
|
|
|
"user stream", "lockbytes", "property", "root storage" };
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1188,7 +1198,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
cdf_dump_property_info(const cdf_property_info_t *info, size_t count)
|
|
|
|
{
|
|
|
|
cdf_timestamp_t tp;
|
|
|
|
- struct timespec ts;
|
|
|
|
+ struct timeval ts;
|
|
|
|
char buf[64];
|
2012-03-27 19:34:46 +08:00
|
|
|
size_t i, j;
|
|
|
|
|
|
|
|
@@ -1232,7 +1242,11 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
break;
|
|
|
|
case CDF_FILETIME:
|
|
|
|
tp = info[i].pi_tp;
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if defined(PHP_WIN32) && _MSC_VER <= 1500
|
2010-02-01 06:54:00 +08:00
|
|
|
+ if (tp < 1000000000000000i64) {
|
|
|
|
+#else
|
|
|
|
if (tp < 1000000000000000LL) {
|
|
|
|
+#endif
|
|
|
|
cdf_print_elapsed_time(buf, sizeof(buf), tp);
|
|
|
|
(void)fprintf(stderr, "timestamp %s\n", buf);
|
|
|
|
} else {
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/cdf.h libmagic/cdf.h
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/cdf.h 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/cdf.h 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -35,7 +35,7 @@
|
|
|
|
#ifndef _H_CDF_
|
|
|
|
#define _H_CDF_
|
|
|
|
|
|
|
|
-#ifdef WIN32
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
#include <winsock2.h>
|
|
|
|
#define timespec timeval
|
|
|
|
#define tv_nsec tv_usec
|
|
|
|
@@ -57,7 +57,11 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint64_t h_magic;
|
|
|
|
-#define CDF_MAGIC 0xE11AB1A1E011CFD0LL
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if defined(PHP_WIN32) && _MSC_VER <= 1500
|
2010-02-01 06:54:00 +08:00
|
|
|
+# define CDF_MAGIC 0xE11AB1A1E011CFD0i64
|
|
|
|
+#else
|
|
|
|
+# define CDF_MAGIC 0xE11AB1A1E011CFD0LL
|
|
|
|
+#endif
|
|
|
|
uint64_t h_uuid[2];
|
|
|
|
uint16_t h_revision;
|
|
|
|
uint16_t h_version;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -267,9 +271,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
size_t i_len;
|
|
|
|
} cdf_info_t;
|
|
|
|
|
|
|
|
-struct timespec;
|
|
|
|
-int cdf_timestamp_to_timespec(struct timespec *, cdf_timestamp_t);
|
|
|
|
-int cdf_timespec_to_timestamp(cdf_timestamp_t *, const struct timespec *);
|
|
|
|
+struct timeval;
|
|
|
|
+int cdf_timestamp_to_timespec(struct timeval *, cdf_timestamp_t);
|
|
|
|
+int cdf_timespec_to_timestamp(cdf_timestamp_t *, const struct timeval *);
|
|
|
|
int cdf_read_header(const cdf_info_t *, cdf_header_t *);
|
|
|
|
void cdf_swap_header(cdf_header_t *);
|
|
|
|
void cdf_unpack_header(cdf_header_t *, char *);
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/cdf_time.c libmagic/cdf_time.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/cdf_time.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/cdf_time.c 2012-04-22 18:57:16.219978162 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -96,7 +96,7 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
-cdf_timestamp_to_timespec(struct timespec *ts, cdf_timestamp_t t)
|
|
|
|
+cdf_timestamp_to_timespec(struct timeval *ts, cdf_timestamp_t t)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
|
|
|
#ifdef HAVE_STRUCT_TM_TM_ZONE
|
|
|
|
@@ -104,8 +104,8 @@
|
|
|
|
#endif
|
|
|
|
int rdays;
|
|
|
|
|
|
|
|
- /* Unit is 100's of nanoseconds */
|
|
|
|
- ts->tv_nsec = (t % CDF_TIME_PREC) * 100;
|
|
|
|
+ /* Time interval, in microseconds */
|
|
|
|
+ ts->tv_usec = (t % CDF_TIME_PREC) * CDF_TIME_PREC;
|
|
|
|
|
|
|
|
t /= CDF_TIME_PREC;
|
2012-03-27 19:34:46 +08:00
|
|
|
tm.tm_sec = (int)(t % 60);
|
2011-10-19 23:08:50 +08:00
|
|
|
@@ -117,7 +117,7 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
tm.tm_hour = (int)(t % 24);
|
2011-10-19 23:08:50 +08:00
|
|
|
t /= 24;
|
|
|
|
|
|
|
|
- // XXX: Approx
|
|
|
|
+ /* XXX: Approx */
|
2012-03-27 19:34:46 +08:00
|
|
|
tm.tm_year = (int)(CDF_BASE_YEAR + (t / 365));
|
2011-10-19 23:08:50 +08:00
|
|
|
|
|
|
|
rdays = cdf_getdays(tm.tm_year);
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -144,7 +144,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
int
|
2012-03-27 19:34:46 +08:00
|
|
|
/*ARGSUSED*/
|
2010-02-01 06:54:00 +08:00
|
|
|
-cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timespec *ts)
|
|
|
|
+cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timeval *ts)
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
#ifndef __lint__
|
2010-02-01 06:54:00 +08:00
|
|
|
(void)&t;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -156,7 +156,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
errno = EINVAL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- *t = (ts->ts_nsec / 100) * CDF_TIME_PREC;
|
|
|
|
+ *t = (ts->ts_usec / CDF_TIME_PREC) * CDF_TIME_PREC;
|
|
|
|
*t = tm.tm_sec;
|
|
|
|
*t += tm.tm_min * 60;
|
|
|
|
*t += tm.tm_hour * 60 * 60;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -182,7 +182,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
- struct timespec ts;
|
|
|
|
+ struct timeval ts;
|
|
|
|
static const cdf_timestamp_t tst = 0x01A5E403C2D59C00ULL;
|
|
|
|
static const char *ref = "Sat Apr 23 01:30:00 1977";
|
|
|
|
char *p, *q;
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/compress.c libmagic/compress.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/compress.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/compress.c 2012-04-22 18:57:16.219978162 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -32,6 +32,7 @@
|
|
|
|
* uncompress(method, old, n, newch) - uncompress old into new,
|
|
|
|
* using method, return sizeof new
|
|
|
|
*/
|
|
|
|
+#include "config.h"
|
|
|
|
#include "file.h"
|
|
|
|
|
|
|
|
#ifndef lint
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -45,7 +46,8 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2012-03-27 19:34:46 +08:00
|
|
|
-#ifndef __MINGW32__
|
2010-02-01 06:54:00 +08:00
|
|
|
+#include <sys/types.h>
|
|
|
|
+#ifndef PHP_WIN32
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
#ifdef HAVE_SYS_WAIT_H
|
|
|
|
@@ -59,6 +61,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#include <zlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
+#undef FIONREAD
|
|
|
|
+
|
|
|
|
+
|
|
|
|
private const struct {
|
|
|
|
const char magic[8];
|
|
|
|
size_t maglen;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -85,8 +90,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#define NODATA ((size_t)~0)
|
|
|
|
|
|
|
|
private ssize_t swrite(int, const void *, size_t);
|
2012-03-27 19:34:46 +08:00
|
|
|
-#if HAVE_FORK
|
|
|
|
-private size_t ncompr = sizeof(compr) / sizeof(compr[0]);
|
2010-02-01 06:54:00 +08:00
|
|
|
+#ifdef PHP_FILEINFO_UNCOMPRESS
|
|
|
|
private size_t uncompressbuf(struct magic_set *, int, size_t,
|
|
|
|
const unsigned char *, unsigned char **, size_t);
|
|
|
|
#ifdef BUILTIN_DECOMPRESS
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -102,10 +106,13 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
size_t i, nsz;
|
|
|
|
int rv = 0;
|
|
|
|
int mime = ms->flags & MAGIC_MIME;
|
|
|
|
+ size_t ncompr;
|
|
|
|
|
|
|
|
if ((ms->flags & MAGIC_COMPRESS) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
+ ncompr = sizeof(compr) / sizeof(compr[0]);
|
|
|
|
+
|
|
|
|
for (i = 0; i < ncompr; i++) {
|
|
|
|
if (nbytes < compr[i].maglen)
|
|
|
|
continue;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -134,7 +141,8 @@
|
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
error:
|
2012-03-27 19:34:46 +08:00
|
|
|
- free(newbuf);
|
|
|
|
+ if (newbuf)
|
2010-02-01 06:54:00 +08:00
|
|
|
+ efree(newbuf);
|
|
|
|
ms->flags |= MAGIC_COMPRESS;
|
|
|
|
return rv;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -168,12 +176,9 @@
|
|
|
|
* `safe' read for sockets and pipes.
|
|
|
|
*/
|
2010-02-01 06:54:00 +08:00
|
|
|
protected ssize_t
|
2012-03-27 19:34:46 +08:00
|
|
|
-sread(int fd, void *buf, size_t n, int canbepipe __attribute__ ((unused)))
|
|
|
|
+sread(int fd, void *buf, size_t n, int canbepipe)
|
2010-02-01 06:54:00 +08:00
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
ssize_t rv;
|
|
|
|
-#ifdef FD_ZERO
|
|
|
|
- ssize_t cnt;
|
|
|
|
-#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifdef FIONREAD
|
|
|
|
int t = 0;
|
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -185,6 +190,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifdef FIONREAD
|
|
|
|
if ((canbepipe && (ioctl(fd, FIONREAD, &t) == -1)) || (t == 0)) {
|
|
|
|
#ifdef FD_ZERO
|
|
|
|
+ int cnt;
|
|
|
|
for (cnt = 0;; cnt++) {
|
|
|
|
fd_set check;
|
|
|
|
struct timeval tout = {0, 100 * 1000};
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -218,7 +224,7 @@
|
|
|
|
|
|
|
|
nocheck:
|
|
|
|
do
|
|
|
|
- switch ((rv = read(fd, buf, n))) {
|
|
|
|
+ switch ((rv = FINFO_READ_FUNC(fd, buf, n))) {
|
|
|
|
case -1:
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
@@ -295,13 +301,14 @@
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
(void)close(tfd);
|
|
|
|
- if (lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, (off_t)0, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
2012-03-27 19:34:46 +08:00
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
return fd;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
-#if HAVE_FORK
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
+#ifdef PHP_FILEINFO_UNCOMPRESS
|
|
|
|
#ifdef BUILTIN_DECOMPRESS
|
|
|
|
|
|
|
|
#define FHCRC (1 << 1)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -338,9 +345,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
if (data_start >= n)
|
|
|
|
return 0;
|
|
|
|
- if ((*newch = CAST(unsigned char *, malloc(HOWMANY + 1))) == NULL) {
|
|
|
|
- return 0;
|
|
|
|
- }
|
|
|
|
+ *newch = (unsigned char *)emalloc(HOWMANY + 1));
|
|
|
|
|
|
|
|
/* XXX: const castaway, via strchr */
|
|
|
|
z.next_in = (Bytef *)strchr((const char *)old + data_start,
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -400,7 +405,7 @@
|
|
|
|
(void) close(0);
|
|
|
|
if (fd != -1) {
|
|
|
|
(void) dup(fd);
|
|
|
|
- (void) lseek(0, (off_t)0, SEEK_SET);
|
|
|
|
+ (void) FINFO_LSEEK_FUNC(0, (off_t)0, SEEK_SET);
|
|
|
|
} else {
|
|
|
|
(void) dup(fdin[0]);
|
|
|
|
(void) close(fdin[0]);
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -465,20 +470,14 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
fdin[1] = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if ((*newch = (unsigned char *) malloc(HOWMANY + 1)) == NULL) {
|
|
|
|
-#ifdef DEBUG
|
|
|
|
- (void)fprintf(stderr, "Malloc failed (%s)\n",
|
|
|
|
- strerror(errno));
|
|
|
|
-#endif
|
|
|
|
- n = 0;
|
|
|
|
- goto err;
|
|
|
|
- }
|
|
|
|
+ *newch = (unsigned char *) emalloc(HOWMANY + 1);
|
|
|
|
+
|
|
|
|
if ((r = sread(fdout[0], *newch, HOWMANY, 0)) <= 0) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
(void)fprintf(stderr, "Read failed (%s)\n",
|
|
|
|
strerror(errno));
|
|
|
|
#endif
|
|
|
|
- free(*newch);
|
|
|
|
+ efree(*newch);
|
|
|
|
n = 0;
|
|
|
|
newch[0] = '\0';
|
|
|
|
goto err;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -502,4 +501,4 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
-#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
+#endif /* if PHP_FILEINFO_UNCOMPRESS */
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/file.h libmagic/file.h
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/file.h 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/file.h 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -33,11 +33,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifndef __file_h__
|
|
|
|
#define __file_h__
|
|
|
|
|
|
|
|
-#ifdef HAVE_CONFIG_H
|
|
|
|
-#include <config.h>
|
|
|
|
-#endif
|
|
|
|
+#include "config.h"
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
-#ifdef WIN32
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
#ifdef _WIN64
|
|
|
|
#define SIZE_T_FORMAT "I64"
|
|
|
|
#else
|
|
|
|
@@ -61,9 +59,20 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifdef HAVE_INTTYPES_H
|
|
|
|
#include <inttypes.h>
|
|
|
|
#endif
|
|
|
|
-#include <regex.h>
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/php_stdint.h"
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+#include "php.h"
|
|
|
|
+#include "ext/standard/php_string.h"
|
|
|
|
+#include "ext/pcre/php_pcre.h"
|
|
|
|
+
|
|
|
|
#include <sys/types.h>
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/param.h"
|
|
|
|
+#else
|
|
|
|
#include <sys/param.h>
|
|
|
|
+#endif
|
|
|
|
/* Do this here and now, because struct stat gets re-defined on solaris */
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <stdarg.h>
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -74,7 +83,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#define MAGIC "/etc/magic"
|
|
|
|
#endif
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
-#if defined(__EMX__) || defined (WIN32)
|
2010-02-01 06:54:00 +08:00
|
|
|
+#if defined(__EMX__) || defined(PHP_WIN32)
|
|
|
|
#define PATHSEP ';'
|
|
|
|
#else
|
|
|
|
#define PATHSEP ':'
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -100,12 +109,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
-#ifndef __GNUC__
|
|
|
|
-#ifndef __attribute__
|
|
|
|
-#define __attribute__(a)
|
|
|
|
-#endif
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
#ifndef MIN
|
|
|
|
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
|
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -209,7 +212,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#define FILE_INDIRECT 41
|
|
|
|
#define FILE_NAMES_SIZE 42/* size of array to contain all names */
|
|
|
|
|
|
|
|
-#define IS_STRING(t) \
|
|
|
|
+#define IS_LIBMAGIC_STRING(t) \
|
|
|
|
((t) == FILE_STRING || \
|
|
|
|
(t) == FILE_PSTRING || \
|
|
|
|
(t) == FILE_BESTRING16 || \
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -231,7 +234,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifdef ENABLE_CONDITIONALS
|
|
|
|
uint8_t cond; /* conditional type */
|
|
|
|
#else
|
|
|
|
- uint8_t dummy;
|
|
|
|
+ uint8_t dummy;
|
|
|
|
#endif
|
|
|
|
uint8_t factor_op;
|
|
|
|
#define FILE_FACTOR_OP_PLUS '+'
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -387,21 +390,18 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
struct stat;
|
|
|
|
protected const char *file_fmttime(uint32_t, int);
|
|
|
|
-protected int file_buffer(struct magic_set *, int, const char *, const void *,
|
|
|
|
+protected int file_buffer(struct magic_set *, php_stream *, const char *, const void *,
|
|
|
|
size_t);
|
|
|
|
-protected int file_fsmagic(struct magic_set *, const char *, struct stat *);
|
|
|
|
+protected int file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb, php_stream *stream);
|
|
|
|
protected int file_pipe2file(struct magic_set *, int, const void *, size_t);
|
|
|
|
-protected int file_vprintf(struct magic_set *, const char *, va_list);
|
2012-03-27 19:34:46 +08:00
|
|
|
-protected size_t file_printedlen(const struct magic_set *);
|
|
|
|
protected int file_replace(struct magic_set *, const char *, const char *);
|
2010-02-01 06:54:00 +08:00
|
|
|
-protected int file_printf(struct magic_set *, const char *, ...)
|
|
|
|
- __attribute__((__format__(__printf__, 2, 3)));
|
|
|
|
+protected int file_printf(struct magic_set *, const char *, ...);
|
|
|
|
protected int file_reset(struct magic_set *);
|
|
|
|
protected int file_tryelf(struct magic_set *, int, const unsigned char *,
|
|
|
|
size_t);
|
|
|
|
protected int file_trycdf(struct magic_set *, int, const unsigned char *,
|
|
|
|
size_t);
|
2012-03-27 19:34:46 +08:00
|
|
|
-#if HAVE_FORK
|
2010-02-01 06:54:00 +08:00
|
|
|
+#ifdef PHP_FILEINFO_UNCOMPRESS
|
|
|
|
protected int file_zmagic(struct magic_set *, int, const char *,
|
|
|
|
const unsigned char *, size_t);
|
2012-03-27 19:34:46 +08:00
|
|
|
#endif
|
|
|
|
@@ -422,13 +422,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
protected void file_badread(struct magic_set *);
|
|
|
|
protected void file_badseek(struct magic_set *);
|
|
|
|
protected void file_oomem(struct magic_set *, size_t);
|
|
|
|
-protected void file_error(struct magic_set *, int, const char *, ...)
|
|
|
|
- __attribute__((__format__(__printf__, 3, 4)));
|
|
|
|
-protected void file_magerror(struct magic_set *, const char *, ...)
|
|
|
|
- __attribute__((__format__(__printf__, 2, 3)));
|
|
|
|
-protected void file_magwarn(struct magic_set *, const char *, ...)
|
|
|
|
- __attribute__((__format__(__printf__, 2, 3)));
|
|
|
|
-protected void file_mdump(struct magic *);
|
|
|
|
+protected void file_error(struct magic_set *, int, const char *, ...);
|
|
|
|
+protected void file_magerror(struct magic_set *, const char *, ...);
|
|
|
|
+protected void file_magwarn(struct magic_set *, const char *, ...);
|
|
|
|
protected void file_showstr(FILE *, const char *, size_t);
|
|
|
|
protected size_t file_mbswidth(const char *);
|
|
|
|
protected const char *file_getbuffer(struct magic_set *);
|
2012-04-22 19:52:07 +08:00
|
|
|
@@ -438,16 +434,14 @@
|
|
|
|
size_t *);
|
|
|
|
protected size_t file_pstring_length_size(const struct magic *);
|
|
|
|
protected size_t file_pstring_get_length(const struct magic *, const char *);
|
|
|
|
+protected size_t file_printedlen(const struct magic_set *ms);
|
|
|
|
#ifdef __EMX__
|
|
|
|
protected int file_os2_apptype(struct magic_set *, const char *, const void *,
|
2010-02-01 06:54:00 +08:00
|
|
|
size_t);
|
|
|
|
#endif /* __EMX__ */
|
|
|
|
|
|
|
|
-
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
extern const char *file_names[];
|
|
|
|
extern const size_t file_nnames;
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_STRERROR
|
|
|
|
extern int sys_nerr;
|
2012-04-22 19:52:07 +08:00
|
|
|
@@ -460,17 +454,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#define strtoul(a, b, c) strtol(a, b, c)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
-#ifndef HAVE_VASPRINTF
|
|
|
|
-int vasprintf(char **, const char *, va_list);
|
|
|
|
-#endif
|
|
|
|
-#ifndef HAVE_ASPRINTF
|
|
|
|
-int asprintf(char **ptr, const char *format_string, ...);
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#ifndef HAVE_STRLCPY
|
|
|
|
+#ifndef strlcpy
|
|
|
|
size_t strlcpy(char *dst, const char *src, size_t siz);
|
|
|
|
#endif
|
|
|
|
-#ifndef HAVE_STRLCAT
|
|
|
|
+#ifndef strlcat
|
|
|
|
size_t strlcat(char *dst, const char *src, size_t siz);
|
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
#ifndef HAVE_GETLINE
|
2012-04-22 19:52:07 +08:00
|
|
|
@@ -500,4 +487,12 @@
|
2012-04-02 23:27:23 +08:00
|
|
|
#define FILE_RCSID(id)
|
2012-04-22 19:38:14 +08:00
|
|
|
#endif
|
|
|
|
|
2012-04-02 23:27:23 +08:00
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#define FINFO_LSEEK_FUNC _lseek
|
|
|
|
+#define FINFO_READ_FUNC _read
|
|
|
|
+#else
|
|
|
|
+#define FINFO_LSEEK_FUNC lseek
|
|
|
|
+#define FINFO_READ_FUNC read
|
2012-04-22 19:38:14 +08:00
|
|
|
+#endif
|
|
|
|
+
|
2012-04-02 23:27:23 +08:00
|
|
|
#endif /* __file_h__ */
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/fsmagic.c libmagic/fsmagic.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/fsmagic.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/fsmagic.c 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -59,27 +59,21 @@
|
|
|
|
# define minor(dev) ((dev) & 0xff)
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
#undef HAVE_MAJOR
|
2012-03-27 19:34:46 +08:00
|
|
|
-#ifdef S_IFLNK
|
2010-02-01 06:54:00 +08:00
|
|
|
-private int
|
|
|
|
-bad_link(struct magic_set *ms, int err, char *buf)
|
|
|
|
-{
|
|
|
|
- int mime = ms->flags & MAGIC_MIME;
|
|
|
|
- if ((mime & MAGIC_MIME_TYPE) &&
|
2012-03-27 19:34:46 +08:00
|
|
|
- file_printf(ms, "inode/symlink")
|
2010-02-01 06:54:00 +08:00
|
|
|
- == -1)
|
|
|
|
- return -1;
|
|
|
|
- else if (!mime) {
|
|
|
|
- if (ms->flags & MAGIC_ERROR) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- file_error(ms, err,
|
|
|
|
- "broken symbolic link to `%s'", buf);
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- }
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (file_printf(ms, "broken symbolic link to `%s'", buf) == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
- return 1;
|
|
|
|
-}
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+
|
|
|
|
+# undef S_IFIFO
|
2012-03-27 19:34:46 +08:00
|
|
|
#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
|
|
|
+
|
|
|
|
+#ifndef S_ISDIR
|
|
|
|
+#define S_ISDIR(mode) ((mode) & _S_IFDIR)
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+#ifndef S_ISREG
|
|
|
|
+#define S_ISREG(mode) ((mode) & _S_IFREG)
|
|
|
|
+#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
private int
|
|
|
|
handle_mime(struct magic_set *ms, int mime, const char *str)
|
2012-03-27 19:34:46 +08:00
|
|
|
{
|
|
|
|
@@ -96,42 +90,36 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
protected int
|
|
|
|
-file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
|
|
|
|
+file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb, php_stream *stream)
|
|
|
|
{
|
|
|
|
- int ret = 0;
|
|
|
|
int mime = ms->flags & MAGIC_MIME;
|
|
|
|
-#ifdef S_IFLNK
|
|
|
|
- char buf[BUFSIZ+4];
|
2012-03-27 19:34:46 +08:00
|
|
|
- ssize_t nch;
|
2010-02-01 06:54:00 +08:00
|
|
|
- struct stat tstatbuf;
|
|
|
|
-#endif
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
|
|
|
|
if (ms->flags & MAGIC_APPLE)
|
|
|
|
return 0;
|
|
|
|
- if (fn == NULL)
|
|
|
|
+
|
|
|
|
+ if (!fn && !stream) {
|
|
|
|
return 0;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
- /*
|
|
|
|
- * Fstat is cheaper but fails for files you don't have read perms on.
|
|
|
|
- * On 4.2BSD and similar systems, use lstat() to identify symlinks.
|
|
|
|
- */
|
|
|
|
-#ifdef S_IFLNK
|
|
|
|
- if ((ms->flags & MAGIC_SYMLINK) == 0)
|
|
|
|
- ret = lstat(fn, sb);
|
|
|
|
- else
|
|
|
|
-#endif
|
|
|
|
- ret = stat(fn, sb); /* don't merge into if; see "ret =" above */
|
|
|
|
-
|
|
|
|
- if (ret) {
|
|
|
|
- if (ms->flags & MAGIC_ERROR) {
|
|
|
|
- file_error(ms, errno, "cannot stat `%s'", fn);
|
|
|
|
- return -1;
|
|
|
|
+ if (stream) {
|
|
|
|
+ php_stream_statbuf ssb;
|
|
|
|
+ if (php_stream_stat(stream, &ssb) < 0) {
|
|
|
|
+ if (ms->flags & MAGIC_ERROR) {
|
|
|
|
+ file_error(ms, errno, "cannot stat `%s'", fn);
|
|
|
|
+ return -1;
|
|
|
|
+ }
|
|
|
|
+ return 1;
|
|
|
|
+ }
|
|
|
|
+ memcpy(sb, &ssb.sb, sizeof(struct stat));
|
|
|
|
+ } else {
|
|
|
|
+ if (php_sys_stat(fn, sb) != 0) {
|
|
|
|
+ if (ms->flags & MAGIC_ERROR) {
|
|
|
|
+ file_error(ms, errno, "cannot stat `%s'", fn);
|
|
|
|
+ return -1;
|
|
|
|
+ }
|
|
|
|
+ return 1;
|
|
|
|
}
|
|
|
|
- if (file_printf(ms, "cannot open `%s' (%s)",
|
|
|
|
- fn, strerror(errno)) == -1)
|
|
|
|
- return -1;
|
2012-03-27 19:34:46 +08:00
|
|
|
- ms->event_flags |= EVENT_HAD_ERR;
|
|
|
|
- return -1;
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!mime) {
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -153,77 +141,42 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
switch (sb->st_mode & S_IFMT) {
|
|
|
|
- case S_IFDIR:
|
|
|
|
- if (mime) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (handle_mime(ms, mime, "directory") == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- } else if (file_printf(ms, "directory") == -1)
|
|
|
|
- return -1;
|
|
|
|
- return 1;
|
|
|
|
-#ifdef S_IFCHR
|
|
|
|
- case S_IFCHR:
|
|
|
|
- /*
|
|
|
|
- * If -s has been specified, treat character special files
|
|
|
|
- * like ordinary files. Otherwise, just report that they
|
|
|
|
- * are block special files and go on to the next file.
|
|
|
|
- */
|
|
|
|
- if ((ms->flags & MAGIC_DEVICES) != 0)
|
|
|
|
- break;
|
|
|
|
- if (mime) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (handle_mime(ms, mime, "chardevice") == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- } else {
|
|
|
|
-#ifdef HAVE_STAT_ST_RDEV
|
|
|
|
-# ifdef dv_unit
|
|
|
|
- if (file_printf(ms, "character special (%d/%d/%d)",
|
|
|
|
- major(sb->st_rdev), dv_unit(sb->st_rdev),
|
|
|
|
- dv_subunit(sb->st_rdev)) == -1)
|
|
|
|
- return -1;
|
|
|
|
-# else
|
|
|
|
- if (file_printf(ms, "character special (%ld/%ld)",
|
|
|
|
- (long)major(sb->st_rdev), (long)minor(sb->st_rdev))
|
|
|
|
- == -1)
|
|
|
|
- return -1;
|
|
|
|
-# endif
|
|
|
|
-#else
|
|
|
|
- if (file_printf(ms, "character special") == -1)
|
|
|
|
- return -1;
|
|
|
|
-#endif
|
|
|
|
- }
|
|
|
|
- return 1;
|
|
|
|
-#endif
|
|
|
|
-#ifdef S_IFBLK
|
|
|
|
- case S_IFBLK:
|
|
|
|
- /*
|
|
|
|
- * If -s has been specified, treat block special files
|
|
|
|
- * like ordinary files. Otherwise, just report that they
|
|
|
|
- * are block special files and go on to the next file.
|
|
|
|
- */
|
|
|
|
- if ((ms->flags & MAGIC_DEVICES) != 0)
|
|
|
|
- break;
|
|
|
|
- if (mime) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (handle_mime(ms, mime, "blockdevice") == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- } else {
|
|
|
|
-#ifdef HAVE_STAT_ST_RDEV
|
|
|
|
-# ifdef dv_unit
|
|
|
|
- if (file_printf(ms, "block special (%d/%d/%d)",
|
|
|
|
- major(sb->st_rdev), dv_unit(sb->st_rdev),
|
|
|
|
- dv_subunit(sb->st_rdev)) == -1)
|
|
|
|
- return -1;
|
|
|
|
-# else
|
|
|
|
- if (file_printf(ms, "block special (%ld/%ld)",
|
|
|
|
- (long)major(sb->st_rdev), (long)minor(sb->st_rdev)) == -1)
|
|
|
|
- return -1;
|
|
|
|
+#ifndef PHP_WIN32
|
|
|
|
+# ifdef S_IFCHR
|
|
|
|
+ case S_IFCHR:
|
|
|
|
+ /*
|
|
|
|
+ * If -s has been specified, treat character special files
|
|
|
|
+ * like ordinary files. Otherwise, just report that they
|
|
|
|
+ * are block special files and go on to the next file.
|
|
|
|
+ */
|
|
|
|
+ if ((ms->flags & MAGIC_DEVICES) != 0) {
|
|
|
|
+ break;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ }
|
|
|
|
+ if (mime) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+ if (handle_mime(ms, mime, "x-character-device") == -1)
|
2012-03-27 19:34:46 +08:00
|
|
|
+ return -1;
|
2010-02-01 06:54:00 +08:00
|
|
|
+ } else {
|
|
|
|
+# ifdef HAVE_STAT_ST_RDEV
|
|
|
|
+# ifdef dv_unit
|
|
|
|
+ if (file_printf(ms, "character special (%d/%d/%d)",
|
|
|
|
+ major(sb->st_rdev), dv_unit(sb->st_rdev),
|
|
|
|
+ dv_subunit(sb->st_rdev)) == -1)
|
|
|
|
+ return -1;
|
|
|
|
+# else
|
|
|
|
+ if (file_printf(ms, "character special (%ld/%ld)",
|
|
|
|
+ (long)major(sb->st_rdev), (long)minor(sb->st_rdev))
|
|
|
|
+ == -1)
|
|
|
|
+ return -1;
|
|
|
|
+# endif
|
|
|
|
+# else
|
|
|
|
+ if (file_printf(ms, "character special") == -1)
|
|
|
|
+ return -1;
|
|
|
|
+# endif
|
|
|
|
+ }
|
2012-03-27 19:34:46 +08:00
|
|
|
+ return 1;
|
|
|
|
# endif
|
|
|
|
-#else
|
|
|
|
- if (file_printf(ms, "block special") == -1)
|
|
|
|
- return -1;
|
2012-04-02 23:27:23 +08:00
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
- }
|
|
|
|
- return 1;
|
2012-04-02 23:27:23 +08:00
|
|
|
-#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
- /* TODO add code to handle V7 MUX and Blit MUX files */
|
|
|
|
+
|
|
|
|
#ifdef S_IFIFO
|
|
|
|
case S_IFIFO:
|
|
|
|
if((ms->flags & MAGIC_DEVICES) != 0)
|
|
|
|
@@ -246,77 +199,14 @@
|
|
|
|
#endif
|
|
|
|
#ifdef S_IFLNK
|
|
|
|
case S_IFLNK:
|
|
|
|
- if ((nch = readlink(fn, buf, BUFSIZ-1)) <= 0) {
|
|
|
|
+ /* stat is used, if it made here then the link is broken */
|
|
|
|
if (ms->flags & MAGIC_ERROR) {
|
|
|
|
- file_error(ms, errno, "unreadable symlink `%s'",
|
|
|
|
- fn);
|
|
|
|
+ file_error(ms, errno, "unreadable symlink `%s'", fn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- if (mime) {
|
|
|
|
- if (handle_mime(ms, mime, "symlink") == -1)
|
|
|
|
- return -1;
|
|
|
|
- } else if (file_printf(ms,
|
|
|
|
- "unreadable symlink `%s' (%s)", fn,
|
|
|
|
- strerror(errno)) == -1)
|
|
|
|
- return -1;
|
|
|
|
- return 1;
|
2010-02-01 06:54:00 +08:00
|
|
|
- }
|
|
|
|
- buf[nch] = '\0'; /* readlink(2) does not do this */
|
|
|
|
-
|
|
|
|
- /* If broken symlink, say so and quit early. */
|
|
|
|
- if (*buf == '/') {
|
|
|
|
- if (stat(buf, &tstatbuf) < 0)
|
|
|
|
- return bad_link(ms, errno, buf);
|
|
|
|
- } else {
|
|
|
|
- char *tmp;
|
|
|
|
- char buf2[BUFSIZ+BUFSIZ+4];
|
2012-03-27 19:34:46 +08:00
|
|
|
-
|
2010-02-01 06:54:00 +08:00
|
|
|
- if ((tmp = strrchr(fn, '/')) == NULL) {
|
|
|
|
- tmp = buf; /* in current directory anyway */
|
|
|
|
- } else {
|
|
|
|
- if (tmp - fn + 1 > BUFSIZ) {
|
|
|
|
- if (ms->flags & MAGIC_ERROR) {
|
|
|
|
- file_error(ms, 0,
|
|
|
|
- "path too long: `%s'", buf);
|
2012-03-27 19:34:46 +08:00
|
|
|
- return -1;
|
2010-02-01 06:54:00 +08:00
|
|
|
- }
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (mime) {
|
2010-02-01 06:54:00 +08:00
|
|
|
- if (handle_mime(ms, mime,
|
|
|
|
- "x-path-too-long") == -1)
|
2012-03-27 19:34:46 +08:00
|
|
|
- return -1;
|
2010-02-01 06:54:00 +08:00
|
|
|
- } else if (file_printf(ms,
|
|
|
|
- "path too long: `%s'", fn) == -1)
|
2012-03-27 19:34:46 +08:00
|
|
|
- return -1;
|
|
|
|
- return 1;
|
2010-02-01 06:54:00 +08:00
|
|
|
- }
|
|
|
|
- /* take dir part */
|
|
|
|
- (void)strlcpy(buf2, fn, sizeof buf2);
|
|
|
|
- buf2[tmp - fn + 1] = '\0';
|
|
|
|
- /* plus (rel) link */
|
|
|
|
- (void)strlcat(buf2, buf, sizeof buf2);
|
|
|
|
- tmp = buf2;
|
|
|
|
- }
|
|
|
|
- if (stat(tmp, &tstatbuf) < 0)
|
|
|
|
- return bad_link(ms, errno, buf);
|
|
|
|
- }
|
2012-03-27 19:34:46 +08:00
|
|
|
-
|
2010-02-01 06:54:00 +08:00
|
|
|
- /* Otherwise, handle it. */
|
|
|
|
- if ((ms->flags & MAGIC_SYMLINK) != 0) {
|
|
|
|
- const char *p;
|
|
|
|
- ms->flags &= MAGIC_SYMLINK;
|
|
|
|
- p = magic_file(ms, buf);
|
|
|
|
- ms->flags |= MAGIC_SYMLINK;
|
|
|
|
- return p != NULL ? 1 : -1;
|
|
|
|
- } else { /* just print what it points to */
|
|
|
|
- if (mime) {
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (handle_mime(ms, mime, "symlink") == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
- return -1;
|
|
|
|
- } else if (file_printf(ms, "symbolic link to `%s'",
|
|
|
|
- buf) == -1)
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
- return 1;
|
|
|
|
+ return 1;
|
|
|
|
#endif
|
|
|
|
+
|
|
|
|
#ifdef S_IFSOCK
|
|
|
|
#ifndef __COHERENT__
|
|
|
|
case S_IFSOCK:
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -328,12 +218,14 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
- case S_IFREG:
|
|
|
|
- break;
|
|
|
|
- default:
|
|
|
|
- file_error(ms, 0, "invalid mode 0%o", sb->st_mode);
|
|
|
|
- return -1;
|
|
|
|
- /*NOTREACHED*/
|
|
|
|
+
|
|
|
|
+ case S_IFREG:
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ file_error(ms, 0, "invalid mode 0%o", sb->st_mode);
|
|
|
|
+ return -1;
|
|
|
|
+ /*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/funcs.c libmagic/funcs.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/funcs.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/funcs.c 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -41,52 +41,42 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#if defined(HAVE_WCTYPE_H)
|
|
|
|
#include <wctype.h>
|
|
|
|
#endif
|
|
|
|
-#if defined(HAVE_LIMITS_H)
|
|
|
|
-#include <limits.h>
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
|
|
|
+#ifndef SIZE_MAX
|
|
|
|
+# define SIZE_MAX ((size_t) -1)
|
|
|
|
#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
-#ifndef SIZE_MAX
|
|
|
|
-#define SIZE_MAX ((size_t)~0)
|
2012-03-27 19:34:46 +08:00
|
|
|
+#ifndef PREG_OFFSET_CAPTURE
|
|
|
|
+# define PREG_OFFSET_CAPTURE (1<<8)
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
+extern public void convert_libmagic_pattern(zval *pattern, int options);
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
/*
|
|
|
|
* Like printf, only we append to a buffer.
|
|
|
|
*/
|
|
|
|
protected int
|
|
|
|
-file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
|
|
|
|
+file_printf(struct magic_set *ms, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
+ va_list ap;
|
|
|
|
int len;
|
|
|
|
- char *buf, *newstr;
|
|
|
|
+ char *buf = NULL, *newstr;
|
|
|
|
|
|
|
|
- len = vasprintf(&buf, fmt, ap);
|
|
|
|
- if (len < 0)
|
|
|
|
- goto out;
|
|
|
|
+ va_start(ap, fmt);
|
|
|
|
+ len = vspprintf(&buf, 0, fmt, ap);
|
|
|
|
+ va_end(ap);
|
|
|
|
|
|
|
|
if (ms->o.buf != NULL) {
|
|
|
|
- len = asprintf(&newstr, "%s%s", ms->o.buf, buf);
|
|
|
|
- free(buf);
|
|
|
|
- if (len < 0)
|
|
|
|
- goto out;
|
|
|
|
- free(ms->o.buf);
|
|
|
|
- buf = newstr;
|
|
|
|
+ len = spprintf(&newstr, 0, "%s%s", ms->o.buf, (buf ? buf : ""));
|
|
|
|
+ if (buf) {
|
|
|
|
+ efree(buf);
|
|
|
|
+ }
|
|
|
|
+ efree(ms->o.buf);
|
|
|
|
+ ms->o.buf = newstr;
|
|
|
|
+ } else {
|
|
|
|
+ ms->o.buf = buf;
|
|
|
|
}
|
|
|
|
- ms->o.buf = buf;
|
|
|
|
return 0;
|
|
|
|
-out:
|
|
|
|
- file_error(ms, errno, "vasprintf failed");
|
|
|
|
- return -1;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-protected int
|
|
|
|
-file_printf(struct magic_set *ms, const char *fmt, ...)
|
|
|
|
-{
|
|
|
|
- int rv;
|
|
|
|
- va_list ap;
|
|
|
|
-
|
|
|
|
- va_start(ap, fmt);
|
|
|
|
- rv = file_vprintf(ms, fmt, ap);
|
|
|
|
- va_end(ap);
|
|
|
|
- return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -97,17 +87,30 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
|
2012-03-27 19:34:46 +08:00
|
|
|
size_t lineno)
|
2010-02-01 06:54:00 +08:00
|
|
|
{
|
|
|
|
+ char *buf = NULL;
|
|
|
|
+
|
|
|
|
/* Only the first error is ok */
|
2012-03-27 19:34:46 +08:00
|
|
|
if (ms->event_flags & EVENT_HAD_ERR)
|
2010-02-01 06:54:00 +08:00
|
|
|
return;
|
|
|
|
if (lineno != 0) {
|
|
|
|
- free(ms->o.buf);
|
|
|
|
+ efree(ms->o.buf);
|
|
|
|
ms->o.buf = NULL;
|
2012-03-27 19:34:46 +08:00
|
|
|
file_printf(ms, "line %" SIZE_T_FORMAT "u: ", lineno);
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
- file_vprintf(ms, f, va);
|
|
|
|
- if (error > 0)
|
|
|
|
- file_printf(ms, " (%s)", strerror(error));
|
|
|
|
+
|
|
|
|
+ vspprintf(&buf, 0, f, va);
|
|
|
|
+ va_end(va);
|
|
|
|
+
|
|
|
|
+ if (error > 0) {
|
|
|
|
+ file_printf(ms, "%s (%s)", (*buf ? buf : ""), strerror(error));
|
|
|
|
+ } else if (*buf) {
|
|
|
|
+ file_printf(ms, "%s", buf);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (buf) {
|
|
|
|
+ efree(buf);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
ms->event_flags |= EVENT_HAD_ERR;
|
|
|
|
ms->error = error;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -154,10 +157,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
file_error(ms, errno, "error reading");
|
|
|
|
}
|
|
|
|
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
protected int
|
2012-03-27 19:34:46 +08:00
|
|
|
-file_buffer(struct magic_set *ms, int fd, const char *inname __attribute__ ((unused)),
|
|
|
|
- const void *buf, size_t nb)
|
2010-02-01 06:54:00 +08:00
|
|
|
+file_buffer(struct magic_set *ms, php_stream *stream, const char *inname, const void *buf,
|
2012-03-27 19:34:46 +08:00
|
|
|
+ size_t nb)
|
2010-02-01 06:54:00 +08:00
|
|
|
{
|
|
|
|
int m = 0, rv = 0, looks_text = 0;
|
|
|
|
int mime = ms->flags & MAGIC_MIME;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -189,7 +191,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
&code, &code_mime, &type);
|
|
|
|
}
|
|
|
|
|
|
|
|
-#ifdef __EMX__
|
|
|
|
+#if defined(__EMX__)
|
|
|
|
if ((ms->flags & MAGIC_NO_CHECK_APPTYPE) == 0 && inname) {
|
|
|
|
switch (file_os2_apptype(ms, inname, buf, nb)) {
|
|
|
|
case -1:
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -201,10 +203,10 @@
|
|
|
|
}
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
-#if HAVE_FORK
|
2010-02-01 06:54:00 +08:00
|
|
|
- /* try compression stuff */
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
+#if PHP_FILEINFO_UNCOMPRESS
|
|
|
|
if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) == 0)
|
|
|
|
- if ((m = file_zmagic(ms, fd, inname, ubuf, nb)) != 0) {
|
|
|
|
+ if ((m = file_zmagic(ms, stream, inname, ubuf, nb)) != 0) {
|
|
|
|
if ((ms->flags & MAGIC_DEBUG) != 0)
|
|
|
|
(void)fprintf(stderr, "zmagic %d\n", m);
|
|
|
|
goto done;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -219,12 +221,17 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if we have a CDF file */
|
|
|
|
- if ((ms->flags & MAGIC_NO_CHECK_CDF) == 0)
|
|
|
|
- if ((m = file_trycdf(ms, fd, ubuf, nb)) != 0) {
|
|
|
|
- if ((ms->flags & MAGIC_DEBUG) != 0)
|
|
|
|
- (void)fprintf(stderr, "cdf %d\n", m);
|
|
|
|
- goto done;
|
|
|
|
+ if ((ms->flags & MAGIC_NO_CHECK_CDF) == 0) {
|
|
|
|
+ int fd;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+ if (stream && SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&fd, 0)) {
|
|
|
|
+ if ((m = file_trycdf(ms, fd, ubuf, nb)) != 0) {
|
|
|
|
+ if ((ms->flags & MAGIC_DEBUG) != 0)
|
|
|
|
+ (void)fprintf(stderr, "cdf %d\n", m);
|
|
|
|
+ goto done;
|
|
|
|
+ }
|
|
|
|
}
|
|
|
|
+ }
|
|
|
|
|
|
|
|
/* try soft magic tests */
|
|
|
|
if ((ms->flags & MAGIC_NO_CHECK_SOFT) == 0)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -296,7 +303,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
protected int
|
|
|
|
file_reset(struct magic_set *ms)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -306,11 +312,11 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (ms->o.buf) {
|
|
|
|
- free(ms->o.buf);
|
|
|
|
+ efree(ms->o.buf);
|
|
|
|
ms->o.buf = NULL;
|
|
|
|
}
|
|
|
|
if (ms->o.pbuf) {
|
|
|
|
- free(ms->o.pbuf);
|
|
|
|
+ efree(ms->o.pbuf);
|
|
|
|
ms->o.pbuf = NULL;
|
|
|
|
}
|
|
|
|
ms->event_flags &= ~EVENT_HAD_ERR;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -344,14 +350,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
/* * 4 is for octal representation, + 1 is for NUL */
|
|
|
|
len = strlen(ms->o.buf);
|
|
|
|
if (len > (SIZE_MAX - 1) / 4) {
|
|
|
|
- file_oomem(ms, len);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
psize = len * 4 + 1;
|
|
|
|
- if ((pbuf = CAST(char *, realloc(ms->o.pbuf, psize))) == NULL) {
|
|
|
|
- file_oomem(ms, psize);
|
|
|
|
- return NULL;
|
|
|
|
- }
|
|
|
|
+ pbuf = erealloc(ms->o.pbuf, psize);
|
|
|
|
ms->o.pbuf = pbuf;
|
|
|
|
|
|
|
|
#if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -411,13 +413,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
if (level >= ms->c.len) {
|
|
|
|
len = (ms->c.len += 20) * sizeof(*ms->c.li);
|
|
|
|
- ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
|
|
|
|
- malloc(len) :
|
|
|
|
- realloc(ms->c.li, len));
|
|
|
|
- if (ms->c.li == NULL) {
|
|
|
|
- file_oomem(ms, len);
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ ms->c.li = (ms->c.li == NULL) ? emalloc(len) : erealloc(ms->c.li, len);
|
|
|
|
}
|
|
|
|
ms->c.li[level].got_match = 0;
|
|
|
|
#ifdef ENABLE_CONDITIONALS
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -433,29 +429,51 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
return ms->o.buf == NULL ? 0 : strlen(ms->o.buf);
|
|
|
|
}
|
|
|
|
|
2012-03-28 18:06:09 +08:00
|
|
|
-protected int
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
|
|
|
+protected int
|
2012-03-28 18:06:09 +08:00
|
|
|
file_replace(struct magic_set *ms, const char *pat, const char *rep)
|
|
|
|
{
|
|
|
|
- regex_t rx;
|
|
|
|
- int rc;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ zval *patt;
|
|
|
|
+ int opts = 0;
|
|
|
|
+ pcre_cache_entry *pce;
|
|
|
|
+ char *res;
|
|
|
|
+ zval *repl;
|
2012-04-22 19:38:14 +08:00
|
|
|
+ int res_len, rep_cnt = 0;
|
2012-03-28 18:06:09 +08:00
|
|
|
+ TSRMLS_FETCH();
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(patt);
|
|
|
|
+ ZVAL_STRINGL(patt, pat, strlen(pat), 0);
|
|
|
|
+ opts |= PCRE_MULTILINE;
|
|
|
|
+ convert_libmagic_pattern(patt, opts);
|
|
|
|
+#if (PHP_MAJOR_VERSION < 6)
|
|
|
|
+ if ((pce = pcre_get_compiled_regex_cache(Z_STRVAL_P(patt), Z_STRLEN_P(patt) TSRMLS_CC)) == NULL) {
|
|
|
|
+#else
|
|
|
|
+ if ((pce = pcre_get_compiled_regex_cache(IS_STRING, Z_STRVAL_P(patt), Z_STRLEN_P(patt) TSRMLS_CC)) == NULL) {
|
|
|
|
+#endif
|
|
|
|
+ zval_dtor(patt);
|
|
|
|
+ FREE_ZVAL(patt);
|
|
|
|
+ return -1;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(repl);
|
|
|
|
+ ZVAL_STRINGL(repl, rep, strlen(rep), 0);
|
2012-03-28 18:06:09 +08:00
|
|
|
|
|
|
|
- rc = regcomp(&rx, pat, REG_EXTENDED);
|
|
|
|
- if (rc) {
|
|
|
|
- char errmsg[512];
|
|
|
|
- (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
|
|
|
|
- file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
|
2012-03-27 19:34:46 +08:00
|
|
|
+ res = php_pcre_replace_impl(pce, ms->o.buf, strlen(ms->o.buf), repl,
|
|
|
|
+ 0, &res_len, -1, &rep_cnt TSRMLS_CC);
|
|
|
|
+
|
|
|
|
+ FREE_ZVAL(repl);
|
|
|
|
+ zval_dtor(patt);
|
|
|
|
+ FREE_ZVAL(patt);
|
|
|
|
+
|
|
|
|
+ if (NULL == res) {
|
2012-03-28 18:06:09 +08:00
|
|
|
return -1;
|
|
|
|
- } else {
|
|
|
|
- regmatch_t rm;
|
|
|
|
- int nm = 0;
|
|
|
|
- while (regexec(&rx, ms->o.buf, 1, &rm, 0) == 0) {
|
|
|
|
- ms->o.buf[rm.rm_so] = '\0';
|
|
|
|
- if (file_printf(ms, "%s%s", rep,
|
|
|
|
- rm.rm_eo != 0 ? ms->o.buf + rm.rm_eo : "") == -1)
|
|
|
|
- return -1;
|
|
|
|
- nm++;
|
|
|
|
- }
|
|
|
|
- regfree(&rx);
|
|
|
|
- return nm;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
+
|
|
|
|
+ strncpy(ms->o.buf, res, res_len);
|
|
|
|
+ ms->o.buf[res_len] = '\0';
|
|
|
|
+
|
|
|
|
+ efree(res);
|
|
|
|
+
|
|
|
|
+ return rep_cnt;
|
|
|
|
}
|
2012-03-28 18:06:09 +08:00
|
|
|
+
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/magic.c libmagic/magic.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/magic.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/magic.c 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -25,11 +25,6 @@
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
-#ifdef WIN32
|
|
|
|
-#include <windows.h>
|
|
|
|
-#include <shlwapi.h>
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
#include "file.h"
|
|
|
|
|
|
|
|
#ifndef lint
|
|
|
|
@@ -39,15 +34,24 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#include "magic.h"
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/unistd.h"
|
|
|
|
+#else
|
|
|
|
#include <unistd.h>
|
|
|
|
+#endif
|
|
|
|
#include <string.h>
|
|
|
|
-#ifdef QUICK
|
|
|
|
-#include <sys/mman.h>
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+# include "config.w32.h"
|
|
|
|
+#else
|
|
|
|
+# include "php_config.h"
|
|
|
|
#endif
|
|
|
|
-#ifdef HAVE_LIMITS_H
|
2012-03-27 19:34:46 +08:00
|
|
|
-#include <limits.h> /* for PIPE_BUF */
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
2012-03-27 19:34:46 +08:00
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include <shlwapi.h>
|
|
|
|
#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
+#include <limits.h> /* for PIPE_BUF */
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
#if defined(HAVE_UTIMES)
|
|
|
|
# include <sys/time.h>
|
2012-03-27 19:34:46 +08:00
|
|
|
#elif defined(HAVE_UTIME)
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -71,19 +75,24 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+# undef S_IFLNK
|
|
|
|
+# undef S_IFIFO
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
private void free_mlist(struct mlist *);
|
|
|
|
private void close_and_restore(const struct magic_set *, const char *, int,
|
|
|
|
const struct stat *);
|
|
|
|
private int unreadable_info(struct magic_set *, mode_t, const char *);
|
2012-03-27 19:34:46 +08:00
|
|
|
private const char* get_default_magic(void);
|
2010-02-01 06:54:00 +08:00
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
-private const char *file_or_fd(struct magic_set *, const char *, int);
|
|
|
|
-#endif
|
|
|
|
+private const char *file_or_stream(struct magic_set *, const char *, php_stream *);
|
|
|
|
|
|
|
|
#ifndef STDIN_FILENO
|
|
|
|
#define STDIN_FILENO 0
|
2012-03-27 19:34:46 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
+/* XXX this functionality is excluded in php, enable it in apprentice.c:340 */
|
2012-03-28 18:06:09 +08:00
|
|
|
+#if 0
|
2012-03-27 19:34:46 +08:00
|
|
|
private const char *
|
|
|
|
get_default_magic(void)
|
|
|
|
{
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -91,7 +100,7 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
static char *default_magic;
|
|
|
|
char *home, *hmagicpath;
|
|
|
|
|
|
|
|
-#ifndef WIN32
|
|
|
|
+#ifndef PHP_WIN32
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (default_magic) {
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -124,6 +133,7 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
#else
|
|
|
|
char *hmagicp = hmagicpath;
|
|
|
|
char *tmppath = NULL;
|
|
|
|
+ LPTSTR dllpath;
|
|
|
|
|
|
|
|
#define APPENDPATH() \
|
|
|
|
do { \
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -168,7 +178,7 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Third, try to get magic file relative to dll location */
|
|
|
|
- LPTSTR dllpath = malloc(sizeof(*dllpath) * (MAX_PATH + 1));
|
|
|
|
+ dllpath = malloc(sizeof(*dllpath) * (MAX_PATH + 1));
|
|
|
|
dllpath[MAX_PATH] = 0; /* just in case long path gets truncated and not null terminated */
|
|
|
|
if (GetModuleFileNameA(NULL, dllpath, MAX_PATH)){
|
|
|
|
PathRemoveFileSpecA(dllpath);
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -206,16 +216,14 @@
|
|
|
|
|
|
|
|
return action == FILE_LOAD ? get_default_magic() : MAGIC;
|
|
|
|
}
|
|
|
|
+#endif
|
|
|
|
|
|
|
|
public struct magic_set *
|
2010-02-01 06:54:00 +08:00
|
|
|
magic_open(int flags)
|
|
|
|
{
|
|
|
|
struct magic_set *ms;
|
|
|
|
- size_t len;
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
- if ((ms = CAST(struct magic_set *, calloc((size_t)1,
|
2010-02-01 06:54:00 +08:00
|
|
|
- sizeof(struct magic_set)))) == NULL)
|
|
|
|
- return NULL;
|
|
|
|
+ ms = ecalloc((size_t)1, sizeof(struct magic_set));
|
|
|
|
|
|
|
|
if (magic_setflags(ms, flags) == -1) {
|
|
|
|
errno = EINVAL;
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -223,11 +231,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ms->o.buf = ms->o.pbuf = NULL;
|
|
|
|
- len = (ms->c.len = 10) * sizeof(*ms->c.li);
|
|
|
|
-
|
|
|
|
- if ((ms->c.li = CAST(struct level_info *, malloc(len))) == NULL)
|
|
|
|
- goto free;
|
|
|
|
|
|
|
|
+ ms->c.li = emalloc((ms->c.len = 10) * sizeof(*ms->c.li));
|
|
|
|
+
|
|
|
|
ms->event_flags = 0;
|
|
|
|
ms->error = -1;
|
|
|
|
ms->mlist = NULL;
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -235,7 +241,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
ms->line = 0;
|
|
|
|
return ms;
|
|
|
|
free:
|
|
|
|
- free(ms);
|
|
|
|
+ efree(ms);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -251,10 +257,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
struct mlist *next = ml->next;
|
|
|
|
struct magic *mg = ml->magic;
|
|
|
|
file_delmagic(mg, ml->mapped, ml->nmagic);
|
|
|
|
- free(ml);
|
|
|
|
+ efree(ml);
|
|
|
|
ml = next;
|
|
|
|
}
|
|
|
|
- free(ml);
|
|
|
|
+ efree(ml);
|
|
|
|
}
|
|
|
|
|
|
|
|
private int
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -278,11 +284,19 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
public void
|
|
|
|
magic_close(struct magic_set *ms)
|
|
|
|
{
|
|
|
|
- free_mlist(ms->mlist);
|
|
|
|
- free(ms->o.pbuf);
|
|
|
|
- free(ms->o.buf);
|
|
|
|
- free(ms->c.li);
|
|
|
|
- free(ms);
|
|
|
|
+ if (ms->mlist) {
|
|
|
|
+ free_mlist(ms->mlist);
|
|
|
|
+ }
|
|
|
|
+ if (ms->o.pbuf) {
|
|
|
|
+ efree(ms->o.pbuf);
|
|
|
|
+ }
|
|
|
|
+ if (ms->o.buf) {
|
|
|
|
+ efree(ms->o.buf);
|
|
|
|
+ }
|
|
|
|
+ if (ms->c.li) {
|
|
|
|
+ efree(ms->c.li);
|
|
|
|
+ }
|
|
|
|
+ efree(ms);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -308,13 +322,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return ml ? 0 : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
-public int
|
|
|
|
-magic_check(struct magic_set *ms, const char *magicfile)
|
|
|
|
-{
|
|
|
|
- struct mlist *ml = file_apprentice(ms, magicfile, FILE_CHECK);
|
|
|
|
- free_mlist(ml);
|
|
|
|
- return ml ? 0 : -1;
|
|
|
|
-}
|
2012-03-27 19:34:46 +08:00
|
|
|
|
|
|
|
public int
|
|
|
|
magic_list(struct magic_set *ms, const char *magicfile)
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -328,9 +335,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
close_and_restore(const struct magic_set *ms, const char *name, int fd,
|
|
|
|
const struct stat *sb)
|
|
|
|
{
|
|
|
|
- if (fd == STDIN_FILENO)
|
|
|
|
- return;
|
|
|
|
- (void) close(fd);
|
|
|
|
|
|
|
|
if ((ms->flags & MAGIC_PRESERVE_ATIME) != 0) {
|
|
|
|
/*
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -357,7 +361,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find type of descriptor
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -365,7 +368,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
public const char *
|
|
|
|
magic_descriptor(struct magic_set *ms, int fd)
|
|
|
|
{
|
|
|
|
- return file_or_fd(ms, NULL, fd);
|
|
|
|
+ return file_or_stream(ms, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -374,30 +377,40 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
public const char *
|
|
|
|
magic_file(struct magic_set *ms, const char *inname)
|
|
|
|
{
|
|
|
|
- return file_or_fd(ms, inname, STDIN_FILENO);
|
|
|
|
+ return file_or_stream(ms, inname, NULL);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+public const char *
|
|
|
|
+magic_stream(struct magic_set *ms, php_stream *stream)
|
|
|
|
+{
|
|
|
|
+ return file_or_stream(ms, NULL, stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
private const char *
|
|
|
|
-file_or_fd(struct magic_set *ms, const char *inname, int fd)
|
|
|
|
+file_or_stream(struct magic_set *ms, const char *inname, php_stream *stream)
|
|
|
|
{
|
|
|
|
int rv = -1;
|
|
|
|
unsigned char *buf;
|
|
|
|
struct stat sb;
|
|
|
|
ssize_t nbytes = 0; /* number of bytes read from a datafile */
|
|
|
|
- int ispipe = 0;
|
|
|
|
+ int no_in_stream = 0;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+
|
|
|
|
+ if (!inname && !stream) {
|
|
|
|
+ return NULL;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
/*
|
|
|
|
* one extra for terminating '\0', and
|
|
|
|
* some overlapping space for matches near EOF
|
|
|
|
*/
|
|
|
|
#define SLOP (1 + sizeof(union VALUETYPE))
|
|
|
|
- if ((buf = CAST(unsigned char *, malloc(HOWMANY + SLOP))) == NULL)
|
|
|
|
- return NULL;
|
|
|
|
+ buf = emalloc(HOWMANY + SLOP);
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
if (file_reset(ms) == -1)
|
2010-02-01 06:54:00 +08:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
- switch (file_fsmagic(ms, inname, &sb)) {
|
|
|
|
+ switch (file_fsmagic(ms, inname, &sb, stream)) {
|
2012-03-27 19:34:46 +08:00
|
|
|
case -1: /* error */
|
|
|
|
goto done;
|
|
|
|
case 0: /* nothing found */
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -407,68 +420,48 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (inname == NULL) {
|
|
|
|
- if (fstat(fd, &sb) == 0 && S_ISFIFO(sb.st_mode))
|
|
|
|
- ispipe = 1;
|
|
|
|
- } else {
|
|
|
|
- int flags = O_RDONLY|O_BINARY;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ errno = 0;
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
- if (stat(inname, &sb) == 0 && S_ISFIFO(sb.st_mode)) {
|
2012-03-27 19:34:46 +08:00
|
|
|
-#ifdef O_NONBLOCK
|
2010-02-01 06:54:00 +08:00
|
|
|
- flags |= O_NONBLOCK;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ if (!stream && inname) {
|
|
|
|
+ no_in_stream = 1;
|
|
|
|
+#if PHP_API_VERSION < 20100412
|
|
|
|
+ stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
|
|
|
|
+#else
|
|
|
|
+ stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS, NULL);
|
|
|
|
#endif
|
2010-02-01 06:54:00 +08:00
|
|
|
- ispipe = 1;
|
|
|
|
- }
|
2012-03-27 19:34:46 +08:00
|
|
|
+ }
|
|
|
|
|
2010-02-01 06:54:00 +08:00
|
|
|
- errno = 0;
|
|
|
|
- if ((fd = open(inname, flags)) < 0) {
|
|
|
|
- if (unreadable_info(ms, sb.st_mode, inname) == -1)
|
|
|
|
- goto done;
|
|
|
|
- rv = 0;
|
2012-03-27 19:34:46 +08:00
|
|
|
+ if (!stream) {
|
|
|
|
+ if (unreadable_info(ms, sb.st_mode, inname) == -1)
|
|
|
|
goto done;
|
2010-02-01 06:54:00 +08:00
|
|
|
- }
|
2012-03-27 19:34:46 +08:00
|
|
|
+ rv = 0;
|
|
|
|
+ goto done;
|
|
|
|
+ }
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
#ifdef O_NONBLOCK
|
|
|
|
- if ((flags = fcntl(fd, F_GETFL)) != -1) {
|
|
|
|
- flags &= ~O_NONBLOCK;
|
|
|
|
- (void)fcntl(fd, F_SETFL, flags);
|
|
|
|
- }
|
|
|
|
+/* we should be already be in non blocking mode for network socket */
|
|
|
|
#endif
|
|
|
|
- }
|
|
|
|
|
|
|
|
/*
|
|
|
|
* try looking at the first HOWMANY bytes
|
|
|
|
*/
|
|
|
|
- if (ispipe) {
|
|
|
|
- ssize_t r = 0;
|
|
|
|
-
|
|
|
|
- while ((r = sread(fd, (void *)&buf[nbytes],
|
|
|
|
- (size_t)(HOWMANY - nbytes), 1)) > 0) {
|
|
|
|
- nbytes += r;
|
|
|
|
- if (r < PIPE_BUF) break;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if (nbytes == 0) {
|
|
|
|
- /* We can not read it, but we were able to stat it. */
|
|
|
|
- if (unreadable_info(ms, sb.st_mode, inname) == -1)
|
|
|
|
- goto done;
|
|
|
|
- rv = 0;
|
|
|
|
- goto done;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- } else {
|
|
|
|
- if ((nbytes = read(fd, (char *)buf, HOWMANY)) == -1) {
|
|
|
|
- file_error(ms, errno, "cannot read `%s'", inname);
|
|
|
|
- goto done;
|
|
|
|
- }
|
|
|
|
+ if ((nbytes = php_stream_read(stream, (char *)buf, HOWMANY)) < 0) {
|
|
|
|
+ file_error(ms, errno, "cannot read `%s'", inname);
|
|
|
|
+ goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
(void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
|
|
|
|
- if (file_buffer(ms, fd, inname, buf, (size_t)nbytes) == -1)
|
|
|
|
+ if (file_buffer(ms, stream, inname, buf, (size_t)nbytes) == -1)
|
|
|
|
goto done;
|
|
|
|
rv = 0;
|
|
|
|
done:
|
|
|
|
- free(buf);
|
|
|
|
- close_and_restore(ms, inname, fd, &sb);
|
|
|
|
+ efree(buf);
|
|
|
|
+
|
|
|
|
+ if (no_in_stream && stream) {
|
|
|
|
+ php_stream_close(stream);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ close_and_restore(ms, inname, 0, &sb);
|
|
|
|
return rv == 0 ? file_getbuffer(ms) : NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-28 18:06:09 +08:00
|
|
|
@@ -480,14 +473,13 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The main work is done here!
|
|
|
|
- * We have the file name and/or the data buffer to be identified.
|
|
|
|
+ * We have the file name and/or the data buffer to be identified.
|
|
|
|
*/
|
|
|
|
- if (file_buffer(ms, -1, NULL, buf, nb) == -1) {
|
|
|
|
+ if (file_buffer(ms, NULL, NULL, buf, nb) == -1) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return file_getbuffer(ms);
|
|
|
|
}
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
public const char *
|
|
|
|
magic_error(struct magic_set *ms)
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/magic.h libmagic/magic.h
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/magic.h 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/magic.h 2012-04-22 18:57:16.219978162 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -85,6 +85,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
const char *magic_getpath(const char *, int);
|
2010-02-01 06:54:00 +08:00
|
|
|
const char *magic_file(magic_t, const char *);
|
|
|
|
+const char *magic_stream(magic_t, php_stream *);
|
|
|
|
const char *magic_descriptor(magic_t, int);
|
|
|
|
const char *magic_buffer(magic_t, const void *, size_t);
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -93,7 +94,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
int magic_load(magic_t, const char *);
|
|
|
|
int magic_compile(magic_t, const char *);
|
|
|
|
-int magic_check(magic_t, const char *);
|
2012-03-27 19:34:46 +08:00
|
|
|
int magic_list(magic_t, const char *);
|
2010-02-01 06:54:00 +08:00
|
|
|
int magic_errno(magic_t);
|
|
|
|
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/print.c libmagic/print.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/print.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/print.c 2012-05-29 14:34:03.770376387 +0200
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -29,6 +29,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
* print.c - debugging printout routines
|
|
|
|
*/
|
2011-10-19 23:08:50 +08:00
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
+#include "php.h"
|
|
|
|
+#include "main/snprintf.h"
|
|
|
|
+
|
2010-02-01 06:54:00 +08:00
|
|
|
#include "file.h"
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
#ifndef lint
|
|
|
|
@@ -45,174 +48,21 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
#define SZOF(a) (sizeof(a) / sizeof(a[0]))
|
|
|
|
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
-protected void
|
|
|
|
-file_mdump(struct magic *m)
|
|
|
|
-{
|
|
|
|
- private const char optyp[] = { FILE_OPS };
|
|
|
|
-
|
2012-03-27 19:34:46 +08:00
|
|
|
- (void) fprintf(stderr, "%u: %.*s %u", m->lineno,
|
|
|
|
- (m->cont_level & 7) + 1, ">>>>>>>>", m->offset);
|
2010-02-01 06:54:00 +08:00
|
|
|
-
|
|
|
|
- if (m->flag & INDIR) {
|
|
|
|
- (void) fprintf(stderr, "(%s,",
|
|
|
|
- /* Note: type is unsigned */
|
|
|
|
- (m->in_type < file_nnames) ?
|
|
|
|
- file_names[m->in_type] : "*bad*");
|
|
|
|
- if (m->in_op & FILE_OPINVERSE)
|
|
|
|
- (void) fputc('~', stderr);
|
|
|
|
- (void) fprintf(stderr, "%c%u),",
|
|
|
|
- ((size_t)(m->in_op & FILE_OPS_MASK) <
|
|
|
|
- SZOF(optyp)) ?
|
|
|
|
- optyp[m->in_op & FILE_OPS_MASK] : '?',
|
|
|
|
- m->in_offset);
|
|
|
|
- }
|
|
|
|
- (void) fprintf(stderr, " %s%s", (m->flag & UNSIGNED) ? "u" : "",
|
|
|
|
- /* Note: type is unsigned */
|
|
|
|
- (m->type < file_nnames) ? file_names[m->type] : "*bad*");
|
|
|
|
- if (m->mask_op & FILE_OPINVERSE)
|
|
|
|
- (void) fputc('~', stderr);
|
|
|
|
-
|
|
|
|
- if (IS_STRING(m->type)) {
|
|
|
|
- if (m->str_flags) {
|
|
|
|
- (void) fputc('/', stderr);
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (m->str_flags & STRING_COMPACT_WHITESPACE)
|
|
|
|
- (void) fputc(CHAR_COMPACT_WHITESPACE, stderr);
|
|
|
|
- if (m->str_flags & STRING_COMPACT_OPTIONAL_WHITESPACE)
|
|
|
|
- (void) fputc(CHAR_COMPACT_OPTIONAL_WHITESPACE,
|
2010-02-01 06:54:00 +08:00
|
|
|
- stderr);
|
|
|
|
- if (m->str_flags & STRING_IGNORE_LOWERCASE)
|
|
|
|
- (void) fputc(CHAR_IGNORE_LOWERCASE, stderr);
|
|
|
|
- if (m->str_flags & STRING_IGNORE_UPPERCASE)
|
|
|
|
- (void) fputc(CHAR_IGNORE_UPPERCASE, stderr);
|
|
|
|
- if (m->str_flags & REGEX_OFFSET_START)
|
|
|
|
- (void) fputc(CHAR_REGEX_OFFSET_START, stderr);
|
2012-03-27 19:34:46 +08:00
|
|
|
- if (m->str_flags & STRING_TEXTTEST)
|
|
|
|
- (void) fputc(CHAR_TEXTTEST, stderr);
|
|
|
|
- if (m->str_flags & STRING_BINTEST)
|
|
|
|
- (void) fputc(CHAR_BINTEST, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_1_BE)
|
|
|
|
- (void) fputc(CHAR_PSTRING_1_BE, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_2_BE)
|
|
|
|
- (void) fputc(CHAR_PSTRING_2_BE, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_2_LE)
|
|
|
|
- (void) fputc(CHAR_PSTRING_2_LE, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_4_BE)
|
|
|
|
- (void) fputc(CHAR_PSTRING_4_BE, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_4_LE)
|
|
|
|
- (void) fputc(CHAR_PSTRING_4_LE, stderr);
|
|
|
|
- if (m->str_flags & PSTRING_LENGTH_INCLUDES_ITSELF)
|
|
|
|
- (void) fputc(
|
|
|
|
- CHAR_PSTRING_LENGTH_INCLUDES_ITSELF,
|
|
|
|
- stderr);
|
2010-02-01 06:54:00 +08:00
|
|
|
- }
|
|
|
|
- if (m->str_range)
|
|
|
|
- (void) fprintf(stderr, "/%u", m->str_range);
|
|
|
|
- }
|
|
|
|
- else {
|
|
|
|
- if ((size_t)(m->mask_op & FILE_OPS_MASK) < SZOF(optyp))
|
|
|
|
- (void) fputc(optyp[m->mask_op & FILE_OPS_MASK], stderr);
|
|
|
|
- else
|
|
|
|
- (void) fputc('?', stderr);
|
|
|
|
-
|
|
|
|
- if (m->num_mask) {
|
|
|
|
- (void) fprintf(stderr, "%.8llx",
|
|
|
|
- (unsigned long long)m->num_mask);
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
- (void) fprintf(stderr, ",%c", m->reln);
|
|
|
|
-
|
|
|
|
- if (m->reln != 'x') {
|
|
|
|
- switch (m->type) {
|
|
|
|
- case FILE_BYTE:
|
|
|
|
- case FILE_SHORT:
|
|
|
|
- case FILE_LONG:
|
|
|
|
- case FILE_LESHORT:
|
|
|
|
- case FILE_LELONG:
|
|
|
|
- case FILE_MELONG:
|
|
|
|
- case FILE_BESHORT:
|
|
|
|
- case FILE_BELONG:
|
|
|
|
- (void) fprintf(stderr, "%d", m->value.l);
|
|
|
|
- break;
|
|
|
|
- case FILE_BEQUAD:
|
|
|
|
- case FILE_LEQUAD:
|
|
|
|
- case FILE_QUAD:
|
2012-03-27 19:34:46 +08:00
|
|
|
- (void) fprintf(stderr, "%" INT64_T_FORMAT "d",
|
2010-02-01 06:54:00 +08:00
|
|
|
- (unsigned long long)m->value.q);
|
|
|
|
- break;
|
|
|
|
- case FILE_PSTRING:
|
|
|
|
- case FILE_STRING:
|
|
|
|
- case FILE_REGEX:
|
|
|
|
- case FILE_BESTRING16:
|
|
|
|
- case FILE_LESTRING16:
|
|
|
|
- case FILE_SEARCH:
|
|
|
|
- file_showstr(stderr, m->value.s, (size_t)m->vallen);
|
|
|
|
- break;
|
|
|
|
- case FILE_DATE:
|
|
|
|
- case FILE_LEDATE:
|
|
|
|
- case FILE_BEDATE:
|
|
|
|
- case FILE_MEDATE:
|
|
|
|
- (void)fprintf(stderr, "%s,",
|
|
|
|
- file_fmttime(m->value.l, 1));
|
|
|
|
- break;
|
|
|
|
- case FILE_LDATE:
|
|
|
|
- case FILE_LELDATE:
|
|
|
|
- case FILE_BELDATE:
|
|
|
|
- case FILE_MELDATE:
|
|
|
|
- (void)fprintf(stderr, "%s,",
|
|
|
|
- file_fmttime(m->value.l, 0));
|
|
|
|
- break;
|
|
|
|
- case FILE_QDATE:
|
|
|
|
- case FILE_LEQDATE:
|
|
|
|
- case FILE_BEQDATE:
|
|
|
|
- (void)fprintf(stderr, "%s,",
|
|
|
|
- file_fmttime((uint32_t)m->value.q, 1));
|
|
|
|
- break;
|
|
|
|
- case FILE_QLDATE:
|
|
|
|
- case FILE_LEQLDATE:
|
|
|
|
- case FILE_BEQLDATE:
|
|
|
|
- (void)fprintf(stderr, "%s,",
|
|
|
|
- file_fmttime((uint32_t)m->value.q, 0));
|
|
|
|
- break;
|
|
|
|
- case FILE_FLOAT:
|
|
|
|
- case FILE_BEFLOAT:
|
|
|
|
- case FILE_LEFLOAT:
|
|
|
|
- (void) fprintf(stderr, "%G", m->value.f);
|
|
|
|
- break;
|
|
|
|
- case FILE_DOUBLE:
|
|
|
|
- case FILE_BEDOUBLE:
|
|
|
|
- case FILE_LEDOUBLE:
|
|
|
|
- (void) fprintf(stderr, "%G", m->value.d);
|
|
|
|
- break;
|
|
|
|
- case FILE_DEFAULT:
|
|
|
|
- /* XXX - do anything here? */
|
|
|
|
- break;
|
|
|
|
- default:
|
|
|
|
- (void) fputs("*bad*", stderr);
|
|
|
|
- break;
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
- (void) fprintf(stderr, ",\"%s\"]\n", m->desc);
|
|
|
|
-}
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
/*VARARGS*/
|
|
|
|
protected void
|
|
|
|
file_magwarn(struct magic_set *ms, const char *f, ...)
|
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
+ char *expanded_format;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
|
|
|
|
- /* cuz we use stdout for most, stderr here */
|
|
|
|
- (void) fflush(stdout);
|
|
|
|
-
|
|
|
|
- if (ms->file)
|
|
|
|
- (void) fprintf(stderr, "%s, %lu: ", ms->file,
|
|
|
|
- (unsigned long)ms->line);
|
|
|
|
- (void) fprintf(stderr, "Warning: ");
|
|
|
|
va_start(va, f);
|
|
|
|
- (void) vfprintf(stderr, f, va);
|
|
|
|
+ vasprintf(&expanded_format, f, va);
|
|
|
|
va_end(va);
|
|
|
|
- (void) fputc('\n', stderr);
|
|
|
|
+
|
|
|
|
+ php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Warning: %s", expanded_format);
|
|
|
|
+
|
|
|
|
+ free(expanded_format);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected const char *
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/readcdf.c libmagic/readcdf.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/readcdf.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/readcdf.c 2012-04-22 18:57:16.219978162 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -30,7 +30,11 @@
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
+#ifdef PHP_WIN32
|
|
|
|
+#include "win32/unistd.h"
|
|
|
|
+#else
|
|
|
|
#include <unistd.h>
|
|
|
|
+#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
@@ -46,7 +50,7 @@
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
size_t i;
|
|
|
|
cdf_timestamp_t tp;
|
|
|
|
- struct timespec ts;
|
|
|
|
+ struct timeval ts;
|
|
|
|
char buf[64];
|
|
|
|
const char *str = NULL;
|
|
|
|
const char *s;
|
|
|
|
@@ -125,7 +129,11 @@
|
|
|
|
case CDF_FILETIME:
|
|
|
|
tp = info[i].pi_tp;
|
|
|
|
if (tp != 0) {
|
|
|
|
- if (tp < 1000000000000000LL) {
|
2010-04-27 07:55:03 +08:00
|
|
|
+#if defined(PHP_WIN32) && _MSC_VER <= 1500
|
2012-03-27 19:34:46 +08:00
|
|
|
+ if (tp < 1000000000000000i64) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+#else
|
2012-03-27 19:34:46 +08:00
|
|
|
+ if (tp < 1000000000000000LL) {
|
2010-02-01 06:54:00 +08:00
|
|
|
+#endif
|
2012-03-27 19:34:46 +08:00
|
|
|
char tbuf[64];
|
|
|
|
cdf_print_elapsed_time(tbuf,
|
|
|
|
sizeof(tbuf), tp);
|
|
|
|
@@ -134,7 +142,9 @@
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
char *c, *ec;
|
|
|
|
- cdf_timestamp_to_timespec(&ts, tp);
|
|
|
|
+ if (cdf_timestamp_to_timespec(&ts, tp) == -1) {
|
|
|
|
+ return -1;
|
|
|
|
+ }
|
|
|
|
c = cdf_ctime(&ts.tv_sec);
|
|
|
|
if ((ec = strchr(c, '\n')) != NULL)
|
|
|
|
*ec = '\0';
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/readelf.c libmagic/readelf.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/readelf.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/readelf.c 2012-04-22 18:57:16.219978162 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -49,7 +49,7 @@
|
|
|
|
off_t, int *, int);
|
2012-03-27 19:34:46 +08:00
|
|
|
private int doshn(struct magic_set *, int, int, int, off_t, int, size_t,
|
|
|
|
off_t, int *, int);
|
2010-02-01 06:54:00 +08:00
|
|
|
-private size_t donote(struct magic_set *, void *, size_t, size_t, int,
|
|
|
|
+private size_t donote(struct magic_set *, unsigned char *, size_t, size_t, int,
|
|
|
|
int, size_t, int *);
|
|
|
|
|
|
|
|
#define ELF_ALIGN(a) ((((a) + align - 1) / align) * align)
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -309,11 +309,11 @@
|
|
|
|
* Loop through all the program headers.
|
|
|
|
*/
|
|
|
|
for ( ; num; num--) {
|
|
|
|
- if (lseek(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- if (read(fd, xph_addr, xph_sizeof) == -1) {
|
|
|
|
+ if (FINFO_READ_FUNC(fd, xph_addr, xph_sizeof) == -1) {
|
|
|
|
file_badread(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
@@ -331,11 +331,11 @@
|
|
|
|
* This is a PT_NOTE section; loop through all the notes
|
|
|
|
* in the section.
|
|
|
|
*/
|
|
|
|
- if (lseek(fd, xph_offset, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, xph_offset, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- bufsize = read(fd, nbuf,
|
|
|
|
+ bufsize = FINFO_READ_FUNC(fd, nbuf,
|
|
|
|
((xph_filesz < sizeof(nbuf)) ? xph_filesz : sizeof(nbuf)));
|
|
|
|
if (bufsize == -1) {
|
|
|
|
file_badread(ms);
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -357,7 +357,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
private size_t
|
|
|
|
-donote(struct magic_set *ms, void *vbuf, size_t offset, size_t size,
|
|
|
|
+donote(struct magic_set *ms, unsigned char *nbuf, size_t offset, size_t size,
|
|
|
|
int clazz, int swap, size_t align, int *flags)
|
|
|
|
{
|
|
|
|
Elf32_Nhdr nh32;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -367,7 +367,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
int os_style = -1;
|
|
|
|
#endif
|
|
|
|
uint32_t namesz, descsz;
|
|
|
|
- unsigned char *nbuf = CAST(unsigned char *, vbuf);
|
|
|
|
|
|
|
|
(void)memcpy(xnh_addr, &nbuf[offset], xnh_sizeof);
|
|
|
|
offset += xnh_sizeof;
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -859,11 +858,11 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( ; num; num--) {
|
|
|
|
- if (lseek(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- if (read(fd, xsh_addr, xsh_sizeof) == -1) {
|
|
|
|
+ if (FINFO_READ_FUNC(fd, xsh_addr, xsh_sizeof) == -1) {
|
|
|
|
file_badread(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -888,20 +887,16 @@
|
|
|
|
/* Things we can determine when we seek */
|
|
|
|
switch (xsh_type) {
|
|
|
|
case SHT_NOTE:
|
2010-02-01 06:54:00 +08:00
|
|
|
- if ((nbuf = malloc((size_t)xsh_size)) == NULL) {
|
|
|
|
- file_error(ms, errno, "Cannot allocate memory"
|
|
|
|
- " for note");
|
|
|
|
- return -1;
|
|
|
|
- }
|
2012-04-02 23:27:23 +08:00
|
|
|
- if ((noff = lseek(fd, (off_t)xsh_offset, SEEK_SET)) ==
|
2010-02-01 06:54:00 +08:00
|
|
|
+ nbuf = emalloc((size_t)xsh_size);
|
2012-04-02 23:27:23 +08:00
|
|
|
+ if ((noff = FINFO_LSEEK_FUNC(fd, (off_t)xsh_offset, SEEK_SET)) ==
|
2010-02-01 06:54:00 +08:00
|
|
|
(off_t)-1) {
|
|
|
|
file_badread(ms);
|
|
|
|
- free(nbuf);
|
|
|
|
+ efree(nbuf);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-04-02 23:27:23 +08:00
|
|
|
- if (read(fd, nbuf, (size_t)xsh_size) !=
|
|
|
|
+ if (FINFO_READ_FUNC(fd, nbuf, (size_t)xsh_size) !=
|
2010-02-01 06:54:00 +08:00
|
|
|
(ssize_t)xsh_size) {
|
|
|
|
- free(nbuf);
|
|
|
|
+ efree(nbuf);
|
|
|
|
file_badread(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-04-02 23:27:23 +08:00
|
|
|
@@ -916,10 +911,10 @@
|
2012-03-27 19:34:46 +08:00
|
|
|
if (noff == 0)
|
2010-02-01 06:54:00 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
- free(nbuf);
|
|
|
|
+ efree(nbuf);
|
|
|
|
break;
|
|
|
|
case SHT_SUNW_cap:
|
2012-04-02 23:27:23 +08:00
|
|
|
- if (lseek(fd, (off_t)xsh_offset, SEEK_SET) ==
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, (off_t)xsh_offset, SEEK_SET) ==
|
|
|
|
(off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
@@ -932,7 +927,7 @@
|
|
|
|
MAX(sizeof cap32, sizeof cap64)];
|
|
|
|
if ((coff += xcap_sizeof) > (off_t)xsh_size)
|
|
|
|
break;
|
|
|
|
- if (read(fd, cbuf, (size_t)xcap_sizeof) !=
|
|
|
|
+ if (FINFO_READ_FUNC(fd, cbuf, (size_t)xcap_sizeof) !=
|
|
|
|
(ssize_t)xcap_sizeof) {
|
|
|
|
file_badread(ms);
|
|
|
|
return -1;
|
|
|
|
@@ -1051,12 +1046,12 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( ; num; num--) {
|
|
|
|
- if (lseek(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, off, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (read(fd, xph_addr, xph_sizeof) == -1) {
|
|
|
|
+ if (FINFO_READ_FUNC(fd, xph_addr, xph_sizeof) == -1) {
|
|
|
|
file_badread(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
@@ -1095,11 +1090,11 @@
|
|
|
|
* This is a PT_NOTE section; loop through all the notes
|
|
|
|
* in the section.
|
|
|
|
*/
|
|
|
|
- if (lseek(fd, xph_offset, SEEK_SET) == (off_t)-1) {
|
|
|
|
+ if (FINFO_LSEEK_FUNC(fd, xph_offset, SEEK_SET) == (off_t)-1) {
|
|
|
|
file_badseek(ms);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- bufsize = read(fd, nbuf, ((xph_filesz < sizeof(nbuf)) ?
|
|
|
|
+ bufsize = FINFO_READ_FUNC(fd, nbuf, ((xph_filesz < sizeof(nbuf)) ?
|
|
|
|
xph_filesz : sizeof(nbuf)));
|
|
|
|
if (bufsize == -1) {
|
|
|
|
file_badread(ms);
|
|
|
|
@@ -1161,7 +1156,7 @@
|
|
|
|
/*
|
|
|
|
* If we cannot seek, it must be a pipe, socket or fifo.
|
|
|
|
*/
|
|
|
|
- if((lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) && (errno == ESPIPE))
|
|
|
|
+ if((FINFO_LSEEK_FUNC(fd, (off_t)0, SEEK_SET) == (off_t)-1) && (errno == ESPIPE))
|
|
|
|
fd = file_pipe2file(ms, fd, buf, nbytes);
|
|
|
|
|
|
|
|
if (fstat(fd, &st) == -1) {
|
2012-04-22 19:38:14 +08:00
|
|
|
diff -u libmagic.orig/softmagic.c libmagic/softmagic.c
|
2012-05-29 23:38:30 +08:00
|
|
|
--- libmagic.orig/softmagic.c 2012-05-29 14:40:41.710960045 +0200
|
|
|
|
+++ libmagic/softmagic.c 2012-05-29 14:34:31.900417647 +0200
|
2010-02-01 06:54:00 +08:00
|
|
|
@@ -41,6 +41,11 @@
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
+#ifndef PREG_OFFSET_CAPTURE
|
|
|
|
+# define PREG_OFFSET_CAPTURE (1<<8)
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+
|
|
|
|
|
|
|
|
private int match(struct magic_set *, struct magic *, uint32_t,
|
2012-03-27 19:34:46 +08:00
|
|
|
const unsigned char *, size_t, int, int);
|
|
|
|
@@ -125,14 +130,14 @@
|
|
|
|
int flush = 0;
|
|
|
|
struct magic *m = &magic[magindex];
|
|
|
|
|
|
|
|
- if ((IS_STRING(m->type) &&
|
|
|
|
+ if ((IS_LIBMAGIC_STRING(m->type) &&
|
|
|
|
((text && (m->str_flags & (STRING_BINTEST | STRING_TEXTTEST)) == STRING_BINTEST) ||
|
|
|
|
(!text && (m->str_flags & (STRING_TEXTTEST | STRING_BINTEST)) == STRING_TEXTTEST))) ||
|
|
|
|
(m->flag & mode) != mode) {
|
2010-02-01 06:54:00 +08:00
|
|
|
/* Skip sub-tests */
|
|
|
|
- while (magic[magindex + 1].cont_level != 0 &&
|
|
|
|
- ++magindex < nmagic)
|
|
|
|
- continue;
|
|
|
|
+ while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
|
|
|
|
+ magindex++;
|
|
|
|
+ }
|
|
|
|
continue; /* Skip to next top-level test*/
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -167,9 +172,9 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
* main entry didn't match,
|
|
|
|
* flush its continuations
|
|
|
|
*/
|
|
|
|
- while (magindex < nmagic - 1 &&
|
|
|
|
- magic[magindex + 1].cont_level != 0)
|
|
|
|
+ while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
|
|
|
|
magindex++;
|
|
|
|
+ }
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -196,8 +201,8 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if (file_check_mem(ms, ++cont_level) == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
- while (magic[magindex+1].cont_level != 0 &&
|
|
|
|
- ++magindex < nmagic) {
|
|
|
|
+ while (magindex < nmagic - 1 && magic[magindex + 1].cont_level != 0) {
|
|
|
|
+ magindex++;
|
|
|
|
m = &magic[magindex];
|
|
|
|
ms->line = m->lineno; /* for messages */
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -212,8 +217,7 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
}
|
|
|
|
ms->offset = m->offset;
|
|
|
|
if (m->flag & OFFADD) {
|
|
|
|
- ms->offset +=
|
|
|
|
- ms->c.li[cont_level - 1].off;
|
|
|
|
+ ms->offset += ms->c.li[cont_level - 1].off;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef ENABLE_CONDITIONALS
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -318,44 +322,22 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
private int
|
|
|
|
check_fmt(struct magic_set *ms, struct magic *m)
|
|
|
|
{
|
|
|
|
- regex_t rx;
|
|
|
|
- int rc;
|
|
|
|
-
|
|
|
|
- if (strchr(m->desc, '%') == NULL)
|
|
|
|
+ pcre *pce;
|
|
|
|
+ int re_options;
|
|
|
|
+ pcre_extra *re_extra;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+
|
|
|
|
+ if (strchr(m->desc, '%') == NULL) {
|
|
|
|
return 0;
|
|
|
|
-
|
|
|
|
- rc = regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB);
|
|
|
|
- if (rc) {
|
|
|
|
- char errmsg[512];
|
|
|
|
- (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
|
|
|
|
- file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if ((pce = pcre_get_compiled_regex("~%[-0-9.]*s~", &re_extra, &re_options TSRMLS_CC)) == NULL) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
- rc = regexec(&rx, m->desc, 0, 0, 0);
|
|
|
|
- regfree(&rx);
|
|
|
|
- return !rc;
|
|
|
|
+ return !pcre_exec(pce, re_extra, m->desc, strlen(m->desc), 0, re_options, NULL, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
-#ifndef HAVE_STRNDUP
|
|
|
|
-char * strndup(const char *, size_t);
|
|
|
|
-
|
|
|
|
-char *
|
|
|
|
-strndup(const char *str, size_t n)
|
|
|
|
-{
|
|
|
|
- size_t len;
|
|
|
|
- char *copy;
|
|
|
|
-
|
|
|
|
- for (len = 0; len < n && str[len]; len++)
|
|
|
|
- continue;
|
|
|
|
- if ((copy = malloc(len + 1)) == NULL)
|
|
|
|
- return NULL;
|
|
|
|
- (void)memcpy(copy, str, len);
|
|
|
|
- copy[len] = '\0';
|
|
|
|
- return copy;
|
|
|
|
-}
|
|
|
|
-#endif /* HAVE_STRNDUP */
|
|
|
|
-
|
|
|
|
private int32_t
|
|
|
|
mprint(struct magic_set *ms, struct magic *m)
|
|
|
|
{
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -538,13 +520,10 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
char *cp;
|
|
|
|
int rval;
|
|
|
|
|
|
|
|
- cp = strndup((const char *)ms->search.s, ms->search.rm_len);
|
|
|
|
- if (cp == NULL) {
|
|
|
|
- file_oomem(ms, ms->search.rm_len);
|
|
|
|
- return -1;
|
|
|
|
- }
|
|
|
|
+ cp = estrndup((const char *)ms->search.s, ms->search.rm_len);
|
|
|
|
+
|
|
|
|
rval = file_printf(ms, m->desc, cp);
|
|
|
|
- free(cp);
|
|
|
|
+ efree(cp);
|
|
|
|
|
|
|
|
if (rval == -1)
|
|
|
|
return -1;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -738,16 +717,16 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if (m->num_mask) \
|
|
|
|
switch (m->mask_op & FILE_OPS_MASK) { \
|
|
|
|
case FILE_OPADD: \
|
|
|
|
- p->fld += cast m->num_mask; \
|
|
|
|
+ p->fld += cast (int64_t)m->num_mask; \
|
|
|
|
break; \
|
|
|
|
case FILE_OPMINUS: \
|
|
|
|
- p->fld -= cast m->num_mask; \
|
|
|
|
+ p->fld -= cast (int64_t)m->num_mask; \
|
|
|
|
break; \
|
|
|
|
case FILE_OPMULTIPLY: \
|
|
|
|
- p->fld *= cast m->num_mask; \
|
|
|
|
+ p->fld *= cast (int64_t)m->num_mask; \
|
|
|
|
break; \
|
|
|
|
case FILE_OPDIVIDE: \
|
|
|
|
- p->fld /= cast m->num_mask; \
|
|
|
|
+ p->fld /= cast (int64_t)m->num_mask; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1029,16 +1008,13 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
|
|
|
|
if ((ms->flags & MAGIC_DEBUG) != 0) {
|
|
|
|
mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE));
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
- file_mdump(m);
|
|
|
|
-#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m->flag & INDIR) {
|
|
|
|
int off = m->in_offset;
|
|
|
|
if (m->in_op & FILE_OPINDIRECT) {
|
|
|
|
- const union VALUETYPE *q = CAST(const union VALUETYPE *,
|
|
|
|
- ((const void *)(s + offset + off)));
|
|
|
|
+ const union VALUETYPE *q =
|
|
|
|
+ ((const void *)(s + offset + off));
|
|
|
|
switch (m->in_type) {
|
|
|
|
case FILE_BYTE:
|
|
|
|
off = q->b;
|
2012-03-27 19:34:46 +08:00
|
|
|
@@ -1518,9 +1494,6 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
if ((ms->flags & MAGIC_DEBUG) != 0) {
|
|
|
|
mdebug(offset, (char *)(void *)p,
|
|
|
|
sizeof(union VALUETYPE));
|
|
|
|
-#ifndef COMPILE_ONLY
|
|
|
|
- file_mdump(m);
|
|
|
|
-#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-29 23:38:30 +08:00
|
|
|
@@ -1669,6 +1642,42 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
return file_strncmp(a, b, len, flags);
|
|
|
|
}
|
|
|
|
|
2012-03-27 19:34:46 +08:00
|
|
|
+public void
|
2010-02-01 06:54:00 +08:00
|
|
|
+convert_libmagic_pattern(zval *pattern, int options)
|
|
|
|
+{
|
|
|
|
+ int i, j=0;
|
|
|
|
+ char *t;
|
|
|
|
+
|
|
|
|
+ t = (char *) safe_emalloc(Z_STRLEN_P(pattern), 2, 5);
|
|
|
|
+
|
|
|
|
+ t[j++] = '~';
|
|
|
|
+
|
|
|
|
+ for (i=0; i<Z_STRLEN_P(pattern); i++, j++) {
|
|
|
|
+ switch (Z_STRVAL_P(pattern)[i]) {
|
|
|
|
+ case '~':
|
|
|
|
+ t[j++] = '\\';
|
|
|
|
+ t[j] = '~';
|
|
|
|
+ break;
|
|
|
|
+ default:
|
|
|
|
+ t[j] = Z_STRVAL_P(pattern)[i];
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ t[j++] = '~';
|
|
|
|
+
|
|
|
|
+ if (options & PCRE_CASELESS)
|
2012-03-27 19:34:46 +08:00
|
|
|
+ t[j++] = 'i';
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
|
|
|
+ if (options & PCRE_MULTILINE)
|
2012-03-27 19:34:46 +08:00
|
|
|
+ t[j++] = 'm';
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
2012-03-27 19:34:46 +08:00
|
|
|
+ t[j]='\0';
|
2010-02-01 06:54:00 +08:00
|
|
|
+
|
|
|
|
+ Z_STRVAL_P(pattern) = t;
|
|
|
|
+ Z_STRLEN_P(pattern) = j;
|
|
|
|
+
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
private int
|
|
|
|
magiccheck(struct magic_set *ms, struct magic *m)
|
|
|
|
{
|
2012-05-29 23:38:30 +08:00
|
|
|
@@ -1825,67 +1834,163 @@
|
2010-02-01 06:54:00 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case FILE_REGEX: {
|
|
|
|
- int rc;
|
|
|
|
- regex_t rx;
|
|
|
|
- char errmsg[512];
|
|
|
|
-
|
|
|
|
- if (ms->search.s == NULL)
|
|
|
|
- return 0;
|
|
|
|
-
|
2012-05-29 23:38:30 +08:00
|
|
|
- l = 0;
|
2012-03-27 19:34:46 +08:00
|
|
|
- rc = regcomp(&rx, m->value.s,
|
|
|
|
- REG_EXTENDED|REG_NEWLINE|
|
|
|
|
- ((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0));
|
|
|
|
- if (rc) {
|
|
|
|
- (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
|
|
|
|
- file_magerror(ms, "regex error %d, (%s)",
|
|
|
|
- rc, errmsg);
|
|
|
|
- v = (uint64_t)-1;
|
|
|
|
- }
|
|
|
|
- else {
|
|
|
|
- regmatch_t pmatch[1];
|
|
|
|
-#ifndef REG_STARTEND
|
|
|
|
-#define REG_STARTEND 0
|
|
|
|
- size_t l = ms->search.s_len - 1;
|
|
|
|
- char c = ms->search.s[l];
|
|
|
|
- ((char *)(intptr_t)ms->search.s)[l] = '\0';
|
2012-05-29 23:38:30 +08:00
|
|
|
+ zval *pattern;
|
|
|
|
+ int options = 0;
|
|
|
|
+ pcre_cache_entry *pce;
|
|
|
|
+ TSRMLS_FETCH();
|
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(pattern);
|
|
|
|
+ ZVAL_STRINGL(pattern, (char *)m->value.s, m->vallen, 0);
|
|
|
|
+
|
|
|
|
+ options |= PCRE_MULTILINE;
|
|
|
|
+
|
|
|
|
+ if (m->str_flags & STRING_IGNORE_CASE) {
|
|
|
|
+ options |= PCRE_CASELESS;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ convert_libmagic_pattern(pattern, options);
|
|
|
|
+
|
|
|
|
+ l = v = 0;
|
2011-10-19 23:08:50 +08:00
|
|
|
+#if (PHP_MAJOR_VERSION < 6)
|
2010-02-01 06:54:00 +08:00
|
|
|
+ if ((pce = pcre_get_compiled_regex_cache(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
|
|
|
|
#else
|
|
|
|
- pmatch[0].rm_so = 0;
|
|
|
|
- pmatch[0].rm_eo = ms->search.s_len;
|
|
|
|
+ if ((pce = pcre_get_compiled_regex_cache(IS_STRING, Z_STRVAL_P(pattern), Z_STRLEN_P(pattern) TSRMLS_CC)) == NULL) {
|
|
|
|
#endif
|
|
|
|
- rc = regexec(&rx, (const char *)ms->search.s,
|
|
|
|
- 1, pmatch, REG_STARTEND);
|
|
|
|
-#if REG_STARTEND == 0
|
|
|
|
- ((char *)(intptr_t)ms->search.s)[l] = c;
|
|
|
|
+ zval_dtor(pattern);
|
|
|
|
+ FREE_ZVAL(pattern);
|
|
|
|
+ return -1;
|
|
|
|
+ } else {
|
|
|
|
+ /* pce now contains the compiled regex */
|
|
|
|
+ zval *retval;
|
|
|
|
+ zval *subpats;
|
|
|
|
+ char *haystack;
|
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(retval);
|
|
|
|
+ ALLOC_INIT_ZVAL(subpats);
|
|
|
|
+
|
|
|
|
+ /* Cut the search len from haystack, equals to REG_STARTEND */
|
|
|
|
+ haystack = estrndup(ms->search.s, ms->search.s_len);
|
|
|
|
+
|
|
|
|
+ /* match v = 0, no match v = 1 */
|
2011-10-19 23:08:50 +08:00
|
|
|
+#if (PHP_MAJOR_VERSION < 6)
|
2010-02-01 06:54:00 +08:00
|
|
|
+ php_pcre_match_impl(pce, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
|
|
|
|
+#else
|
|
|
|
+ php_pcre_match_impl(pce, IS_STRING, haystack, ms->search.s_len, retval, subpats, 1, 1, PREG_OFFSET_CAPTURE, 0 TSRMLS_CC);
|
|
|
|
#endif
|
|
|
|
- switch (rc) {
|
|
|
|
- case 0:
|
|
|
|
- ms->search.s += (int)pmatch[0].rm_so;
|
|
|
|
- ms->search.offset += (size_t)pmatch[0].rm_so;
|
|
|
|
- ms->search.rm_len =
|
|
|
|
- (size_t)(pmatch[0].rm_eo - pmatch[0].rm_so);
|
|
|
|
- v = 0;
|
|
|
|
- break;
|
|
|
|
+ /* Free haystack */
|
|
|
|
+ efree(haystack);
|
|
|
|
+
|
|
|
|
+ if (Z_LVAL_P(retval) < 0) {
|
|
|
|
+ zval_ptr_dtor(&subpats);
|
|
|
|
+ FREE_ZVAL(retval);
|
|
|
|
+ zval_dtor(pattern);
|
|
|
|
+ FREE_ZVAL(pattern);
|
|
|
|
+ return -1;
|
|
|
|
+ } else if ((Z_LVAL_P(retval) > 0) && (Z_TYPE_P(subpats) == IS_ARRAY)) {
|
|
|
|
+
|
|
|
|
+ /* Need to fetch global match which equals pmatch[0] */
|
|
|
|
+ HashTable *ht = Z_ARRVAL_P(subpats);
|
|
|
|
+ HashPosition outer_pos;
|
|
|
|
+ zval *pattern_match = NULL, *pattern_offset = NULL;
|
|
|
|
+
|
|
|
|
+ zend_hash_internal_pointer_reset_ex(ht, &outer_pos);
|
|
|
|
+
|
|
|
|
+ if (zend_hash_has_more_elements_ex(ht, &outer_pos) == SUCCESS &&
|
|
|
|
+ zend_hash_move_forward_ex(ht, &outer_pos)) {
|
|
|
|
+
|
|
|
|
+ zval **ppzval;
|
|
|
|
+
|
|
|
|
+ /* The first element (should be) is the global match
|
|
|
|
+ Need to move to the inner array to get the global match */
|
|
|
|
+
|
|
|
|
+ if (zend_hash_get_current_data_ex(ht, (void**)&ppzval, &outer_pos) != FAILURE) {
|
|
|
|
+
|
|
|
|
+ HashTable *inner_ht;
|
|
|
|
+ HashPosition inner_pos;
|
|
|
|
+ zval **match, **offset;
|
|
|
|
+ zval tmpcopy = **ppzval, matchcopy, offsetcopy;
|
|
|
|
+
|
|
|
|
+ zval_copy_ctor(&tmpcopy);
|
|
|
|
+ INIT_PZVAL(&tmpcopy);
|
|
|
|
+
|
|
|
|
+ inner_ht = Z_ARRVAL(tmpcopy);
|
|
|
|
+
|
|
|
|
+ /* If everything goes according to the master plan
|
|
|
|
+ tmpcopy now contains two elements:
|
|
|
|
+ 0 = the match
|
|
|
|
+ 1 = starting position of the match */
|
|
|
|
+ zend_hash_internal_pointer_reset_ex(inner_ht, &inner_pos);
|
|
|
|
+
|
|
|
|
+ if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
|
|
|
|
+ zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
|
|
|
|
+
|
|
|
|
+ if (zend_hash_get_current_data_ex(inner_ht, (void**)&match, &inner_pos) != FAILURE) {
|
|
|
|
+
|
|
|
|
+ matchcopy = **match;
|
|
|
|
+ zval_copy_ctor(&matchcopy);
|
|
|
|
+ INIT_PZVAL(&matchcopy);
|
|
|
|
+ convert_to_string(&matchcopy);
|
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(pattern_match);
|
|
|
|
+ Z_STRVAL_P(pattern_match) = (char *)Z_STRVAL(matchcopy);
|
|
|
|
+ Z_STRLEN_P(pattern_match) = Z_STRLEN(matchcopy);
|
|
|
|
+ Z_TYPE_P(pattern_match) = IS_STRING;
|
|
|
|
+
|
|
|
|
+ zval_dtor(&matchcopy);
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (zend_hash_has_more_elements_ex(inner_ht, &inner_pos) == SUCCESS &&
|
|
|
|
+ zend_hash_move_forward_ex(inner_ht, &inner_pos)) {
|
|
|
|
+
|
|
|
|
+ if (zend_hash_get_current_data_ex(inner_ht, (void**)&offset, &inner_pos) != FAILURE) {
|
|
|
|
+
|
|
|
|
+ offsetcopy = **offset;
|
|
|
|
+ zval_copy_ctor(&offsetcopy);
|
|
|
|
+ INIT_PZVAL(&offsetcopy);
|
|
|
|
+ convert_to_long(&offsetcopy);
|
|
|
|
+
|
|
|
|
+ MAKE_STD_ZVAL(pattern_offset);
|
|
|
|
+ Z_LVAL_P(pattern_offset) = Z_LVAL(offsetcopy);
|
|
|
|
+ Z_TYPE_P(pattern_offset) = IS_LONG;
|
|
|
|
+
|
|
|
|
+ zval_dtor(&offsetcopy);
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ zval_dtor(&tmpcopy);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if ((pattern_match != NULL) && (pattern_offset != NULL)) {
|
|
|
|
+ ms->search.s += (int)Z_LVAL_P(pattern_offset); /* this is where the match starts */
|
|
|
|
+ ms->search.offset += (size_t)Z_LVAL_P(pattern_offset); /* this is where the match starts as size_t */
|
|
|
|
+ ms->search.rm_len = Z_STRLEN_P(pattern_match) /* This is the length of the matched pattern */;
|
|
|
|
+ v = 0;
|
|
|
|
+
|
|
|
|
+ efree(pattern_match);
|
|
|
|
+ efree(pattern_offset);
|
|
|
|
+
|
|
|
|
+ } else {
|
|
|
|
+ zval_ptr_dtor(&subpats);
|
|
|
|
+ FREE_ZVAL(retval);
|
|
|
|
+ zval_dtor(pattern);
|
|
|
|
+ FREE_ZVAL(pattern);
|
|
|
|
+ return -1;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
|
|
|
|
- case REG_NOMATCH:
|
|
|
|
+
|
|
|
|
+ } else {
|
|
|
|
v = 1;
|
|
|
|
- break;
|
|
|
|
-
|
|
|
|
- default:
|
|
|
|
- (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
|
|
|
|
- file_magerror(ms, "regexec error %d, (%s)",
|
|
|
|
- rc, errmsg);
|
|
|
|
- v = (uint64_t)-1;
|
|
|
|
- break;
|
|
|
|
}
|
|
|
|
- regfree(&rx);
|
|
|
|
+ zval_ptr_dtor(&subpats);
|
|
|
|
+ FREE_ZVAL(retval);
|
|
|
|
}
|
|
|
|
- if (v == (uint64_t)-1)
|
|
|
|
- return -1;
|
|
|
|
- break;
|
|
|
|
+ zval_dtor(pattern);
|
|
|
|
+ FREE_ZVAL(pattern);
|
|
|
|
+ break;
|
|
|
|
}
|
|
|
|
case FILE_INDIRECT:
|
|
|
|
- return 1;
|
|
|
|
+ return 1;
|
|
|
|
default:
|
|
|
|
file_magerror(ms, "invalid type %d in magiccheck()", m->type);
|
|
|
|
return -1;
|