#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_streams.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_mime_magic.h"
#include "phpmimemagic.h"
#include <fcntl.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef PHP_WIN32
#define PHP_MIME_MAGIC_FILE_PATH PHP_PREFIX "\\magic.mime"
#endif
#define BYTE 1
#define SHORT 2
#define LONG 4
#define STRING 5
#define DATE 6
#define BESHORT 7
#define BELONG 8
#define BEDATE 9
#define LESHORT 10
#define LELONG 11
#define LEDATE 12
static int apprentice(void);
static int ascmagic(unsigned char *, int);
static int is_tar(unsigned char *, unsigned int);
static int softmagic(unsigned char *, int);
static void tryit(unsigned char *, int, int);
static int getvalue(struct magic *, char **);
static int hextoint(int);
static char *getstr(char *, char *, int, int *);
static int parse(char *, int);
static int match(unsigned char *, int);
static int mget(union VALUETYPE *, unsigned char *,
struct magic *, int);
static int mcheck(union VALUETYPE *, struct magic *);
static void mprint(union VALUETYPE *, struct magic *);
static int mconvert(union VALUETYPE *, struct magic *);
static int magic_rsl_get(char **, char **);
static int magic_process(zval * TSRMLS_DC);
static long from_oct(int, char *);
static int fsmagic(zval * TSRMLS_DC);
#if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB)
static int zmagic(unsigned char *, int);
#endif
static magic_req_rec *magic_set_config(void);
static void magic_free_config(magic_req_rec *);
ZEND_DECLARE_MODULE_GLOBALS(mime_magic)
static PHP_GINIT_FUNCTION(mime_magic);
static magic_server_config_rec mime_global;
zend_function_entry mime_magic_functions[] = {
PHP_FE(mime_content_type, NULL)
{NULL, NULL, NULL}
};
zend_module_entry mime_magic_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
"mime_magic",
mime_magic_functions,
PHP_MINIT(mime_magic),
PHP_MSHUTDOWN(mime_magic),
NULL,
NULL,
PHP_MINFO(mime_magic),
#if ZEND_MODULE_API_NO >= 20010901
"0.1",
#endif
#if ZEND_MODULE_API_NO >= 20060613
PHP_MODULE_GLOBALS(mime_magic),
PHP_GINIT(mime_magic),
NULL,
NULL,
STANDARD_MODULE_PROPERTIES_EX
#else
STANDARD_MODULE_PROPERTIES
#endif
};
#ifdef COMPILE_DL_MIME_MAGIC
ZEND_GET_MODULE(mime_magic)
#endif
PHP_INI_BEGIN()
STD_PHP_INI_ENTRY("mime_magic.magicfile", PHP_MIME_MAGIC_FILE_PATH, PHP_INI_SYSTEM, OnUpdateString, magicfile, zend_mime_magic_globals, mime_magic_globals)
STD_PHP_INI_BOOLEAN("mime_magic.debug", "0", PHP_INI_SYSTEM, OnUpdateBool, debug, zend_mime_magic_globals, mime_magic_globals)
PHP_INI_END()
static PHP_GINIT_FUNCTION(mime_magic)
{
memset(mime_magic_globals, 0, sizeof(zend_mime_magic_globals));
mime_global.magic = NULL;
mime_global.last = NULL;
}
PHP_MINIT_FUNCTION(mime_magic)
{
REGISTER_INI_ENTRIES();
if(MIME_MAGIC_G(magicfile)) {
if(apprentice()) {
MIME_MAGIC_G(status) = "invalid magic file, disabled";
} else {
MIME_MAGIC_G(status) = "enabled";
}
} else {
MIME_MAGIC_G(status) = "no magic file given, disabled";
}
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(mime_magic)
{
UNREGISTER_INI_ENTRIES();
if (mime_global.magic != NULL && mime_global.magic != (struct magic *) -1) {
struct magic *iter = mime_global.magic;
while (iter != NULL) {
struct magic *iter_next = iter->next;
free(iter);
iter = iter_next;
}
}
return SUCCESS;
}
PHP_MINFO_FUNCTION(mime_magic)
{
php_info_print_table_start();
php_info_print_table_header(2, "mime_magic support", MIME_MAGIC_G(status));
php_info_print_table_end();
DISPLAY_INI_ENTRIES();
}
PHP_FUNCTION(mime_content_type)
{
zval *what;
magic_server_config_rec *conf = &mime_global;
char *content_type=NULL, *content_encoding=NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &what) == FAILURE) {
return;
}
switch (Z_TYPE_P(what)) {
case IS_STRING:
break;
case IS_RESOURCE:
{
php_stream *stream;
php_stream_from_zval_no_verify(stream, &what);
if (stream) {
break;
}
}
default:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "can only process string or stream arguments");
RETURN_FALSE;
break;
}
if (conf->magic == (struct magic *)-1) {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_ERROR, "mime_magic could not be initialized, magic file %s is not available", MIME_MAGIC_G(magicfile));
RETURN_FALSE;
}
if(!conf->magic) {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, "mime_magic not initialized");
RETURN_FALSE;
}
MIME_MAGIC_G(req_dat) = magic_set_config();
if(MIME_MAGIC_OK != magic_process(what TSRMLS_CC)) {
RETVAL_FALSE;
} else if(MIME_MAGIC_OK != magic_rsl_get(&content_type, &content_encoding)) {
RETVAL_FALSE;
} else {
RETVAL_STRING(content_type, 1);
}
if(content_type) efree(content_type);
if(content_encoding) efree(content_encoding);
magic_free_config(MIME_MAGIC_G(req_dat));
}
#define EATAB {while (isspace((unsigned char) *l)) ++l;}
static int apprentice(void)
{
FILE *f;
char line[BUFSIZ + 1];
int errs = 0;
int lineno;
char *fname;
magic_server_config_rec *conf = &mime_global;
TSRMLS_FETCH();
if (!MIME_MAGIC_G(magicfile)) {
return -1;
}
fname = MIME_MAGIC_G(magicfile);
f = fopen(fname, "rb");
if (f == NULL) {
conf->magic = (struct magic *)-1;
return -1;
}
conf->magic = conf->last = NULL;
for (lineno = 1; fgets(line, BUFSIZ, f) != NULL; lineno++) {
int ws_offset;
if (line[0]) {
line[strlen(line) - 1] = '\0';
}
ws_offset = 0;
while (line[ws_offset] && isspace(line[ws_offset])) {
ws_offset++;
}
if (line[ws_offset] == 0) {
continue;
}
if (line[ws_offset] == '#')
continue;
if (parse(line + ws_offset, lineno) != 0)
++errs;
}
(void) fclose(f);
return (errs ? -1 : 0);
}
static unsigned long signextend(struct magic *m, unsigned long v)
{
if (!(m->flag & UNSIGNED))
switch (m->type) {
case BYTE:
v = (char) v;
break;
case SHORT:
case BESHORT:
case LESHORT:
v = (short) v;
break;
case DATE:
case BEDATE:
case LEDATE:
case LONG:
case BELONG:
case LELONG:
v = (long) v;
break;
case STRING:
break;
default:
{
TSRMLS_FETCH();
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": can't happen: m->type=%d", m->type);
return -1;
}
}
return v;
}
static int is_valid_mimetype(char *p, int p_len)
{
if (p_len > 0) {
do {
if (!isalnum(*p) && (*p != '-') && (*p != '.')) {
return 0;
}
} while (*(++p) != '/');
++p;
do {
if (!isalnum(*p) && (*p != '-') && (*p != '.') && !isspace(*p)) {
return 0;
}
} while (*(++p));
}
return 1;
}
static int parse(char *l, int lineno)
{
struct magic *m;
char *t, *s;
magic_server_config_rec *conf = &mime_global;
TSRMLS_FETCH();
m = (struct magic *) calloc(1, sizeof(struct magic));
m->next = NULL;
if (!conf->magic || !conf->last) {
conf->magic = conf->last = m;
}
else {
conf->last->next = m;
conf->last = m;
}
m->flag = 0;
m->cont_level = 0;
m->lineno = lineno;
while (*l == '>') {
++l;
m->cont_level++;
}
if (m->cont_level != 0 && *l == '(') {
++l;
m->flag |= INDIR;
}
m->offset = (int) strtol(l, &t, 0);
if (l == t) {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": (%s:%d) offset `%s' invalid", MIME_MAGIC_G(magicfile), lineno, l);
}
l = t;
if (m->flag & INDIR) {
m->in.type = LONG;
m->in.offset = 0;
if (*l == '.') {
switch (*++l) {
case 'l':
m->in.type = LONG;
break;
case 's':
m->in.type = SHORT;
break;
case 'b':
m->in.type = BYTE;
break;
default:
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": (%s:%d) indirect offset type %c invalid", MIME_MAGIC_G(magicfile), lineno, *l);
break;
}
l++;
}
s = l;
if (*l == '+' || *l == '-')
l++;
if (isdigit((unsigned char) *l)) {
m->in.offset = strtol(l, &t, 0);
if (*s == '-')
m->in.offset = -m->in.offset;
}
else
t = l;
if (*t++ != ')') {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": (%s:%d) missing ')' in indirect offset", MIME_MAGIC_G(magicfile), lineno);
}
l = t;
}
while (isdigit((unsigned char) *l))
++l;
EATAB;
#define NBYTE 4
#define NSHORT 5
#define NLONG 4
#define NSTRING 6
#define NDATE 4
#define NBESHORT 7
#define NBELONG 6
#define NBEDATE 6
#define NLESHORT 7
#define NLELONG 6
#define NLEDATE 6
if (*l == 'u') {
++l;
m->flag |= UNSIGNED;
}
if (strncmp(l, "byte", NBYTE) == 0) {
m->type = BYTE;
l += NBYTE;
}
else if (strncmp(l, "short", NSHORT) == 0) {
m->type = SHORT;
l += NSHORT;
}
else if (strncmp(l, "long", NLONG) == 0) {
m->type = LONG;
l += NLONG;
}
else if (strncmp(l, "string", NSTRING) == 0) {
m->type = STRING;
l += NSTRING;
}
else if (strncmp(l, "date", NDATE) == 0) {
m->type = DATE;
l += NDATE;
}
else if (strncmp(l, "beshort", NBESHORT) == 0) {
m->type = BESHORT;
l += NBESHORT;
}
else if (strncmp(l, "belong", NBELONG) == 0) {
m->type = BELONG;
l += NBELONG;
}
else if (strncmp(l, "bedate", NBEDATE) == 0) {
m->type = BEDATE;
l += NBEDATE;
}
else if (strncmp(l, "leshort", NLESHORT) == 0) {
m->type = LESHORT;
l += NLESHORT;
}
else if (strncmp(l, "lelong", NLELONG) == 0) {
m->type = LELONG;
l += NLELONG;
}
else if (strncmp(l, "ledate", NLEDATE) == 0) {
m->type = LEDATE;
l += NLEDATE;
}
else {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": (%s:%d) type %s invalid", MIME_MAGIC_G(magicfile), lineno, l);
return -1;
}
if (*l == '&') {
++l;
m->mask = signextend(m, strtol(l, &l, 0));
}
else
m->mask = ~0L;
EATAB;
switch (*l) {
case '>':
case '<':
case '&':
case '^':
case '=':
m->reln = *l;
++l;
break;
case '!':
if (m->type != STRING) {
m->reln = *l;
++l;
break;
}
default:
if (*l == 'x' && isspace((unsigned char) l[1])) {
m->reln = *l;
++l;
goto GetDesc;
}
m->reln = '=';
break;
}
EATAB;
if (getvalue(m, &l))
return -1;
GetDesc:
EATAB;
if (l[0] == '\b') {
++l;
m->nospflag = 1;
}
else if ((l[0] == '\\') && (l[1] == 'b')) {
++l;
++l;
m->nospflag = 1;
}
else
m->nospflag = 0;
if (!is_valid_mimetype(l, strlen(l))) {
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, ": (%s:%d) '%s' is not a valid mimetype, entry skipped", MIME_MAGIC_G(magicfile), lineno, l);
return -1;
}
strlcpy(m->desc, l, sizeof(m->desc));
return 0;
}
static int getvalue(struct magic *m, char **p)
{
int slen;
if (m->type == STRING) {
*p = getstr(*p, m->value.s, sizeof(m->value.s), &slen);
m->vallen = slen;
}
else if (m->reln != 'x')
m->value.l = signextend(m, strtol(*p, p, 0));
return 0;
}
static char *getstr(register char *s, register char *p,
int plen, int *slen)
{
char *origs = s, *origp = p;
char *pmax = p + plen - 1;
register int c;
register int val;
while ((c = *s++) != '\0') {
if (isspace((unsigned char) c))
break;
if (p >= pmax) {
TSRMLS_FETCH();
if(MIME_MAGIC_G(debug))
php_error_docref("http://www.php.net/mime_magic" TSRMLS_CC, E_WARNING, "string too long: %s", origs);
break;
}
if (c == '\\') {
switch (c = *s++) {
case '\0':
goto out;
default:
*p++ = (char) c;
break;
case 'n':
*p++ = '\n';
break;
case 'r':
*p++ = '\r';
break;
case 'b':
*p++ = '\b';
break;
case 't':
*p++ = '\t';
break;
case 'f':
*p++ = '\f';
break;
case 'v':
*p++ = '\v';
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
val = c - '0';
c = *s++;
if (c >= '0' && c <= '7') {
val = (val << 3) | (c - '0');
c = *s++;
if (c >= '0' && c <= '7')
val = (val << 3) | (c - '0');
else
--s;
}
else
--s;
*p++ = (char) val;
break;
case 'x':
val = 'x';
c = hextoint(*s++);
if (c >= 0) {
val = c;
c = hextoint(*s++);
if (c >= 0) {
val = (val << 4) + c;
c = hextoint(*s++);
if (c >= 0) {
val = (val << 4) + c;
}
else
--s;
}
else
--s;
}
else
--s;
*p++ = (char) val;
break;
}
}
else
*p++ = (char) c;
}
out:
*p = '\0';
*slen = p - origp;
return s;
}
static int hextoint(int c)
{
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;
}
static magic_req_rec *magic_set_config(void)
{
magic_req_rec *req_dat = (magic_req_rec *) emalloc(sizeof(magic_req_rec));
req_dat->head = req_dat->tail = (magic_rsl *) NULL;
return req_dat;
}
static void magic_free_config(magic_req_rec *req_dat) {
magic_rsl *curr, *next;
if(!req_dat) return;
curr = req_dat->head;
while(curr) {
next = curr->next;
efree(curr->str);
efree(curr);
curr = next;
}
efree(req_dat);
}
static int magic_rsl_add(char *str)
{
magic_req_rec *req_dat;
magic_rsl *rsl;
TSRMLS_FETCH();
req_dat = MIME_MAGIC_G(req_dat);
if (!req_dat) {
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "request config should not be NULL");
if (!(req_dat = magic_set_config())) {
return -1;
}
}
rsl = (magic_rsl *) emalloc(sizeof(magic_rsl));
rsl->str = estrdup(str);
rsl->next = (magic_rsl *) NULL;
if (req_dat->head && req_dat->tail) {
req_dat->tail->next = rsl;
req_dat->tail = rsl;
}
else {
req_dat->head = req_dat->tail = rsl;
}
return 0;
}
static int magic_rsl_puts(char *str)
{
return magic_rsl_add(str);
}
static int magic_rsl_printf(char *str,...)
{
va_list ap;
char buf[MAXMIMESTRING];
va_start(ap, str);
vsnprintf(buf, sizeof(buf), str, ap);
va_end(ap);
return magic_rsl_add(buf);
}
static int magic_rsl_putchar(char c)
{
char str[2];
str[0] = c;
str[1] = '\0';
return magic_rsl_add(str);
}
static char *rsl_strdup(int start_frag, int start_pos, int len)
{
char *result;
int cur_frag,
cur_pos,
res_pos;
magic_rsl *frag;
magic_req_rec *req_dat;
TSRMLS_FETCH();
req_dat = MIME_MAGIC_G(req_dat);
result = (char *) emalloc(len + 2);
res_pos = 0;
for (frag = req_dat->head, cur_frag = 0;
frag->next;
frag = frag->next, cur_frag++) {
if (cur_frag < start_frag)
continue;
for (cur_pos = (cur_frag == start_frag) ? start_pos : 0;
frag->str[cur_pos];
cur_pos++) {
if (cur_frag >= start_frag
&& cur_pos >= start_pos
&& res_pos <= len) {
result[res_pos++] = frag->str[cur_pos];
if (res_pos > len) {
break;
}
}
}
}
result[res_pos] = 0;
return result;
}
static int magic_process(zval *what TSRMLS_DC)
{
php_stream *stream;
unsigned char buf[HOWMANY + 1];
int nbytes = 0;
int result;
off_t streampos;
switch ((result = fsmagic(what TSRMLS_CC))) {
case MIME_MAGIC_DONE:
magic_rsl_putchar('\n');
return MIME_MAGIC_OK;
case MIME_MAGIC_OK:
break;
default:
return result;
}
switch (Z_TYPE_P(what)) {
case IS_STRING:
stream = php_stream_open_wrapper(Z_STRVAL_P(what), "rb", IGNORE_PATH | ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL);
if (stream == NULL) {
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "can't read `%s'", Z_STRVAL_P(what));
return MIME_MAGIC_DECLINED;
}
break;
case IS_RESOURCE:
php_stream_from_zval_no_verify(stream, &what);
streampos = php_stream_tell(stream);
php_stream_seek(stream, 0, SEEK_SET);
break;
default:
return -1;
}
if ((nbytes = php_stream_read(stream, (char *) buf, sizeof(buf) - 1)) == -1) {
if(MIME_MAGIC_G(debug)) {
if (Z_TYPE_P(what) == IS_RESOURCE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "read failed on stream");
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "read failed: %s", Z_STRVAL_P(what));
}
}
return MIME_MAGIC_ERROR;
}
if (nbytes == 0)
magic_rsl_puts(MIME_TEXT_UNKNOWN);
else {
buf[nbytes++] = '\0';
tryit(buf, nbytes, 1);
}
if (Z_TYPE_P(what) == IS_RESOURCE) {
php_stream_seek(stream, streampos, SEEK_SET);
} else {
(void) php_stream_close(stream);
}
(void) magic_rsl_putchar('\n');
return MIME_MAGIC_OK;
}
static void tryit(unsigned char *buf, int nb, int checkzmagic)
{
#if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB)
if (checkzmagic == 1) {
if (zmagic(buf, nb) == 1)
return;
}
#endif
if (softmagic(buf, nb) == 1)
return;
if (ascmagic(buf, nb) == 1)
return;
magic_rsl_puts(MIME_BINARY_UNKNOWN);
}
static int fsmagic(zval *what TSRMLS_DC)
{
php_stream_statbuf stat_ssb;
switch (Z_TYPE_P(what)) {
case IS_STRING:
if (php_stream_stat_path_ex(Z_STRVAL_P(what), PHP_STREAM_URL_STAT_QUIET, &stat_ssb, NULL)) {
if (MIME_MAGIC_G(debug)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Non-statable file path (%s)", Z_STRVAL_P(what));
}
return MIME_MAGIC_ERROR;
}
break;
case IS_RESOURCE:
{
php_stream *stream;
php_stream_from_zval_no_verify(stream, &what);
if (php_stream_stat(stream, &stat_ssb)) {
if (MIME_MAGIC_G(debug)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Non-statable file path (%s)", Z_STRVAL_P(what));
}
return MIME_MAGIC_ERROR;
}
}
break;
default:
return MIME_MAGIC_OK;
}
switch (stat_ssb.sb.st_mode & S_IFMT) {
case S_IFDIR:
magic_rsl_puts(DIR_MAGIC_TYPE);
return MIME_MAGIC_DONE;
case S_IFCHR:
(void) magic_rsl_puts(MIME_BINARY_UNKNOWN);
return MIME_MAGIC_DONE;
#ifdef S_IFBLK
case S_IFBLK:
(void) magic_rsl_puts(MIME_BINARY_UNKNOWN);
return MIME_MAGIC_DONE;
#endif
#ifdef S_IFIFO
case S_IFIFO:
(void) magic_rsl_puts(MIME_BINARY_UNKNOWN);
return MIME_MAGIC_DONE;
#endif
#ifdef S_IFLNK
case S_IFLNK:
if(MIME_MAGIC_G(debug)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "broken symlink (%s)", Z_STRVAL_P(what));
}
return MIME_MAGIC_ERROR;
#endif
#ifdef S_IFSOCK
#ifndef __COHERENT__
case S_IFSOCK:
magic_rsl_puts(MIME_BINARY_UNKNOWN);
return MIME_MAGIC_DONE;
#endif
#endif
case S_IFREG:
break;
case 0:
break;
default:
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid mode 0%o.", (unsigned int)stat_ssb.sb.st_mode);
return MIME_MAGIC_ERROR;
}
if (stat_ssb.sb.st_size == 0) {
magic_rsl_puts(MIME_TEXT_UNKNOWN);
return MIME_MAGIC_DONE;
}
return MIME_MAGIC_OK;
}
static int softmagic(unsigned char *buf, int nbytes)
{
if (match(buf, nbytes))
return 1;
return 0;
}
static int match(unsigned char *s, int nbytes)
{
int cont_level = 0;
int need_separator = 0;
union VALUETYPE p;
magic_server_config_rec *conf = &mime_global;
struct magic *m;
for (m = conf->magic; m; m = m->next) {
if (!mget(&p, s, m, nbytes) ||
!mcheck(&p, m)) {
struct magic *m_cont;
if (!m->next || (m->next->cont_level == 0)) {
continue;
}
m_cont = m->next;
while (m_cont && (m_cont->cont_level != 0)) {
m = m_cont;
m_cont = m_cont->next;
}
continue;
}
mprint(&p, m);
if (m->desc[0])
need_separator = 1;
cont_level++;
m = m->next;
while (m && (m->cont_level != 0)) {
if (cont_level >= m->cont_level) {
if (cont_level > m->cont_level) {
cont_level = m->cont_level;
}
if (mget(&p, s, m, nbytes) &&
mcheck(&p, m)) {
if (need_separator
&& (m->nospflag == 0)
&& (m->desc[0] != '\0')
) {
(void) magic_rsl_putchar(' ');
need_separator = 0;
}
mprint(&p, m);
if (m->desc[0])
need_separator = 1;
cont_level++;
}
}
m = m->next;
}
return 1;
}
return 0;
}
#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
static int ascmagic(unsigned char *buf, int nbytes)
{
int has_escapes = 0;
unsigned char *s;
char nbuf[HOWMANY + 1];
char *token;
register struct names *p;
int small_nbytes;
char *strtok_buf = NULL;
if (*buf == '.') {
unsigned char *tp = buf + 1;
while (isspace(*tp))
++tp;
if ((isalnum(*tp) || *tp == '\\') &&
(isalnum(*(tp + 1)) || *tp == '"')) {
magic_rsl_puts("application/x-troff");
return 1;
}
}
if ((*buf == 'c' || *buf == 'C') && isspace(*(buf + 1))) {
magic_rsl_puts("text/plain");
return 1;
}
small_nbytes = (nbytes > SMALL_HOWMANY) ? SMALL_HOWMANY : nbytes;
s = (unsigned char *) memcpy(nbuf, buf, small_nbytes);
s[small_nbytes] = '\0';
has_escapes = (memchr(s, '\033', small_nbytes) != NULL);
while ((token = php_strtok_r((char *) s, " \t\n\r\f", &strtok_buf)) != NULL) {
s = NULL;
for (p = names; p < names + NNAMES; p++) {
if (STREQ(p->name, token)) {
magic_rsl_puts(types[p->type]);
if (has_escapes)
magic_rsl_puts(" (with escape sequences)");
return 1;
}
}
}
switch (is_tar(buf, nbytes)) {
case 1:
magic_rsl_puts("application/x-tar");
return 1;
case 2:
magic_rsl_puts("application/x-tar");
return 1;
}
if (has_escapes) {
magic_rsl_puts("text/plain");
}
else {
magic_rsl_puts("text/plain");
}
return 1;
}
#define isodigit(c) ( ((c) >= '0') && ((c) <= '7') )
static int is_tar(unsigned char *buf, unsigned int nbytes)
{
register union record *header = (union record *) buf;
register int i;
register long sum, recsum;
register char *p;
if (nbytes < sizeof(union record))
return 0;
recsum = from_oct(8, header->header.chksum);
sum = 0;
p = header->charptr;
for (i = sizeof(union record); --i >= 0;) {
sum += 0xFF & *p++;
}
for (i = sizeof(header->header.chksum); --i >= 0;)
sum -= 0xFF & header->header.chksum[i];
sum += ' ' * sizeof header->header.chksum;
if (sum != recsum)
return 0;
if (0 == strcmp(header->header.magic, TMAGIC))
return 2;
return 1;
}
static long from_oct(int digs, char *where)
{
register long value;
while (isspace(*where)) {
where++;
if (--digs <= 0)
return -1;
}
value = 0;
while (digs > 0 && isodigit(*where)) {
value = (value << 3) | (*where++ - '0');
--digs;
}
if (digs > 0 && *where && !isspace(*where))
return -1;
return value;
}
static int mget(union VALUETYPE *p, unsigned char *s,
struct magic *m, int nbytes)
{
long offset = m->offset;
if (offset + (long)sizeof(union VALUETYPE) > nbytes)
return 0;
memcpy(p, s + offset, sizeof(union VALUETYPE));
if (!mconvert(p, m))
return 0;
if (m->flag & INDIR) {
switch (m->in.type) {
case BYTE:
offset = p->b + m->in.offset;
break;
case SHORT:
offset = p->h + m->in.offset;
break;
case LONG:
offset = p->l + m->in.offset;
break;
}
if (offset + (long)sizeof(union VALUETYPE) > nbytes)
return 0;
memcpy(p, s + offset, sizeof(union VALUETYPE));
if (!mconvert(p, m))
return 0;
}
return 1;
}
static int mcheck(union VALUETYPE *p, struct magic *m)
{
register unsigned long l = m->value.l;
register unsigned long v;
int matched;
TSRMLS_FETCH();
if ((m->value.s[0] == 'x') && (m->value.s[1] == '\0')) {
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "BOINK");
return 1;
}
switch (m->type) {
case BYTE:
v = p->b;
break;
case SHORT:
case BESHORT:
case LESHORT:
v = p->h;
break;
case LONG:
case BELONG:
case LELONG:
case DATE:
case BEDATE:
case LEDATE:
v = p->l;
break;
case STRING:
l = 0;
v = 0;
{
register unsigned char *a = (unsigned char *) m->value.s;
register unsigned char *b = (unsigned char *) p->s;
register int len = m->vallen;
while (--len >= 0)
if ((v = *b++ - *a++) != 0)
break;
}
break;
default:
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid type %d in mcheck().", m->type);
return 0;
}
v = signextend(m, v) & m->mask;
switch (m->reln) {
case 'x':
matched = 1;
break;
case '!':
matched = v != l;
break;
case '=':
matched = v == l;
break;
case '>':
if (m->flag & UNSIGNED) {
matched = v > l;
}
else {
matched = (long) v > (long) l;
}
break;
case '<':
if (m->flag & UNSIGNED) {
matched = v < l;
}
else {
matched = (long) v < (long) l;
}
break;
case '&':
matched = (v & l) == l;
break;
case '^':
matched = (v & l) != l;
break;
default:
matched = 0;
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "mcheck: can't happen: invalid relation %d.", m->reln);
break;
}
return matched;
}
#if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB)
static int zmagic(unsigned char *buf, int nbytes)
{
if (buf[0] != 0x1f) return 0;
switch(buf[1]) {
case 0x9d:
break;
case 0x8b:
#if 0
if ((newsize = magic_uncompress(i, &newbuf, nbytes)) > 0) {
tryit(newbuf, newsize, 0);
}
#endif
break;
case 0x1e:
break;
}
return 0;
}
#endif
static void mprint(union VALUETYPE *p, struct magic *m)
{
char *pp, *rt;
unsigned long v;
switch (m->type) {
case BYTE:
v = p->b;
break;
case SHORT:
case BESHORT:
case LESHORT:
v = p->h;
break;
case LONG:
case BELONG:
case LELONG:
v = p->l;
break;
case STRING:
if (m->reln == '=') {
(void) magic_rsl_printf(m->desc, m->value.s);
}
else {
(void) magic_rsl_printf(m->desc, p->s);
}
return;
case DATE:
case BEDATE:
case LEDATE:
{
char ctimebuf[52];
pp = php_ctime_r((time_t *) &p->l, ctimebuf);
if (!pp) {
return;
}
if ((rt = strchr(pp, '\n')) != NULL) {
*rt = '\0';
}
(void) magic_rsl_printf(m->desc, pp);
return;
}
default:
{
TSRMLS_FETCH();
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid m->type (%d) in mprint().", m->type);
return;
}
}
v = signextend(m, v) & m->mask;
(void) magic_rsl_printf(m->desc, (unsigned long) v);
}
static int mconvert(union VALUETYPE *p, struct magic *m)
{
char *rt;
switch (m->type) {
case BYTE:
case SHORT:
case LONG:
case DATE:
return 1;
case STRING:
p->s[sizeof(p->s) - 1] = '\0';
if ((rt = strchr(p->s, '\n')) != NULL)
*rt = '\0';
return 1;
case BESHORT:
p->h = (short) ((p->hs[0] << 8) | (p->hs[1]));
return 1;
case BELONG:
case BEDATE:
p->l = (long)
((p->hl[0] << 24) | (p->hl[1] << 16) | (p->hl[2] << 8) | (p->hl[3]));
return 1;
case LESHORT:
p->h = (short) ((p->hs[1] << 8) | (p->hs[0]));
return 1;
case LELONG:
case LEDATE:
p->l = (long)
((p->hl[3] << 24) | (p->hl[2] << 16) | (p->hl[1] << 8) | (p->hl[0]));
return 1;
default:
{
TSRMLS_FETCH();
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid type %d in mconvert().", m->type);
return 0;
}
}
}
typedef enum {
rsl_leading_space, rsl_type, rsl_subtype, rsl_separator, rsl_encoding
} rsl_states;
static int magic_rsl_get(char **content_type, char **content_encoding)
{
int cur_frag,
cur_pos,
type_frag,
type_pos,
type_len,
encoding_frag,
encoding_pos,
encoding_len;
magic_rsl *frag;
rsl_states state;
magic_req_rec *req_dat;
TSRMLS_FETCH();
req_dat = MIME_MAGIC_G(req_dat);
if (!req_dat || !req_dat->head) {
return MIME_MAGIC_DECLINED;
}
state = rsl_leading_space;
type_frag = type_pos = type_len = 0;
encoding_frag = encoding_pos = encoding_len = 0;
for (frag = req_dat->head, cur_frag = 0;
frag && frag->next;
frag = frag->next, cur_frag++) {
for (cur_pos = 0; frag->str[cur_pos]; cur_pos++) {
if (isspace(frag->str[cur_pos])) {
if (state == rsl_leading_space) {
continue;
}
else if (state == rsl_type) {
return MIME_MAGIC_DECLINED;
}
else if (state == rsl_subtype) {
state++;
continue;
}
else if (state == rsl_separator) {
continue;
}
else if (state == rsl_encoding) {
frag = req_dat->tail;
break;
}
else {
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, ": bad state %d (ws)", state);
return MIME_MAGIC_DECLINED;
}
}
else if (state == rsl_type &&
frag->str[cur_pos] == '/') {
type_len++;
state++;
}
else {
if (state == rsl_leading_space) {
state++;
type_frag = cur_frag;
type_pos = cur_pos;
type_len = 1;
continue;
}
else if (state == rsl_type ||
state == rsl_subtype) {
type_len++;
continue;
}
else if (state == rsl_separator) {
state++;
encoding_frag = cur_frag;
encoding_pos = cur_pos;
encoding_len = 1;
continue;
}
else if (state == rsl_encoding) {
encoding_len++;
continue;
}
else {
if(MIME_MAGIC_G(debug))
php_error_docref(NULL TSRMLS_CC, E_WARNING, "bad state %d (ns)", state);
return MIME_MAGIC_DECLINED;
}
}
}
}
if (state != rsl_subtype && state != rsl_separator &&
state != rsl_encoding) {
return MIME_MAGIC_DECLINED;
}
if (state == rsl_subtype || state == rsl_encoding ||
state == rsl_encoding) {
char *tmp;
tmp = rsl_strdup(type_frag, type_pos, type_len);
*content_type = tmp;
}
if (state == rsl_encoding) {
char *tmp;
tmp = rsl_strdup(encoding_frag,
encoding_pos, encoding_len);
*content_encoding = tmp;
}
if (!content_type || !(*content_type) || (state == rsl_encoding && !*content_encoding)) {
return MIME_MAGIC_ERROR;
}
return MIME_MAGIC_OK;
}