d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
de36ad45b6
freebsd-skq/contrib/file/apprentice.c
mckay 3671fbcc9a Correct a regression introduced during the import of file(1) 5.11. 
Magic tests containing "search" or "regex" directives were incorrectly
compiled by "mkmagic" and were effectively ignored.  This caused troff
files (for example) to be detected as simply "ASCII text" instead of
as "troff or preprocessor input, ASCII text".

PR:		bin/170415
Approved by:	consensus on developers@
MFC after:	3 days
2012-08-17 02:27:17 +00:00

2542 lines
54 KiB
C
Raw Blame History

/*
* Copyright (c) Ian F. Darwin 1986-1995.
* Software written by Ian F. Darwin and others;
* maintained 1995-present by Christos Zoulas and others.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice immediately at the beginning of the file, without modification,
* this list of conditions, and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* apprentice - make one pass through /etc/magic, learning its secrets.
*/
#include "file.h"
#ifndef lint
FILE_RCSID("@(#)$File: apprentice.c,v 1.173 2011/12/08 12:38:24 rrt Exp $")
#endif /* lint */
#include "magic.h"
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <fcntl.h>
#ifdef QUICK
#include <sys/mman.h>
#endif
#include <dirent.h>
#define EATAB {while (isascii((unsigned char) *l) && \
isspace((unsigned char) *l)) ++l;}
#define LOWCASE(l) (isupper((unsigned char) (l)) ? \
tolower((unsigned char) (l)) : (l))
/*
* Work around a bug in headers on Digital Unix.
* At least confirmed for: OSF1 V4.0 878
*/
#if defined(__osf__) && defined(__DECC)
#ifdef MAP_FAILED
#undef MAP_FAILED
#endif
#endif
#ifndef MAP_FAILED
#define MAP_FAILED (void *) -1
#endif
#ifndef MAP_FILE
#define MAP_FILE 0
#endif
struct magic_entry {
struct magic *mp;
uint32_t cont_count;
uint32_t max_count;
};
int file_formats[FILE_NAMES_SIZE];
const size_t file_nformats = FILE_NAMES_SIZE;
const char *file_names[FILE_NAMES_SIZE];
const size_t file_nnames = FILE_NAMES_SIZE;
private int getvalue(struct magic_set *ms, struct magic *, const char **, int);
private int hextoint(int);
private const char *getstr(struct magic_set *, struct magic *, const char *,
int);
private int parse(struct magic_set *, struct magic_entry **, uint32_t *,
const char *, size_t, int);
private void eatsize(const char **);
private int apprentice_1(struct magic_set *, const char *, int, struct mlist *);
private size_t apprentice_magic_strength(const struct magic *);
private int apprentice_sort(const void *, const void *);
#ifndef COMPILE_ONLY
private void apprentice_list(struct mlist *, int );
#endif
private int apprentice_load(struct magic_set *, struct magic **, uint32_t *,
const char *, int);
#ifndef COMPILE_ONLY
private void byteswap(struct magic *, uint32_t);
private void bs1(struct magic *);
private uint16_t swap2(uint16_t);
private uint32_t swap4(uint32_t);
private uint64_t swap8(uint64_t);
#endif
private char *mkdbname(struct magic_set *, const char *, int);
#ifndef COMPILE_ONLY
private int apprentice_map(struct magic_set *, struct magic **, uint32_t *,
const char *);
#endif
private int apprentice_compile(struct magic_set *, struct magic **, uint32_t *,
const char *);
private int check_format_type(const char *, int);
private int check_format(struct magic_set *, struct magic *);
private int get_op(char);
private int parse_mime(struct magic_set *, struct magic_entry *, const char *);
private int parse_strength(struct magic_set *, struct magic_entry *, const char *);
private int parse_apple(struct magic_set *, struct magic_entry *, const char *);
private size_t maxmagic = 0;
private size_t magicsize = sizeof(struct magic);
private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
private struct {
const char *name;
size_t len;
int (*fun)(struct magic_set *, struct magic_entry *, const char *);
} bang[] = {
#define DECLARE_FIELD(name) { # name, sizeof(# name) - 1, parse_ ## name }
DECLARE_FIELD(mime),
DECLARE_FIELD(apple),
DECLARE_FIELD(strength),
#undef DECLARE_FIELD
{ 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 */
static const struct type_tbl_s {
const char name[16];
const size_t len;
const int type;
const int format;
} type_tbl[] = {
# define XX(s) s, (sizeof(s) - 1)
# define XX_NULL "", 0
{ XX("byte"), FILE_BYTE, FILE_FMT_NUM },
{ XX("short"), FILE_SHORT, FILE_FMT_NUM },
{ XX("default"), FILE_DEFAULT, FILE_FMT_STR },
{ XX("long"), FILE_LONG, FILE_FMT_NUM },
{ XX("string"), FILE_STRING, FILE_FMT_STR },
{ XX("date"), FILE_DATE, FILE_FMT_STR },
{ XX("beshort"), FILE_BESHORT, FILE_FMT_NUM },
{ XX("belong"), FILE_BELONG, FILE_FMT_NUM },
{ XX("bedate"), FILE_BEDATE, FILE_FMT_STR },
{ XX("leshort"), FILE_LESHORT, FILE_FMT_NUM },
{ XX("lelong"), FILE_LELONG, FILE_FMT_NUM },
{ XX("ledate"), FILE_LEDATE, FILE_FMT_STR },
{ XX("pstring"), FILE_PSTRING, FILE_FMT_STR },
{ XX("ldate"), FILE_LDATE, FILE_FMT_STR },
{ XX("beldate"), FILE_BELDATE, FILE_FMT_STR },
{ XX("leldate"), FILE_LELDATE, FILE_FMT_STR },
{ XX("regex"), FILE_REGEX, FILE_FMT_STR },
{ XX("bestring16"), FILE_BESTRING16, FILE_FMT_STR },
{ XX("lestring16"), FILE_LESTRING16, FILE_FMT_STR },
{ XX("search"), FILE_SEARCH, FILE_FMT_STR },
{ XX("medate"), FILE_MEDATE, FILE_FMT_STR },
{ XX("meldate"), FILE_MELDATE, FILE_FMT_STR },
{ XX("melong"), FILE_MELONG, FILE_FMT_NUM },
{ XX("quad"), FILE_QUAD, FILE_FMT_QUAD },
{ XX("lequad"), FILE_LEQUAD, FILE_FMT_QUAD },
{ XX("bequad"), FILE_BEQUAD, FILE_FMT_QUAD },
{ XX("qdate"), FILE_QDATE, FILE_FMT_STR },
{ XX("leqdate"), FILE_LEQDATE, FILE_FMT_STR },
{ XX("beqdate"), FILE_BEQDATE, FILE_FMT_STR },
{ XX("qldate"), FILE_QLDATE, FILE_FMT_STR },
{ XX("leqldate"), FILE_LEQLDATE, FILE_FMT_STR },
{ XX("beqldate"), FILE_BEQLDATE, FILE_FMT_STR },
{ XX("float"), FILE_FLOAT, FILE_FMT_FLOAT },
{ XX("befloat"), FILE_BEFLOAT, FILE_FMT_FLOAT },
{ XX("lefloat"), FILE_LEFLOAT, FILE_FMT_FLOAT },
{ XX("double"), FILE_DOUBLE, FILE_FMT_DOUBLE },
{ XX("bedouble"), FILE_BEDOUBLE, FILE_FMT_DOUBLE },
{ XX("ledouble"), FILE_LEDOUBLE, FILE_FMT_DOUBLE },
{ XX("leid3"), FILE_LEID3, FILE_FMT_NUM },
{ XX("beid3"), FILE_BEID3, FILE_FMT_NUM },
{ XX("indirect"), FILE_INDIRECT, FILE_FMT_NONE },
{ XX_NULL, FILE_INVALID, FILE_FMT_NONE },
# undef XX
# undef XX_NULL
};
private int
get_type(const char *l, const char **t)
{
const struct type_tbl_s *p;
for (p = type_tbl; p->len; p++) {
if (strncmp(l, p->name, p->len) == 0) {
if (t)
*t = l + p->len;
break;
}
}
return p->type;
}
private void
init_file_tables(void)
{
static int done = 0;
const struct type_tbl_s *p;
if (done)
return;
done++;
for (p = type_tbl; p->len; p++) {
assert(p->type < FILE_NAMES_SIZE);
file_names[p->type] = p->name;
file_formats[p->type] = p->format;
}
}
/*
* Handle one file or directory.
*/
private int
apprentice_1(struct magic_set *ms, const char *fn, int action,
struct mlist *mlist)
{
struct magic *magic = NULL;
uint32_t nmagic = 0;
#ifndef COMPILE_ONLY
struct mlist *ml;
#endif
int rv = -1;
#ifndef COMPILE_ONLY
int mapped;
#endif
if (magicsize != FILE_MAGICSIZE) {
file_error(ms, 0, "magic element size %lu != %lu",
(unsigned long)sizeof(*magic),
(unsigned long)FILE_MAGICSIZE);
return -1;
}
if (action == FILE_COMPILE) {
rv = apprentice_load(ms, &magic, &nmagic, fn, action);
if (rv != 0)
return -1;
rv = apprentice_compile(ms, &magic, &nmagic, fn);
free(magic);
return rv;
}
#ifndef COMPILE_ONLY
if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "using regular magic file `%s'", fn);
rv = apprentice_load(ms, &magic, &nmagic, fn, action);
if (rv != 0)
return -1;
}
mapped = rv;
if (magic == NULL) {
file_delmagic(magic, mapped, nmagic);
return -1;
}
if ((ml = CAST(struct mlist *, malloc(sizeof(*ml)))) == NULL) {
file_delmagic(magic, mapped, nmagic);
file_oomem(ms, sizeof(*ml));
return -1;
}
ml->magic = magic;
ml->nmagic = nmagic;
ml->mapped = mapped;
mlist->prev->next = ml;
ml->prev = mlist->prev;
ml->next = mlist;
mlist->prev = ml;
if (action == FILE_LIST) {
printf("Binary patterns:\n");
apprentice_list(mlist, BINTEST);
printf("Text patterns:\n");
apprentice_list(mlist, TEXTTEST);
}
#endif /* COMPILE_ONLY */
return 0;
}
protected void
file_delmagic(struct magic *p, int type, size_t entries)
{
if (p == NULL)
return;
switch (type) {
case 2:
#ifdef QUICK
p--;
(void)munmap((void *)p, sizeof(*p) * (entries + 1));
break;
#else
(void)&entries;
abort();
/*NOTREACHED*/
#endif
case 1:
p--;
/*FALLTHROUGH*/
case 0:
free(p);
break;
default:
abort();
}
}
/* const char *fn: list of magic files and directories */
protected struct mlist *
file_apprentice(struct magic_set *ms, const char *fn, int action)
{
char *p, *mfn;
int file_err, errs = -1;
struct mlist *mlist;
if ((fn = magic_getpath(fn, action)) == NULL)
return NULL;
init_file_tables();
if ((mfn = strdup(fn)) == NULL) {
file_oomem(ms, strlen(fn));
return NULL;
}
fn = mfn;
if ((mlist = CAST(struct mlist *, malloc(sizeof(*mlist)))) == NULL) {
free(mfn);
file_oomem(ms, sizeof(*mlist));
return NULL;
}
mlist->next = mlist->prev = mlist;
while (fn) {
p = strchr(fn, PATHSEP);
if (p)
*p++ = '\0';
if (*fn == '\0')
break;
file_err = apprentice_1(ms, fn, action, mlist);
errs = MAX(errs, file_err);
fn = p;
}
if (errs == -1) {
free(mfn);
free(mlist);
mlist = NULL;
file_error(ms, 0, "could not find any magic files!");
return NULL;
}
free(mfn);
return mlist;
}
/*
* Get weight of this magic entry, for sorting purposes.
*/
private size_t
apprentice_magic_strength(const struct magic *m)
{
#define MULT 10
size_t val = 2 * MULT; /* baseline strength */
switch (m->type) {
case FILE_DEFAULT: /* make sure this sorts last */
if (m->factor_op != FILE_FACTOR_OP_NONE)
abort();
return 0;
case FILE_BYTE:
val += 1 * MULT;
break;
case FILE_SHORT:
case FILE_LESHORT:
case FILE_BESHORT:
val += 2 * MULT;
break;
case FILE_LONG:
case FILE_LELONG:
case FILE_BELONG:
case FILE_MELONG:
val += 4 * MULT;
break;
case FILE_PSTRING:
case FILE_STRING:
val += m->vallen * MULT;
break;
case FILE_BESTRING16:
case FILE_LESTRING16:
val += m->vallen * MULT / 2;
break;
case FILE_SEARCH:
case FILE_REGEX:
val += m->vallen * MAX(MULT / m->vallen, 1);
break;
case FILE_DATE:
case FILE_LEDATE:
case FILE_BEDATE:
case FILE_MEDATE:
case FILE_LDATE:
case FILE_LELDATE:
case FILE_BELDATE:
case FILE_MELDATE:
case FILE_FLOAT:
case FILE_BEFLOAT:
case FILE_LEFLOAT:
val += 4 * MULT;
break;
case FILE_QUAD:
case FILE_BEQUAD:
case FILE_LEQUAD:
case FILE_QDATE:
case FILE_LEQDATE:
case FILE_BEQDATE:
case FILE_QLDATE:
case FILE_LEQLDATE:
case FILE_BEQLDATE:
case FILE_DOUBLE:
case FILE_BEDOUBLE:
case FILE_LEDOUBLE:
val += 8 * MULT;
break;
default:
val = 0;
(void)fprintf(stderr, "Bad type %d\n", m->type);
abort();
}
switch (m->reln) {
case 'x': /* matches anything penalize */
case '!': /* matches almost anything penalize */
val = 0;
break;
case '=': /* Exact match, prefer */
val += MULT;
break;
case '>':
case '<': /* comparison match reduce strength */
val -= 2 * MULT;
break;
case '^':
case '&': /* masking bits, we could count them too */
val -= MULT;
break;
default:
(void)fprintf(stderr, "Bad relation %c\n", m->reln);
abort();
}
if (val == 0) /* ensure we only return 0 for FILE_DEFAULT */
val = 1;
switch (m->factor_op) {
case FILE_FACTOR_OP_NONE:
break;
case FILE_FACTOR_OP_PLUS:
val += m->factor;
break;
case FILE_FACTOR_OP_MINUS:
val -= m->factor;
break;
case FILE_FACTOR_OP_TIMES:
val *= m->factor;
break;
case FILE_FACTOR_OP_DIV:
val /= m->factor;
break;
default:
abort();
}
/*
* Magic entries with no description get a bonus because they depend
* on subsequent magic entries to print something.
*/
if (m->desc[0] == '\0')
val++;
return val;
}
/*
* Sort callback for sorting entries by "strength" (basically length)
*/
private int
apprentice_sort(const void *a, const void *b)
{
const struct magic_entry *ma = CAST(const struct magic_entry *, a);
const struct magic_entry *mb = CAST(const struct magic_entry *, b);
size_t sa = apprentice_magic_strength(ma->mp);
size_t sb = apprentice_magic_strength(mb->mp);
if (sa == sb)
return 0;
else if (sa > sb)
return -1;
else
return 1;
}
/*
* Shows sorted patterns list in the order which is used for the matching
*/
#ifndef COMPILE_ONLY
private void
apprentice_list(struct mlist *mlist, int mode)
{
uint32_t magindex = 0;
struct mlist *ml;
for (ml = mlist->next; ml != mlist; ml = ml->next) {
for (magindex = 0; magindex < ml->nmagic; magindex++) {
struct magic *m = &ml->magic[magindex];
if ((m->flag & mode) != mode) {
/* Skip sub-tests */
while (magindex + 1 < ml->nmagic &&
ml->magic[magindex + 1].cont_level != 0)
++magindex;
continue; /* Skip to next top-level test*/
}
/*
* Try to iterate over the tree until we find item with
* description/mimetype.
*/
while (magindex + 1 < ml->nmagic &&
ml->magic[magindex + 1].cont_level != 0 &&
*ml->magic[magindex].desc == '\0' &&
*ml->magic[magindex].mimetype == '\0')
magindex++;
printf("Strength = %3" SIZE_T_FORMAT "u : %s [%s]\n",
apprentice_magic_strength(m),
ml->magic[magindex].desc,
ml->magic[magindex].mimetype);
}
}
}
#endif /* COMPILE_ONLY */
private void
set_test_type(struct magic *mstart, struct magic *m)
{
switch (m->type) {
case FILE_BYTE:
case FILE_SHORT:
case FILE_LONG:
case FILE_DATE:
case FILE_BESHORT:
case FILE_BELONG:
case FILE_BEDATE:
case FILE_LESHORT:
case FILE_LELONG:
case FILE_LEDATE:
case FILE_LDATE:
case FILE_BELDATE:
case FILE_LELDATE:
case FILE_MEDATE:
case FILE_MELDATE:
case FILE_MELONG:
case FILE_QUAD:
case FILE_LEQUAD:
case FILE_BEQUAD:
case FILE_QDATE:
case FILE_LEQDATE:
case FILE_BEQDATE:
case FILE_QLDATE:
case FILE_LEQLDATE:
case FILE_BEQLDATE:
case FILE_FLOAT:
case FILE_BEFLOAT:
case FILE_LEFLOAT:
case FILE_DOUBLE:
case FILE_BEDOUBLE:
case FILE_LEDOUBLE:
mstart->flag |= BINTEST;
break;
case FILE_STRING:
case FILE_PSTRING:
case FILE_BESTRING16:
case FILE_LESTRING16:
/* Allow text overrides */
if (mstart->str_flags & STRING_TEXTTEST)
mstart->flag |= TEXTTEST;
else
mstart->flag |= BINTEST;
break;
case FILE_REGEX:
case FILE_SEARCH:
/* Check for override */
if (mstart->str_flags & STRING_BINTEST)
mstart->flag |= BINTEST;
if (mstart->str_flags & STRING_TEXTTEST)
mstart->flag |= TEXTTEST;
if (mstart->flag & (TEXTTEST|BINTEST))
break;
/* binary test if pattern is not text */
if (file_looks_utf8(m->value.us, (size_t)m->vallen, NULL,
NULL) <= 0)
mstart->flag |= BINTEST;
else
mstart->flag |= TEXTTEST;
break;
case FILE_DEFAULT:
/* can't deduce anything; we shouldn't see this at the
top level anyway */
break;
case FILE_INVALID:
default:
/* invalid search type, but no need to complain here */
break;
}
}
/*
* Load and parse one file.
*/
private void
load_1(struct magic_set *ms, int action, const char *fn, int *errs,
struct magic_entry **marray, uint32_t *marraycount)
{
size_t lineno = 0, llen = 0;
char *line = NULL;
ssize_t len;
FILE *f = fopen(ms->file = fn, "r");
if (f == NULL) {
if (errno != ENOENT)
file_error(ms, errno, "cannot read magic file `%s'",
fn);
(*errs)++;
return;
}
/* read and parse this file */
for (ms->line = 1; (len = getline(&line, &llen, f)) != -1;
ms->line++) {
if (len == 0) /* null line, garbage, etc */
continue;
if (line[len - 1] == '\n') {
lineno++;
line[len - 1] = '\0'; /* delete newline */
}
switch (line[0]) {
case '\0': /* empty, do not parse */
case '#': /* comment, do not parse */
continue;
case '!':
if (line[1] == ':') {
size_t i;
for (i = 0; bang[i].name != NULL; i++) {
if ((size_t)(len - 2) > bang[i].len &&
memcmp(bang[i].name, line + 2,
bang[i].len) == 0)
break;
}
if (bang[i].name == NULL) {
file_error(ms, 0,
"Unknown !: entry `%s'", line);
(*errs)++;
continue;
}
if (*marraycount == 0) {
file_error(ms, 0,
"No current entry for :!%s type",
bang[i].name);
(*errs)++;
continue;
}
if ((*bang[i].fun)(ms,
&(*marray)[*marraycount - 1],
line + bang[i].len + 2) != 0) {
(*errs)++;
continue;
}
continue;
}
/*FALLTHROUGH*/
default:
if (parse(ms, marray, marraycount, line, lineno,
action) != 0)
(*errs)++;
break;
}
}
free(line);
(void)fclose(f);
}
/*
* parse a file or directory of files
* const char *fn: name of magic file or directory
*/
private int
cmpstrp(const void *p1, const void *p2)
{
return strcmp(*(char *const *)p1, *(char *const *)p2);
}
private int
apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
const char *fn, int action)
{
int errs = 0;
struct magic_entry *marray;
uint32_t marraycount, i, mentrycount = 0, starttest;
size_t slen, files = 0, maxfiles = 0;
char **filearr = NULL, *mfn;
struct stat st;
DIR *dir;
struct dirent *d;
ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
maxmagic = MAXMAGIS;
if ((marray = CAST(struct magic_entry *, calloc(maxmagic,
sizeof(*marray)))) == NULL) {
file_oomem(ms, maxmagic * sizeof(*marray));
return -1;
}
marraycount = 0;
/* print silly verbose header for USG compat. */
if (action == FILE_CHECK)
(void)fprintf(stderr, "%s\n", usg_hdr);
/* load directory or file */
if (stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
dir = opendir(fn);
if (!dir) {
errs++;
goto out;
}
while ((d = readdir(dir)) != NULL) {
if (asprintf(&mfn, "%s/%s", fn, d->d_name) < 0) {
file_oomem(ms,
strlen(fn) + strlen(d->d_name) + 2);
errs++;
closedir(dir);
goto out;
}
if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
free(mfn);
continue;
}
if (files >= maxfiles) {
size_t mlen;
maxfiles = (maxfiles + 1) * 2;
mlen = maxfiles * sizeof(*filearr);
if ((filearr = CAST(char **,
realloc(filearr, mlen))) == NULL) {
file_oomem(ms, mlen);
free(mfn);
closedir(dir);
errs++;
goto out;
}
}
filearr[files++] = mfn;
}
closedir(dir);
qsort(filearr, files, sizeof(*filearr), cmpstrp);
for (i = 0; i < files; i++) {
load_1(ms, action, filearr[i], &errs, &marray,
&marraycount);
free(filearr[i]);
}
free(filearr);
} else
load_1(ms, action, fn, &errs, &marray, &marraycount);
if (errs)
goto out;
/* Set types of tests */
for (i = 0; i < marraycount; ) {
if (marray[i].mp->cont_level != 0) {
i++;
continue;
}
starttest = i;
do {
static const char text[] = "text";
static const char binary[] = "binary";
static const size_t len = sizeof(text);
set_test_type(marray[starttest].mp, marray[i].mp);
if ((ms->flags & MAGIC_DEBUG) == 0)
continue;
(void)fprintf(stderr, "%s%s%s: %s\n",
marray[i].mp->mimetype,
marray[i].mp->mimetype[0] == '\0' ? "" : "; ",
marray[i].mp->desc[0] ? marray[i].mp->desc :
"(no description)",
marray[i].mp->flag & BINTEST ? binary : text);
if (marray[i].mp->flag & BINTEST) {
char *p = strstr(marray[i].mp->desc, text);
if (p && (p == marray[i].mp->desc ||
isspace((unsigned char)p[-1])) &&
(p + len - marray[i].mp->desc ==
MAXstring || (p[len] == '\0' ||
isspace((unsigned char)p[len]))))
(void)fprintf(stderr, "*** Possible "
"binary test for text type\n");
}
} while (++i < marraycount && marray[i].mp->cont_level != 0);
}
qsort(marray, marraycount, sizeof(*marray), apprentice_sort);
/*
* Make sure that any level 0 "default" line is last (if one exists).
*/
for (i = 0; i < marraycount; i++) {
if (marray[i].mp->cont_level == 0 &&
marray[i].mp->type == FILE_DEFAULT) {
while (++i < marraycount)
if (marray[i].mp->cont_level == 0)
break;
if (i != marraycount) {
/* XXX - Ugh! */
ms->line = marray[i].mp->lineno;
file_magwarn(ms,
"level 0 \"default\" did not sort last");
}
break;
}
}
for (i = 0; i < marraycount; i++)
mentrycount += marray[i].cont_count;
slen = sizeof(**magicp) * mentrycount;
if ((*magicp = CAST(struct magic *, malloc(slen))) == NULL) {
file_oomem(ms, slen);
errs++;
goto out;
}
mentrycount = 0;
for (i = 0; i < marraycount; i++) {
(void)memcpy(*magicp + mentrycount, marray[i].mp,
marray[i].cont_count * sizeof(**magicp));
mentrycount += marray[i].cont_count;
}
out:
for (i = 0; i < marraycount; i++)
free(marray[i].mp);
free(marray);
if (errs) {
*magicp = NULL;
*nmagicp = 0;
return errs;
} else {
*nmagicp = mentrycount;
return 0;
}
}
/*
* extend the sign bit if the comparison is to be signed
*/
protected uint64_t
file_signextend(struct magic_set *ms, struct magic *m, uint64_t v)
{
if (!(m->flag & UNSIGNED)) {
switch(m->type) {
/*
* Do not remove the casts below. They are
* vital. When later compared with the data,
* the sign extension must have happened.
*/
case FILE_BYTE:
v = (char) v;
break;
case FILE_SHORT:
case FILE_BESHORT:
case FILE_LESHORT:
v = (short) v;
break;
case FILE_DATE:
case FILE_BEDATE:
case FILE_LEDATE:
case FILE_MEDATE:
case FILE_LDATE:
case FILE_BELDATE:
case FILE_LELDATE:
case FILE_MELDATE:
case FILE_LONG:
case FILE_BELONG:
case FILE_LELONG:
case FILE_MELONG:
case FILE_FLOAT:
case FILE_BEFLOAT:
case FILE_LEFLOAT:
v = (int32_t) v;
break;
case FILE_QUAD:
case FILE_BEQUAD:
case FILE_LEQUAD:
case FILE_QDATE:
case FILE_QLDATE:
case FILE_BEQDATE:
case FILE_BEQLDATE:
case FILE_LEQDATE:
case FILE_LEQLDATE:
case FILE_DOUBLE:
case FILE_BEDOUBLE:
case FILE_LEDOUBLE:
v = (int64_t) v;
break;
case FILE_STRING:
case FILE_PSTRING:
case FILE_BESTRING16:
case FILE_LESTRING16:
case FILE_REGEX:
case FILE_SEARCH:
case FILE_DEFAULT:
case FILE_INDIRECT:
break;
default:
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "cannot happen: m->type=%d\n",
m->type);
return ~0U;
}
}
return v;
}
private int
string_modifier_check(struct magic_set *ms, struct magic *m)
{
if ((ms->flags & MAGIC_CHECK) == 0)
return 0;
if (m->type != FILE_PSTRING && (m->str_flags & PSTRING_LEN) != 0) {
file_magwarn(ms,
"'/BHhLl' modifiers are only allowed for pascal strings\n");
return -1;
}
switch (m->type) {
case FILE_BESTRING16:
case FILE_LESTRING16:
if (m->str_flags != 0) {
file_magwarn(ms,
"no modifiers allowed for 16-bit strings\n");
return -1;
}
break;
case FILE_STRING:
case FILE_PSTRING:
if ((m->str_flags & REGEX_OFFSET_START) != 0) {
file_magwarn(ms,
"'/%c' only allowed on regex and search\n",
CHAR_REGEX_OFFSET_START);
return -1;
}
break;
case FILE_SEARCH:
if (m->str_range == 0) {
file_magwarn(ms,
"missing range; defaulting to %d\n",
STRING_DEFAULT_RANGE);
m->str_range = STRING_DEFAULT_RANGE;
return -1;
}
break;
case FILE_REGEX:
if ((m->str_flags & STRING_COMPACT_WHITESPACE) != 0) {
file_magwarn(ms, "'/%c' not allowed on regex\n",
CHAR_COMPACT_WHITESPACE);
return -1;
}
if ((m->str_flags & STRING_COMPACT_OPTIONAL_WHITESPACE) != 0) {
file_magwarn(ms, "'/%c' not allowed on regex\n",
CHAR_COMPACT_OPTIONAL_WHITESPACE);
return -1;
}
break;
default:
file_magwarn(ms, "coding error: m->type=%d\n",
m->type);
return -1;
}
return 0;
}
private int
get_op(char c)
{
switch (c) {
case '&':
return FILE_OPAND;
case '|':
return FILE_OPOR;
case '^':
return FILE_OPXOR;
case '+':
return FILE_OPADD;
case '-':
return FILE_OPMINUS;
case '*':
return FILE_OPMULTIPLY;
case '/':
return FILE_OPDIVIDE;
case '%':
return FILE_OPMODULO;
default:
return -1;
}
}
#ifdef ENABLE_CONDITIONALS
private int
get_cond(const char *l, const char **t)
{
static const struct cond_tbl_s {
char name[8];
size_t len;
int cond;
} cond_tbl[] = {
{ "if", 2, COND_IF },
{ "elif", 4, COND_ELIF },
{ "else", 4, COND_ELSE },
{ "", 0, COND_NONE },
};
const struct cond_tbl_s *p;
for (p = cond_tbl; p->len; p++) {
if (strncmp(l, p->name, p->len) == 0 &&
isspace((unsigned char)l[p->len])) {
if (t)
*t = l + p->len;
break;
}
}
return p->cond;
}
private int
check_cond(struct magic_set *ms, int cond, uint32_t cont_level)
{
int last_cond;
last_cond = ms->c.li[cont_level].last_cond;
switch (cond) {
case COND_IF:
if (last_cond != COND_NONE && last_cond != COND_ELIF) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "syntax error: `if'");
return -1;
}
last_cond = COND_IF;
break;
case COND_ELIF:
if (last_cond != COND_IF && last_cond != COND_ELIF) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "syntax error: `elif'");
return -1;
}
last_cond = COND_ELIF;
break;
case COND_ELSE:
if (last_cond != COND_IF && last_cond != COND_ELIF) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "syntax error: `else'");
return -1;
}
last_cond = COND_NONE;
break;
case COND_NONE:
last_cond = COND_NONE;
break;
}
ms->c.li[cont_level].last_cond = last_cond;
return 0;
}
#endif /* ENABLE_CONDITIONALS */
/*
* parse one line from magic file, put into magic[index++] if valid
*/
private int
parse(struct magic_set *ms, struct magic_entry **mentryp, uint32_t *nmentryp,
const char *line, size_t lineno, int action)
{
#ifdef ENABLE_CONDITIONALS
static uint32_t last_cont_level = 0;
#endif
size_t i;
struct magic_entry *me;
struct magic *m;
const char *l = line;
char *t;
int op;
uint32_t cont_level;
cont_level = 0;
while (*l == '>') {
++l; /* step over */
cont_level++;
}
#ifdef ENABLE_CONDITIONALS
if (cont_level == 0 || cont_level > last_cont_level)
if (file_check_mem(ms, cont_level) == -1)
return -1;
last_cont_level = cont_level;
#endif
#define ALLOC_CHUNK (size_t)10
#define ALLOC_INCR (size_t)200
if (cont_level != 0) {
if (*nmentryp == 0) {
file_error(ms, 0, "No current entry for continuation");
return -1;
}
me = &(*mentryp)[*nmentryp - 1];
if (me->cont_count == me->max_count) {
struct magic *nm;
size_t cnt = me->max_count + ALLOC_CHUNK;
if ((nm = CAST(struct magic *, realloc(me->mp,
sizeof(*nm) * cnt))) == NULL) {
file_oomem(ms, sizeof(*nm) * cnt);
return -1;
}
me->mp = m = nm;
me->max_count = CAST(uint32_t, cnt);
}
m = &me->mp[me->cont_count++];
(void)memset(m, 0, sizeof(*m));
m->cont_level = cont_level;
} else {
if (*nmentryp == maxmagic) {
struct magic_entry *mp;
maxmagic += ALLOC_INCR;
if ((mp = CAST(struct magic_entry *,
realloc(*mentryp, sizeof(*mp) * maxmagic))) ==
NULL) {
file_oomem(ms, sizeof(*mp) * maxmagic);
return -1;
}
(void)memset(&mp[*nmentryp], 0, sizeof(*mp) *
ALLOC_INCR);
*mentryp = mp;
}
me = &(*mentryp)[*nmentryp];
if (me->mp == NULL) {
size_t len = sizeof(*m) * ALLOC_CHUNK;
if ((m = CAST(struct magic *, malloc(len))) == NULL) {
file_oomem(ms, len);
return -1;
}
me->mp = m;
me->max_count = ALLOC_CHUNK;
} else
m = me->mp;
(void)memset(m, 0, sizeof(*m));
m->factor_op = FILE_FACTOR_OP_NONE;
m->cont_level = 0;
me->cont_count = 1;
}
m->lineno = CAST(uint32_t, lineno);
if (*l == '&') { /* m->cont_level == 0 checked below. */
++l; /* step over */
m->flag |= OFFADD;
}
if (*l == '(') {
++l; /* step over */
m->flag |= INDIR;
if (m->flag & OFFADD)
m->flag = (m->flag & ~OFFADD) | INDIROFFADD;
if (*l == '&') { /* m->cont_level == 0 checked below */
++l; /* step over */
m->flag |= OFFADD;
}
}
/* Indirect offsets are not valid at level 0. */
if (m->cont_level == 0 && (m->flag & (OFFADD | INDIROFFADD)))
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "relative offset at level 0");
/* get offset, then skip over it */
m->offset = (uint32_t)strtoul(l, &t, 0);
if (l == t)
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "offset `%s' invalid", l);
l = t;
if (m->flag & INDIR) {
m->in_type = FILE_LONG;
m->in_offset = 0;
/*
* read [.lbs][+-]nnnnn)
*/
if (*l == '.') {
l++;
switch (*l) {
case 'l':
m->in_type = FILE_LELONG;
break;
case 'L':
m->in_type = FILE_BELONG;
break;
case 'm':
m->in_type = FILE_MELONG;
break;
case 'h':
case 's':
m->in_type = FILE_LESHORT;
break;
case 'H':
case 'S':
m->in_type = FILE_BESHORT;
break;
case 'c':
case 'b':
case 'C':
case 'B':
m->in_type = FILE_BYTE;
break;
case 'e':
case 'f':
case 'g':
m->in_type = FILE_LEDOUBLE;
break;
case 'E':
case 'F':
case 'G':
m->in_type = FILE_BEDOUBLE;
break;
case 'i':
m->in_type = FILE_LEID3;
break;
case 'I':
m->in_type = FILE_BEID3;
break;
default:
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms,
"indirect offset type `%c' invalid",
*l);
break;
}
l++;
}
m->in_op = 0;
if (*l == '~') {
m->in_op |= FILE_OPINVERSE;
l++;
}
if ((op = get_op(*l)) != -1) {
m->in_op |= op;
l++;
}
if (*l == '(') {
m->in_op |= FILE_OPINDIRECT;
l++;
}
if (isdigit((unsigned char)*l) || *l == '-') {
m->in_offset = (int32_t)strtol(l, &t, 0);
if (l == t)
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms,
"in_offset `%s' invalid", l);
l = t;
}
if (*l++ != ')' ||
((m->in_op & FILE_OPINDIRECT) && *l++ != ')'))
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms,
"missing ')' in indirect offset");
}
EATAB;
#ifdef ENABLE_CONDITIONALS
m->cond = get_cond(l, &l);
if (check_cond(ms, m->cond, cont_level) == -1)
return -1;
EATAB;
#endif
if (*l == 'u') {
++l;
m->flag |= UNSIGNED;
}
m->type = get_type(l, &l);
if (m->type == FILE_INVALID) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "type `%s' invalid", l);
return -1;
}
/* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
/* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */
m->mask_op = 0;
if (*l == '~') {
if (!IS_STRING(m->type))
m->mask_op |= FILE_OPINVERSE;
else if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "'~' invalid for string types");
++l;
}
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)) {
uint64_t val;
++l;
m->mask_op |= op;
val = (uint64_t)strtoull(l, &t, 0);
l = t;
m->num_mask = file_signextend(ms, m, val);
eatsize(&l);
}
else if (op == FILE_OPDIVIDE) {
int have_range = 0;
while (!isspace((unsigned char)*++l)) {
switch (*l) {
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7': case '8':
case '9':
if (have_range &&
(ms->flags & MAGIC_CHECK))
file_magwarn(ms,
"multiple ranges");
have_range = 1;
m->str_range = CAST(uint32_t,
strtoul(l, &t, 0));
if (m->str_range == 0)
file_magwarn(ms,
"zero range");
l = t - 1;
break;
case CHAR_COMPACT_WHITESPACE:
m->str_flags |=
STRING_COMPACT_WHITESPACE;
break;
case CHAR_COMPACT_OPTIONAL_WHITESPACE:
m->str_flags |=
STRING_COMPACT_OPTIONAL_WHITESPACE;
break;
case CHAR_IGNORE_LOWERCASE:
m->str_flags |= STRING_IGNORE_LOWERCASE;
break;
case CHAR_IGNORE_UPPERCASE:
m->str_flags |= STRING_IGNORE_UPPERCASE;
break;
case CHAR_REGEX_OFFSET_START:
m->str_flags |= REGEX_OFFSET_START;
break;
case CHAR_BINTEST:
m->str_flags |= STRING_BINTEST;
break;
case CHAR_TEXTTEST:
m->str_flags |= STRING_TEXTTEST;
break;
case CHAR_PSTRING_1_LE:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_1_LE;
break;
case CHAR_PSTRING_2_BE:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_2_BE;
break;
case CHAR_PSTRING_2_LE:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_2_LE;
break;
case CHAR_PSTRING_4_BE:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_4_BE;
break;
case CHAR_PSTRING_4_LE:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags = (m->str_flags & ~PSTRING_LEN) | PSTRING_4_LE;
break;
case CHAR_PSTRING_LENGTH_INCLUDES_ITSELF:
if (m->type != FILE_PSTRING)
goto bad;
m->str_flags |= PSTRING_LENGTH_INCLUDES_ITSELF;
break;
default:
bad:
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms,
"string extension `%c' "
"invalid", *l);
return -1;
}
/* allow multiple '/' for readability */
if (l[1] == '/' &&
!isspace((unsigned char)l[2]))
l++;
}
if (string_modifier_check(ms, m) == -1)
return -1;
}
else {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "invalid string op: %c", *t);
return -1;
}
}
/*
* We used to set mask to all 1's here, instead let's just not do
* anything if mask = 0 (unless you have a better idea)
*/
EATAB;
switch (*l) {
case '>':
case '<':
m->reln = *l;
++l;
if (*l == '=') {
if (ms->flags & MAGIC_CHECK) {
file_magwarn(ms, "%c= not supported",
m->reln);
return -1;
}
++l;
}
break;
/* Old-style anding: "0 byte &0x80 dynamically linked" */
case '&':
case '^':
case '=':
m->reln = *l;
++l;
if (*l == '=') {
/* HP compat: ignore &= etc. */
++l;
}
break;
case '!':
m->reln = *l;
++l;
break;
default:
m->reln = '='; /* the default relation */
if (*l == 'x' && ((isascii((unsigned char)l[1]) &&
isspace((unsigned char)l[1])) || !l[1])) {
m->reln = *l;
++l;
}
break;
}
/*
* Grab the value part, except for an 'x' reln.
*/
if (m->reln != 'x' && getvalue(ms, m, &l, action))
return -1;
/*
* TODO finish this macro and start using it!
* #define offsetcheck {if (offset > HOWMANY-1)
* magwarn("offset too big"); }
*/
/*
* Now get last part - the description
*/
EATAB;
if (l[0] == '\b') {
++l;
m->flag |= NOSPACE;
} else if ((l[0] == '\\') && (l[1] == 'b')) {
++l;
++l;
m->flag |= NOSPACE;
}
for (i = 0; (m->desc[i++] = *l++) != '\0' && i < sizeof(m->desc); )
continue;
if (i == sizeof(m->desc)) {
m->desc[sizeof(m->desc) - 1] = '\0';
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "description `%s' truncated", m->desc);
}
/*
* We only do this check while compiling, or if any of the magic
* files were not compiled.
*/
if (ms->flags & MAGIC_CHECK) {
if (check_format(ms, m) == -1)
return -1;
}
#ifndef COMPILE_ONLY
if (action == FILE_CHECK) {
file_mdump(m);
}
#endif
m->mimetype[0] = '\0'; /* initialise MIME type to none */
if (m->cont_level == 0)
++(*nmentryp); /* make room for next */
return 0;
}
/*
* parse a STRENGTH annotation line from magic file, put into magic[index - 1]
* if valid
*/
private int
parse_strength(struct magic_set *ms, struct magic_entry *me, const char *line)
{
const char *l = line;
char *el;
unsigned long factor;
struct magic *m = &me->mp[0];
if (m->factor_op != FILE_FACTOR_OP_NONE) {
file_magwarn(ms,
"Current entry already has a strength type: %c %d",
m->factor_op, m->factor);
return -1;
}
EATAB;
switch (*l) {
case FILE_FACTOR_OP_NONE:
case FILE_FACTOR_OP_PLUS:
case FILE_FACTOR_OP_MINUS:
case FILE_FACTOR_OP_TIMES:
case FILE_FACTOR_OP_DIV:
m->factor_op = *l++;
break;
default:
file_magwarn(ms, "Unknown factor op `%c'", *l);
return -1;
}
EATAB;
factor = strtoul(l, &el, 0);
if (factor > 255) {
file_magwarn(ms, "Too large factor `%lu'", factor);
goto out;
}
if (*el && !isspace((unsigned char)*el)) {
file_magwarn(ms, "Bad factor `%s'", l);
goto out;
}
m->factor = (uint8_t)factor;
if (m->factor == 0 && m->factor_op == FILE_FACTOR_OP_DIV) {
file_magwarn(ms, "Cannot have factor op `%c' and factor %u",
m->factor_op, m->factor);
goto out;
}
return 0;
out:
m->factor_op = FILE_FACTOR_OP_NONE;
m->factor = 0;
return -1;
}
/*
* Parse an Apple CREATOR/TYPE annotation from magic file and put it into
* magic[index - 1]
*/
private int
parse_apple(struct magic_set *ms, struct magic_entry *me, const char *line)
{
size_t i;
const char *l = line;
struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1];
if (m->apple[0] != '\0') {
file_magwarn(ms, "Current entry already has a APPLE type "
"`%.8s', new type `%s'", m->mimetype, l);
return -1;
}
EATAB;
for (i = 0; *l && ((isascii((unsigned char)*l) &&
isalnum((unsigned char)*l)) || strchr("-+/.", *l)) &&
i < sizeof(m->apple); m->apple[i++] = *l++)
continue;
if (i == sizeof(m->apple) && *l) {
/* We don't need to NUL terminate here, printing handles it */
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "APPLE type `%s' truncated %"
SIZE_T_FORMAT "u", line, i);
}
if (i > 0)
return 0;
else
return -1;
}
/*
* parse a MIME annotation line from magic file, put into magic[index - 1]
* if valid
*/
private int
parse_mime(struct magic_set *ms, struct magic_entry *me, const char *line)
{
size_t i;
const char *l = line;
struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1];
if (m->mimetype[0] != '\0') {
file_magwarn(ms, "Current entry already has a MIME type `%s',"
" new type `%s'", m->mimetype, l);
return -1;
}
EATAB;
for (i = 0; *l && ((isascii((unsigned char)*l) &&
isalnum((unsigned char)*l)) || strchr("-+/.", *l)) &&
i < sizeof(m->mimetype); m->mimetype[i++] = *l++)
continue;
if (i == sizeof(m->mimetype)) {
m->mimetype[sizeof(m->mimetype) - 1] = '\0';
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "MIME type `%s' truncated %"
SIZE_T_FORMAT "u", m->mimetype, i);
} else
m->mimetype[i] = '\0';
if (i > 0)
return 0;
else
return -1;
}
private int
check_format_type(const char *ptr, int type)
{
int quad = 0;
if (*ptr == '\0') {
/* Missing format string; bad */
return -1;
}
switch (type) {
case FILE_FMT_QUAD:
quad = 1;
/*FALLTHROUGH*/
case FILE_FMT_NUM:
if (*ptr == '-')
ptr++;
if (*ptr == '.')
ptr++;
while (isdigit((unsigned char)*ptr)) ptr++;
if (*ptr == '.')
ptr++;
while (isdigit((unsigned char)*ptr)) ptr++;
if (quad) {
if (*ptr++ != 'l')
return -1;
if (*ptr++ != 'l')
return -1;
}
switch (*ptr++) {
case 'l':
switch (*ptr++) {
case 'i':
case 'd':
case 'u':
case 'x':
case 'X':
return 0;
default:
return -1;
}
case 'h':
switch (*ptr++) {
case 'h':
switch (*ptr++) {
case 'i':
case 'd':
case 'u':
case 'x':
case 'X':
return 0;
default:
return -1;
}
case 'd':
return 0;
default:
return -1;
}
case 'i':
case 'c':
case 'd':
case 'u':
case 'x':
case 'X':
return 0;
default:
return -1;
}
case FILE_FMT_FLOAT:
case FILE_FMT_DOUBLE:
if (*ptr == '-')
ptr++;
if (*ptr == '.')
ptr++;
while (isdigit((unsigned char)*ptr)) ptr++;
if (*ptr == '.')
ptr++;
while (isdigit((unsigned char)*ptr)) ptr++;
switch (*ptr++) {
case 'e':
case 'E':
case 'f':
case 'F':
case 'g':
case 'G':
return 0;
default:
return -1;
}
case FILE_FMT_STR:
if (*ptr == '-')
ptr++;
while (isdigit((unsigned char )*ptr))
ptr++;
if (*ptr == '.') {
ptr++;
while (isdigit((unsigned char )*ptr))
ptr++;
}
switch (*ptr++) {
case 's':
return 0;
default:
return -1;
}
default:
/* internal error */
abort();
}
/*NOTREACHED*/
return -1;
}
/*
* Check that the optional printf format in description matches
* the type of the magic.
*/
private int
check_format(struct magic_set *ms, struct magic *m)
{
char *ptr;
for (ptr = m->desc; *ptr; ptr++)
if (*ptr == '%')
break;
if (*ptr == '\0') {
/* No format string; ok */
return 1;
}
assert(file_nformats == file_nnames);
if (m->type >= file_nformats) {
file_magwarn(ms, "Internal error inconsistency between "
"m->type and format strings");
return -1;
}
if (file_formats[m->type] == FILE_FMT_NONE) {
file_magwarn(ms, "No format string for `%s' with description "
"`%s'", m->desc, file_names[m->type]);
return -1;
}
ptr++;
if (check_format_type(ptr, file_formats[m->type]) == -1) {
/*
* TODO: this error message is unhelpful if the format
* string is not one character long
*/
file_magwarn(ms, "Printf format `%c' is not valid for type "
"`%s' in description `%s'", *ptr ? *ptr : '?',
file_names[m->type], m->desc);
return -1;
}
for (; *ptr; ptr++) {
if (*ptr == '%') {
file_magwarn(ms,
"Too many format strings (should have at most one) "
"for `%s' with description `%s'",
file_names[m->type], m->desc);
return -1;
}
}
return 0;
}
/*
* Read a numeric value from a pointer, into the value union of a magic
* pointer, according to the magic type. Update the string pointer to point
* just after the number read. Return 0 for success, non-zero for failure.
*/
private int
getvalue(struct magic_set *ms, struct magic *m, const char **p, int action)
{
switch (m->type) {
case FILE_BESTRING16:
case FILE_LESTRING16:
case FILE_STRING:
case FILE_PSTRING:
case FILE_REGEX:
case FILE_SEARCH:
*p = getstr(ms, m, *p, action == FILE_COMPILE);
if (*p == NULL) {
if (ms->flags & MAGIC_CHECK)
file_magwarn(ms, "cannot get string from `%s'",
m->value.s);
return -1;
}
return 0;
case FILE_FLOAT:
case FILE_BEFLOAT:
case FILE_LEFLOAT:
if (m->reln != 'x') {
char *ep;
#ifdef HAVE_STRTOF
m->value.f = strtof(*p, &ep);
#else
m->value.f = (float)strtod(*p, &ep);
#endif
*p = ep;
}
return 0;
case FILE_DOUBLE:
case FILE_BEDOUBLE:
case FILE_LEDOUBLE:
if (m->reln != 'x') {
char *ep;
m->value.d = strtod(*p, &ep);
*p = ep;
}
return 0;
default:
if (m->reln != 'x') {
char *ep;
m->value.q = file_signextend(ms, m,
(uint64_t)strtoull(*p, &ep, 0));
*p = ep;
eatsize(p);
}
return 0;
}
}
/*
* Convert a string containing C character escapes. Stop at an unescaped
* space or tab.
* Copy the converted version to "m->value.s", and the length in m->vallen.
* Return updated scan pointer as function result. Warn if set.
*/
private const char *
getstr(struct magic_set *ms, struct magic *m, const char *s, int warn)
{
const char *origs = s;
char *p = m->value.s;
size_t plen = sizeof(m->value.s);
char *origp = p;
char *pmax = p + plen - 1;
int c;
int val;
while ((c = *s++) != '\0') {
if (isspace((unsigned char) c))
break;
if (p >= pmax) {
file_error(ms, 0, "string too long: `%s'", origs);
return NULL;
}
if (c == '\\') {
switch(c = *s++) {
case '\0':
if (warn)
file_magwarn(ms, "incomplete escape");
goto out;
case '\t':
if (warn) {
file_magwarn(ms,
"escaped tab found, use \\t instead");
warn = 0; /* already did */
}
/*FALLTHROUGH*/
default:
if (warn) {
if (isprint((unsigned char)c)) {
/* Allow escaping of
* ``relations'' */
if (strchr("<>&^=!", c) == NULL
&& (m->type != FILE_REGEX ||
strchr("[]().*?^$|{}", c)
== NULL)) {
file_magwarn(ms, "no "
"need to escape "
"`%c'", c);
}
} else {
file_magwarn(ms,
"unknown escape sequence: "
"\\%03o", c);
}
}
/*FALLTHROUGH*/
/* space, perhaps force people to use \040? */
case ' ':
#if 0
/*
* Other things people escape, but shouldn't need to,
* so we disallow them
*/
case '\'':
case '"':
case '?':
#endif
/* Relations */
case '>':
case '<':
case '&':
case '^':
case '=':
case '!':
/* and baskslash itself */
case '\\':
*p++ = (char) c;
break;
case 'a':
*p++ = '\a';
break;
case 'b':
*p++ = '\b';
break;
case 'f':
*p++ = '\f';
break;
case 'n':
*p++ = '\n';
break;
case 'r':
*p++ = '\r';
break;
case 't':
*p++ = '\t';
break;
case 'v':
*p++ = '\v';
break;
/* \ and up to 3 octal digits */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
val = c - '0';
c = *s++; /* try for 2 */
if (c >= '0' && c <= '7') {
val = (val << 3) | (c - '0');
c = *s++; /* try for 3 */
if (c >= '0' && c <= '7')
val = (val << 3) | (c-'0');
else
--s;
}
else
--s;
*p++ = (char)val;
break;
/* \x and up to 2 hex digits */
case 'x':
val = 'x'; /* Default if no digits */
c = hextoint(*s++); /* Get next char */
if (c >= 0) {
val = c;
c = hextoint(*s++);
if (c >= 0)
val = (val << 4) + c;
else
--s;
} else
--s;
*p++ = (char)val;
break;
}
} else
*p++ = (char)c;
}
out:
*p = '\0';
m->vallen = CAST(unsigned char, (p - origp));
if (m->type == FILE_PSTRING)
m->vallen += (unsigned char)file_pstring_length_size(m);
return s;
}
/* Single hex char to int; -1 if not a hex char. */
private int
hextoint(int c)
{
if (!isascii((unsigned char) c))
return -1;
if (isdigit((unsigned char) c))
return c - '0';
if ((c >= 'a') && (c <= 'f'))
return c + 10 - 'a';
if (( c>= 'A') && (c <= 'F'))
return c + 10 - 'A';
return -1;
}
/*
* Print a string containing C character escapes.
*/
protected void
file_showstr(FILE *fp, const char *s, size_t len)
{
char c;
for (;;) {
if (len == ~0U) {
c = *s++;
if (c == '\0')
break;
}
else {
if (len-- == 0)
break;
c = *s++;
}
if (c >= 040 && c <= 0176) /* TODO isprint && !iscntrl */
(void) fputc(c, fp);
else {
(void) fputc('\\', fp);
switch (c) {
case '\a':
(void) fputc('a', fp);
break;
case '\b':
(void) fputc('b', fp);
break;
case '\f':
(void) fputc('f', fp);
break;
case '\n':
(void) fputc('n', fp);
break;
case '\r':
(void) fputc('r', fp);
break;
case '\t':
(void) fputc('t', fp);
break;
case '\v':
(void) fputc('v', fp);
break;
default:
(void) fprintf(fp, "%.3o", c & 0377);
break;
}
}
}
}
/*
* eatsize(): Eat the size spec from a number [eg. 10UL]
*/
private void
eatsize(const char **p)
{
const char *l = *p;
if (LOWCASE(*l) == 'u')
l++;
switch (LOWCASE(*l)) {
case 'l': /* long */
case 's': /* short */
case 'h': /* short */
case 'b': /* char/byte */
case 'c': /* char/byte */
l++;
/*FALLTHROUGH*/
default:
break;
}
*p = l;
}
#ifndef COMPILE_ONLY
/*
* handle a compiled file.
*/
private int
apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
const char *fn)
{
int fd;
struct stat st;
uint32_t *ptr;
uint32_t version;
int needsbyteswap;
char *dbname = NULL;
void *mm = NULL;
dbname = mkdbname(ms, fn, 0);
if (dbname == NULL)
goto error2;
if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
goto error2;
if (fstat(fd, &st) == -1) {
file_error(ms, errno, "cannot stat `%s'", dbname);
goto error1;
}
if (st.st_size < 8) {
file_error(ms, 0, "file `%s' is too small", dbname);
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;
}
#define RET 2
#else
if ((mm = CAST(void *, malloc((size_t)st.st_size))) == NULL) {
file_oomem(ms, (size_t)st.st_size);
goto error1;
}
if (read(fd, mm, (size_t)st.st_size) != (ssize_t)st.st_size) {
file_badread(ms);
goto error1;
}
#define RET 1
#endif
*magicp = CAST(struct magic *, mm);
(void)close(fd);
fd = -1;
ptr = (uint32_t *)(void *)*magicp;
if (*ptr != MAGICNO) {
if (swap4(*ptr) != MAGICNO) {
file_error(ms, 0, "bad magic in `%s'", dbname);
goto error1;
}
needsbyteswap = 1;
} else
needsbyteswap = 0;
if (needsbyteswap)
version = swap4(ptr[1]);
else
version = ptr[1];
if (version != VERSIONNO) {
file_error(ms, 0, "File %s supports only version %d magic "
"files. `%s' is version %d", VERSION,
VERSIONNO, dbname, version);
goto error1;
}
*nmagicp = (uint32_t)(st.st_size / sizeof(struct magic));
if (*nmagicp > 0)
(*nmagicp)--;
(*magicp)++;
if (needsbyteswap)
byteswap(*magicp, *nmagicp);
free(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
} else {
*magicp = NULL;
*nmagicp = 0;
}
error2:
free(dbname);
return -1;
}
#endif /* COMPILE_ONLY */
private const uint32_t ar[] = {
MAGICNO, VERSIONNO
};
/*
* handle an mmaped file.
*/
private int
apprentice_compile(struct magic_set *ms, struct magic **magicp,
uint32_t *nmagicp, const char *fn)
{
int fd = -1;
char *dbname;
int rv = -1;
dbname = mkdbname(ms, fn, 1);
if (dbname == NULL)
goto out;
if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1) {
file_error(ms, errno, "cannot open `%s'", dbname);
goto out;
}
if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
file_error(ms, errno, "error writing `%s'", dbname);
goto out;
}
if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET)
!= sizeof(struct magic)) {
file_error(ms, errno, "error seeking `%s'", dbname);
goto out;
}
if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp))
!= (ssize_t)(sizeof(struct magic) * *nmagicp)) {
file_error(ms, errno, "error writing `%s'", dbname);
goto out;
}
if (fd != -1)
(void)close(fd);
rv = 0;
out:
free(dbname);
return rv;
}
private const char ext[] = ".mgc";
/*
* make a dbname
*/
private char *
mkdbname(struct magic_set *ms, const char *fn, int strip)
{
const char *p, *q;
char *buf;
if (strip) {
if ((p = strrchr(fn, '/')) != NULL)
fn = ++p;
}
for (q = fn; *q; q++)
continue;
/* Look for .mgc */
for (p = ext + sizeof(ext) - 1; p >= ext && q >= fn; p--, q--)
if (*p != *q)
break;
/* Did not find .mgc, restore q */
if (p >= ext)
while (*q)
q++;
q++;
/* Compatibility with old code that looked in .mime */
if (ms->flags & MAGIC_MIME) {
asprintf(&buf, "%.*s.mime%s", (int)(q - fn), fn, ext);
if (access(buf, R_OK) != -1) {
ms->flags &= MAGIC_MIME_TYPE;
return buf;
}
free(buf);
}
asprintf(&buf, "%.*s%s", (int)(q - fn), fn, ext);
/* Compatibility with old code that looked in .mime */
if (strstr(p, ".mime") != NULL)
ms->flags &= MAGIC_MIME_TYPE;
return buf;
}
#ifndef COMPILE_ONLY
/*
* Byteswap an mmap'ed file if needed
*/
private void
byteswap(struct magic *magic, uint32_t nmagic)
{
uint32_t i;
for (i = 0; i < nmagic; i++)
bs1(&magic[i]);
}
/*
* swap a short
*/
private uint16_t
swap2(uint16_t sv)
{
uint16_t rv;
uint8_t *s = (uint8_t *)(void *)&sv;
uint8_t *d = (uint8_t *)(void *)&rv;
d[0] = s[1];
d[1] = s[0];
return rv;
}
/*
* swap an int
*/
private uint32_t
swap4(uint32_t sv)
{
uint32_t rv;
uint8_t *s = (uint8_t *)(void *)&sv;
uint8_t *d = (uint8_t *)(void *)&rv;
d[0] = s[3];
d[1] = s[2];
d[2] = s[1];
d[3] = s[0];
return rv;
}
/*
* swap a quad
*/
private uint64_t
swap8(uint64_t sv)
{
uint64_t rv;
uint8_t *s = (uint8_t *)(void *)&sv;
uint8_t *d = (uint8_t *)(void *)&rv;
#if 0
d[0] = s[3];
d[1] = s[2];
d[2] = s[1];
d[3] = s[0];
d[4] = s[7];
d[5] = s[6];
d[6] = s[5];
d[7] = s[4];
#else
d[0] = s[7];
d[1] = s[6];
d[2] = s[5];
d[3] = s[4];
d[4] = s[3];
d[5] = s[2];
d[6] = s[1];
d[7] = s[0];
#endif
return rv;
}
/*
* byteswap a single magic entry
*/
private void
bs1(struct magic *m)
{
m->cont_level = swap2(m->cont_level);
m->offset = swap4((uint32_t)m->offset);
m->in_offset = swap4((uint32_t)m->in_offset);
m->lineno = swap4((uint32_t)m->lineno);
if (IS_STRING(m->type)) {
m->str_range = swap4(m->str_range);
m->str_flags = swap4(m->str_flags);
}
else {
m->value.q = swap8(m->value.q);
m->num_mask = swap8(m->num_mask);
}
}
#endif /* COMPILE_ONLY */
protected size_t
file_pstring_length_size(const struct magic *m)
{
switch (m->str_flags & PSTRING_LEN) {
case PSTRING_1_LE:
return 1;
case PSTRING_2_LE:
case PSTRING_2_BE:
return 2;
case PSTRING_4_LE:
case PSTRING_4_BE:
return 4;
default:
abort(); /* Impossible */
return 1;
}
}
protected size_t
file_pstring_get_length(const struct magic *m, const char *s)
{
size_t len = 0;
switch (m->str_flags & PSTRING_LEN) {
case PSTRING_1_LE:
len = *s;
break;
case PSTRING_2_LE:
len = (s[1] << 8) | s[0];
break;
case PSTRING_2_BE:
len = (s[0] << 8) | s[1];
break;
case PSTRING_4_LE:
len = (s[3] << 24) | (s[2] << 16) | (s[1] << 8) | s[0];
break;
case PSTRING_4_BE:
len = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3];
break;
default:
abort(); /* Impossible */
}
if (m->str_flags & PSTRING_LENGTH_INCLUDES_ITSELF)
len -= file_pstring_length_size(m);
return len;
}
Reference in New Issue View Git Blame Copy Permalink