mirror of
https://github.com/php/php-src.git
synced 2024-09-22 10:27:25 +00:00
MFB:
Upgraded the lib to use PHP memory allocation routines. Fixed a crash caused by analysis of DEADJOE files A little bit of CS inside libmagic
This commit is contained in:
Ilia Alshanetsky
parent
a46a628c7d
commit
caa3217c68
@ -42,9 +42,6 @@
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/param.h>
|
||||
#ifdef QUICK
|
||||
#include <sys/mman.h>
|
||||
#endif
|
||||
#include <sys/types.h>
|
||||
#include <dirent.h>
|
||||
|
||||
@ -124,42 +121,7 @@ private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
|
||||
private const char mime_marker[] = "!:mime";
|
||||
private const size_t mime_marker_len = sizeof(mime_marker) - 1;
|
||||
|
||||
#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 */
|
||||
|
||||
#ifdef PHP_BUNDLE
|
||||
#include "../data_file.c"
|
||||
#endif
|
||||
|
||||
static const struct type_tbl_s {
|
||||
const char name[16];
|
||||
@ -269,7 +231,7 @@ apprentice_1(struct magic_set *ms, const char *fn, int action,
|
||||
if (rv != 0)
|
||||
return -1;
|
||||
rv = apprentice_compile(ms, &magic, &nmagic, fn);
|
||||
free(magic);
|
||||
efree(magic);
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -289,11 +251,7 @@ apprentice_1(struct magic_set *ms, const char *fn, int action,
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((ml = 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;
|
||||
@ -314,23 +272,18 @@ file_delmagic(struct magic *p, int type, size_t entries)
|
||||
if (p == NULL)
|
||||
return;
|
||||
switch (type) {
|
||||
#ifdef PHP_BUNDLE
|
||||
case 3:
|
||||
/* Do nothing, it's part of the code segment */
|
||||
break;
|
||||
#endif
|
||||
#ifdef QUICK
|
||||
case 2:
|
||||
p--;
|
||||
(void)munmap((void *)p, sizeof(*p) * (entries + 1));
|
||||
break;
|
||||
#endif
|
||||
|
||||
case 1:
|
||||
p--;
|
||||
/*FALLTHROUGH*/
|
||||
|
||||
case 0:
|
||||
free(p);
|
||||
efree(p);
|
||||
break;
|
||||
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
@ -349,30 +302,16 @@ file_apprentice(struct magic_set *ms, const char *fn, int action)
|
||||
if (fn == NULL)
|
||||
fn = getenv("MAGIC");
|
||||
if (fn == NULL) {
|
||||
#ifdef PHP_BUNDLE
|
||||
if ((mlist = malloc(sizeof(*mlist))) == NULL) {
|
||||
file_oomem(ms, sizeof(*mlist));
|
||||
return NULL;
|
||||
}
|
||||
mlist = emalloc(sizeof(*mlist));
|
||||
mlist->next = mlist->prev = mlist;
|
||||
apprentice_1(ms, fn, action, mlist);
|
||||
return mlist;
|
||||
#else
|
||||
fn = MAGIC;
|
||||
#endif
|
||||
}
|
||||
|
||||
if ((mfn = strdup(fn)) == NULL) {
|
||||
file_oomem(ms, strlen(fn));
|
||||
return NULL;
|
||||
}
|
||||
mfn = estrdup(fn);
|
||||
fn = mfn;
|
||||
|
||||
if ((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) {
|
||||
@ -386,13 +325,13 @@ file_apprentice(struct magic_set *ms, const char *fn, int action)
|
||||
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;
|
||||
}
|
||||
|
||||
@ -649,10 +588,7 @@ apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
||||
ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
|
||||
|
||||
maxmagic = MAXMAGIS;
|
||||
if ((marray = calloc(maxmagic, sizeof(*marray))) == NULL) {
|
||||
file_oomem(ms, maxmagic * sizeof(*marray));
|
||||
return -1;
|
||||
}
|
||||
marray = ecalloc(maxmagic, sizeof(*marray));
|
||||
marraycount = 0;
|
||||
|
||||
/* print silly verbose header for USG compat. */
|
||||
@ -735,11 +671,7 @@ apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
||||
for (i = 0; i < marraycount; i++)
|
||||
mentrycount += marray[i].cont_count;
|
||||
|
||||
if ((*magicp = malloc(sizeof(**magicp) * mentrycount)) == NULL) {
|
||||
file_oomem(ms, sizeof(**magicp) * mentrycount);
|
||||
errs++;
|
||||
goto out;
|
||||
}
|
||||
*magicp = emalloc(sizeof(**magicp) * mentrycount);
|
||||
|
||||
mentrycount = 0;
|
||||
for (i = 0; i < marraycount; i++) {
|
||||
@ -749,8 +681,8 @@ apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
||||
}
|
||||
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;
|
||||
@ -823,9 +755,9 @@ file_signextend(struct magic_set *ms, struct magic *m, uint64_t v)
|
||||
case FILE_DEFAULT:
|
||||
break;
|
||||
default:
|
||||
if (ms->flags & MAGIC_CHECK)
|
||||
file_magwarn(ms, "cannot happen: m->type=%d\n",
|
||||
m->type);
|
||||
if (ms->flags & MAGIC_CHECK) {
|
||||
file_magwarn(ms, "cannot happen: m->type=%d\n", m->type);
|
||||
}
|
||||
return ~0U;
|
||||
}
|
||||
}
|
||||
@ -1024,10 +956,7 @@ parse(struct magic_set *ms, struct magic_entry **mentryp, uint32_t *nmentryp,
|
||||
if (me->cont_count == me->max_count) {
|
||||
struct magic *nm;
|
||||
size_t cnt = me->max_count + ALLOC_CHUNK;
|
||||
if ((nm = 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;
|
||||
me->max_count = cnt;
|
||||
}
|
||||
@ -1039,21 +968,13 @@ parse(struct magic_set *ms, struct magic_entry **mentryp, uint32_t *nmentryp,
|
||||
struct magic_entry *mp;
|
||||
|
||||
maxmagic += ALLOC_INCR;
|
||||
if ((mp = 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) {
|
||||
if ((m = malloc(sizeof(*m) * ALLOC_CHUNK)) == NULL) {
|
||||
file_oomem(ms, sizeof(*m) * ALLOC_CHUNK);
|
||||
return -1;
|
||||
}
|
||||
m = safe_emalloc(sizeof(*m), ALLOC_CHUNK, 0);
|
||||
me->mp = m;
|
||||
me->max_count = ALLOC_CHUNK;
|
||||
} else
|
||||
@ -1908,13 +1829,11 @@ apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
||||
void *mm = NULL;
|
||||
int ret = 0;
|
||||
|
||||
#ifdef PHP_BUNDLE
|
||||
if (fn == NULL) {
|
||||
mm = &php_magic_database;
|
||||
ret = 3;
|
||||
goto internal_loaded;
|
||||
}
|
||||
#endif
|
||||
|
||||
mkdbname(fn, &dbname, 0);
|
||||
if (dbname == NULL)
|
||||
@ -1932,29 +1851,18 @@ apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
|
||||
goto error1;
|
||||
}
|
||||
|
||||
#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;
|
||||
}
|
||||
ret = 2;
|
||||
#else
|
||||
if ((mm = malloc((size_t)st.st_size)) == NULL) {
|
||||
file_oomem(ms, (size_t)st.st_size);
|
||||
goto error1;
|
||||
}
|
||||
mm = emalloc((size_t)st.st_size);
|
||||
if (read(fd, mm, (size_t)st.st_size) != (size_t)st.st_size) {
|
||||
file_badread(ms);
|
||||
goto error1;
|
||||
}
|
||||
ret = 1;
|
||||
#endif
|
||||
|
||||
(void)close(fd);
|
||||
fd = -1;
|
||||
#ifdef PHP_BUNDLE
|
||||
|
||||
internal_loaded:
|
||||
#endif
|
||||
|
||||
*magicp = mm;
|
||||
ptr = (uint32_t *)(void *)*magicp;
|
||||
if (*ptr != MAGICNO) {
|
||||
@ -1975,35 +1883,36 @@ internal_loaded:
|
||||
VERSIONNO, dbname, version);
|
||||
goto error1;
|
||||
}
|
||||
#ifdef PHP_BUNDLE
|
||||
if (fn == NULL)
|
||||
|
||||
if (fn == NULL) {
|
||||
*nmagicp = (sizeof(php_magic_database) / sizeof(struct magic));
|
||||
else /* the statement after the #endif is used */
|
||||
#endif
|
||||
*nmagicp = (uint32_t)(st.st_size / sizeof(struct magic));
|
||||
if (*nmagicp > 0)
|
||||
} else {
|
||||
*nmagicp = (uint32_t)(st.st_size / sizeof(struct magic));
|
||||
}
|
||||
if (*nmagicp > 0) {
|
||||
(*nmagicp)--;
|
||||
}
|
||||
(*magicp)++;
|
||||
if (needsbyteswap)
|
||||
if (needsbyteswap) {
|
||||
byteswap(*magicp, *nmagicp);
|
||||
free(dbname);
|
||||
}
|
||||
|
||||
if (dbname) {
|
||||
efree(dbname);
|
||||
}
|
||||
return ret;
|
||||
|
||||
error1:
|
||||
if (fd != -1)
|
||||
(void)close(fd);
|
||||
if (mm) {
|
||||
#ifdef QUICK
|
||||
(void)munmap((void *)mm, (size_t)st.st_size);
|
||||
#else
|
||||
free(mm);
|
||||
#endif
|
||||
efree(mm);
|
||||
} else {
|
||||
*magicp = NULL;
|
||||
*nmagicp = 0;
|
||||
}
|
||||
error2:
|
||||
free(dbname);
|
||||
efree(dbname);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -2051,7 +1960,7 @@ apprentice_compile(struct magic_set *ms, struct magic **magicp,
|
||||
(void)close(fd);
|
||||
rv = 0;
|
||||
out:
|
||||
free(dbname);
|
||||
efree(dbname);
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -2068,9 +1977,9 @@ mkdbname(const char *fn, char **buf, int strip)
|
||||
fn = ++p;
|
||||
}
|
||||
|
||||
(void)asprintf(buf, "%s%s", fn, ext);
|
||||
(void)spprintf(buf, 0, "%s%s", fn, ext);
|
||||
if (*buf && strlen(*buf) > MAXPATHLEN) {
|
||||
free(*buf);
|
||||
efree(*buf);
|
||||
*buf = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -101,13 +101,12 @@ file_ascmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
|
||||
* Undo the NUL-termination kindly provided by process()
|
||||
* but leave at least one byte to look at
|
||||
*/
|
||||
while (nbytes > 1 && buf[nbytes - 1] == '\0')
|
||||
while (nbytes > 1 && buf[nbytes - 1] == '\0') {
|
||||
nbytes--;
|
||||
}
|
||||
|
||||
if ((nbuf = calloc(1, (nbytes + 1) * sizeof(nbuf[0]))) == NULL)
|
||||
goto done;
|
||||
if ((ubuf = calloc(1, (nbytes + 1) * sizeof(ubuf[0]))) == NULL)
|
||||
goto done;
|
||||
nbuf = ecalloc(1, (nbytes + 1) * sizeof(nbuf[0]));
|
||||
ubuf = ecalloc(1, (nbytes + 1) * sizeof(ubuf[0]));
|
||||
|
||||
/*
|
||||
* Then try to determine whether it's any character code we can
|
||||
@ -172,10 +171,8 @@ file_ascmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
|
||||
re-converting improved, or at least realloced after
|
||||
re-converting conversion. */
|
||||
mlen = ulen * 6;
|
||||
if ((utf8_buf = malloc(mlen)) == NULL) {
|
||||
file_oomem(ms, mlen);
|
||||
goto done;
|
||||
}
|
||||
utf8_buf = emalloc(mlen);
|
||||
|
||||
if ((utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen)) == NULL)
|
||||
goto done;
|
||||
if (file_softmagic(ms, utf8_buf, utf8_end - utf8_buf, TEXTTEST) != 0) {
|
||||
@ -348,11 +345,11 @@ subtype_identified:
|
||||
rv = 1;
|
||||
done:
|
||||
if (nbuf)
|
||||
free(nbuf);
|
||||
efree(nbuf);
|
||||
if (ubuf)
|
||||
free(ubuf);
|
||||
efree(ubuf);
|
||||
if (utf8_buf)
|
||||
free(utf8_buf);
|
||||
efree(utf8_buf);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -32,6 +32,7 @@
|
||||
* uncompress(method, old, n, newch) - uncompress old into new,
|
||||
* using method, return sizeof new
|
||||
*/
|
||||
#include "config.h"
|
||||
#include "file.h"
|
||||
#include "magic.h"
|
||||
#include <stdio.h>
|
||||
@ -133,7 +134,7 @@ file_zmagic(struct magic_set *ms, int fd, const char *name,
|
||||
}
|
||||
error:
|
||||
if (newbuf)
|
||||
free(newbuf);
|
||||
efree(newbuf);
|
||||
ms->flags |= MAGIC_COMPRESS;
|
||||
return rv;
|
||||
}
|
||||
@ -330,9 +331,7 @@ uncompressgzipped(struct magic_set *ms, const unsigned char *old,
|
||||
|
||||
if (data_start >= n)
|
||||
return 0;
|
||||
if ((*newch = (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,
|
||||
@ -455,20 +454,14 @@ uncompressbuf(struct magic_set *ms, int fd, size_t method,
|
||||
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;
|
||||
|
||||
@ -1,10 +1 @@
|
||||
#ifdef PHP_WIN32
|
||||
# include "config.w32.h"
|
||||
#else
|
||||
# include <php_config.h>
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "../config.h"
|
||||
#endif
|
||||
#define PHP_BUNDLE
|
||||
#include "php.h"
|
||||
|
||||
@ -366,13 +366,6 @@ extern char *sys_errlist[];
|
||||
#define strtoul(a, b, c) strtol(a, b, c)
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_VASPRINTF
|
||||
int vasprintf(char **ptr, const char *format_string, va_list vargs);
|
||||
#endif
|
||||
#ifndef HAVE_ASPRINTF
|
||||
int asprintf(char **ptr, const char *format_string, ...);
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_MMAP) && defined(HAVE_SYS_MMAN_H) && !defined(QUICK)
|
||||
#define QUICK
|
||||
#endif
|
||||
|
||||
@ -54,27 +54,23 @@ file_printf(struct magic_set *ms, const char *fmt, ...)
|
||||
va_list ap;
|
||||
size_t size;
|
||||
int len;
|
||||
char *buf, *newstr;
|
||||
char *buf = NULL, *newstr;
|
||||
|
||||
va_start(ap, fmt);
|
||||
len = vasprintf(&buf, fmt, ap);
|
||||
if (len < 0)
|
||||
goto out;
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -89,7 +85,7 @@ file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
|
||||
if (ms->haderr)
|
||||
return;
|
||||
if (lineno != 0) {
|
||||
free(ms->o.buf);
|
||||
efree(ms->o.buf);
|
||||
ms->o.buf = NULL;
|
||||
file_printf(ms, "line %u: ", lineno);
|
||||
}
|
||||
@ -123,12 +119,6 @@ file_magerror(struct magic_set *ms, const char *f, ...)
|
||||
va_end(va);
|
||||
}
|
||||
|
||||
protected void
|
||||
file_oomem(struct magic_set *ms, size_t len)
|
||||
{
|
||||
file_error(ms, errno, "cannot allocate %zu bytes", len);
|
||||
}
|
||||
|
||||
protected void
|
||||
file_badseek(struct magic_set *ms)
|
||||
{
|
||||
@ -223,6 +213,9 @@ file_reset(struct magic_set *ms)
|
||||
file_error(ms, 0, "no magic files loaded");
|
||||
return -1;
|
||||
}
|
||||
if (ms->o.buf) {
|
||||
efree(ms->o.buf);
|
||||
}
|
||||
ms->o.buf = NULL;
|
||||
ms->haderr = 0;
|
||||
ms->error = -1;
|
||||
@ -252,14 +245,10 @@ file_getbuffer(struct magic_set *ms)
|
||||
/* * 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 = 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)
|
||||
@ -319,12 +308,7 @@ file_check_mem(struct magic_set *ms, unsigned int level)
|
||||
|
||||
if (level >= ms->c.len) {
|
||||
len = (ms->c.len += 20) * sizeof(*ms->c.li);
|
||||
ms->c.li = (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
|
||||
|
||||
@ -35,9 +35,6 @@
|
||||
#include <sys/types.h>
|
||||
#include <sys/param.h> /* for MAXPATHLEN */
|
||||
#include <sys/stat.h>
|
||||
#ifdef QUICK
|
||||
#include <sys/mman.h>
|
||||
#endif
|
||||
#include <limits.h> /* for PIPE_BUF */
|
||||
|
||||
#if defined(HAVE_UTIMES)
|
||||
@ -98,8 +95,7 @@ magic_open(int flags)
|
||||
{
|
||||
struct magic_set *ms;
|
||||
|
||||
if ((ms = calloc((size_t)1, sizeof(struct magic_set))) == NULL)
|
||||
return NULL;
|
||||
ms = ecalloc((size_t)1, sizeof(struct magic_set));
|
||||
|
||||
if (magic_setflags(ms, flags) == -1) {
|
||||
errno = EINVAL;
|
||||
@ -108,9 +104,7 @@ magic_open(int flags)
|
||||
|
||||
ms->o.buf = ms->o.pbuf = NULL;
|
||||
|
||||
ms->c.li = malloc((ms->c.len = 10) * sizeof(*ms->c.li));
|
||||
if (ms->c.li == NULL)
|
||||
goto free;
|
||||
ms->c.li = emalloc((ms->c.len = 10) * sizeof(*ms->c.li));
|
||||
|
||||
ms->haderr = 0;
|
||||
ms->error = -1;
|
||||
@ -119,7 +113,7 @@ magic_open(int flags)
|
||||
ms->line = 0;
|
||||
return ms;
|
||||
free:
|
||||
free(ms);
|
||||
efree(ms);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -135,10 +129,10 @@ free_mlist(struct mlist *mlist)
|
||||
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
|
||||
@ -162,11 +156,19 @@ info_from_stat(struct magic_set *ms, mode_t md)
|
||||
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);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -267,8 +269,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 = malloc(HOWMANY + SLOP)) == NULL)
|
||||
return NULL;
|
||||
buf = emalloc(HOWMANY + SLOP);
|
||||
|
||||
if (file_reset(ms) == -1)
|
||||
goto done;
|
||||
@ -351,7 +352,7 @@ file_or_fd(struct magic_set *ms, const char *inname, int fd)
|
||||
goto done;
|
||||
rv = 0;
|
||||
done:
|
||||
free(buf);
|
||||
efree(buf);
|
||||
close_and_restore(ms, inname, fd, &sb);
|
||||
return rv == 0 ? file_getbuffer(ms) : NULL;
|
||||
}
|
||||
|
||||
@ -789,20 +789,16 @@ doshn(struct magic_set *ms, int class, int swap, int fd, off_t off, int num,
|
||||
file_badread(ms);
|
||||
return -1;
|
||||
}
|
||||
if ((nbuf = malloc((size_t)xsh_size)) == NULL) {
|
||||
file_error(ms, errno, "Cannot allocate memory"
|
||||
" for note");
|
||||
return -1;
|
||||
}
|
||||
nbuf = emalloc((size_t)xsh_size);
|
||||
if ((noff = lseek(fd, (off_t)xsh_offset, SEEK_SET)) ==
|
||||
(off_t)-1) {
|
||||
file_badread(ms);
|
||||
free(nbuf);
|
||||
efree(nbuf);
|
||||
return -1;
|
||||
}
|
||||
if (read(fd, nbuf, (size_t)xsh_size) !=
|
||||
(ssize_t)xsh_size) {
|
||||
free(nbuf);
|
||||
efree(nbuf);
|
||||
file_badread(ms);
|
||||
return -1;
|
||||
}
|
||||
@ -818,11 +814,11 @@ doshn(struct magic_set *ms, int class, int swap, int fd, off_t off, int num,
|
||||
break;
|
||||
}
|
||||
if ((lseek(fd, off, SEEK_SET)) == (off_t)-1) {
|
||||
free(nbuf);
|
||||
efree(nbuf);
|
||||
file_badread(ms);
|
||||
return -1;
|
||||
}
|
||||
free(nbuf);
|
||||
efree(nbuf);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -127,9 +127,9 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
|
||||
|
||||
if ((m->flag & BINTEST) != mode) {
|
||||
/* Skip sub-tests */
|
||||
while (magic[magindex + 1].cont_level != 0 &&
|
||||
++magindex < nmagic)
|
||||
while (magic[magindex + 1].cont_level != 0 && ++magindex < nmagic) {
|
||||
continue;
|
||||
}
|
||||
continue; /* Skip to next top-level test*/
|
||||
}
|
||||
|
||||
@ -157,9 +157,9 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
|
||||
* 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;
|
||||
}
|
||||
|
||||
@ -197,8 +197,7 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
|
||||
}
|
||||
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
|
||||
@ -282,11 +281,12 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
|
||||
private int
|
||||
check_fmt(struct magic_set *ms, struct magic *m)
|
||||
{
|
||||
regex_t rx;
|
||||
regex_t rx = {0};
|
||||
int rc;
|
||||
|
||||
if (strchr(MAGIC_DESC, '%') == NULL)
|
||||
if (strchr(MAGIC_DESC, '%') == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
rc = regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB);
|
||||
if (rc) {
|
||||
@ -295,32 +295,14 @@ check_fmt(struct magic_set *ms, struct magic *m)
|
||||
file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
|
||||
return -1;
|
||||
} else {
|
||||
rc = regexec(&rx, MAGIC_DESC, 0, 0, 0);
|
||||
regmatch_t *pmatch = (regmatch_t *)ecalloc(sizeof(regmatch_t), rx.re_nsub + 1);
|
||||
rc = regexec(&rx, MAGIC_DESC, rx.re_nsub + 1, pmatch, 0);
|
||||
efree(pmatch);
|
||||
regfree(&rx);
|
||||
return !rc;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef HAVE_STRNDUP
|
||||
char * strndup(const char *, size_t);
|
||||
|
||||
char *
|
||||
strndup(const char *str, size_t n)
|
||||
{
|
||||
size_t len;
|
||||
char *copy;
|
||||
|
||||
len = strlen(str);
|
||||
if (len > n)
|
||||
len = n;
|
||||
if (!(copy = malloc(len + 1)))
|
||||
return (NULL);
|
||||
(void) memcpy(copy, str, len + 1);
|
||||
copy[len] = '\0';
|
||||
return (copy);
|
||||
}
|
||||
#endif /* HAVE_STRNDUP */
|
||||
|
||||
private int32_t
|
||||
mprint(struct magic_set *ms, struct magic *m)
|
||||
{
|
||||
@ -338,7 +320,7 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
case -1:
|
||||
return -1;
|
||||
case 1:
|
||||
if (asprintf(&buf, "%c", (unsigned char)v) < 0)
|
||||
if (spprintf(&buf, 0, "%c", (unsigned char)v) < 0)
|
||||
return -1;
|
||||
if (file_printf(ms, MAGIC_DESC, buf) == -1)
|
||||
return -1;
|
||||
@ -359,7 +341,7 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
case -1:
|
||||
return -1;
|
||||
case 1:
|
||||
if (asprintf(&buf, "%hu", (unsigned short)v) < 0)
|
||||
if (spprintf(&buf, 0, "%hu", (unsigned short)v) < 0)
|
||||
return -1;
|
||||
if (file_printf(ms, MAGIC_DESC, buf) == -1)
|
||||
return -1;
|
||||
@ -381,7 +363,7 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
case -1:
|
||||
return -1;
|
||||
case 1:
|
||||
if (asprintf(&buf, "%u", (uint32_t)v) < 0)
|
||||
if (spprintf(&buf, 0, "%u", (uint32_t)v) < 0)
|
||||
return -1;
|
||||
if (file_printf(ms, MAGIC_DESC, buf) == -1)
|
||||
return -1;
|
||||
@ -467,7 +449,7 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
case -1:
|
||||
return -1;
|
||||
case 1:
|
||||
if (asprintf(&buf, "%g", vf) < 0)
|
||||
if (spprintf(&buf, 0, "%g", vf) < 0)
|
||||
return -1;
|
||||
if (file_printf(ms, MAGIC_DESC, buf) == -1)
|
||||
return -1;
|
||||
@ -488,7 +470,7 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
case -1:
|
||||
return -1;
|
||||
case 1:
|
||||
if (asprintf(&buf, "%g", vd) < 0)
|
||||
if (spprintf(&buf, 0, "%g", vd) < 0)
|
||||
return -1;
|
||||
if (file_printf(ms, MAGIC_DESC, buf) == -1)
|
||||
return -1;
|
||||
@ -505,13 +487,10 @@ mprint(struct magic_set *ms, struct magic *m)
|
||||
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, MAGIC_DESC, cp);
|
||||
free(cp);
|
||||
efree(cp);
|
||||
|
||||
if (rval == -1)
|
||||
return -1;
|
||||
@ -1665,24 +1644,20 @@ magiccheck(struct magic_set *ms, struct magic *m)
|
||||
}
|
||||
case FILE_REGEX: {
|
||||
int rc;
|
||||
regex_t rx;
|
||||
regex_t rx = {0};
|
||||
char errmsg[512];
|
||||
|
||||
if (ms->search.s == NULL)
|
||||
return 0;
|
||||
|
||||
l = 0;
|
||||
rc = regcomp(&rx, m->value.s,
|
||||
REG_EXTENDED|REG_NEWLINE|
|
||||
((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0));
|
||||
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);
|
||||
file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
|
||||
v = (uint64_t)-1;
|
||||
}
|
||||
else {
|
||||
regmatch_t pmatch[1];
|
||||
} else {
|
||||
regmatch_t *pmatch = (regmatch_t *)ecalloc(sizeof(regmatch_t), rx.re_nsub + 1);
|
||||
#ifndef REG_STARTEND
|
||||
#define REG_STARTEND 0
|
||||
size_t l = ms->search.s_len - 1;
|
||||
@ -1692,8 +1667,7 @@ magiccheck(struct magic_set *ms, struct magic *m)
|
||||
pmatch[0].rm_so = 0;
|
||||
pmatch[0].rm_eo = ms->search.s_len;
|
||||
#endif
|
||||
rc = regexec(&rx, (const char *)ms->search.s,
|
||||
1, pmatch, REG_STARTEND);
|
||||
rc = regexec(&rx, (const char *)ms->search.s, 1, pmatch, REG_STARTEND);
|
||||
#if REG_STARTEND == 0
|
||||
((char *)(intptr_t)ms->search.s)[l] = c;
|
||||
#endif
|
||||
@ -1701,8 +1675,7 @@ magiccheck(struct magic_set *ms, struct magic *m)
|
||||
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);
|
||||
ms->search.rm_len = (size_t)(pmatch[0].rm_eo - pmatch[0].rm_so);
|
||||
v = 0;
|
||||
break;
|
||||
|
||||
@ -1712,15 +1685,16 @@ magiccheck(struct magic_set *ms, struct magic *m)
|
||||
|
||||
default:
|
||||
(void)regerror(rc, &rx, errmsg, sizeof(errmsg));
|
||||
file_magerror(ms, "regexec error %d, (%s)",
|
||||
rc, errmsg);
|
||||
file_magerror(ms, "regexec error %d, (%s)", rc, errmsg);
|
||||
v = (uint64_t)-1;
|
||||
break;
|
||||
}
|
||||
regfree(&rx);
|
||||
efree(pmatch);
|
||||
}
|
||||
if (v == (uint64_t)-1)
|
||||
if (v == (uint64_t)-1) {
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user