archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 05:58:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

fileinfo: libmagic: Apply libmagic.patch

Browse source 
Signed-off-by: Anatol Belski <ab@php.net>
This commit is contained in:
Anatol Belski 2022-09-14 00:44:53 +02:00
parent 6219d7fbc6
commit a24727a5ca
23 changed files with 4259 additions and 2222 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ext/fileinfo/generate_patch.sh
View file

@ -1,4 +1,4 @@
VERSION=5.40
VERSION=5.43
if [[ ! -d libmagic.orig ]]; then
mkdir libmagic.orig
wget -O - ftp://ftp.astron.com/pub/file/file-$VERSION.tar.gz \

1084
ext/fileinfo/libmagic.patch
View file

File diff suppressed because it is too large Load diff

451
ext/fileinfo/libmagic/apprentice.c
View file

@ -29,6 +29,8 @@
* apprentice - make one pass through /etc/magic, learning its secrets.
*/
#include "php.h"
#include "file.h"
#ifndef lint
@ -37,6 +39,19 @@ FILE_RCSID("@(#)$File: apprentice.c,v 1.326 2022/09/13 18:46:07 christos Exp $")
#include "magic.h"
#include <stdlib.h>
#if defined(__hpux) && !defined(HAVE_STRTOULL)
#if SIZEOF_LONG == 8
# define strtoull strtoul
#else
# define strtoull __strtoull
#endif
#endif
#ifdef PHP_WIN32
#include "win32/unistd.h"
#define strtoull _strtoui64
#else
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
@ -72,6 +87,10 @@ FILE_RCSID("@(#)$File: apprentice.c,v 1.326 2022/09/13 18:46:07 christos Exp $")
#endif
#endif
#ifndef offsetof
#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
#endif
#ifndef MAP_FAILED
#define MAP_FAILED (void *) -1
#endif
@ -186,38 +205,7 @@ private struct {
{ 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"
struct type_tbl_s {
const char name[16];
@ -446,7 +434,7 @@ add_mlist(struct mlist *mlp, struct magic_map *map, size_t idx)
struct mlist *ml;
mlp->map = NULL;
if ((ml = CAST(struct mlist *, malloc(sizeof(*ml)))) == NULL)
if ((ml = CAST(struct mlist *, emalloc(sizeof(*ml)))) == NULL)
return -1;
ml->map = idx == 0 ? map : NULL;
@ -454,9 +442,9 @@ add_mlist(struct mlist *mlp, struct magic_map *map, size_t idx)
ml->nmagic = map->nmagic[idx];
if (ml->nmagic) {
ml->magic_rxcomp = CAST(file_regex_t **,
calloc(ml->nmagic, sizeof(*ml->magic_rxcomp)));
ecalloc(ml->nmagic, sizeof(*ml->magic_rxcomp)));
if (ml->magic_rxcomp == NULL) {
free(ml);
efree(ml);
return -1;
}
} else
@ -539,13 +527,19 @@ file_ms_free(struct magic_set *ms)
return;
for (i = 0; i < MAGIC_SETS; i++)
mlist_free(ms->mlist[i]);
free(ms->o.pbuf);
free(ms->o.buf);
free(ms->c.li);
if (ms->o.pbuf) {
efree(ms->o.pbuf);
}
if (ms->o.buf) {
efree(ms->o.buf);
}
if (ms->c.li) {
efree(ms->c.li);
}
#ifdef USE_C_LOCALE
freelocale(ms->c_lc_ctype);
#endif
free(ms);
efree(ms);
}
protected struct magic_set *
@ -554,7 +548,7 @@ file_ms_alloc(int flags)
struct magic_set *ms;
size_t i, len;
if ((ms = CAST(struct magic_set *, calloc(CAST(size_t, 1u),
if ((ms = CAST(struct magic_set *, ecalloc(CAST(size_t, 1u),
sizeof(struct magic_set)))) == NULL)
return NULL;
@ -567,7 +561,7 @@ file_ms_alloc(int flags)
ms->o.blen = 0;
len = (ms->c.len = 10) * sizeof(*ms->c.li);
if ((ms->c.li = CAST(struct level_info *, malloc(len))) == NULL)
if ((ms->c.li = CAST(struct level_info *, emalloc(len))) == NULL)
goto free;
ms->event_flags = 0;
@ -601,38 +595,26 @@ apprentice_unmap(struct magic_map *map)
char *p;
if (map == NULL)
return;
switch (map->type) {
case MAP_TYPE_USER:
break;
case MAP_TYPE_MALLOC:
p = CAST(char *, map->p);
for (i = 0; i < MAGIC_SETS; i++) {
char *b = RCAST(char *, map->magic[i]);
if (p != NULL && b >= p && b <= p + map->len)
continue;
free(b);
if (map->p != php_magic_database) {
if (map->p == NULL) {
int j;
for (j = 0; j < MAGIC_SETS; j++) {
if (map->magic[j]) {
efree(map->magic[j]);
}
free(p);
break;
#ifdef QUICK
case MAP_TYPE_MMAP:
if (map->p && map->p != MAP_FAILED)
(void)munmap(map->p, map->len);
break;
#endif
default:
fprintf(stderr, "Bad map type %d", map->type);
abort();
}
free(map);
} else {
efree(map->p);
}
}
efree(map);
}
private struct mlist *
mlist_alloc(void)
{
struct mlist *mlist;
if ((mlist = CAST(struct mlist *, calloc(1, sizeof(*mlist)))) == NULL) {
if ((mlist = CAST(struct mlist *, ecalloc(1, sizeof(*mlist)))) == NULL) {
return NULL;
}
mlist->next = mlist->prev = mlist;
@ -653,21 +635,9 @@ mlist_free_all(struct magic_set *ms)
private void
mlist_free_one(struct mlist *ml)
{
size_t i;
if (ml->map)
apprentice_unmap(CAST(struct magic_map *, ml->map));
for (i = 0; i < ml->nmagic; ++i) {
if (ml->magic_rxcomp[i]) {
file_regfree(ml->magic_rxcomp[i]);
free(ml->magic_rxcomp[i]);
ml->magic_rxcomp[i] = NULL;
}
}
free(ml->magic_rxcomp);
ml->magic_rxcomp = NULL;
free(ml);
efree(ml);
}
private void
@ -741,12 +711,28 @@ file_apprentice(struct magic_set *ms, const char *fn, int action)
(void)file_reset(ms, 0);
/* XXX disabling default magic loading so the compiled in data is used */
#if 0
if ((fn = magic_getpath(fn, action)) == NULL)
return -1;
#endif
init_file_tables();
if ((mfn = strdup(fn)) == NULL) {
if (fn == NULL)
fn = getenv("MAGIC");
if (fn == NULL) {
for (i = 0; i < MAGIC_SETS; i++) {
mlist_free(ms->mlist[i]);
if ((ms->mlist[i] = mlist_alloc()) == NULL) {
file_oomem(ms, sizeof(*ms->mlist[i]));
return -1;
}
}
return apprentice_1(ms, fn, action);
}
if ((mfn = estrdup(fn)) == NULL) {
file_oomem(ms, strlen(fn));
return -1;
}
@ -759,7 +745,7 @@ file_apprentice(struct magic_set *ms, const char *fn, int action)
mlist_free(ms->mlist[j]);
ms->mlist[j] = NULL;
}
free(mfn);
efree(mfn);
return -1;
}
}
@ -776,7 +762,7 @@ file_apprentice(struct magic_set *ms, const char *fn, int action)
fn = p;
}
free(mfn);
efree(mfn);
if (errs == -1) {
for (i = 0; i < MAGIC_SETS; i++) {
@ -1289,7 +1275,7 @@ addentry(struct magic_set *ms, struct magic_entry *me,
size_t incr = mset[i].max + ALLOC_INCR;
if ((mp = CAST(struct magic_entry *,
realloc(mset[i].me, sizeof(*mp) * incr))) ==
erealloc(mset[i].me, sizeof(*mp) * incr))) ==
NULL) {
file_oomem(ms, sizeof(*mp) * incr);
return -1;
@ -1312,13 +1298,19 @@ private void
load_1(struct magic_set *ms, int action, const char *fn, int *errs,
struct magic_entry_set *mset)
{
size_t lineno = 0, llen = 0;
char buffer[BUFSIZ + 1];
char *line = NULL;
ssize_t len;
size_t len;
size_t lineno = 0;
struct magic_entry me;
FILE *f = fopen(ms->file = fn, "r");
if (f == NULL) {
php_stream *stream;
ms->file = fn;
stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
if (stream == NULL) {
if (errno != ENOENT)
file_error(ms, errno, "cannot read magic file `%s'",
fn);
@ -1328,8 +1320,7 @@ load_1(struct magic_set *ms, int action, const char *fn, int *errs,
memset(&me, 0, sizeof(me));
/* read and parse this file */
for (ms->line = 1; (len = getline(&line, &llen, f)) != -1;
ms->line++) {
for (ms->line = 1; (line = php_stream_get_line(stream, buffer , BUFSIZ, &len)) != NULL; ms->line++) {
if (len == 0) /* null line, garbage, etc */
continue;
if (line[len - 1] == '\n') {
@ -1388,8 +1379,8 @@ load_1(struct magic_set *ms, int action, const char *fn, int *errs,
}
if (me.mp)
(void)addentry(ms, &me, mset);
free(line);
(void)fclose(f);
efree(line);
php_stream_close(stream);
}
/*
@ -1474,7 +1465,7 @@ coalesce_entries(struct magic_set *ms, struct magic_entry *me, uint32_t nme,
}
slen = sizeof(**ma) * mentrycount;
if ((*ma = CAST(struct magic *, malloc(slen))) == NULL) {
if ((*ma = CAST(struct magic *, emalloc(slen))) == NULL) {
file_oomem(ms, slen);
return -1;
}
@ -1496,8 +1487,8 @@ magic_entry_free(struct magic_entry *me, uint32_t nme)
if (me == NULL)
return;
for (i = 0; i < nme; i++)
free(me[i].mp);
free(me);
efree(me[i].mp);
efree(me);
}
private struct magic_map *
@ -1506,18 +1497,19 @@ apprentice_load(struct magic_set *ms, const char *fn, int action)
int errs = 0;
uint32_t i, j;
size_t files = 0, maxfiles = 0;
char **filearr = NULL, *mfn;
struct stat st;
char **filearr = NULL;
zend_stat_t st = {0};
struct magic_map *map;
struct magic_entry_set mset[MAGIC_SETS];
DIR *dir;
struct dirent *d;
php_stream *dir;
php_stream_dirent d;
memset(mset, 0, sizeof(mset));
ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL)
if ((map = CAST(struct magic_map *, ecalloc(1, sizeof(*map)))) == NULL)
{
file_oomem(ms, sizeof(*map));
return NULL;
@ -1529,52 +1521,50 @@ apprentice_load(struct magic_set *ms, const char *fn, int action)
(void)fprintf(stderr, "%s\n", usg_hdr);
/* load directory or file */
if (stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
dir = opendir(fn);
/* FIXME: Read file names and sort them to prevent
non-determinism. See Debian bug #488562. */
if (php_sys_stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
int mflen;
char mfn[MAXPATHLEN];
dir = php_stream_opendir((char *)fn, REPORT_ERRORS, NULL);
if (!dir) {
errs++;
goto out;
}
while ((d = readdir(dir)) != NULL) {
if (d->d_name[0] == '.')
continue;
if (asprintf(&mfn, "%s/%s", fn, d->d_name) < 0) {
while (php_stream_readdir(dir, &d)) {
if ((mflen = snprintf(mfn, sizeof(mfn), "%s/%s", fn, d.d_name)) < 0) {
file_oomem(ms,
strlen(fn) + strlen(d->d_name) + 2);
strlen(fn) + strlen(d.d_name) + 2);
errs++;
closedir(dir);
php_stream_closedir(dir);
goto out;
}
if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
free(mfn);
if (zend_stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
continue;
}
if (files >= maxfiles) {
size_t mlen;
char **nfilearr;
maxfiles = (maxfiles + 1) * 2;
mlen = maxfiles * sizeof(*filearr);
if ((nfilearr = CAST(char **,
realloc(filearr, mlen))) == NULL) {
if ((filearr = CAST(char **,
erealloc(filearr, mlen))) == NULL) {
file_oomem(ms, mlen);
free(mfn);
closedir(dir);
php_stream_closedir(dir);
errs++;
goto out;
}
filearr = nfilearr;
}
filearr[files++] = mfn;
filearr[files++] = estrndup(mfn, (mflen > sizeof(mfn) - 1)? sizeof(mfn) - 1: mflen);
}
closedir(dir);
php_stream_closedir(dir);
if (filearr) {
qsort(filearr, files, sizeof(*filearr), cmpstrp);
for (i = 0; i < files; i++) {
load_1(ms, action, filearr[i], &errs, mset);
free(filearr[i]);
efree(filearr[i]);
}
free(filearr);
filearr = NULL;
efree(filearr);
}
} else
load_1(ms, action, fn, &errs, mset);
@ -1612,7 +1602,6 @@ apprentice_load(struct magic_set *ms, const char *fn, int action)
}
out:
free(filearr);
for (j = 0; j < MAGIC_SETS; j++)
magic_entry_free(mset[j].me, mset[j].count);
@ -2060,7 +2049,7 @@ parse(struct magic_set *ms, struct magic_entry *me, const char *line,
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,
if ((nm = CAST(struct magic *, erealloc(me->mp,
sizeof(*nm) * cnt))) == NULL) {
file_oomem(ms, sizeof(*nm) * cnt);
return -1;
@ -2075,7 +2064,7 @@ parse(struct magic_set *ms, struct magic_entry *me, const char *line,
static const size_t len = sizeof(*m) * ALLOC_CHUNK;
if (me->mp != NULL)
return 1;
if ((m = CAST(struct magic *, malloc(len))) == NULL) {
if ((m = CAST(struct magic *, emalloc(len))) == NULL) {
file_oomem(ms, len);
return -1;
}
@ -2301,7 +2290,7 @@ parse(struct magic_set *ms, struct magic_entry *me, const char *line,
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");
@ -2310,7 +2299,7 @@ parse(struct magic_set *ms, struct magic_entry *me, const char *line,
m->str_range = 0;
m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0;
if ((op = get_op(*l)) != -1) {
if (IS_STRING(m->type)) {
if (IS_LIBMAGIC_STRING(m->type)) {
int r;
if (op != FILE_OPDIVIDE) {
@ -2493,8 +2482,7 @@ goodchar(unsigned char x, const char *extra)
private int
parse_extra(struct magic_set *ms, struct magic_entry *me, const char *line,
size_t llen, off_t off, size_t len, const char *name, const char *extra,
int nt)
size_t llen, zend_off_t off, size_t len, const char *name, const char *extra, int nt)
{
size_t i;
const char *l = line;
@ -2852,13 +2840,19 @@ getvalue(struct magic_set *ms, struct magic *m, const char **p, int action)
return -1;
}
if (m->type == FILE_REGEX) {
file_regex_t rx;
int rc = file_regcomp(ms, &rx, m->value.s,
REG_EXTENDED);
if (rc == 0) {
file_regfree(&rx);
zend_string *pattern;
int options = 0;
pcre_cache_entry *pce;
pattern = convert_libmagic_pattern(m->value.s, strlen(m->value.s), options);
if ((pce = pcre_get_compiled_regex_cache(pattern)) == NULL) {
zend_string_release(pattern);
return -1;
}
return rc ? -1 : 0;
zend_string_release(pattern);
return 0;
}
return 0;
default:
@ -3258,92 +3252,77 @@ apprentice_buf(struct magic_set *ms, struct magic *buf, size_t len)
private struct magic_map *
apprentice_map(struct magic_set *ms, const char *fn)
{
int fd;
struct stat st;
uint32_t *ptr;
uint32_t version, entries = 0, nentries;
int needsbyteswap;
char *dbname = NULL;
struct magic_map *map;
struct magic_map *rv = NULL;
size_t i;
php_stream *stream = NULL;
php_stream_statbuf st;
fd = -1;
if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL) {
if ((map = CAST(struct magic_map *, ecalloc(1, sizeof(*map)))) == NULL) {
file_oomem(ms, sizeof(*map));
return NULL;
}
if (fn == NULL) {
map->p = (void *)&php_magic_database;
goto internal_loaded;
}
#ifdef PHP_WIN32
/* Don't bother on windows with php_stream_open_wrapper,
return to give apprentice_load() a chance. */
if (php_stream_stat_path_ex((char *)fn, 0, &st, NULL) == SUCCESS) {
if (st.sb.st_mode & S_IFDIR) {
goto error;
}
map->type = MAP_TYPE_USER; /* unspecified */
}
#endif
dbname = mkdbname(ms, fn, 0);
if (dbname == NULL)
goto error;
if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
goto error;
stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
if (fstat(fd, &st) == -1) {
if (!stream) {
goto error;
}
#ifndef PHP_WIN32
if (php_stream_stat(stream, &st) < 0) {
file_error(ms, errno, "cannot stat `%s'", dbname);
goto error;
}
if (st.st_size < 8 || st.st_size > maxoff_t()) {
#endif
if (st.sb.st_size < 8 || st.sb.st_size > maxoff_t()) {
file_error(ms, 0, "file `%s' is too %s", dbname,
st.st_size < 8 ? "small" : "large");
st.sb.st_size < 8 ? "small" : "large");
goto error;
}
map->len = CAST(size_t, st.st_size);
#ifdef QUICK
map->type = MAP_TYPE_MMAP;
if ((map->p = mmap(0, CAST(size_t, st.st_size), PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_FILE, fd, CAST(off_t, 0))) == MAP_FAILED) {
file_error(ms, errno, "cannot map `%s'", dbname);
goto error;
}
#else
map->type = MAP_TYPE_MALLOC;
if ((map->p = CAST(void *, malloc(map->len))) == NULL) {
file_oomem(ms, map->len);
goto error;
}
if (read(fd, map->p, map->len) != (ssize_t)map->len) {
map->len = CAST(size_t, st.sb.st_size);
map->p = CAST(void *, emalloc(map->len));
if (php_stream_read(stream, map->p, (size_t)st.sb.st_size) != (size_t)st.sb.st_size) {
file_badread(ms);
goto error;
}
#endif
(void)close(fd);
fd = -1;
if (check_buffer(ms, map, dbname) != 0) {
goto error;
}
#ifdef QUICK
if (mprotect(map->p, CAST(size_t, st.st_size), PROT_READ) == -1) {
file_error(ms, errno, "cannot mprotect `%s'", dbname);
goto error;
}
#endif
php_stream_close(stream);
stream = NULL;
free(dbname);
return map;
error:
if (fd != -1)
(void)close(fd);
apprentice_unmap(map);
free(dbname);
return rv;
}
private int
check_buffer(struct magic_set *ms, struct magic_map *map, const char *dbname)
{
uint32_t *ptr;
uint32_t entries, nentries;
uint32_t version;
int i, needsbyteswap;
ptr = CAST(uint32_t *, map->p);
internal_loaded:
ptr = (uint32_t *)(void *)map->p;
if (*ptr != MAGICNO) {
if (swap4(*ptr) != MAGICNO) {
file_error(ms, 0, "bad magic in `%s'", dbname);
return -1;
goto error;
}
needsbyteswap = 1;
} else
@ -3353,17 +3332,29 @@ check_buffer(struct magic_set *ms, struct magic_map *map, const char *dbname)
else
version = ptr[1];
if (version != VERSIONNO) {
file_error(ms, 0, "File %s supports only version %d magic "
"files. `%s' is version %d", VERSION,
file_error(ms, 0, "File %d supports only version %d magic "
"files. `%s' is version %d", MAGIC_VERSION,
VERSIONNO, dbname, version);
return -1;
goto error;
}
/* 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) {
map->p = emalloc(sizeof(php_magic_database));
map->p = memcpy(map->p, php_magic_database, sizeof(php_magic_database));
}
if (NULL != fn) {
nentries = (uint32_t)(st.sb.st_size / sizeof(struct magic));
entries = (uint32_t)(st.sb.st_size / sizeof(struct magic));
if ((zend_off_t)(entries * sizeof(struct magic)) != st.sb.st_size) {
file_error(ms, 0, "Size of `%s' %llu is not a multiple of %zu",
dbname, (unsigned long long)st.sb.st_size,
sizeof(struct magic));
goto error;
}
entries = CAST(uint32_t, map->len / sizeof(struct magic));
if ((entries * sizeof(struct magic)) != map->len) {
file_error(ms, 0, "Size of `%s' %" SIZE_T_FORMAT "u is not "
"a multiple of %" SIZE_T_FORMAT "u",
dbname, map->len, sizeof(struct magic));
return -1;
}
map->magic[0] = CAST(struct magic *, map->p) + 1;
nentries = 0;
@ -3376,15 +3367,29 @@ check_buffer(struct magic_set *ms, struct magic_map *map, const char *dbname)
map->magic[i + 1] = map->magic[i] + map->nmagic[i];
nentries += map->nmagic[i];
}
if (entries != nentries + 1) {
if (NULL != fn && entries != nentries + 1) {
file_error(ms, 0, "Inconsistent entries in `%s' %u != %u",
dbname, entries, nentries + 1);
return -1;
goto error;
}
if (needsbyteswap)
for (i = 0; i < MAGIC_SETS; i++)
byteswap(map->magic[i], map->nmagic[i]);
return 0;
if (dbname) {
efree(dbname);
}
return map;
error:
if (stream) {
php_stream_close(stream);
}
apprentice_unmap(map);
if (dbname) {
efree(dbname);
}
return NULL;
}
/*
@ -3395,7 +3400,6 @@ apprentice_compile(struct magic_set *ms, struct magic_map *map, const char *fn)
{
static const size_t nm = sizeof(*map->nmagic) * MAGIC_SETS;
static const size_t m = sizeof(**map->magic);
int fd = -1;
size_t len;
char *dbname;
int rv = -1;
@ -3404,14 +3408,17 @@ apprentice_compile(struct magic_set *ms, struct magic_map *map, const char *fn)
struct magic m;
uint32_t h[2 + MAGIC_SETS];
} hdr;
php_stream *stream;
dbname = mkdbname(ms, fn, 1);
if (dbname == NULL)
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 */
stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS, NULL);
if (!stream) {
file_error(ms, errno, "cannot open `%s'", dbname);
goto out;
}
@ -3420,26 +3427,25 @@ apprentice_compile(struct magic_set *ms, struct magic_map *map, const char *fn)
hdr.h[1] = VERSIONNO;
memcpy(hdr.h + 2, map->nmagic, nm);
if (write(fd, &hdr, sizeof(hdr)) != CAST(ssize_t, sizeof(hdr))) {
if (php_stream_write(stream,(const char *)&hdr, sizeof(hdr)) != (ssize_t)sizeof(hdr)) {
file_error(ms, errno, "error writing `%s'", dbname);
goto out2;
goto out;
}
for (i = 0; i < MAGIC_SETS; i++) {
len = m * map->nmagic[i];
if (write(fd, map->magic[i], len) != CAST(ssize_t, len)) {
if (php_stream_write(stream, (const char *)map->magic[i], len) != (ssize_t)len) {
file_error(ms, errno, "error writing `%s'", dbname);
goto out2;
goto out;
}
}
if (stream) {
php_stream_close(stream);
}
rv = 0;
out2:
if (fd != -1)
(void)close(fd);
out:
apprentice_unmap(map);
free(dbname);
efree(dbname);
return rv;
}
@ -3473,17 +3479,18 @@ mkdbname(struct magic_set *ms, const char *fn, int strip)
q++;
/* Compatibility with old code that looked in .mime */
if (ms->flags & MAGIC_MIME) {
if (asprintf(&buf, "%.*s.mime%s", CAST(int, q - fn), fn, ext)
< 0)
return NULL;
if (access(buf, R_OK) != -1) {
spprintf(&buf, MAXPATHLEN, "%.*s.mime%s", CAST(int, q - fn), fn, ext);
#ifdef PHP_WIN32
if (VCWD_ACCESS(buf, R_OK) == 0) {
#else
if (VCWD_ACCESS(buf, R_OK) != -1) {
#endif
ms->flags &= MAGIC_MIME_TYPE;
return buf;
}
free(buf);
efree(buf);
}
if (asprintf(&buf, "%.*s%s", CAST(int, q - fn), fn, ext) < 0)
return NULL;
spprintf(&buf, MAXPATHLEN, "%.*s%s", CAST(int, q - fn), fn, ext);
/* Compatibility with old code that looked in .mime */
if (strstr(fn, ".mime") != NULL)
@ -3605,7 +3612,7 @@ bs1(struct magic *m)
m->offset = swap4(CAST(uint32_t, m->offset));
m->in_offset = swap4(CAST(uint32_t, m->in_offset));
m->lineno = swap4(CAST(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);
}

7
ext/fileinfo/libmagic/ascmagic.c
View file

@ -96,7 +96,7 @@ file_ascmagic(struct magic_set *ms, const struct buffer *b, int text)
rv = file_ascmagic_with_encoding(ms, &bb,
ubuf, ulen, code, type, text);
free(ubuf);
efree(ubuf);
return rv;
}
@ -143,7 +143,7 @@ file_ascmagic_with_encoding(struct magic_set *ms, const struct buffer *b,
/* 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) {
if ((utf8_buf = CAST(unsigned char *, emalloc(mlen))) == NULL) {
file_oomem(ms, mlen);
goto done;
}
@ -330,7 +330,8 @@ file_ascmagic_with_encoding(struct magic_set *ms, const struct buffer *b,
}
rv = 1;
done:
free(utf8_buf);
if (utf8_buf)
efree(utf8_buf);
return rv;
}

18
ext/fileinfo/libmagic/buffer.c
View file

@ -31,19 +31,23 @@ FILE_RCSID("@(#)$File: buffer.c,v 1.8 2020/02/16 15:52:49 christos Exp $")
#endif /* lint */
#include "magic.h"
#ifdef PHP_WIN32
#include "win32/unistd.h"
#else
#include <unistd.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
void
buffer_init(struct buffer *b, int fd, const struct stat *st, const void *data,
buffer_init(struct buffer *b, int fd, const zend_stat_t *st, const void *data,
size_t len)
{
b->fd = fd;
if (st)
memcpy(&b->st, st, sizeof(b->st));
else if (b->fd == -1 || fstat(b->fd, &b->st) == -1)
else if (b->fd == -1 || zend_fstat(b->fd, &b->st) == -1)
memset(&b->st, 0, sizeof(b->st));
b->fbuf = data;
b->flen = len;
@ -55,7 +59,7 @@ buffer_init(struct buffer *b, int fd, const struct stat *st, const void *data,
void
buffer_fini(struct buffer *b)
{
free(b->ebuf);
efree(b->ebuf);
}
int
@ -71,12 +75,14 @@ buffer_fill(const struct buffer *bb)
b->elen = CAST(size_t, b->st.st_size) < b->flen ?
CAST(size_t, b->st.st_size) : b->flen;
if ((b->ebuf = malloc(b->elen)) == NULL)
if ((b->ebuf = emalloc(b->elen)) == NULL)
goto out;
b->eoff = b->st.st_size - b->elen;
if (pread(b->fd, b->ebuf, b->elen, b->eoff) == -1) {
free(b->ebuf);
if (FINFO_LSEEK_FUNC(b->fd, b->eoff, SEEK_SET) == (zend_off_t)-1 ||
FINFO_READ_FUNC(b->fd, b->ebuf, b->elen) != (ssize_t)b->elen)
{
efree(b->ebuf);
b->ebuf = NULL;
goto out;
}

55
ext/fileinfo/libmagic/cdf.c
View file

@ -43,7 +43,17 @@ FILE_RCSID("@(#)$File: cdf.c,v 1.121 2021/10/20 13:56:15 christos Exp $")
#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>
@ -334,7 +344,7 @@ cdf_zero_stream(cdf_stream_t *scn)
scn->sst_len = 0;
scn->sst_dirlen = 0;
scn->sst_ss = 0;
free(scn->sst_tab);
efree(scn->sst_tab);
scn->sst_tab = NULL;
return -1;
}
@ -342,9 +352,11 @@ cdf_zero_stream(cdf_stream_t *scn)
static size_t
cdf_check_stream(const cdf_stream_t *sst, const cdf_header_t *h)
{
#ifndef NDEBUG
size_t ss = sst->sst_dirlen < h->h_min_size_standard_stream ?
CDF_SHORT_SEC_SIZE(h) : CDF_SEC_SIZE(h);
assert(ss == sst->sst_ss);
#endif
return sst->sst_ss;
}
@ -367,11 +379,11 @@ cdf_check_stream_offset(const cdf_stream_t *sst, const cdf_header_t *h,
}
static ssize_t
cdf_read(const cdf_info_t *info, off_t off, void *buf, size_t len)
cdf_read(const cdf_info_t *info, zend_off_t off, void *buf, size_t len)
{
size_t siz = CAST(size_t, off + len);
if (CAST(off_t, off + len) != CAST(off_t, siz))
if (CAST(zend_off_t, off + len) != CAST(zend_off_t, siz))
goto out;
if (info->i_buf != NULL && info->i_len >= siz) {
@ -382,7 +394,10 @@ cdf_read(const cdf_info_t *info, off_t off, void *buf, size_t len)
if (info->i_fd == -1)
goto out;
if (pread(info->i_fd, buf, len, off) != CAST(ssize_t, len))
if (FINFO_LSEEK_FUNC(info->i_fd, off, SEEK_SET) == (zend_off_t)-1)
return -1;
if (FINFO_READ_FUNC(info->i_fd, buf, len) != (ssize_t)len)
return -1;
return CAST(ssize_t, len);
@ -397,7 +412,7 @@ cdf_read_header(const cdf_info_t *info, cdf_header_t *h)
char buf[512];
(void)memcpy(cdf_bo.s, "\01\02\03\04", 4);
if (cdf_read(info, CAST(off_t, 0), buf, sizeof(buf)) == -1)
if (cdf_read(info, CAST(zend_off_t, 0), buf, sizeof(buf)) == -1)
return -1;
cdf_unpack_header(h, buf);
cdf_swap_header(h);
@ -544,14 +559,14 @@ cdf_read_sat(const cdf_info_t *info, cdf_header_t *h, cdf_sat_t *sat)
}
out:
sat->sat_len = i;
free(msa);
efree(msa);
return 0;
out3:
errno = EFTYPE;
out2:
free(msa);
efree(msa);
out1:
free(sat->sat_tab);
efree(sat->sat_tab);
return -1;
}
@ -719,7 +734,7 @@ cdf_read_dir(const cdf_info_t *info, const cdf_header_t *h,
return -1;
if ((buf = CAST(char *, CDF_MALLOC(ss))) == NULL) {
free(dir->dir_tab);
efree(dir->dir_tab);
return -1;
}
@ -742,11 +757,11 @@ cdf_read_dir(const cdf_info_t *info, const cdf_header_t *h,
if (NEED_SWAP)
for (i = 0; i < dir->dir_len; i++)
cdf_swap_dir(&dir->dir_tab[i]);
free(buf);
efree(buf);
return 0;
out:
free(dir->dir_tab);
free(buf);
efree(dir->dir_tab);
efree(buf);
errno = EFTYPE;
return -1;
}
@ -791,7 +806,7 @@ cdf_read_ssat(const cdf_info_t *info, const cdf_header_t *h,
out:
errno = EFTYPE;
out1:
free(ssat->sat_tab);
efree(ssat->sat_tab);
return -1;
}
@ -953,7 +968,7 @@ cdf_grow_info(cdf_property_info_t **info, size_t *maxcount, size_t incr)
*maxcount = newcount;
return inp;
out:
free(*info);
efree(*info);
*maxcount = 0;
*info = NULL;
return NULL;
@ -1136,7 +1151,7 @@ cdf_read_property_info(const cdf_stream_t *sst, const cdf_header_t *h,
}
return 0;
out:
free(*info);
efree(*info);
*info = NULL;
*count = 0;
*maxcount = 0;
@ -1428,7 +1443,7 @@ cdf_dump_dir(const cdf_info_t *info, const cdf_header_t *h,
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" };
@ -1470,7 +1485,7 @@ cdf_dump_dir(const cdf_info_t *info, const cdf_header_t *h,
break;
}
cdf_dump_stream(&scn);
free(scn.sst_tab);
efree(scn.sst_tab);
break;
default:
break;
@ -1483,7 +1498,7 @@ void
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];
size_t i, j;
@ -1568,7 +1583,7 @@ cdf_dump_summary_info(const cdf_header_t *h, const cdf_stream_t *sst)
(void)fprintf(stderr, "Class %s\n", buf);
(void)fprintf(stderr, "Count %d\n", ssi.si_count);
cdf_dump_property_info(info, count);
free(info);
efree(info);
}
@ -1589,7 +1604,7 @@ cdf_dump_catalog(const cdf_header_t *h, const cdf_stream_t *sst)
cdf_u16tos8(sbuf, ce[i].ce_namlen, ce[i].ce_name),
cdf_ctime(&ts.tv_sec, tbuf));
}
free(cat);
efree(cat);
}
#endif

6
ext/fileinfo/libmagic/cdf.h
View file

@ -35,10 +35,10 @@
#ifndef _H_CDF_
#define _H_CDF_
#ifdef WIN32
#ifdef PHP_WIN32
#include <winsock2.h>
#define timespec timeval
#define tv_nsec tv_usec
#define asctime_r php_asctime_r
#define ctime_r php_ctime_r
#endif
#ifdef __DJGPP__
#define timespec timeval

5
ext/fileinfo/libmagic/cdf_time.c
View file

@ -23,6 +23,7 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "php.h"
#include "file.h"
@ -152,7 +153,7 @@ cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timespec *ts)
#endif
#ifdef notyet
struct tm tm;
if (gmtime_r(&ts->ts_sec, &tm) == NULL) {
if (php_gmtime_r(&ts->ts_sec, &tm) == NULL) {
errno = EINVAL;
return -1;
}
@ -168,7 +169,7 @@ cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timespec *ts)
char *
cdf_ctime(const time_t *sec, char *buf)
{
char *ptr = ctime_r(sec, buf);
char *ptr = php_ctime_r(sec, buf);
if (ptr != NULL)
return buf;
#ifdef WIN32

29
ext/fileinfo/libmagic/compress.c
View file

@ -63,13 +63,14 @@ typedef void (*sig_t)(int);
#if defined(HAVE_SYS_TIME_H)
#include <sys/time.h>
#endif
#if defined(HAVE_ZLIB_H) && defined(ZLIBSUPPORT)
#if defined(HAVE_ZLIB_H) && defined(PHP_FILEINFO_UNCOMPRESS)
#define BUILTIN_DECOMPRESS
#include <zlib.h>
#endif
#if defined(HAVE_BZLIB_H) && defined(BZLIBSUPPORT)
#undef FIONREAD
#if defined(PHP_FILEINFO_UNCOMPRESS)
#define BUILTIN_BZLIB
#include <bzlib.h>
#endif
@ -121,6 +122,8 @@ zlibcmp(const unsigned char *buf)
}
#endif
#ifdef PHP_FILEINFO_UNCOMPRESS
static int
lzmacmp(const unsigned char *buf)
{
@ -297,7 +300,7 @@ file_zmagic(struct magic_set *ms, const struct buffer *b, const char *name)
if (urv == ERRDATA)
prv = format_decompression_error(ms, i, newbuf);
else
prv = file_buffer(ms, -1, NULL, name, newbuf, nsz);
prv = file_buffer(ms, NULL, NULL, name, newbuf, nsz);
if (prv == -1)
goto error;
rv = 1;
@ -314,17 +317,17 @@ file_zmagic(struct magic_set *ms, const struct buffer *b, const char *name)
* XXX: If file_buffer fails here, we overwrite
* the compressed text. FIXME.
*/
if (file_buffer(ms, -1, NULL, NULL, buf, nbytes) == -1) {
if (file_buffer(ms, NULL, NULL, NULL, buf, nbytes) == -1) {
if (file_pop_buffer(ms, pb) != NULL)
abort();
goto error;
}
if ((rbuf = file_pop_buffer(ms, pb)) != NULL) {
if (file_printf(ms, "%s", rbuf) == -1) {
free(rbuf);
efree(rbuf);
goto error;
}
free(rbuf);
efree(rbuf);
}
if (!mime && file_printf(ms, ")") == -1)
goto error;
@ -345,7 +348,8 @@ out:
if (sa_saved && sig_act.sa_handler != SIG_IGN)
(void)sigaction(SIGPIPE, &sig_act, NULL);
free(newbuf);
if (newbuf)
efree(newbuf);
ms->flags |= MAGIC_COMPRESS;
DPRINTF("Zmagic returns %d\n", rv);
return rv;
@ -428,7 +432,7 @@ sread(int fd, void *buf, size_t n, int canbepipe __attribute__((__unused__)))
nocheck:
do
switch ((rv = read(fd, buf, n))) {
switch ((rv = FINFO_READ_FUNC(fd, buf, n))) {
case -1:
if (errno == EINTR)
continue;
@ -521,13 +525,13 @@ file_pipe2file(struct magic_set *ms, int fd, const void *startbuf,
return -1;
}
(void)close(tfd);
if (lseek(fd, CAST(off_t, 0), SEEK_SET) == CAST(off_t, -1)) {
if (FINFO_LSEEK_FUNC(fd, (zend_off_t)0, SEEK_SET) == (zend_off_t)-1) {
file_badseek(ms);
return -1;
}
return fd;
}
#if HAVE_FORK
#ifdef PHP_FILEINFO_UNCOMPRESS
#ifdef BUILTIN_DECOMPRESS
#define FHCRC (1 << 1)
@ -578,7 +582,7 @@ uncompresszlib(const unsigned char *old, unsigned char **newch,
int rc;
z_stream z;
if ((*newch = CAST(unsigned char *, malloc(bytes_max + 1))) == NULL)
if ((*newch = CAST(unsigned char *, emalloc(bytes_max + 1))) == NULL)
return makeerror(newch, n, "No buffer, %s", strerror(errno));
z.next_in = CCAST(Bytef *, old);
@ -1048,3 +1052,4 @@ wait_err:
return rv;
}
#endif
#endif

1
ext/fileinfo/libmagic/config.h Normal file
View file

@ -0,0 +1 @@
#include "php.h"

2
ext/fileinfo/libmagic/der.c
View file

@ -54,7 +54,9 @@ FILE_RCSID("@(#)$File: der.c,v 1.24 2022/07/30 18:08:36 christos Exp $")
#include "magic.h"
#include "der.h"
#else
#ifndef PHP_WIN32
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#include <err.h>
#endif

6
ext/fileinfo/libmagic/elfclass.h
View file

@ -41,7 +41,7 @@
return toomany(ms, "program headers", phnum);
flags |= FLAGS_IS_CORE;
if (dophn_core(ms, clazz, swap, fd,
CAST(off_t, elf_getu(swap, elfhdr.e_phoff)), phnum,
CAST(zend_off_t, elf_getu(swap, elfhdr.e_phoff)), phnum,
CAST(size_t, elf_getu16(swap, elfhdr.e_phentsize)),
fsize, &flags, &notecount) == -1)
return -1;
@ -56,7 +56,7 @@
if (shnum > ms->elf_shnum_max)
return toomany(ms, "section", shnum);
if (dophn_exec(ms, clazz, swap, fd,
CAST(off_t, elf_getu(swap, elfhdr.e_phoff)), phnum,
CAST(zend_off_t, elf_getu(swap, elfhdr.e_phoff)), phnum,
CAST(size_t, elf_getu16(swap, elfhdr.e_phentsize)),
fsize, shnum, &flags, &notecount) == -1)
return -1;
@ -66,7 +66,7 @@
if (shnum > ms->elf_shnum_max)
return toomany(ms, "section headers", shnum);
if (doshn(ms, clazz, swap, fd,
CAST(off_t, elf_getu(swap, elfhdr.e_shoff)), shnum,
CAST(zend_off_t, elf_getu(swap, elfhdr.e_shoff)), shnum,
CAST(size_t, elf_getu16(swap, elfhdr.e_shentsize)),
fsize, elf_getu16(swap, elfhdr.e_machine),
CAST(int, elf_getu16(swap, elfhdr.e_shstrndx)),

6
ext/fileinfo/libmagic/encoding.c
View file

@ -97,7 +97,7 @@ file_encoding(struct magic_set *ms, const struct buffer *b,
nbytes = ms->encoding_max;
mlen = (nbytes + 1) * sizeof((*ubuf)[0]);
*ubuf = CAST(file_unichar_t *, calloc(CAST(size_t, 1), mlen));
*ubuf = CAST(file_unichar_t *, ecalloc(CAST(size_t, 1), mlen));
if (*ubuf == NULL) {
file_oomem(ms, mlen);
goto done;
@ -150,7 +150,7 @@ file_encoding(struct magic_set *ms, const struct buffer *b,
unsigned char *nbuf;
mlen = (nbytes + 1) * sizeof(nbuf[0]);
if ((nbuf = CAST(unsigned char *, malloc(mlen))) == NULL) {
if ((nbuf = CAST(unsigned char *, emalloc(mlen))) == NULL) {
file_oomem(ms, mlen);
goto done;
}
@ -170,7 +170,7 @@ file_encoding(struct magic_set *ms, const struct buffer *b,
rv = 0;
*type = "binary";
}
free(nbuf);
efree(nbuf);
}
done:

115
ext/fileinfo/libmagic/file.h
View file

@ -33,17 +33,14 @@
#ifndef __file_h__
#define __file_h__
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "config.h"
#include "php.h"
#include "ext/standard/php_string.h"
#include "ext/pcre/php_pcre.h"
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
@ -79,19 +76,18 @@
#include <stdio.h> /* Include that here, to make sure __P gets defined */
#include <errno.h>
#include <fcntl.h> /* For open and flags */
#include <regex.h>
#include <time.h>
#include <sys/types.h>
#ifndef WIN32
#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>
#include <locale.h>
#if defined(HAVE_XLOCALE_H)
#include <xlocale.h>
#endif
#define abort() zend_error_noreturn(E_ERROR, "fatal libmagic error")
#define ENABLE_CONDITIONALS
@ -171,14 +167,12 @@
#define FILE_COMPILE 2
#define FILE_LIST 3
typedef regex_t file_regex_t;
struct buffer {
int fd;
struct stat st;
zend_stat_t st;
const void *fbuf;
size_t flen;
off_t eoff;
zend_off_t eoff;
void *ebuf;
size_t elen;
};
@ -281,7 +275,7 @@ struct magic {
#define FILE_OCTAL 59
#define FILE_NAMES_SIZE 60 /* 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 || \
@ -515,10 +509,9 @@ protected const char *file_fmtvarint(char *, size_t, const unsigned char *,
protected const char *file_fmtnum(char *, size_t, const char *, int);
protected struct magic_set *file_ms_alloc(int);
protected void file_ms_free(struct magic_set *);
protected int file_default(struct magic_set *, size_t);
protected int file_buffer(struct magic_set *, int, struct stat *, const char *,
const void *, size_t);
protected int file_fsmagic(struct magic_set *, const char *, struct stat *);
protected int file_buffer(struct magic_set *, php_stream *, zend_stat_t *, const char *, const void *,
size_t);
protected int file_fsmagic(struct magic_set *, const char *, zend_stat_t *);
protected int file_pipe2file(struct magic_set *, int, const void *, size_t);
protected int file_vprintf(struct magic_set *, const char *, va_list)
__attribute__((__format__(__printf__, 2, 0)));
@ -534,7 +527,7 @@ protected int file_printf(struct magic_set *, const char *, ...)
protected int file_reset(struct magic_set *, int);
protected int file_tryelf(struct magic_set *, const struct buffer *);
protected int file_trycdf(struct magic_set *, const struct buffer *);
#if HAVE_FORK
#ifdef PHP_FILEINFO_UNCOMPRESS
protected int file_zmagic(struct magic_set *, const struct buffer *,
const char *);
#endif
@ -588,18 +581,12 @@ protected int file_pipe_closexec(int *);
protected int file_clear_closexec(int);
protected char *file_strtrim(char *);
protected void buffer_init(struct buffer *, int, const struct stat *,
protected void buffer_init(struct buffer *, int, const zend_stat_t *,
const void *, size_t);
protected void buffer_fini(struct buffer *);
protected int buffer_fill(const struct buffer *);
protected int file_regcomp(struct magic_set *, file_regex_t *, const char *,
int);
protected int file_regexec(struct magic_set *, file_regex_t *, const char *,
size_t, regmatch_t *, int);
protected void file_regfree(file_regex_t *);
public zend_string* convert_libmagic_pattern(const char *val, size_t len, uint32_t options);
typedef struct {
char *buf;
@ -615,23 +602,10 @@ extern const char *file_names[];
extern const size_t file_nnames;
#endif
#ifndef HAVE_PREAD
ssize_t pread(int, void *, size_t, off_t);
#endif
#ifndef HAVE_VASPRINTF
int vasprintf(char **, const char *, va_list);
#endif
#ifndef HAVE_ASPRINTF
int asprintf(char **, const char *, ...);
#endif
#ifndef HAVE_DPRINTF
int dprintf(int, const char *, ...);
#endif
#ifndef HAVE_STRLCPY
#ifndef strlcpy
size_t strlcpy(char *, const char *, size_t);
#endif
#ifndef HAVE_STRLCAT
#ifndef strlcat
size_t strlcat(char *, const char *, size_t);
#endif
#ifndef HAVE_STRCASESTR
@ -647,39 +621,6 @@ char *ctime_r(const time_t *, char *);
#ifndef HAVE_ASCTIME_R
char *asctime_r(const struct tm *, char *);
#endif
#ifndef HAVE_GMTIME_R
struct tm *gmtime_r(const time_t *, struct tm *);
#endif
#ifndef HAVE_LOCALTIME_R
struct tm *localtime_r(const time_t *, struct tm *);
#endif
#ifndef HAVE_FMTCHECK
const char *fmtcheck(const char *, const char *)
__attribute__((__format_arg__(2)));
#endif
#ifdef HAVE_LIBSECCOMP
// basic filter
// this mode should not interfere with normal operations
// only some dangerous syscalls are blacklisted
int enable_sandbox_basic(void);
// enhanced filter
// this mode allows only the necessary syscalls used during normal operation
// extensive testing required !!!
int enable_sandbox_full(void);
#endif
protected const char *file_getprogname(void);
protected void file_setprogname(const char *);
protected void file_err(int, const char *, ...)
__attribute__((__format__(__printf__, 2, 3), __noreturn__));
protected void file_errx(int, const char *, ...)
__attribute__((__format__(__printf__, 2, 3), __noreturn__));
protected void file_warn(const char *, ...)
__attribute__((__format__(__printf__, 1, 2)));
protected void file_warnx(const char *, ...)
__attribute__((__format__(__printf__, 1, 2)));
#if defined(HAVE_MMAP) && defined(HAVE_SYS_MMAN_H) && !defined(QUICK)
#define QUICK
@ -709,4 +650,16 @@ static const char *rcsid(const char *p) { \
#define __RCSID(a)
#endif
#ifdef PHP_WIN32
#ifdef _WIN64
#define FINFO_LSEEK_FUNC _lseeki64
#else
#define FINFO_LSEEK_FUNC _lseek
#endif
#define FINFO_READ_FUNC _read
#else
#define FINFO_LSEEK_FUNC lseek
#define FINFO_READ_FUNC read
#endif
#endif /* __file_h__ */

207
ext/fileinfo/libmagic/fsmagic.c
View file

@ -66,26 +66,10 @@ FILE_RCSID("@(#)$File: fsmagic.c,v 1.82 2022/04/11 18:14:41 christos Exp $")
# define minor(dev) ((dev) & 0xff)
#endif
#undef HAVE_MAJOR
#ifdef S_IFLNK
private int
bad_link(struct magic_set *ms, int err, char *buf)
{
int mime = ms->flags & MAGIC_MIME;
if ((mime & MAGIC_MIME_TYPE) &&
file_printf(ms, "inode/symlink")
== -1)
return -1;
else if (!mime) {
if (ms->flags & MAGIC_ERROR) {
file_error(ms, err,
"broken symbolic link to %s", buf);
return -1;
}
if (file_printf(ms, "broken symbolic link to %s", buf) == -1)
return -1;
}
return 1;
}
#ifdef PHP_WIN32
# undef S_IFIFO
#endif
private int
handle_mime(struct magic_set *ms, int mime, const char *str)
@ -103,60 +87,17 @@ handle_mime(struct magic_set *ms, int mime, const char *str)
}
protected int
file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
file_fsmagic(struct magic_set *ms, const char *fn, zend_stat_t *sb)
{
int ret, did = 0;
int mime = ms->flags & MAGIC_MIME;
int silent = ms->flags & (MAGIC_APPLE|MAGIC_EXTENSION);
#ifdef S_IFLNK
char buf[BUFSIZ+4];
ssize_t nch;
struct stat tstatbuf;
#endif
if (fn == NULL)
return 0;
#define COMMA (did++ ? ", " : "")
/*
* 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 */
#ifdef WIN32
{
HANDLE hFile = CreateFile((LPCSTR)fn, 0, FILE_SHARE_DELETE |
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0,
NULL);
if (hFile != INVALID_HANDLE_VALUE) {
/*
* Stat failed, but we can still open it - assume it's
* a block device, if nothing else.
*/
if (ret) {
sb->st_mode = S_IFBLK;
ret = 0;
}
switch (GetFileType(hFile)) {
case FILE_TYPE_CHAR:
sb->st_mode |= S_IFCHR;
sb->st_mode &= ~S_IFREG;
break;
case FILE_TYPE_PIPE:
sb->st_mode |= S_IFIFO;
sb->st_mode &= ~S_IFREG;
break;
}
CloseHandle(hFile);
}
}
#endif
ret = php_sys_stat(fn, sb);
if (ret) {
if (ms->flags & MAGIC_ERROR) {
@ -189,15 +130,8 @@ file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
}
switch (sb->st_mode & S_IFMT) {
case S_IFDIR:
if (mime) {
if (handle_mime(ms, mime, "directory") == -1)
return -1;
} else if (silent) {
} else if (file_printf(ms, "%sdirectory", COMMA) == -1)
return -1;
break;
#ifdef S_IFCHR
#ifndef PHP_WIN32
# ifdef S_IFCHR
case S_IFCHR:
/*
* If -s has been specified, treat character special files
@ -211,9 +145,8 @@ file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
if (mime) {
if (handle_mime(ms, mime, "chardevice") == -1)
return -1;
} else if (silent) {
} else {
#ifdef HAVE_STRUCT_STAT_ST_RDEV
# ifdef HAVE_STAT_ST_RDEV
# ifdef dv_unit
if (file_printf(ms, "%scharacter special (%d/%d/%d)",
COMMA, major(sb->st_rdev), dv_unit(sb->st_rdev),
@ -230,44 +163,10 @@ file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
return -1;
#endif
}
break;
#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) {
ret = 0;
break;
}
if (mime) {
if (handle_mime(ms, mime, "blockdevice") == -1)
return -1;
} else if (silent) {
} else {
#ifdef HAVE_STRUCT_STAT_ST_RDEV
# ifdef dv_unit
if (file_printf(ms, "%sblock special (%d/%d/%d)",
COMMA, major(sb->st_rdev), dv_unit(sb->st_rdev),
dv_subunit(sb->st_rdev)) == -1)
return -1;
# else
if (file_printf(ms, "%sblock special (%ld/%ld)",
COMMA, (long)major(sb->st_rdev),
(long)minor(sb->st_rdev)) == -1)
return -1;
return 1;
# endif
#else
if (file_printf(ms, "%sblock special", COMMA) == -1)
return -1;
#endif
}
break;
#endif
/* TODO add code to handle V7 MUX and Blit MUX files */
#ifdef S_IFIFO
case S_IFIFO:
if((ms->flags & MAGIC_DEVICES) != 0)
@ -292,92 +191,14 @@ file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
#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 (silent) {
} else if (file_printf(ms,
"%sunreadable symlink `%s' (%s)", COMMA, fn,
strerror(errno)) == -1)
return -1;
break;
}
buf[nch] = '\0'; /* readlink(2) does not do this */
/* If broken symlink, say so and quit early. */
#ifdef __linux__
/*
* linux procfs/devfs makes symlinks like pipe:[3515864880]
* that we can't stat their readlink output, so stat the
* original filename instead.
*/
if (stat(fn, &tstatbuf) < 0)
return bad_link(ms, errno, buf);
#else
if (*buf == '/') {
if (stat(buf, &tstatbuf) < 0)
return bad_link(ms, errno, buf);
} else {
char *tmp;
char buf2[BUFSIZ+BUFSIZ+4];
if ((tmp = CCAST(char *, 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);
return -1;
}
if (mime) {
if (handle_mime(ms, mime,
"x-path-too-long") == -1)
return -1;
} else if (silent) {
} else if (file_printf(ms,
"%spath too long: `%s'", COMMA,
fn) == -1)
return -1;
break;
}
/* 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);
}
return 1;
#endif
/* 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;
if (p == NULL)
return -1;
} else { /* just print what it points to */
if (mime) {
if (handle_mime(ms, mime, "symlink") == -1)
return -1;
} else if (silent) {
} else if (file_printf(ms, "%ssymbolic link to %s",
COMMA, buf) == -1)
return -1;
}
break;
#endif
#ifdef S_IFSOCK
#ifndef __COHERENT__
case S_IFSOCK:

174
ext/fileinfo/libmagic/funcs.c
View file

@ -51,6 +51,13 @@ FILE_RCSID("@(#)$File: funcs.c,v 1.131 2022/09/13 18:46:07 christos Exp $")
#define SIZE_MAX ((size_t)~0)
#endif
#include "php.h"
#include "main/php_network.h"
#ifndef PREG_OFFSET_CAPTURE
# define PREG_OFFSET_CAPTURE (1<<8)
#endif
protected char *
file_copystr(char *buf, size_t blen, size_t width, const char *str)
{
@ -66,7 +73,7 @@ file_copystr(char *buf, size_t blen, size_t width, const char *str)
private void
file_clearbuf(struct magic_set *ms)
{
free(ms->o.buf);
efree(ms->o.buf);
ms->o.buf = NULL;
ms->o.blen = 0;
}
@ -132,7 +139,7 @@ file_checkfmt(char *msg, size_t mlen, const char *fmt)
protected int
file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
{
int len;
size_t len;
char *buf, *newstr;
char tbuf[1024];
@ -145,10 +152,10 @@ file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
return -1;
}
len = vasprintf(&buf, fmt, ap);
if (len < 0 || (size_t)len > 1024 || len + ms->o.blen > 1024 * 1024) {
len = vspprintf(&buf, 0, fmt, ap);
if (len > 1024 || len + ms->o.blen > 1024 * 1024) {
size_t blen = ms->o.blen;
free(buf);
if (buf) efree(buf);
file_clearbuf(ms);
file_error(ms, 0, "Output buffer space exceeded %d+%"
SIZE_T_FORMAT "u", len, blen);
@ -156,20 +163,14 @@ file_vprintf(struct magic_set *ms, const char *fmt, va_list 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);
len = spprintf(&newstr, 0, "%s%s", ms->o.buf, buf);
efree(buf);
efree(ms->o.buf);
buf = newstr;
}
ms->o.buf = buf;
ms->o.blen = len;
return 0;
out:
file_clearbuf(ms);
file_error(ms, errno, "vasprintf failed");
return -1;
}
protected int
@ -320,8 +321,8 @@ file_default(struct magic_set *ms, size_t nb)
*/
/*ARGSUSED*/
protected int
file_buffer(struct magic_set *ms, int fd, struct stat *st,
const char *inname __attribute__ ((__unused__)),
file_buffer(struct magic_set *ms, php_stream *stream, zend_stat_t *st,
const char *inname,
const void *buf, size_t nb)
{
int m = 0, rv = 0, looks_text = 0;
@ -331,6 +332,19 @@ file_buffer(struct magic_set *ms, int fd, struct stat *st,
const char *ftype = NULL;
char *rbuf = NULL;
struct buffer b;
int fd = -1;
if (stream) {
#ifdef _WIN64
php_socket_t _fd = fd;
#else
int _fd;
#endif
int _ret = php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&_fd, 0);
if (SUCCESS == _ret) {
fd = (int)_fd;
}
}
buffer_init(&b, fd, st, buf, nb);
ms->mode = b.st.st_mode;
@ -363,7 +377,8 @@ file_buffer(struct magic_set *ms, int fd, struct stat *st,
}
}
#endif
#if HAVE_FORK
#if PHP_FILEINFO_UNCOMPRESS
/* try compression stuff */
if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) == 0) {
m = file_zmagic(ms, &b, inname);
@ -488,10 +503,10 @@ simple:
if (file_printf(ms, "%s", code_mime) == -1)
rv = -1;
}
#if HAVE_FORK
#if PHP_FILEINFO_UNCOMPRESS
done_encoding:
#endif
free(rbuf);
efree(rbuf);
buffer_fini(&b);
if (rv)
return rv;
@ -509,7 +524,7 @@ file_reset(struct magic_set *ms, int checkloaded)
}
file_clearbuf(ms);
if (ms->o.pbuf) {
free(ms->o.pbuf);
efree(ms->o.pbuf);
ms->o.pbuf = NULL;
}
ms->event_flags &= ~EVENT_HAD_ERR;
@ -547,7 +562,7 @@ file_getbuffer(struct magic_set *ms)
return NULL;
}
psize = len * 4 + 1;
if ((pbuf = CAST(char *, realloc(ms->o.pbuf, psize))) == NULL) {
if ((pbuf = CAST(char *, erealloc(ms->o.pbuf, psize))) == NULL) {
file_oomem(ms, psize);
return NULL;
}
@ -611,8 +626,8 @@ file_check_mem(struct magic_set *ms, unsigned int level)
if (level >= ms->c.len) {
len = (ms->c.len = 20 + level) * sizeof(*ms->c.li);
ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
malloc(len) :
realloc(ms->c.li, len));
emalloc(len) :
erealloc(ms->c.li, len));
if (ms->c.li == NULL) {
file_oomem(ms, len);
return -1;
@ -635,87 +650,38 @@ file_printedlen(const struct magic_set *ms)
protected int
file_replace(struct magic_set *ms, const char *pat, const char *rep)
{
file_regex_t rx;
int rc, rv = -1;
zend_string *pattern;
uint32_t opts = 0;
pcre_cache_entry *pce;
zend_string *res;
zend_string *repl;
size_t rep_cnt = 0;
rc = file_regcomp(ms, &rx, pat, REG_EXTENDED);
if (rc == 0) {
regmatch_t rm;
int nm = 0;
while (file_regexec(ms, &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)
opts |= PCRE2_MULTILINE;
pattern = convert_libmagic_pattern((char*)pat, strlen(pat), opts);
if ((pce = pcre_get_compiled_regex_cache_ex(pattern, 0)) == NULL) {
zend_string_release(pattern);
rep_cnt = -1;
goto out;
nm++;
}
rv = nm;
zend_string_release(pattern);
repl = zend_string_init(rep, strlen(rep), 0);
res = php_pcre_replace_impl(pce, NULL, ms->o.buf, strlen(ms->o.buf), repl, -1, &rep_cnt);
zend_string_release_ex(repl, 0);
if (NULL == res) {
rep_cnt = -1;
goto out;
}
strncpy(ms->o.buf, ZSTR_VAL(res), ZSTR_LEN(res));
ms->o.buf[ZSTR_LEN(res)] = '\0';
zend_string_release_ex(res, 0);
out:
file_regfree(&rx);
return rv;
}
protected int
file_regcomp(struct magic_set *ms file_locale_used, file_regex_t *rx,
const char *pat, int flags)
{
#ifdef USE_C_LOCALE
locale_t old = uselocale(ms->c_lc_ctype);
assert(old != NULL);
#else
char old[1024];
strlcpy(old, setlocale(LC_CTYPE, NULL), sizeof(old));
(void)setlocale(LC_CTYPE, "C");
#endif
int rc;
rc = regcomp(rx, pat, flags);
#ifdef USE_C_LOCALE
uselocale(old);
#else
(void)setlocale(LC_CTYPE, old);
#endif
if (rc > 0 && (ms->flags & MAGIC_CHECK)) {
char errmsg[512];
(void)regerror(rc, rx, errmsg, sizeof(errmsg));
file_magerror(ms, "regex error %d for `%s', (%s)", rc, pat,
errmsg);
}
return rc;
}
/*ARGSUSED*/
protected int
file_regexec(struct magic_set *ms file_locale_used, file_regex_t *rx,
const char *str, size_t nmatch, regmatch_t* pmatch, int eflags)
{
#ifdef USE_C_LOCALE
locale_t old = uselocale(ms->c_lc_ctype);
assert(old != NULL);
#else
char old[1024];
strlcpy(old, setlocale(LC_CTYPE, NULL), sizeof(old));
(void)setlocale(LC_CTYPE, "C");
#endif
int rc;
/* XXX: force initialization because glibc does not always do this */
if (nmatch != 0)
memset(pmatch, 0, nmatch * sizeof(*pmatch));
rc = regexec(rx, str, nmatch, pmatch, eflags);
#ifdef USE_C_LOCALE
uselocale(old);
#else
(void)setlocale(LC_CTYPE, old);
#endif
return rc;
}
protected void
file_regfree(file_regex_t *rx)
{
regfree(rx);
return rep_cnt;
}
protected file_pushbuf_t *
@ -726,7 +692,7 @@ file_push_buffer(struct magic_set *ms)
if (ms->event_flags & EVENT_HAD_ERR)
return NULL;
if ((pb = (CAST(file_pushbuf_t *, malloc(sizeof(*pb))))) == NULL)
if ((pb = (CAST(file_pushbuf_t *, emalloc(sizeof(*pb))))) == NULL)
return NULL;
pb->buf = ms->o.buf;
@ -746,8 +712,8 @@ file_pop_buffer(struct magic_set *ms, file_pushbuf_t *pb)
char *rbuf;
if (ms->event_flags & EVENT_HAD_ERR) {
free(pb->buf);
free(pb);
efree(pb->buf);
efree(pb);
return NULL;
}
@ -757,7 +723,7 @@ file_pop_buffer(struct magic_set *ms, file_pushbuf_t *pb)
ms->o.blen = pb->blen;
ms->offset = pb->offset;
free(pb);
efree(pb);
return rbuf;
}
@ -841,6 +807,7 @@ file_print_guid(char *str, size_t len, const uint64_t *guid)
#endif
}
#if 0
protected int
file_pipe_closexec(int *fds)
{
@ -856,6 +823,7 @@ file_pipe_closexec(int *fds)
return 0;
#endif
}
#endif
protected int
file_clear_closexec(int fd) {

375
ext/fileinfo/libmagic/magic.c
View file

@ -25,11 +25,6 @@
* SUCH DAMAGE.
*/
#ifdef WIN32
#include <windows.h>
#include <shlwapi.h>
#endif
#include "file.h"
#ifndef lint
@ -39,10 +34,16 @@ FILE_RCSID("@(#)$File: magic.c,v 1.117 2021/12/06 15:33:00 christos Exp $")
#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>
#include "config.h"
#ifdef PHP_WIN32
#include <shlwapi.h>
#endif
#include <limits.h> /* for PIPE_BUF */
@ -69,200 +70,18 @@ FILE_RCSID("@(#)$File: magic.c,v 1.117 2021/12/06 15:33:00 christos Exp $")
#endif
#endif
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 *);
private const char* get_default_magic(void);
#ifndef COMPILE_ONLY
private const char *file_or_fd(struct magic_set *, const char *, int);
#ifdef PHP_WIN32
# undef S_IFLNK
# undef S_IFIFO
#endif
private int unreadable_info(struct magic_set *, mode_t, const char *);
private const char *file_or_stream(struct magic_set *, const char *, php_stream *);
#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif
#ifdef WIN32
/* HINSTANCE of this shared library. Needed for get_default_magic() */
static HINSTANCE _w32_dll_instance = NULL;
static void
_w32_append_path(char **hmagicpath, const char *fmt, ...)
{
char *tmppath;
char *newpath;
va_list ap;
va_start(ap, fmt);
if (vasprintf(&tmppath, fmt, ap) < 0) {
va_end(ap);
return;
}
va_end(ap);
if (access(tmppath, R_OK) == -1)
goto out;
if (*hmagicpath == NULL) {
*hmagicpath = tmppath;
return;
}
if (asprintf(&newpath, "%s%c%s", *hmagicpath, PATHSEP, tmppath) < 0)
goto out;
free(*hmagicpath);
free(tmppath);
*hmagicpath = newpath;
return;
out:
free(tmppath);
}
static void
_w32_get_magic_relative_to(char **hmagicpath, HINSTANCE module)
{
static const char *trypaths[] = {
"%s/share/misc/magic.mgc",
"%s/magic.mgc",
};
LPSTR dllpath;
size_t sp;
dllpath = calloc(MAX_PATH + 1, sizeof(*dllpath));
if (!GetModuleFileNameA(module, dllpath, MAX_PATH))
goto out;
PathRemoveFileSpecA(dllpath);
if (module) {
char exepath[MAX_PATH];
GetModuleFileNameA(NULL, exepath, MAX_PATH);
PathRemoveFileSpecA(exepath);
if (stricmp(exepath, dllpath) == 0)
goto out;
}
sp = strlen(dllpath);
if (sp > 3 && stricmp(&dllpath[sp - 3], "bin") == 0) {
_w32_append_path(hmagicpath,
"%s/../share/misc/magic.mgc", dllpath);
goto out;
}
for (sp = 0; sp < __arraycount(trypaths); sp++)
_w32_append_path(hmagicpath, trypaths[sp], dllpath);
out:
free(dllpath);
}
#ifndef BUILD_AS_WINDOWS_STATIC_LIBARAY
/* Placate GCC by offering a sacrificial previous prototype */
BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID);
BOOL WINAPI
DllMain(HINSTANCE hinstDLL, DWORD fdwReason,
LPVOID lpvReserved __attribute__((__unused__)))
{
if (fdwReason == DLL_PROCESS_ATTACH)
_w32_dll_instance = hinstDLL;
return 1;
}
#endif
#endif
private const char *
get_default_magic(void)
{
static const char hmagic[] = "/.magic/magic.mgc";
static char *default_magic;
char *home, *hmagicpath;
#ifndef WIN32
struct stat st;
if (default_magic) {
free(default_magic);
default_magic = NULL;
}
if ((home = getenv("HOME")) == NULL)
return MAGIC;
if (asprintf(&hmagicpath, "%s/.magic.mgc", home) < 0)
return MAGIC;
if (stat(hmagicpath, &st) == -1) {
free(hmagicpath);
if (asprintf(&hmagicpath, "%s/.magic", home) < 0)
return MAGIC;
if (stat(hmagicpath, &st) == -1)
goto out;
if (S_ISDIR(st.st_mode)) {
free(hmagicpath);
if (asprintf(&hmagicpath, "%s/%s", home, hmagic) < 0)
return MAGIC;
if (access(hmagicpath, R_OK) == -1)
goto out;
}
}
if (asprintf(&default_magic, "%s:%s", hmagicpath, MAGIC) < 0)
goto out;
free(hmagicpath);
return default_magic;
out:
default_magic = NULL;
free(hmagicpath);
return MAGIC;
#else
hmagicpath = NULL;
if (default_magic) {
free(default_magic);
default_magic = NULL;
}
/* Before anything else, try to get a magic file from user HOME */
if ((home = getenv("HOME")) != NULL)
_w32_append_path(&hmagicpath, "%s%s", home, hmagic);
/* First, try to get a magic file from user-application data */
if ((home = getenv("LOCALAPPDATA")) != NULL)
_w32_append_path(&hmagicpath, "%s%s", home, hmagic);
/* Second, try to get a magic file from the user profile data */
if ((home = getenv("USERPROFILE")) != NULL)
_w32_append_path(&hmagicpath,
"%s/Local Settings/Application Data%s", home, hmagic);
/* Third, try to get a magic file from Common Files */
if ((home = getenv("COMMONPROGRAMFILES")) != NULL)
_w32_append_path(&hmagicpath, "%s%s", home, hmagic);
/* Fourth, try to get magic file relative to exe location */
_w32_get_magic_relative_to(&hmagicpath, NULL);
/* Fifth, try to get magic file relative to dll location */
_w32_get_magic_relative_to(&hmagicpath, _w32_dll_instance);
/* Avoid MAGIC constant - it likely points to a file within MSys tree */
default_magic = hmagicpath;
return default_magic;
#endif
}
public const char *
magic_getpath(const char *magicfile, int action)
{
if (magicfile != NULL)
return magicfile;
magicfile = getenv("MAGIC");
if (magicfile != NULL)
return magicfile;
return action == FILE_LOAD ? get_default_magic() : MAGIC;
}
public struct magic_set *
magic_open(int flags)
{
@ -321,21 +140,6 @@ magic_load(struct magic_set *ms, const char *magicfile)
return file_apprentice(ms, magicfile, FILE_LOAD);
}
#ifndef COMPILE_ONLY
/*
* Install a set of compiled magic buffers.
*/
public int
magic_load_buffers(struct magic_set *ms, void **bufs, size_t *sizes,
size_t nbufs)
{
if (ms == NULL)
return -1;
return buffer_apprentice(ms, RCAST(struct magic **, bufs),
sizes, nbufs);
}
#endif
public int
magic_compile(struct magic_set *ms, const char *magicfile)
{
@ -360,39 +164,6 @@ magic_list(struct magic_set *ms, const char *magicfile)
return file_apprentice(ms, magicfile, FILE_LIST);
}
private void
close_and_restore(const struct magic_set *ms, const char *name, int fd,
const struct stat *sb)
{
if (fd == STDIN_FILENO || name == NULL)
return;
(void) close(fd);
if ((ms->flags & MAGIC_PRESERVE_ATIME) != 0) {
/*
* Try to restore access, modification times if read it.
* This is really *bad* because it will modify the status
* time of the file... And of course this will affect
* backup programs
*/
#ifdef HAVE_UTIMES
struct timeval utsbuf[2];
(void)memset(utsbuf, 0, sizeof(utsbuf));
utsbuf[0].tv_sec = sb->st_atime;
utsbuf[1].tv_sec = sb->st_mtime;
(void) utimes(name, utsbuf); /* don't care if loses */
#elif defined(HAVE_UTIME_H) || defined(HAVE_SYS_UTIME_H)
struct utimbuf utbuf;
(void)memset(&utbuf, 0, sizeof(utbuf));
utbuf.actime = sb->st_atime;
utbuf.modtime = sb->st_mtime;
(void) utime(name, &utbuf); /* don't care if loses */
#endif
}
}
#ifndef COMPILE_ONLY
/*
@ -403,7 +174,7 @@ magic_descriptor(struct magic_set *ms, int fd)
{
if (ms == NULL)
return NULL;
return file_or_fd(ms, NULL, fd);
return file_or_stream(ms, NULL, NULL);
}
/*
@ -414,19 +185,25 @@ magic_file(struct magic_set *ms, const char *inname)
{
if (ms == NULL)
return NULL;
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)
{
if (ms == NULL)
return NULL;
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;
zend_stat_t sb = {0};
ssize_t nbytes = 0; /* number of bytes read from a datafile */
int ispipe = 0;
int okstat = 0;
off_t pos = CAST(off_t, -1);
int no_in_stream = 0;
if (file_reset(ms, 1) == -1)
goto out;
@ -436,7 +213,7 @@ file_or_fd(struct magic_set *ms, const char *inname, int fd)
* some overlapping space for matches near EOF
*/
#define SLOP (1 + sizeof(union VALUETYPE))
if ((buf = CAST(unsigned char *, malloc(ms->bytes_max + SLOP))) == NULL)
if ((buf = CAST(unsigned char *, emalloc(ms->bytes_max + SLOP))) == NULL)
return NULL;
switch (file_fsmagic(ms, inname, &sb)) {
@ -449,96 +226,46 @@ file_or_fd(struct magic_set *ms, const char *inname, int fd)
goto done;
}
#ifdef WIN32
/* Place stdin in binary mode, so EOF (Ctrl+Z) doesn't stop early. */
if (fd == STDIN_FILENO)
_setmode(STDIN_FILENO, O_BINARY);
#endif
if (inname != NULL) {
int flags = O_RDONLY|O_BINARY|O_NONBLOCK|O_CLOEXEC;
errno = 0;
if ((fd = open(inname, flags)) < 0) {
okstat = stat(inname, &sb) == 0;
#ifdef WIN32
/*
* Can't stat, can't open. It may have been opened in
* fsmagic, so if the user doesn't have read permission,
* allow it to say so; otherwise an error was probably
* displayed in fsmagic.
*/
if (!okstat && errno == EACCES) {
sb.st_mode = S_IFBLK;
okstat = 1;
}
#endif
if (okstat &&
unreadable_info(ms, sb.st_mode, inname) == -1)
if (inname && !stream) {
no_in_stream = 1;
stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS, NULL);
if (!stream) {
if (unreadable_info(ms, sb.st_mode, inname) == -1)
goto done;
rv = 0;
rv = -1;
goto done;
}
#if O_CLOEXEC == 0 && defined(F_SETFD)
(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
#endif
}
if (fd != -1) {
okstat = fstat(fd, &sb) == 0;
if (okstat && S_ISFIFO(sb.st_mode))
ispipe = 1;
if (inname == NULL)
pos = lseek(fd, CAST(off_t, 0), SEEK_CUR);
php_stream_statbuf ssb;
if (php_stream_stat(stream, &ssb) < 0) {
if (ms->flags & MAGIC_ERROR) {
file_error(ms, errno, "cannot stat `%s'", inname);
rv = -1;
goto done;
}
}
memcpy(&sb, &ssb.sb, sizeof(zend_stat_t));
/*
* try looking at the first ms->bytes_max bytes
*/
if (ispipe) {
if (fd != -1) {
ssize_t r = 0;
while ((r = sread(fd, RCAST(void *, &buf[nbytes]),
CAST(size_t, ms->bytes_max - nbytes), 1)) > 0) {
nbytes += r;
if (r < PIPE_BUF) break;
}
}
if (nbytes == 0 && inname) {
/* We can not read it, but we were able to stat it. */
if (unreadable_info(ms, sb.st_mode, inname) == -1)
if ((nbytes = php_stream_read(stream, (char *)buf, ms->bytes_max - nbytes)) < 0) {
file_error(ms, errno, "cannot read `%s'", inname);
goto done;
rv = 0;
goto done;
}
} else if (fd != -1) {
/* Windows refuses to read from a big console buffer. */
size_t howmany =
#ifdef WIN32
_isatty(fd) ? 8 * 1024 :
#endif
ms->bytes_max;
if ((nbytes = read(fd, RCAST(void *, buf), howmany)) == -1) {
if (inname == NULL && fd != STDIN_FILENO)
file_error(ms, errno, "cannot read fd %d", fd);
else
file_error(ms, errno, "cannot read `%s'",
inname == NULL ? "/dev/stdin" : inname);
goto done;
}
}
(void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
if (file_buffer(ms, fd, okstat ? &sb : NULL, inname, buf, CAST(size_t, nbytes)) == -1)
if (file_buffer(ms, stream, &sb, inname, buf, CAST(size_t, nbytes)) == -1)
goto done;
rv = 0;
done:
free(buf);
if (fd != -1) {
if (pos != CAST(off_t, -1))
(void)lseek(fd, pos, SEEK_SET);
close_and_restore(ms, inname, fd, &sb);
efree(buf);
if (no_in_stream && stream) {
php_stream_close(stream);
}
out:
return rv == 0 ? file_getbuffer(ms) : NULL;
@ -556,7 +283,7 @@ magic_buffer(struct magic_set *ms, const void *buf, size_t nb)
* The main work is done here!
* We have the file name and/or the data buffer to be identified.
*/
if (file_buffer(ms, -1, NULL, NULL, buf, nb) == -1) {
if (file_buffer(ms, NULL, NULL, NULL, buf, nb) == -1) {
return NULL;
}
return file_getbuffer(ms);

27
ext/fileinfo/libmagic/print.c
View file

@ -28,6 +28,7 @@
/*
* print.c - debugging printout routines
*/
#include "php.h"
#include "file.h"
@ -73,7 +74,7 @@ file_mdump(struct magic *m)
if (m->mask_op & FILE_OPINVERSE)
(void) fputc('~', stderr);
if (IS_STRING(m->type)) {
if (IS_LIBMAGIC_STRING(m->type)) {
if (m->str_flags) {
(void) fputc('/', stderr);
if (m->str_flags & STRING_COMPACT_WHITESPACE)
@ -246,18 +247,18 @@ protected void
file_magwarn(struct magic_set *ms, const char *f, ...)
{
va_list va;
char *expanded_format = NULL;
int expanded_len;
/* cuz we use stdout for most, stderr here */
(void) fflush(stdout);
if (ms->file)
(void) fprintf(stderr, "%s, %lu: ", ms->file,
CAST(unsigned long, ms->line));
(void) fprintf(stderr, "Warning: ");
va_start(va, f);
(void) vfprintf(stderr, f, va);
expanded_len = vasprintf(&expanded_format, f, va);
va_end(va);
(void) fputc('\n', stderr);
if (expanded_len >= 0 && expanded_format) {
php_error_docref(NULL, E_WARNING, "%s", expanded_format);
free(expanded_format);
}
}
protected const char *
@ -285,13 +286,13 @@ file_fmtdatetime(char *buf, size_t bsize, uint64_t v, int flags)
}
if (flags & FILE_T_LOCAL) {
tm = localtime_r(&t, &tmz);
tm = php_localtime_r(&t, &tmz);
} else {
tm = gmtime_r(&t, &tmz);
tm = php_gmtime_r(&t, &tmz);
}
if (tm == NULL)
goto out;
pp = asctime_r(tm, buf);
pp = php_asctime_r(tm, buf);
if (pp == NULL)
goto out;

61
ext/fileinfo/libmagic/readcdf.c
View file

@ -31,7 +31,11 @@ FILE_RCSID("@(#)$File: readcdf.c,v 1.76 2022/01/17 16:59:01 christos Exp $")
#include <assert.h>
#include <stdlib.h>
#ifdef PHP_WIN32
#include "win32/unistd.h"
#else
#include <unistd.h>
#endif
#include <string.h>
#include <time.h>
#include <ctype.h>
@ -100,10 +104,6 @@ cdf_clsid_to_mime(const uint64_t clsid[2], const struct cv *cv)
if (clsid[0] == cv[i].clsid[0] && clsid[1] == cv[i].clsid[1])
return cv[i].mime;
}
#ifdef CDF_DEBUG
fprintf(stderr, "unknown mime %" PRIx64 ", %" PRIx64 "\n", clsid[0],
clsid[1]);
#endif
return NULL;
}
@ -112,35 +112,24 @@ cdf_app_to_mime(const char *vbuf, const struct nv *nv)
{
size_t i;
const char *rv = NULL;
#ifdef USE_C_LOCALE
locale_t old_lc_ctype, c_lc_ctype;
char *vbuf_lower;
c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0);
assert(c_lc_ctype != NULL);
old_lc_ctype = uselocale(c_lc_ctype);
assert(old_lc_ctype != NULL);
#else
char *old_lc_ctype = setlocale(LC_CTYPE, NULL);
assert(old_lc_ctype != NULL);
old_lc_ctype = strdup(old_lc_ctype);
assert(old_lc_ctype != NULL);
(void)setlocale(LC_CTYPE, "C");
#endif
for (i = 0; nv[i].pattern != NULL; i++)
if (strcasestr(vbuf, nv[i].pattern) != NULL) {
vbuf_lower = zend_str_tolower_dup(vbuf, strlen(vbuf));
for (i = 0; nv[i].pattern != NULL; i++) {
char *pattern_lower;
int found;
pattern_lower = zend_str_tolower_dup(nv[i].pattern, strlen(nv[i].pattern));
found = (strstr(vbuf_lower, pattern_lower) != NULL);
efree(pattern_lower);
if (found) {
rv = nv[i].mime;
break;
}
#ifdef CDF_DEBUG
fprintf(stderr, "unknown app %s\n", vbuf);
#endif
#ifdef USE_C_LOCALE
(void)uselocale(old_lc_ctype);
freelocale(c_lc_ctype);
#else
(void)setlocale(LC_CTYPE, old_lc_ctype);
free(old_lc_ctype);
#endif
}
efree(vbuf_lower);
return rv;
}
@ -156,6 +145,8 @@ cdf_file_property_info(struct magic_set *ms, const cdf_property_info_t *info,
const char *s, *e;
int len;
memset(&ts, 0, sizeof(ts));
if (!NOTMIME(ms) && root_storage)
str = cdf_clsid_to_mime(root_storage->d_storage_uuid,
clsid2mime);
@ -282,10 +273,10 @@ cdf_file_catalog(struct magic_set *ms, const cdf_header_t *h,
if (file_printf(ms, "%s%s",
cdf_u16tos8(buf, ce[i].ce_namlen, ce[i].ce_name),
i == cat->cat_num - 1 ? "]" : ", ") == -1) {
free(cat);
efree(cat);
return -1;
}
free(cat);
efree(cat);
} else if (ms->flags & MAGIC_MIME_TYPE) {
if (file_printf(ms, "application/CDFV2") == -1)
return -1;
@ -346,7 +337,7 @@ cdf_file_summary_info(struct magic_set *ms, const cdf_header_t *h,
}
m = cdf_file_property_info(ms, info, count, root_storage);
free(info);
efree(info);
return m == -1 ? -2 : m;
}
@ -656,11 +647,11 @@ out5:
cdf_zero_stream(&scn);
cdf_zero_stream(&sst);
out3:
free(dir.dir_tab);
efree(dir.dir_tab);
out2:
free(ssat.sat_tab);
efree(ssat.sat_tab);
out1:
free(sat.sat_tab);
efree(sat.sat_tab);
out0:
/* If we handled it already, return */
if (i != -1)

208
ext/fileinfo/libmagic/softmagic.c
View file

@ -43,6 +43,10 @@ FILE_RCSID("@(#)$File: softmagic.c,v 1.328 2022/09/13 18:46:07 christos Exp $")
#include <time.h>
#include "der.h"
#ifndef PREG_OFFSET_CAPTURE
# define PREG_OFFSET_CAPTURE (1<<8)
#endif
private int match(struct magic_set *, struct magic *, file_regex_t **, size_t,
const struct buffer *, size_t, int, int, int, uint16_t *,
uint16_t *, int *, int *, int *, int *);
@ -150,8 +154,8 @@ file_softmagic(struct magic_set *ms, const struct buffer *b,
return rv;
}
#define FILE_FMTDEBUG
#ifdef FILE_FMTDEBUG
#if defined(FILE_FMTDEBUG) && defined(HAVE_FMTCHECK)
#define F(a, b, c) file_fmtcheck((a), (b), (c), __FILE__, __LINE__)
private const char * __attribute__((__format_arg__(3)))
@ -170,10 +174,14 @@ file_fmtcheck(struct magic_set *ms, const char *desc, const char *def,
" with `%s'", file, line, desc, def);
return ptr;
}
#else
#elif defined(HAVE_FMTCHECK)
#define F(a, b, c) fmtcheck((b), (c))
#else
#define F(a, b, c) ((b))
#endif
/* NOTE this function has been kept an the state of 5.39 for BC. Observe
* further as the upgrade to 5.41 or above goes. */
/*
* Go through the whole list, stopping if you find a match. Process all
* the continuations of that match before returning.
@ -235,7 +243,7 @@ match(struct magic_set *ms, struct magic *magic, file_regex_t **magic_rxcomp,
file_regex_t **m_rxcomp = &magic_rxcomp[magindex];
if (m->type != FILE_NAME)
if ((IS_STRING(m->type) &&
if ((IS_LIBMAGIC_STRING(m->type) &&
#define FLT (STRING_BINTEST | STRING_TEXTTEST)
((text && (m->str_flags & FLT) == STRING_BINTEST) ||
(!text && (m->str_flags & FLT) == STRING_TEXTTEST))) ||
@ -484,19 +492,25 @@ flush:
private int
check_fmt(struct magic_set *ms, const char *fmt)
{
file_regex_t rx;
int rc, rv = -1;
const char* pat = "%[-0-9\\.]*s";
pcre_cache_entry *pce;
int rv = -1;
zend_string *pattern;
if (strchr(fmt, '%') == NULL)
return 0;
rc = file_regcomp(ms, &rx, pat, REG_EXTENDED|REG_NOSUB);
if (rc == 0) {
rc = file_regexec(ms, &rx, fmt, 0, 0, 0);
rv = !rc;
pattern = zend_string_init("~%[-0-9\\.]*s~", sizeof("~%[-0-9\\.]*s~") - 1, 0);
if ((pce = pcre_get_compiled_regex_cache_ex(pattern, 0)) == NULL) {
rv = -1;
} else {
pcre2_code *re = php_pcre_pce_re(pce);
pcre2_match_data *match_data = php_pcre_create_match_data(0, re);
if (match_data) {
rv = pcre2_match(re, (PCRE2_SPTR)fmt, strlen(fmt), 0, 0, match_data, php_pcre_mctx()) > 0;
php_pcre_free_match_data(match_data);
}
file_regfree(&rx);
}
zend_string_release(pattern);
return rv;
}
@ -514,7 +528,7 @@ strndup(const char *str, size_t n)
for (len = 0; len < n && str[len]; len++)
continue;
if ((copy = CAST(char *, malloc(len + 1))) == NULL)
if ((copy = CAST(char *, emalloc(len + 1))) == NULL)
return NULL;
(void)memcpy(copy, str, len);
copy[len] = '\0';
@ -1544,7 +1558,7 @@ save_cont(struct magic_set *ms, struct cont *c)
size_t len;
*c = ms->c;
len = c->len * sizeof(*c->li);
ms->c.li = CAST(struct level_info *, malloc(len));
ms->c.li = CAST(struct level_info *, emalloc(len));
if (ms->c.li == NULL) {
ms->c = *c;
return -1;
@ -1556,7 +1570,7 @@ save_cont(struct magic_set *ms, struct cont *c)
private void
restore_cont(struct magic_set *ms, struct cont *c)
{
free(ms->c.li);
efree(ms->c.li);
ms->c = *c;
}
@ -1878,15 +1892,15 @@ mget(struct magic_set *ms, struct magic *m, const struct buffer *b,
if ((ms->flags & MAGIC_NODESC) == 0 &&
file_printf(ms, F(ms, m->desc, "%u"), offset) == -1)
{
free(rbuf);
if (rbuf) efree(rbuf);
return -1;
}
if (file_printf(ms, "%s", rbuf) == -1) {
free(rbuf);
if (rbuf) efree(rbuf);
return -1;
}
}
free(rbuf);
if (rbuf) efree(rbuf);
return rv;
case FILE_USE:
@ -2057,6 +2071,60 @@ alloc_regex(struct magic_set *ms, struct magic *m)
return NULL;
}
public zend_string* convert_libmagic_pattern(const char *val, size_t len, uint32_t options)
{
int i, j;
zend_string *t;
for (i = j = 0; i < len; i++) {
switch (val[i]) {
case '~':
j += 2;
break;
case '\0':
j += 4;
break;
default:
j++;
break;
}
}
t = zend_string_alloc(j + 4, 0);
j = 0;
ZSTR_VAL(t)[j++] = '~';
for (i = 0; i < len; i++, j++) {
switch (val[i]) {
case '~':
ZSTR_VAL(t)[j++] = '\\';
ZSTR_VAL(t)[j] = '~';
break;
case '\0':
ZSTR_VAL(t)[j++] = '\\';
ZSTR_VAL(t)[j++] = 'x';
ZSTR_VAL(t)[j++] = '0';
ZSTR_VAL(t)[j] = '0';
break;
default:
ZSTR_VAL(t)[j] = val[i];
break;
}
}
ZSTR_VAL(t)[j++] = '~';
if (options & PCRE2_CASELESS)
ZSTR_VAL(t)[j++] = 'i';
if (options & PCRE2_MULTILINE)
ZSTR_VAL(t)[j++] = 'm';
ZSTR_VAL(t)[j]='\0';
ZSTR_LEN(t) = j;
return t;
}
private int
magiccheck(struct magic_set *ms, struct magic *m, file_regex_t **m_cache)
{
@ -2218,8 +2286,8 @@ magiccheck(struct magic_set *ms, struct magic *m, file_regex_t **m_cache)
idx = m->str_range + slen;
if (m->str_range == 0 || ms->search.s_len < idx)
idx = ms->search.s_len;
found = CAST(const char *, memmem(ms->search.s, idx,
m->value.s, slen));
found = CAST(const char *, php_memnstr(ms->search.s,
m->value.s, slen, ms->search.s + idx));
if (!found) {
v = 1;
break;
@ -2229,7 +2297,6 @@ magiccheck(struct magic_set *ms, struct magic *m, file_regex_t **m_cache)
ms->search.rm_len = ms->search.s_len - idx;
break;
}
#endif
for (idx = 0; m->str_range == 0 || idx < m->str_range; idx++) {
if (slen + idx > ms->search.s_len) {
@ -2248,55 +2315,80 @@ magiccheck(struct magic_set *ms, struct magic *m, file_regex_t **m_cache)
break;
}
case FILE_REGEX: {
int rc;
file_regex_t *rx = *m_cache;
const char *search;
regmatch_t pmatch;
size_t slen = ms->search.s_len;
char *copy;
zend_string *pattern;
uint32_t options = 0;
pcre_cache_entry *pce;
if (ms->search.s == NULL)
return 0;
options |= PCRE2_MULTILINE;
if (rx == NULL) {
rx = *m_cache = alloc_regex(ms, m);
if (rx == NULL)
return -1;
if (m->str_flags & STRING_IGNORE_CASE) {
options |= PCRE2_CASELESS;
}
l = 0;
if (slen != 0) {
copy = CAST(char *, malloc(slen));
if (copy == NULL) {
file_error(ms, errno,
"can't allocate %" SIZE_T_FORMAT "u bytes",
slen);
pattern = convert_libmagic_pattern((char *)m->value.s, m->vallen, options);
l = v = 0;
if ((pce = pcre_get_compiled_regex_cache(pattern)) == NULL) {
zend_string_release(pattern);
return -1;
}
memcpy(copy, ms->search.s, slen);
copy[--slen] = '\0';
search = copy;
} else {
search = CCAST(char *, "");
copy = NULL;
}
rc = file_regexec(ms, rx, RCAST(const char *, search),
1, &pmatch, 0);
free(copy);
switch (rc) {
case 0:
ms->search.s += CAST(int, pmatch.rm_so);
ms->search.offset += CAST(size_t, pmatch.rm_so);
ms->search.rm_len = CAST(size_t,
pmatch.rm_eo - pmatch.rm_so);
v = 0;
break;
/* pce now contains the compiled regex */
zval retval;
zval subpats;
zend_string *haystack;
case REG_NOMATCH:
v = 1;
break;
ZVAL_NULL(&retval);
ZVAL_NULL(&subpats);
default:
/* Cut the search len from haystack, equals to REG_STARTEND */
haystack = zend_string_init(ms->search.s, ms->search.s_len, 0);
/* match v = 0, no match v = 1 */
php_pcre_match_impl(pce, haystack, &retval, &subpats, 0, 1, PREG_OFFSET_CAPTURE, 0);
/* Free haystack */
zend_string_release(haystack);
if (Z_LVAL(retval) < 0) {
zval_ptr_dtor(&subpats);
zend_string_release(pattern);
return -1;
} else if ((Z_LVAL(retval) > 0) && (Z_TYPE(subpats) == IS_ARRAY)) {
/* Need to fetch global match which equals pmatch[0] */
zval *pzval;
HashTable *ht = Z_ARRVAL(subpats);
if ((pzval = zend_hash_index_find(ht, 0)) != NULL && Z_TYPE_P(pzval) == IS_ARRAY) {
/* If everything goes according to the master plan
tmpcopy now contains two elements:
0 = the match
1 = starting position of the match */
zval *match, *offset;
if ((match = zend_hash_index_find(Z_ARRVAL_P(pzval), 0)) &&
(offset = zend_hash_index_find(Z_ARRVAL_P(pzval), 1))) {
if (Z_TYPE_P(match) != IS_STRING && Z_TYPE_P(offset) != IS_LONG) {
goto error_out;
}
ms->search.s += Z_LVAL_P(offset); /* this is where the match starts */
ms->search.offset += Z_LVAL_P(offset); /* this is where the match starts as size_t */
ms->search.rm_len = Z_STRLEN_P(match) /* This is the length of the matched pattern */;
v = 0;
} else {
goto error_out;
}
} else {
error_out:
zval_ptr_dtor(&subpats);
zend_string_release(pattern);
return -1;
}
} else {
v = 1;
}
zval_ptr_dtor(&subpats);
zend_string_release(pattern);
}
break;
}

2
ext/fileinfo/libmagic/strcasestr.c
View file

@ -39,6 +39,8 @@ __RCSID("$NetBSD: strncasecmp.c,v 1.2 2007/06/04 18:19:27 christos Exp $");
#include "file.h"
#include <inttypes.h>
#include <stdint.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>

1782
ext/fileinfo/tests/magic
View file

File diff suppressed because it is too large Load diff

1782
ext/fileinfo/tests/magic私はガラスを食べられます
View file

File diff suppressed because it is too large Load diff