�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2F'>modules</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Fmetadata%2F'>metadata</a>/</p><hr><h3>✏️ Editing: mod_mime_magic.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the &quot;License&quot;); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * mod_mime_magic: MIME type lookup via file magic numbers
 * Copyright (c) 1996-1997 Cisco Systems, Inc.
 *
 * This software was submitted by Cisco Systems to the Apache Software Foundation in July
 * 1997.  Future revisions and derivatives of this source code must
 * acknowledge Cisco Systems as the original contributor of this module.
 * All other licensing and usage conditions are those of the Apache Software Foundation.
 *
 * Some of this code is derived from the free version of the file command
 * originally posted to comp.sources.unix.  Copyright info for that program
 * is included below as required.
 * ---------------------------------------------------------------------------
 * - Copyright (c) Ian F. Darwin, 1987. Written by Ian F. Darwin.
 *
 * This software is not subject to any license of the American Telephone and
 * Telegraph Company or of the Regents of the University of California.
 *
 * Permission is granted to anyone to use this software for any purpose on any
 * computer system, and to alter it and redistribute it freely, subject to
 * the following restrictions:
 *
 * 1. The author is not responsible for the consequences of use of this
 * software, no matter how awful, even if they arise from flaws in it.
 *
 * 2. The origin of this software must not be misrepresented, either by
 * explicit claim or by omission.  Since few users ever read sources, credits
 * must appear in the documentation.
 *
 * 3. Altered versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.  Since few users ever read
 * sources, credits must appear in the documentation.
 *
 * 4. This notice may not be removed or altered.
 * -------------------------------------------------------------------------
 *
 * For compliance with Mr Darwin&#039;s terms: this has been very significantly
 * modified from the free &quot;file&quot; command.
 * - all-in-one file for compilation convenience when moving from one
 *   version of Apache to the next.
 * - Memory allocation is done through the Apache API&#039;s apr_pool_t structure.
 * - All functions have had necessary Apache API request or server
 *   structures passed to them where necessary to call other Apache API
 *   routines.  (i.e. usually for logging, files, or memory allocation in
 *   itself or a called function.)
 * - struct magic has been converted from an array to a single-ended linked
 *   list because it only grows one record at a time, it&#039;s only accessed
 *   sequentially, and the Apache API has no equivalent of realloc().
 * - Functions have been changed to get their parameters from the server
 *   configuration instead of globals.  (It should be reentrant now but has
 *   not been tested in a threaded environment.)
 * - Places where it used to print results to stdout now saves them in a
 *   list where they&#039;re used to set the MIME type in the Apache request
 *   record.
 * - Command-line flags have been removed since they will never be used here.
 *
 * Ian Kluft &lt;ikluft@cisco.com&gt;
 * Engineering Information Framework
 * Central Engineering
 * Cisco Systems, Inc.
 * San Jose, CA, USA
 *
 * Initial installation          July/August 1996
 * Misc bug fixes                May 1997
 * Submission to Apache Software Foundation    July 1997
 *
 */

#include &quot;apr.h&quot;
#include &quot;apr_strings.h&quot;
#include &quot;apr_lib.h&quot;
#define APR_WANT_STRFUNC
#include &quot;apr_want.h&quot;

#if APR_HAVE_UNISTD_H
#include &lt;unistd.h&gt;
#endif

#include &quot;ap_config.h&quot;
#include &quot;httpd.h&quot;
#include &quot;http_config.h&quot;
#include &quot;http_request.h&quot;
#include &quot;http_core.h&quot;
#include &quot;http_log.h&quot;
#include &quot;http_protocol.h&quot;
#include &quot;util_script.h&quot;

/* ### this isn&#039;t set by configure? does anybody set this? */
#ifdef HAVE_UTIME_H
#include &lt;utime.h&gt;
#endif

/*
 * data structures and related constants
 */

#define MODNAME        &quot;mod_mime_magic&quot;
#define MIME_MAGIC_DEBUG        0

#define MIME_BINARY_UNKNOWN    &quot;application/octet-stream&quot;
#define MIME_TEXT_UNKNOWN    &quot;text/plain&quot;

#define MAXMIMESTRING        256

/* HOWMANY must be at least 4096 to make gzip -dcq work */
#define HOWMANY  4096
/* SMALL_HOWMANY limits how much work we do to figure out text files */
#define SMALL_HOWMANY 1024
#define MAXDESC    50   /* max leng of text description */
#define MAXstring 64    /* max leng of &quot;string&quot; types */

struct magic {
    struct magic *next;     /* link to next entry */
    int lineno;             /* line number from magic file */

    short flag;
#define INDIR  1            /* if &#039;&gt;(...)&#039; appears,  */
#define UNSIGNED 2          /* comparison is unsigned */
    short cont_level;       /* level of &quot;&gt;&quot; */
    struct {
        char type;          /* byte short long */
        long offset;        /* offset from indirection */
    } in;
    long offset;            /* offset to magic number */
    unsigned char reln;     /* relation (0=eq, &#039;&gt;&#039;=gt, etc) */
    char type;              /* int, short, long or string. */
    char vallen;            /* length of string value, if any */
#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
    union VALUETYPE {
        unsigned char b;
        unsigned short h;
        unsigned long l;
        char s[MAXstring];
        unsigned char hs[2];   /* 2 bytes of a fixed-endian &quot;short&quot; */
        unsigned char hl[4];   /* 2 bytes of a fixed-endian &quot;long&quot; */
    } value;                   /* either number or string */
    unsigned long mask;        /* mask before comparison with value */
    char nospflag;             /* suppress space character */

    /* NOTE: this string is suspected of overrunning - find it! */
    char desc[MAXDESC];        /* description */
};

/*
 * data structures for tar file recognition
 * --------------------------------------------------------------------------
 * Header file for public domain tar (tape archive) program.
 *
 * @(#)tar.h 1.20 86/10/29    Public Domain. Created 25 August 1985 by John
 * Gilmore, ihnp4!hoptoad!gnu.
 *
 * Header block on tape.
 *
 * I&#039;m going to use traditional DP naming conventions here. A &quot;block&quot; is a big
 * chunk of stuff that we do I/O on. A &quot;record&quot; is a piece of info that we
 * care about. Typically many &quot;record&quot;s fit into a &quot;block&quot;.
 */
#define RECORDSIZE    512
#define NAMSIZ    100
#define TUNMLEN    32
#define TGNMLEN    32

union record {
    char charptr[RECORDSIZE];
    struct header {
        char name[NAMSIZ];
        char mode[8];
        char uid[8];
        char gid[8];
        char size[12];
        char mtime[12];
        char chksum[8];
        char linkflag;
        char linkname[NAMSIZ];
        char magic[8];
        char uname[TUNMLEN];
        char gname[TGNMLEN];
        char devmajor[8];
        char devminor[8];
    } header;
};

/* The magic field is filled with this if uname and gname are valid. */
#define    TMAGIC        &quot;ustar  &quot;   /* 7 chars and a null */

/*
 * file-function prototypes
 */
static int ascmagic(request_rec *, unsigned char *, apr_size_t);
static int is_tar(unsigned char *, apr_size_t);
static int softmagic(request_rec *, unsigned char *, apr_size_t);
static int tryit(request_rec *, unsigned char *, apr_size_t, int);
static int zmagic(request_rec *, unsigned char *, apr_size_t);

static int getvalue(server_rec *, struct magic *, char **);
static int hextoint(int);
static char *getstr(server_rec *, char *, char *, int, int *);
static int parse(server_rec *, apr_pool_t *p, char *, int);

static int match(request_rec *, unsigned char *, apr_size_t);
static int mget(request_rec *, union VALUETYPE *, unsigned char *,
                struct magic *, apr_size_t);
static int mcheck(request_rec *, union VALUETYPE *, struct magic *);
static void mprint(request_rec *, union VALUETYPE *, struct magic *);

static int uncompress(request_rec *, int,
                      unsigned char **, apr_size_t);
static long from_oct(int, char *);
static int fsmagic(request_rec *r, const char *fn);

/*
 * includes for ASCII substring recognition formerly &quot;names.h&quot; in file
 * command
 *
 * Original notes: names and types used by ascmagic in file(1). These tokens are
 * here because they can appear anywhere in the first HOWMANY bytes, while
 * tokens in /etc/magic must appear at fixed offsets into the file. Don&#039;t
 * make HOWMANY too high unless you have a very fast CPU.
 */

/* these types are used to index the apr_table_t &#039;types&#039;: keep em in sync! */
/* HTML inserted in first because this is a web server module now */
#define L_HTML    0   /* HTML */
#define L_C       1   /* first and foremost on UNIX */
#define L_FORT    2   /* the oldest one */
#define L_MAKE    3   /* Makefiles */
#define L_PLI     4   /* PL/1 */
#define L_MACH    5   /* some kinda assembler */
#define L_ENG     6   /* English */
#define L_PAS     7   /* Pascal */
#define L_MAIL    8   /* Electronic mail */
#define L_NEWS    9   /* Usenet Netnews */

static const char *const types[] =
{
    &quot;text/html&quot;,             /* HTML */
    &quot;text/plain&quot;,            /* &quot;c program text&quot;, */
    &quot;text/plain&quot;,            /* &quot;fortran program text&quot;, */
    &quot;text/plain&quot;,            /* &quot;make commands text&quot;, */
    &quot;text/plain&quot;,            /* &quot;pl/1 program text&quot;, */
    &quot;text/plain&quot;,            /* &quot;assembler program text&quot;, */
    &quot;text/plain&quot;,            /* &quot;English text&quot;, */
    &quot;text/plain&quot;,            /* &quot;pascal program text&quot;, */
    &quot;message/rfc822&quot;,        /* &quot;mail text&quot;, */
    &quot;message/news&quot;,          /* &quot;news text&quot;, */
    &quot;application/binary&quot;,    /* &quot;can&#039;t happen error on names.h/types&quot;, */
    0
};

static const struct names {
    const char *name;
    short type;
} names[] = {

    /* These must be sorted by eye for optimal hit rate */
    /* Add to this list only after substantial meditation */
    {
        &quot;&lt;html&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;HTML&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;head&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;HEAD&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;title&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;TITLE&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;h1&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;H1&gt;&quot;, L_HTML
    },
    {
        &quot;&lt;!--&quot;, L_HTML
    },
    {
        &quot;&lt;!DOCTYPE HTML&quot;, L_HTML
    },
    {
        &quot;/*&quot;, L_C
    },               /* must precede &quot;The&quot;, &quot;the&quot;, etc. */
    {
        &quot;#include&quot;, L_C
    },
    {
        &quot;char&quot;, L_C
    },
    {
        &quot;The&quot;, L_ENG
    },
    {
        &quot;the&quot;, L_ENG
    },
    {
        &quot;double&quot;, L_C
    },
    {
        &quot;extern&quot;, L_C
    },
    {
        &quot;float&quot;, L_C
    },
    {
        &quot;real&quot;, L_C
    },
    {
        &quot;struct&quot;, L_C
    },
    {
        &quot;union&quot;, L_C
    },
    {
        &quot;CFLAGS&quot;, L_MAKE
    },
    {
        &quot;LDFLAGS&quot;, L_MAKE
    },
    {
        &quot;all:&quot;, L_MAKE
    },
    {
        &quot;.PRECIOUS&quot;, L_MAKE
    },
    /*
     * Too many files of text have these words in them.  Find another way to
     * recognize Fortrash.
     */
#ifdef    NOTDEF
    {
        &quot;subroutine&quot;, L_FORT
    },
    {
        &quot;function&quot;, L_FORT
    },
    {
        &quot;block&quot;, L_FORT
    },
    {
        &quot;common&quot;, L_FORT
    },
    {
        &quot;dimension&quot;, L_FORT
    },
    {
        &quot;integer&quot;, L_FORT
    },
    {
        &quot;data&quot;, L_FORT
    },
#endif /* NOTDEF */
    {
        &quot;.ascii&quot;, L_MACH
    },
    {
        &quot;.asciiz&quot;, L_MACH
    },
    {
        &quot;.byte&quot;, L_MACH
    },
    {
        &quot;.even&quot;, L_MACH
    },
    {
        &quot;.globl&quot;, L_MACH
    },
    {
        &quot;clr&quot;, L_MACH
    },
    {
        &quot;(input,&quot;, L_PAS
    },
    {
        &quot;dcl&quot;, L_PLI
    },
    {
        &quot;Received:&quot;, L_MAIL
    },
    {
        &quot;&gt;From&quot;, L_MAIL
    },
    {
        &quot;Return-Path:&quot;, L_MAIL
    },
    {
        &quot;Cc:&quot;, L_MAIL
    },
    {
        &quot;Newsgroups:&quot;, L_NEWS
    },
    {
        &quot;Path:&quot;, L_NEWS
    },
    {
        &quot;Organization:&quot;, L_NEWS
    },
    {
        NULL, 0
    }
};

#define NNAMES ((sizeof(names)/sizeof(struct names)) - 1)

/*
 * Result String List (RSL)
 *
 * The file(1) command prints its output.  Instead, we store the various
 * &quot;printed&quot; strings in a list (allocating memory as we go) and concatenate
 * them at the end when we finally know how much space they&#039;ll need.
 */

typedef struct magic_rsl_s {
    const char *str;                  /* string, possibly a fragment */
    struct magic_rsl_s *next;   /* pointer to next fragment */
} magic_rsl;

/*
 * Apache module configuration structures
 */

/* per-server info */
typedef struct {
    const char *magicfile;    /* where magic be found */
    struct magic *magic;      /* head of magic config list */
    struct magic *last;
} magic_server_config_rec;

/* per-request info */
typedef struct {
    magic_rsl *head;          /* result string list */
    magic_rsl *tail;
} magic_req_rec;

/*
 * configuration functions - called by Apache API routines
 */

module AP_MODULE_DECLARE_DATA mime_magic_module;

static void *create_magic_server_config(apr_pool_t *p, server_rec *d)
{
    /* allocate the config - use pcalloc because it needs to be zeroed */
    return apr_pcalloc(p, sizeof(magic_server_config_rec));
}

static void *merge_magic_server_config(apr_pool_t *p, void *basev, void *addv)
{
    magic_server_config_rec *base = (magic_server_config_rec *) basev;
    magic_server_config_rec *add = (magic_server_config_rec *) addv;
    magic_server_config_rec *new = (magic_server_config_rec *)
                            apr_palloc(p, sizeof(magic_server_config_rec));

    new-&gt;magicfile = add-&gt;magicfile ? add-&gt;magicfile : base-&gt;magicfile;
    new-&gt;magic = NULL;
    new-&gt;last = NULL;
    return new;
}

static const char *set_magicfile(cmd_parms *cmd, void *dummy, const char *arg)
{
    magic_server_config_rec *conf = (magic_server_config_rec *)
    ap_get_module_config(cmd-&gt;server-&gt;module_config,
                      &amp;mime_magic_module);

    if (!conf) {
        return MODNAME &quot;: server structure not allocated&quot;;
    }
    conf-&gt;magicfile = arg;
    return NULL;
}

/*
 * configuration file commands - exported to Apache API
 */

static const command_rec mime_magic_cmds[] =
{
    AP_INIT_TAKE1(&quot;MimeMagicFile&quot;, set_magicfile, NULL, RSRC_CONF,
     &quot;Path to MIME Magic file (in file(1) format)&quot;),
    {NULL}
};

/*
 * RSL (result string list) processing routines
 *
 * These collect strings that would have been printed in fragments by file(1)
 * into a list of magic_rsl structures with the strings. When complete,
 * they&#039;re concatenated together to become the MIME content and encoding
 * types.
 *
 * return value conventions for these functions: functions which return int:
 * failure = -1, other = result functions which return pointers: failure = 0,
 * other = result
 */

/* allocate a per-request structure and put it in the request record */
static magic_req_rec *magic_set_config(request_rec *r)
{
    magic_req_rec *req_dat = (magic_req_rec *) apr_palloc(r-&gt;pool,
                                                      sizeof(magic_req_rec));

    req_dat-&gt;head = req_dat-&gt;tail = (magic_rsl *) NULL;
    ap_set_module_config(r-&gt;request_config, &amp;mime_magic_module, req_dat);
    return req_dat;
}

/* add a string to the result string list for this request */
/* it is the responsibility of the caller to allocate &quot;str&quot; */
static int magic_rsl_add(request_rec *r, const char *str)
{
    magic_req_rec *req_dat = (magic_req_rec *)
                    ap_get_module_config(r-&gt;request_config, &amp;mime_magic_module);
    magic_rsl *rsl;

    /* make sure we have a list to put it in */
    if (!req_dat) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_EINVAL, r, APLOGNO(01507)
                    MODNAME &quot;: request config should not be NULL&quot;);
        if (!(req_dat = magic_set_config(r))) {
            /* failure */
            return -1;
        }
    }

    /* allocate the list entry */
    rsl = (magic_rsl *) apr_palloc(r-&gt;pool, sizeof(magic_rsl));

    /* fill it */
    rsl-&gt;str = str;
    rsl-&gt;next = (magic_rsl *) NULL;

    /* append to the list */
    if (req_dat-&gt;head &amp;&amp; req_dat-&gt;tail) {
        req_dat-&gt;tail-&gt;next = rsl;
        req_dat-&gt;tail = rsl;
    }
    else {
        req_dat-&gt;head = req_dat-&gt;tail = rsl;
    }

    /* success */
    return 0;
}

/* RSL hook for puts-type functions */
static int magic_rsl_puts(request_rec *r, const char *str)
{
    return magic_rsl_add(r, str);
}

/* RSL hook for printf-type functions */
static int magic_rsl_printf(request_rec *r, char *str,...)
{
    va_list ap;

    char buf[MAXMIMESTRING];

    /* assemble the string into the buffer */
    va_start(ap, str);
    apr_vsnprintf(buf, sizeof(buf), str, ap);
    va_end(ap);

    /* add the buffer to the list */
    return magic_rsl_add(r, apr_pstrdup(r-&gt;pool, buf));
}

/* RSL hook for putchar-type functions */
static int magic_rsl_putchar(request_rec *r, char c)
{
    char str[2];

    /* high overhead for 1 char - just hope they don&#039;t do this much */
    str[0] = c;
    str[1] = &#039;\0&#039;;
    return magic_rsl_add(r, apr_pstrdup(r-&gt;pool, str));
}

/* allocate and copy a contiguous string from a result string list */
static char *rsl_strdup(request_rec *r, int start_frag, int start_pos, int len)
{
    char *result;       /* return value */
    int cur_frag,       /* current fragment number/counter */
        cur_pos,        /* current position within fragment */
        res_pos;        /* position in result string */
    magic_rsl *frag;    /* list-traversal pointer */
    magic_req_rec *req_dat = (magic_req_rec *)
                    ap_get_module_config(r-&gt;request_config, &amp;mime_magic_module);

    /* allocate the result string */
    result = (char *) apr_palloc(r-&gt;pool, len + 1);

    /* loop through and collect the string */
    res_pos = 0;
    for (frag = req_dat-&gt;head, cur_frag = 0;
         frag-&gt;next;
         frag = frag-&gt;next, cur_frag++) {
        /* loop to the first fragment */
        if (cur_frag &lt; start_frag)
            continue;

        /* loop through and collect chars */
        for (cur_pos = (cur_frag == start_frag) ? start_pos : 0;
             frag-&gt;str[cur_pos];
             cur_pos++) {
            if (cur_frag &gt;= start_frag
                &amp;&amp; cur_pos &gt;= start_pos
                &amp;&amp; res_pos &lt;= len) {
                result[res_pos++] = frag-&gt;str[cur_pos];
                if (res_pos &gt; len) {
                    break;
                }
            }
        }
    }

    /* clean up and return */
    result[res_pos] = 0;
#if MIME_MAGIC_DEBUG
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01508)
             MODNAME &quot;: rsl_strdup() %d chars: %s&quot;, res_pos - 1, result);
#endif
    return result;
}

/* states for the state-machine algorithm in magic_rsl_to_request() */
typedef enum {
    rsl_leading_space, rsl_type, rsl_subtype, rsl_separator, rsl_encoding
} rsl_states;

/* process the RSL and set the MIME info in the request record */
static int magic_rsl_to_request(request_rec *r)
{
    int cur_frag,         /* current fragment number/counter */
        cur_pos,          /* current position within fragment */
        type_frag,        /* content type starting point: fragment */
        type_pos,         /* content type starting point: position */
        type_len,         /* content type length */
        encoding_frag,    /* content encoding starting point: fragment */
        encoding_pos,     /* content encoding starting point: position */
        encoding_len;     /* content encoding length */

    char *tmp;
    magic_rsl *frag;      /* list-traversal pointer */
    rsl_states state;

    magic_req_rec *req_dat = (magic_req_rec *)
                    ap_get_module_config(r-&gt;request_config, &amp;mime_magic_module);

    /* check if we have a result */
    if (!req_dat || !req_dat-&gt;head) {
        /* empty - no match, we defer to other Apache modules */
        return DECLINED;
    }

    /* start searching for the type and encoding */
    state = rsl_leading_space;
    type_frag = type_pos = type_len = 0;
    encoding_frag = encoding_pos = encoding_len = 0;
    for (frag = req_dat-&gt;head, cur_frag = 0;
         frag &amp;&amp; frag-&gt;next;
         frag = frag-&gt;next, cur_frag++) {
        /* loop through the characters in the fragment */
        for (cur_pos = 0; frag-&gt;str[cur_pos]; cur_pos++) {
            if (apr_isspace(frag-&gt;str[cur_pos])) {
                /* process whitespace actions for each state */
                if (state == rsl_leading_space) {
                    /* eat whitespace in this state */
                    continue;
                }
                else if (state == rsl_type) {
                    /* whitespace: type has no slash! */
                    return DECLINED;
                }
                else if (state == rsl_subtype) {
                    /* whitespace: end of MIME type */
                    state++;
                    continue;
                }
                else if (state == rsl_separator) {
                    /* eat whitespace in this state */
                    continue;
                }
                else if (state == rsl_encoding) {
                    /* whitespace: end of MIME encoding */
                    /* we&#039;re done */
                    frag = req_dat-&gt;tail;
                    break;
                }
                else {
                    /* should not be possible */
                    /* abandon malfunctioning module */
                    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01509)
                                MODNAME &quot;: bad state %d (ws)&quot;, state);
                    return DECLINED;
                }
                /* NOTREACHED */
            }
            else if (state == rsl_type &amp;&amp;
                     frag-&gt;str[cur_pos] == &#039;/&#039;) {
                /* copy the char and go to rsl_subtype state */
                type_len++;
                state++;
            }
            else {
                /* process non-space actions for each state */
                if (state == rsl_leading_space) {
                    /* non-space: begin MIME type */
                    state++;
                    type_frag = cur_frag;
                    type_pos = cur_pos;
                    type_len = 1;
                    continue;
                }
                else if (state == rsl_type ||
                         state == rsl_subtype) {
                    /* non-space: adds to type */
                    type_len++;
                    continue;
                }
                else if (state == rsl_separator) {
                    /* non-space: begin MIME encoding */
                    state++;
                    encoding_frag = cur_frag;
                    encoding_pos = cur_pos;
                    encoding_len = 1;
                    continue;
                }
                else if (state == rsl_encoding) {
                    /* non-space: adds to encoding */
                    encoding_len++;
                    continue;
                }
                else {
                    /* should not be possible */
                    /* abandon malfunctioning module */
                    ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01510)
                                MODNAME &quot;: bad state %d (ns)&quot;, state);
                    return DECLINED;
                }
                /* NOTREACHED */
            }
            /* NOTREACHED */
        }
    }

    /* if we ended prior to state rsl_subtype, we had incomplete info */
    if (state != rsl_subtype &amp;&amp; state != rsl_separator &amp;&amp;
        state != rsl_encoding) {
        /* defer to other modules */
        return DECLINED;
    }

    /* save the info in the request record */
    tmp = rsl_strdup(r, type_frag, type_pos, type_len);
    /* XXX: this could be done at config time I&#039;m sure... but I&#039;m
     * confused by all this magic_rsl stuff. -djg */
    ap_content_type_tolower(tmp);
    ap_set_content_type_ex(r, tmp, 1);

    if (state == rsl_encoding) {
        tmp = rsl_strdup(r, encoding_frag,
                                         encoding_pos, encoding_len);
        /* XXX: this could be done at config time I&#039;m sure... but I&#039;m
         * confused by all this magic_rsl stuff. -djg */
        ap_str_tolower(tmp);
        r-&gt;content_encoding = tmp;
    }

    /* detect memory allocation or other errors */
    if (!r-&gt;content_type ||
        (state == rsl_encoding &amp;&amp; !r-&gt;content_encoding)) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01511)
                      MODNAME &quot;: unexpected state %d; could be caused by bad &quot;
                      &quot;data in magic file&quot;,
                      state);
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    /* success! */
    return OK;
}

/*
 * magic_process - process input file r        Apache API request record
 * (formerly called &quot;process&quot; in file command, prefix added for clarity) Opens
 * the file and reads a fixed-size buffer to begin processing the contents.
 */
static int magic_process(request_rec *r)
{
    apr_file_t *fd = NULL;
    unsigned char buf[HOWMANY + 1];  /* one extra for terminating &#039;\0&#039; */
    apr_size_t nbytes = 0;           /* number of bytes read from a datafile */
    int result;

    /*
     * first try judging the file based on its filesystem status
     */
    switch ((result = fsmagic(r, r-&gt;filename))) {
    case DONE:
        magic_rsl_putchar(r, &#039;\n&#039;);
        return OK;
    case OK:
        break;
    default:
        /* fatal error, bail out */
        return result;
    }

    if (apr_file_open(&amp;fd, r-&gt;filename, APR_READ, APR_OS_DEFAULT, r-&gt;pool) != APR_SUCCESS) {
        /* We can&#039;t open it, but we were able to stat it. */
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01512)
                    MODNAME &quot;: can&#039;t read `%s&#039;&quot;, r-&gt;filename);
        /* let some other handler decide what the problem is */
        return DECLINED;
    }

    /*
     * try looking at the first HOWMANY bytes
     */
    nbytes = sizeof(buf) - 1;
    if ((result = apr_file_read(fd, (char *) buf, &amp;nbytes)) != APR_SUCCESS) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, result, r, APLOGNO(01513)
                    MODNAME &quot;: read failed: %s&quot;, r-&gt;filename);
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    if (nbytes == 0) {
        return DECLINED;
    }
    else {
        buf[nbytes++] = &#039;\0&#039;;  /* null-terminate it */
        result = tryit(r, buf, nbytes, 1);
        if (result != OK) {
            return result;
        }
    }

    (void) apr_file_close(fd);
    (void) magic_rsl_putchar(r, &#039;\n&#039;);

    return OK;
}


static int tryit(request_rec *r, unsigned char *buf, apr_size_t nb,
                 int checkzmagic)
{
    /*
     * Try compression stuff
     */
    if (checkzmagic == 1) {
        if (zmagic(r, buf, nb) == 1)
            return OK;
    }

    /*
     * try tests in /etc/magic (or surrogate magic file)
     */
    if (softmagic(r, buf, nb) == 1)
        return OK;

    /*
     * try known keywords, check for ascii-ness too.
     */
    if (ascmagic(r, buf, nb) == 1)
        return OK;

    /*
     * abandon hope, all ye who remain here
     */
    return DECLINED;
}

#define    EATAB {while (apr_isspace(*l))  ++l;}

/*
 * apprentice - load configuration from the magic file r
 *  API request record
 */
static int apprentice(server_rec *s, apr_pool_t *p)
{
    apr_file_t *f = NULL;
    apr_status_t result;
    char line[BUFSIZ + 1];
    int errs = 0;
    int lineno;
#if MIME_MAGIC_DEBUG
    int rule = 0;
    struct magic *m, *prevm;
#endif
    magic_server_config_rec *conf = (magic_server_config_rec *)
                    ap_get_module_config(s-&gt;module_config, &amp;mime_magic_module);
    const char *fname = ap_server_root_relative(p, conf-&gt;magicfile);

    if (!fname) {
        ap_log_error(APLOG_MARK, APLOG_ERR, APR_EBADPATH, s, APLOGNO(01514)
                     MODNAME &quot;: Invalid magic file path %s&quot;, conf-&gt;magicfile);
        return -1;
    }
    if ((result = apr_file_open(&amp;f, fname, APR_READ | APR_BUFFERED,
                                APR_OS_DEFAULT, p)) != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, result, s, APLOGNO(01515)
                     MODNAME &quot;: can&#039;t read magic file %s&quot;, fname);
        return -1;
    }

    /* set up the magic list (empty) */
    conf-&gt;magic = conf-&gt;last = NULL;

    /* parse it */
    for (lineno = 1; apr_file_gets(line, BUFSIZ, f) == APR_SUCCESS; lineno++) {
        int ws_offset;
        char *last = line + strlen(line) - 1; /* guaranteed that len &gt;= 1 since an
                                               * &quot;empty&quot; line contains a &#039;\n&#039;
                                               */

        /* delete newline and any other trailing whitespace */
        while (last &gt;= line
               &amp;&amp; apr_isspace(*last)) {
            *last = &#039;\0&#039;;
            --last;
        }

        /* skip leading whitespace */
        ws_offset = 0;
        while (line[ws_offset] &amp;&amp; apr_isspace(line[ws_offset])) {
            ws_offset++;
        }

        /* skip blank lines */
        if (line[ws_offset] == 0) {
            continue;
        }

        /* comment, do not parse */
        if (line[ws_offset] == &#039;#&#039;)
            continue;

#if MIME_MAGIC_DEBUG
        /* if we get here, we&#039;re going to use it so count it */
        rule++;
#endif

        /* parse it */
        if (parse(s, p, line + ws_offset, lineno) != 0)
            ++errs;
    }

    (void) apr_file_close(f);

#if MIME_MAGIC_DEBUG
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01516)
                MODNAME &quot;: apprentice conf=%pp file=%s m=%s m-&gt;next=%s last=%s&quot;,
                conf,
                conf-&gt;magicfile ? conf-&gt;magicfile : &quot;NULL&quot;,
                conf-&gt;magic ? &quot;set&quot; : &quot;NULL&quot;,
                (conf-&gt;magic &amp;&amp; conf-&gt;magic-&gt;next) ? &quot;set&quot; : &quot;NULL&quot;,
                conf-&gt;last ? &quot;set&quot; : &quot;NULL&quot;);
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01517)
                MODNAME &quot;: apprentice read %d lines, %d rules, %d errors&quot;,
                lineno, rule, errs);
#endif

#if MIME_MAGIC_DEBUG
    prevm = 0;
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01518)
                MODNAME &quot;: apprentice test&quot;);
    for (m = conf-&gt;magic; m; m = m-&gt;next) {
        if (apr_isprint((((unsigned long) m) &gt;&gt; 24) &amp; 255) &amp;&amp;
            apr_isprint((((unsigned long) m) &gt;&gt; 16) &amp; 255) &amp;&amp;
            apr_isprint((((unsigned long) m) &gt;&gt; 8) &amp; 255) &amp;&amp;
            apr_isprint(((unsigned long) m) &amp; 255)) {
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01519)
                        MODNAME &quot;: apprentice: POINTER CLOBBERED! &quot;
                        &quot;m=\&quot;%c%c%c%c\&quot; line=%d&quot;,
                        (((unsigned long) m) &gt;&gt; 24) &amp; 255,
                        (((unsigned long) m) &gt;&gt; 16) &amp; 255,
                        (((unsigned long) m) &gt;&gt; 8) &amp; 255,
                        ((unsigned long) m) &amp; 255,
                        prevm ? prevm-&gt;lineno : -1);
            break;
        }
        prevm = m;
    }
#endif

    return (errs ? -1 : 0);
}

/*
 * extend the sign bit if the comparison is to be signed
 */
static unsigned long signextend(server_rec *s, struct magic *m, unsigned long v)
{
    if (!(m-&gt;flag &amp; UNSIGNED))
        switch (m-&gt;type) {
            /*
             * Do not remove the casts below.  They are vital. When later
             * compared with the data, the sign extension must have happened.
             */
        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:
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, APLOGNO(01520)
                        MODNAME &quot;: can&#039;t happen: m-&gt;type=%d&quot;, m-&gt;type);
            return -1;
        }
    return v;
}

/*
 * parse one line from magic file, put into magic[index++] if valid
 */
static int parse(server_rec *serv, apr_pool_t *p, char *l, int lineno)
{
    struct magic *m;
    char *t, *s;
    magic_server_config_rec *conf = (magic_server_config_rec *)
                    ap_get_module_config(serv-&gt;module_config, &amp;mime_magic_module);

    /* allocate magic structure entry */
    m = (struct magic *) apr_pcalloc(p, sizeof(struct magic));

    /* append to linked list */
    m-&gt;next = NULL;
    if (!conf-&gt;magic || !conf-&gt;last) {
        conf-&gt;magic = conf-&gt;last = m;
    }
    else {
        conf-&gt;last-&gt;next = m;
        conf-&gt;last = m;
    }

    /* set values in magic structure */
    m-&gt;flag = 0;
    m-&gt;cont_level = 0;
    m-&gt;lineno = lineno;

    while (*l == &#039;&gt;&#039;) {
        ++l;  /* step over */
        m-&gt;cont_level++;
    }

    if (m-&gt;cont_level != 0 &amp;&amp; *l == &#039;(&#039;) {
        ++l;  /* step over */
        m-&gt;flag |= INDIR;
    }

    /* get offset, then skip over it */
    m-&gt;offset = (int) strtol(l, &amp;t, 0);
    if (l == t) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, serv, APLOGNO(01521)
                    MODNAME &quot;: offset %s invalid&quot;, l);
    }
    l = t;

    if (m-&gt;flag &amp; INDIR) {
        m-&gt;in.type = LONG;
        m-&gt;in.offset = 0;
        /*
         * read [.lbs][+-]nnnnn)
         */
        if (*l == &#039;.&#039;) {
            switch (*++l) {
            case &#039;l&#039;:
                m-&gt;in.type = LONG;
                break;
            case &#039;s&#039;:
                m-&gt;in.type = SHORT;
                break;
            case &#039;b&#039;:
                m-&gt;in.type = BYTE;
                break;
            default:
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, serv, APLOGNO(01522)
                        MODNAME &quot;: indirect offset type %c invalid&quot;, *l);
                break;
            }
            l++;
        }
        s = l;
        if (*l == &#039;+&#039; || *l == &#039;-&#039;)
            l++;
        if (apr_isdigit((unsigned char) *l)) {
            m-&gt;in.offset = strtol(l, &amp;t, 0);
            if (*s == &#039;-&#039;)
                m-&gt;in.offset = -m-&gt;in.offset;
        }
        else
            t = l;
        if (*t++ != &#039;)&#039;) {
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, serv, APLOGNO(01523)
                        MODNAME &quot;: missing &#039;)&#039; in indirect offset&quot;);
        }
        l = t;
    }


    while (apr_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 == &#039;u&#039;) {
        ++l;
        m-&gt;flag |= UNSIGNED;
    }

    /* get type, skip it */
    if (strncmp(l, &quot;byte&quot;, NBYTE) == 0) {
        m-&gt;type = BYTE;
        l += NBYTE;
    }
    else if (strncmp(l, &quot;short&quot;, NSHORT) == 0) {
        m-&gt;type = SHORT;
        l += NSHORT;
    }
    else if (strncmp(l, &quot;long&quot;, NLONG) == 0) {
        m-&gt;type = LONG;
        l += NLONG;
    }
    else if (strncmp(l, &quot;string&quot;, NSTRING) == 0) {
        m-&gt;type = STRING;
        l += NSTRING;
    }
    else if (strncmp(l, &quot;date&quot;, NDATE) == 0) {
        m-&gt;type = DATE;
        l += NDATE;
    }
    else if (strncmp(l, &quot;beshort&quot;, NBESHORT) == 0) {
        m-&gt;type = BESHORT;
        l += NBESHORT;
    }
    else if (strncmp(l, &quot;belong&quot;, NBELONG) == 0) {
        m-&gt;type = BELONG;
        l += NBELONG;
    }
    else if (strncmp(l, &quot;bedate&quot;, NBEDATE) == 0) {
        m-&gt;type = BEDATE;
        l += NBEDATE;
    }
    else if (strncmp(l, &quot;leshort&quot;, NLESHORT) == 0) {
        m-&gt;type = LESHORT;
        l += NLESHORT;
    }
    else if (strncmp(l, &quot;lelong&quot;, NLELONG) == 0) {
        m-&gt;type = LELONG;
        l += NLELONG;
    }
    else if (strncmp(l, &quot;ledate&quot;, NLEDATE) == 0) {
        m-&gt;type = LEDATE;
        l += NLEDATE;
    }
    else {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, serv, APLOGNO(01524)
                    MODNAME &quot;: type %s invalid&quot;, l);
        return -1;
    }
    /* New-style anding: &quot;0 byte&amp;0x80 =0x80 dynamically linked&quot; */
    if (*l == &#039;&amp;&#039;) {
        ++l;
        m-&gt;mask = signextend(serv, m, strtol(l, &amp;l, 0));
    }
    else
        m-&gt;mask = ~0L;
    EATAB;

    switch (*l) {
    case &#039;&gt;&#039;:
    case &#039;&lt;&#039;:
        /* Old-style anding: &quot;0 byte &amp;0x80 dynamically linked&quot; */
    case &#039;&amp;&#039;:
    case &#039;^&#039;:
    case &#039;=&#039;:
        m-&gt;reln = *l;
        ++l;
        break;
    case &#039;!&#039;:
        if (m-&gt;type != STRING) {
            m-&gt;reln = *l;
            ++l;
            break;
        }
        /* FALL THROUGH */
    default:
        if (*l == &#039;x&#039; &amp;&amp; apr_isspace(l[1])) {
            m-&gt;reln = *l;
            ++l;
            goto GetDesc;  /* Bill The Cat */
        }
        m-&gt;reln = &#039;=&#039;;
        break;
    }
    EATAB;

    if (getvalue(serv, m, &amp;l))
        return -1;
    /*
     * now get last part - the description
     */
  GetDesc:
    EATAB;
    if (l[0] == &#039;\b&#039;) {
        ++l;
        m-&gt;nospflag = 1;
    }
    else if ((l[0] == &#039;\\&#039;) &amp;&amp; (l[1] == &#039;b&#039;)) {
        ++l;
        ++l;
        m-&gt;nospflag = 1;
    }
    else
        m-&gt;nospflag = 0;
    apr_cpystrn(m-&gt;desc, l, sizeof(m-&gt;desc));

#if MIME_MAGIC_DEBUG
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, serv, APLOGNO(01525)
                MODNAME &quot;: parse line=%d m=%pp next=%pp cont=%d desc=%s&quot;,
                lineno, m, m-&gt;next, m-&gt;cont_level, m-&gt;desc);
#endif /* MIME_MAGIC_DEBUG */

    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.
 */
static int getvalue(server_rec *s, struct magic *m, char **p)
{
    int slen;

    if (m-&gt;type == STRING) {
        *p = getstr(s, *p, m-&gt;value.s, sizeof(m-&gt;value.s), &amp;slen);
        m-&gt;vallen = slen;
    }
    else if (m-&gt;reln != &#039;x&#039;)
        m-&gt;value.l = signextend(s, m, strtol(*p, p, 0));
    return 0;
}

/*
 * Convert a string containing C character escapes.  Stop at an unescaped
 * space or tab. Copy the converted version to &quot;p&quot;, returning its length in
 * *slen. Return updated scan pointer as function result.
 */
static char *getstr(server_rec *serv, 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++) != &#039;\0&#039;) {
        if (apr_isspace(c))
            break;
        if (p &gt;= pmax) {
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, serv, APLOGNO(01526)
                        MODNAME &quot;: string too long: %s&quot;, origs);
            break;
        }
        if (c == &#039;\\&#039;) {
            switch (c = *s++) {

            case &#039;\0&#039;:
                goto out;

            default:
                *p++ = (char) c;
                break;

            case &#039;n&#039;:
                *p++ = &#039;\n&#039;;
                break;

            case &#039;r&#039;:
                *p++ = &#039;\r&#039;;
                break;

            case &#039;b&#039;:
                *p++ = &#039;\b&#039;;
                break;

            case &#039;t&#039;:
                *p++ = &#039;\t&#039;;
                break;

            case &#039;f&#039;:
                *p++ = &#039;\f&#039;;
                break;

            case &#039;v&#039;:
                *p++ = &#039;\v&#039;;
                break;

                /* \ and up to 3 octal digits */
            case &#039;0&#039;:
            case &#039;1&#039;:
            case &#039;2&#039;:
            case &#039;3&#039;:
            case &#039;4&#039;:
            case &#039;5&#039;:
            case &#039;6&#039;:
            case &#039;7&#039;:
                val = c - &#039;0&#039;;
                c = *s++;  /* try for 2 */
                if (c &gt;= &#039;0&#039; &amp;&amp; c &lt;= &#039;7&#039;) {
                    val = (val &lt;&lt; 3) | (c - &#039;0&#039;);
                    c = *s++;  /* try for 3 */
                    if (c &gt;= &#039;0&#039; &amp;&amp; c &lt;= &#039;7&#039;)
                        val = (val &lt;&lt; 3) | (c - &#039;0&#039;);
                    else
                        --s;
                }
                else
                    --s;
                *p++ = (char) val;
                break;

                /* \x and up to 3 hex digits */
            case &#039;x&#039;:
                val = &#039;x&#039;;            /* Default if no digits */
                c = hextoint(*s++);   /* Get next char */
                if (c &gt;= 0) {
                    val = c;
                    c = hextoint(*s++);
                    if (c &gt;= 0) {
                        val = (val &lt;&lt; 4) + c;
                        c = hextoint(*s++);
                        if (c &gt;= 0) {
                            val = (val &lt;&lt; 4) + c;
                        }
                        else
                            --s;
                    }
                    else
                        --s;
                }
                else
                    --s;
                *p++ = (char) val;
                break;
            }
        }
        else
            *p++ = (char) c;
    }
  out:
    *p = &#039;\0&#039;;
    *slen = p - origp;
    return s;
}


/* Single hex char to int; -1 if not a hex char. */
static int hextoint(int c)
{
    if (apr_isdigit(c))
        return c - &#039;0&#039;;
    if ((c &gt;= &#039;a&#039;) &amp;&amp; (c &lt;= &#039;f&#039;))
        return c + 10 - &#039;a&#039;;
    if ((c &gt;= &#039;A&#039;) &amp;&amp; (c &lt;= &#039;F&#039;))
        return c + 10 - &#039;A&#039;;
    return -1;
}


/*
 * return DONE to indicate it&#039;s been handled
 * return OK to indicate it&#039;s a regular file still needing handling
 * other returns indicate a failure of some sort
 */
static int fsmagic(request_rec *r, const char *fn)
{
    switch (r-&gt;finfo.filetype) {
    case APR_DIR:
        magic_rsl_puts(r, DIR_MAGIC_TYPE);
        return DONE;
    case APR_CHR:
        /*
         * (void) magic_rsl_printf(r,&quot;character special (%d/%d)&quot;,
         * major(sb-&gt;st_rdev), minor(sb-&gt;st_rdev));
         */
        (void) magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
        return DONE;
    case APR_BLK:
        /*
         * (void) magic_rsl_printf(r,&quot;block special (%d/%d)&quot;,
         * major(sb-&gt;st_rdev), minor(sb-&gt;st_rdev));
         */
        (void) magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
        return DONE;
        /* TODO add code to handle V7 MUX and Blit MUX files */
    case APR_PIPE:
        /*
         * magic_rsl_puts(r,&quot;fifo (named pipe)&quot;);
         */
        (void) magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
        return DONE;
    case APR_LNK:
        /* We used stat(), the only possible reason for this is that the
         * symlink is broken.
         */
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01527)
                    MODNAME &quot;: broken symlink (%s)&quot;, fn);
        return HTTP_INTERNAL_SERVER_ERROR;
    case APR_SOCK:
        magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
        return DONE;
    case APR_REG:
        break;
    default:
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01528)
                      MODNAME &quot;: invalid file type %d.&quot;, r-&gt;finfo.filetype);
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    /*
     * regular file, check next possibility
     */
    if (r-&gt;finfo.size == 0) {
        magic_rsl_puts(r, MIME_TEXT_UNKNOWN);
        return DONE;
    }
    return OK;
}

/*
 * softmagic - lookup one file in database (already read from /etc/magic by
 * apprentice.c). Passed the name and FILE * of one file to be typed.
 */
                /* ARGSUSED1 *//* nbytes passed for regularity, maybe need later */
static int softmagic(request_rec *r, unsigned char *buf, apr_size_t nbytes)
{
    if (match(r, buf, nbytes))
        return 1;

    return 0;
}

/*
 * Go through the whole list, stopping if you find a match.  Process all the
 * continuations of that match before returning.
 *
 * We support multi-level continuations:
 *
 * At any time when processing a successful top-level match, there is a current
 * continuation level; it represents the level of the last successfully
 * matched continuation.
 *
 * Continuations above that level are skipped as, if we see one, it means that
 * the continuation that controls them - i.e, the lower-level continuation
 * preceding them - failed to match.
 *
 * Continuations below that level are processed as, if we see one, it means
 * we&#039;ve finished processing or skipping higher-level continuations under the
 * control of a successful or unsuccessful lower-level continuation, and are
 * now seeing the next lower-level continuation and should process it.  The
 * current continuation level reverts to the level of the one we&#039;re seeing.
 *
 * Continuations at the current level are processed as, if we see one, there&#039;s
 * no lower-level continuation that may have failed.
 *
 * If a continuation matches, we bump the current continuation level so that
 * higher-level continuations are processed.
 */
static int match(request_rec *r, unsigned char *s, apr_size_t nbytes)
{
#if MIME_MAGIC_DEBUG
    int rule_counter = 0;
#endif
    int cont_level = 0;
    int need_separator = 0;
    union VALUETYPE p;
    magic_server_config_rec *conf = (magic_server_config_rec *)
                ap_get_module_config(r-&gt;server-&gt;module_config, &amp;mime_magic_module);
    struct magic *m;

#if MIME_MAGIC_DEBUG
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01529)
                MODNAME &quot;: match conf=%pp file=%s m=%s m-&gt;next=%s last=%s&quot;,
                conf,
                conf-&gt;magicfile ? conf-&gt;magicfile : &quot;NULL&quot;,
                conf-&gt;magic ? &quot;set&quot; : &quot;NULL&quot;,
                (conf-&gt;magic &amp;&amp; conf-&gt;magic-&gt;next) ? &quot;set&quot; : &quot;NULL&quot;,
                conf-&gt;last ? &quot;set&quot; : &quot;NULL&quot;);
#endif

#if MIME_MAGIC_DEBUG
    for (m = conf-&gt;magic; m; m = m-&gt;next) {
        if (apr_isprint((((unsigned long) m) &gt;&gt; 24) &amp; 255) &amp;&amp;
            apr_isprint((((unsigned long) m) &gt;&gt; 16) &amp; 255) &amp;&amp;
            apr_isprint((((unsigned long) m) &gt;&gt; 8) &amp; 255) &amp;&amp;
            apr_isprint(((unsigned long) m) &amp; 255)) {
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01530)
                        MODNAME &quot;: match: POINTER CLOBBERED! &quot;
                        &quot;m=\&quot;%c%c%c%c\&quot;&quot;,
                        (((unsigned long) m) &gt;&gt; 24) &amp; 255,
                        (((unsigned long) m) &gt;&gt; 16) &amp; 255,
                        (((unsigned long) m) &gt;&gt; 8) &amp; 255,
                        ((unsigned long) m) &amp; 255);
            break;
        }
    }
#endif

    for (m = conf-&gt;magic; m; m = m-&gt;next) {
#if MIME_MAGIC_DEBUG
        rule_counter++;
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01531)
                    MODNAME &quot;: line=%d desc=%s&quot;, m-&gt;lineno, m-&gt;desc);
#endif

        /* check if main entry matches */
        if (!mget(r, &amp;p, s, m, nbytes) ||
            !mcheck(r, &amp;p, m)) {
            struct magic *m_cont;

            /*
             * main entry didn&#039;t match, flush its continuations
             */
            if (!m-&gt;next || (m-&gt;next-&gt;cont_level == 0)) {
                continue;
            }

            m_cont = m-&gt;next;
            while (m_cont &amp;&amp; (m_cont-&gt;cont_level != 0)) {
#if MIME_MAGIC_DEBUG
                rule_counter++;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01532)
                        MODNAME &quot;: line=%d mc=%pp mc-&gt;next=%pp cont=%d desc=%s&quot;,
                            m_cont-&gt;lineno, m_cont,
                            m_cont-&gt;next, m_cont-&gt;cont_level,
                            m_cont-&gt;desc);
#endif
                /*
                 * this trick allows us to keep *m in sync when the continue
                 * advances the pointer
                 */
                m = m_cont;
                m_cont = m_cont-&gt;next;
            }
            continue;
        }

        /* if we get here, the main entry rule was a match */
        /* this will be the last run through the loop */
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01533)
                    MODNAME &quot;: rule matched, line=%d type=%d %s&quot;,
                    m-&gt;lineno, m-&gt;type,
                    (m-&gt;type == STRING) ? m-&gt;value.s : &quot;&quot;);
#endif

        /* print the match */
        mprint(r, &amp;p, m);

        /*
         * If we printed something, we&#039;ll need to print a blank before we
         * print something else.
         */
        if (m-&gt;desc[0])
            need_separator = 1;
        /* and any continuations that match */
        cont_level++;
        /*
         * while (m &amp;&amp; m-&gt;next &amp;&amp; m-&gt;next-&gt;cont_level != 0 &amp;&amp; ( m = m-&gt;next
         * ))
         */
        m = m-&gt;next;
        while (m &amp;&amp; (m-&gt;cont_level != 0)) {
#if MIME_MAGIC_DEBUG
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01534)
                        MODNAME &quot;: match line=%d cont=%d type=%d %s&quot;,
                        m-&gt;lineno, m-&gt;cont_level, m-&gt;type,
                        (m-&gt;type == STRING) ? m-&gt;value.s : &quot;&quot;);
#endif
            if (cont_level &gt;= m-&gt;cont_level) {
                if (cont_level &gt; m-&gt;cont_level) {
                    /*
                     * We&#039;re at the end of the level &quot;cont_level&quot;
                     * continuations.
                     */
                    cont_level = m-&gt;cont_level;
                }
                if (mget(r, &amp;p, s, m, nbytes) &amp;&amp;
                    mcheck(r, &amp;p, m)) {
                    /*
                     * This continuation matched. Print its message, with a
                     * blank before it if the previous item printed and this
                     * item isn&#039;t empty.
                     */
                    /* space if previous printed */
                    if (need_separator
                        &amp;&amp; (m-&gt;nospflag == 0)
                        &amp;&amp; (m-&gt;desc[0] != &#039;\0&#039;)
                        ) {
                        (void) magic_rsl_putchar(r, &#039; &#039;);
                        need_separator = 0;
                    }
                    mprint(r, &amp;p, m);
                    if (m-&gt;desc[0])
                        need_separator = 1;

                    /*
                     * If we see any continuations at a higher level, process
                     * them.
                     */
                    cont_level++;
                }
            }

            /* move to next continuation record */
            m = m-&gt;next;
        }
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01535)
                    MODNAME &quot;: matched after %d rules&quot;, rule_counter);
#endif
        return 1;  /* all through */
    }
#if MIME_MAGIC_DEBUG
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01536)
                MODNAME &quot;: failed after %d rules&quot;, rule_counter);
#endif
    return 0;  /* no match at all */
}

static void mprint(request_rec *r, union VALUETYPE *p, struct magic *m)
{
    char *pp;
    unsigned long v;
    char time_str[APR_CTIME_LEN];

    switch (m-&gt;type) {
    case BYTE:
        v = p-&gt;b;
        break;

    case SHORT:
    case BESHORT:
    case LESHORT:
        v = p-&gt;h;
        break;

    case LONG:
    case BELONG:
    case LELONG:
        v = p-&gt;l;
        break;

    case STRING:
        if (m-&gt;reln == &#039;=&#039;) {
            (void) magic_rsl_printf(r, m-&gt;desc, m-&gt;value.s);
        }
        else {
            (void) magic_rsl_printf(r, m-&gt;desc, p-&gt;s);
        }
        return;

    case DATE:
    case BEDATE:
    case LEDATE:
        apr_ctime(time_str, apr_time_from_sec(*(time_t *)&amp;p-&gt;l));
        pp = time_str;
        (void) magic_rsl_printf(r, m-&gt;desc, pp);
        return;
    default:
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01537)
                    MODNAME &quot;: invalid m-&gt;type (%d) in mprint().&quot;,
                    m-&gt;type);
        return;
    }

    v = signextend(r-&gt;server, m, v) &amp; m-&gt;mask;
    (void) magic_rsl_printf(r, m-&gt;desc, (unsigned long) v);
}

/*
 * Convert the byte order of the data we are looking at
 */
static int mconvert(request_rec *r, union VALUETYPE *p, struct magic *m)
{
    char *rt;

    switch (m-&gt;type) {
    case BYTE:
    case SHORT:
    case LONG:
    case DATE:
        return 1;
    case STRING:
        /* Null terminate and eat the return */
        p-&gt;s[sizeof(p-&gt;s) - 1] = &#039;\0&#039;;
        if ((rt = strchr(p-&gt;s, &#039;\n&#039;)) != NULL)
            *rt = &#039;\0&#039;;
        return 1;
    case BESHORT:
        p-&gt;h = (short) ((p-&gt;hs[0] &lt;&lt; 8) | (p-&gt;hs[1]));
        return 1;
    case BELONG:
    case BEDATE:
        p-&gt;l = (long)
            ((p-&gt;hl[0] &lt;&lt; 24) | (p-&gt;hl[1] &lt;&lt; 16) | (p-&gt;hl[2] &lt;&lt; 8) | (p-&gt;hl[3]));
        return 1;
    case LESHORT:
        p-&gt;h = (short) ((p-&gt;hs[1] &lt;&lt; 8) | (p-&gt;hs[0]));
        return 1;
    case LELONG:
    case LEDATE:
        p-&gt;l = (long)
            ((p-&gt;hl[3] &lt;&lt; 24) | (p-&gt;hl[2] &lt;&lt; 16) | (p-&gt;hl[1] &lt;&lt; 8) | (p-&gt;hl[0]));
        return 1;
    default:
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01538)
                    MODNAME &quot;: invalid type %d in mconvert().&quot;, m-&gt;type);
        return 0;
    }
}


static int mget(request_rec *r, union VALUETYPE *p, unsigned char *s,
                struct magic *m, apr_size_t nbytes)
{
    long offset = m-&gt;offset;

    if (offset + sizeof(union VALUETYPE) &gt; nbytes)
                  return 0;

    memcpy(p, s + offset, sizeof(union VALUETYPE));

    if (!mconvert(r, p, m))
        return 0;

    if (m-&gt;flag &amp; INDIR) {

        switch (m-&gt;in.type) {
        case BYTE:
            offset = p-&gt;b + m-&gt;in.offset;
            break;
        case SHORT:
            offset = p-&gt;h + m-&gt;in.offset;
            break;
        case LONG:
            offset = p-&gt;l + m-&gt;in.offset;
            break;
        }

        if (offset + sizeof(union VALUETYPE) &gt; nbytes)
                      return 0;

        memcpy(p, s + offset, sizeof(union VALUETYPE));

        if (!mconvert(r, p, m))
            return 0;
    }
    return 1;
}

static int mcheck(request_rec *r, union VALUETYPE *p, struct magic *m)
{
    register unsigned long l = m-&gt;value.l;
    register unsigned long v;
    int matched;

    if ((m-&gt;value.s[0] == &#039;x&#039;) &amp;&amp; (m-&gt;value.s[1] == &#039;\0&#039;)) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01539)
                    MODNAME &quot;: BOINK&quot;);
        return 1;
    }

    switch (m-&gt;type) {
    case BYTE:
        v = p-&gt;b;
        break;

    case SHORT:
    case BESHORT:
    case LESHORT:
        v = p-&gt;h;
        break;

    case LONG:
    case BELONG:
    case LELONG:
    case DATE:
    case BEDATE:
    case LEDATE:
        v = p-&gt;l;
        break;

    case STRING:
        l = 0;
        /*
         * What we want here is: v = strncmp(m-&gt;value.s, p-&gt;s, m-&gt;vallen);
         * but ignoring any nulls.  bcmp doesn&#039;t give -/+/0 and isn&#039;t
         * universally available anyway.
         */
        v = 0;
        {
            register unsigned char *a = (unsigned char *) m-&gt;value.s;
            register unsigned char *b = (unsigned char *) p-&gt;s;
            register int len = m-&gt;vallen;

            while (--len &gt;= 0)
                if ((v = *b++ - *a++) != 0)
                    break;
        }
        break;
    default:
        /*  bogosity, pretend that it just wasn&#039;t a match */
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01540)
                    MODNAME &quot;: invalid type %d in mcheck().&quot;, m-&gt;type);
        return 0;
    }

    v = signextend(r-&gt;server, m, v) &amp; m-&gt;mask;

    switch (m-&gt;reln) {
    case &#039;x&#039;:
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01541)
                    &quot;%lu == *any* = 1&quot;, v);
#endif
        matched = 1;
        break;

    case &#039;!&#039;:
        matched = v != l;
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01542)
                    &quot;%lu != %lu = %d&quot;, v, l, matched);
#endif
        break;

    case &#039;=&#039;:
        matched = v == l;
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01543)
                    &quot;%lu == %lu = %d&quot;, v, l, matched);
#endif
        break;

    case &#039;&gt;&#039;:
        if (m-&gt;flag &amp; UNSIGNED) {
            matched = v &gt; l;
#if MIME_MAGIC_DEBUG
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01544)
                        &quot;%lu &gt; %lu = %d&quot;, v, l, matched);
#endif
        }
        else {
            matched = (long) v &gt; (long) l;
#if MIME_MAGIC_DEBUG
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01545)
                        &quot;%ld &gt; %ld = %d&quot;, v, l, matched);
#endif
        }
        break;

    case &#039;&lt;&#039;:
        if (m-&gt;flag &amp; UNSIGNED) {
            matched = v &lt; l;
#if MIME_MAGIC_DEBUG
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01546)
                        &quot;%lu &lt; %lu = %d&quot;, v, l, matched);
#endif
        }
        else {
            matched = (long) v &lt; (long) l;
#if MIME_MAGIC_DEBUG
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01547)
                        &quot;%ld &lt; %ld = %d&quot;, v, l, matched);
#endif
        }
        break;

    case &#039;&amp;&#039;:
        matched = (v &amp; l) == l;
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01548)
                    &quot;((%lx &amp; %lx) == %lx) = %d&quot;, v, l, l, matched);
#endif
        break;

    case &#039;^&#039;:
        matched = (v &amp; l) != l;
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01549)
                    &quot;((%lx &amp; %lx) != %lx) = %d&quot;, v, l, l, matched);
#endif
        break;

    default:
        /* bogosity, pretend it didn&#039;t match */
        matched = 0;
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01550)
                    MODNAME &quot;: mcheck: can&#039;t happen: invalid relation %d.&quot;,
                    m-&gt;reln);
        break;
    }

    return matched;
}

/* an optimization over plain strcmp() */
#define    STREQ(a, b)    (*(a) == *(b) &amp;&amp; strcmp((a), (b)) == 0)

static int ascmagic(request_rec *r, unsigned char *buf, apr_size_t nbytes)
{
    int has_escapes = 0;
    unsigned char *s;
    char nbuf[SMALL_HOWMANY + 1];  /* one extra for terminating &#039;\0&#039; */
    char *token;
    const struct names *p;
    int small_nbytes;
    char *strtok_state;

    /* these are easy, do them first */

    /*
     * for troff, look for . + letter + letter or .\&quot;; this must be done to
     * disambiguate tar archives&#039; ./file and other trash from real troff
     * input.
     */
    if (*buf == &#039;.&#039;) {
        unsigned char *tp = buf + 1;

        while (apr_isspace(*tp))
            ++tp;  /* skip leading whitespace */
        if ((apr_isalnum(*tp) || *tp == &#039;\\&#039;) &amp;&amp;
             (apr_isalnum(*(tp + 1)) || *tp == &#039;&quot;&#039;)) {
            magic_rsl_puts(r, &quot;application/x-troff&quot;);
            return 1;
        }
    }
    if ((*buf == &#039;c&#039; || *buf == &#039;C&#039;) &amp;&amp; apr_isspace(*(buf + 1))) {
        /* Fortran */
        magic_rsl_puts(r, &quot;text/plain&quot;);
        return 1;
    }

    /* look for tokens from names.h - this is expensive!, so we&#039;ll limit
     * ourselves to only SMALL_HOWMANY bytes */
    small_nbytes = (nbytes &gt; SMALL_HOWMANY) ? SMALL_HOWMANY : nbytes;
    /* make a copy of the buffer here because apr_strtok() will destroy it */
    s = (unsigned char *) memcpy(nbuf, buf, small_nbytes);
    s[small_nbytes] = &#039;\0&#039;;
    has_escapes = (memchr(s, &#039;\033&#039;, small_nbytes) != NULL);
    while ((token = apr_strtok((char *) s, &quot; \t\n\r\f&quot;, &amp;strtok_state)) != NULL) {
        s = NULL;  /* make apr_strtok() keep on tokin&#039; */
        for (p = names; p &lt; names + NNAMES; p++) {
            if (STREQ(p-&gt;name, token)) {
                magic_rsl_puts(r, types[p-&gt;type]);
                if (has_escapes)
                    magic_rsl_puts(r, &quot; (with escape sequences)&quot;);
                return 1;
            }
        }
    }

    switch (is_tar(buf, nbytes)) {
    case 1:
        /* V7 tar archive */
        magic_rsl_puts(r, &quot;application/x-tar&quot;);
        return 1;
    case 2:
        /* POSIX tar archive */
        magic_rsl_puts(r, &quot;application/x-tar&quot;);
        return 1;
    }

    /* all else fails, but it is ascii... */
    return 0;
}


/*
 * compress routines: zmagic() - returns 0 if not recognized, uncompresses
 * and prints information if recognized uncompress(s, method, old, n, newch)
 * - uncompress old into new, using method, return sizeof new
 */

static const struct {
    const char *magic;
    apr_size_t maglen;
    const char *argv[3];
    int silent;
    const char *encoding;  /* MUST be lowercase */
} compr[] = {

    /* we use gzip here rather than uncompress because we have to pass
     * it a full filename -- and uncompress only considers filenames
     * ending with .Z
     */
    {
        &quot;\037\235&quot;, 2, {
            &quot;gzip&quot;, &quot;-dcq&quot;, NULL
        }, 0, &quot;x-compress&quot;
    },
    {
        &quot;\037\213&quot;, 2, {
            &quot;gzip&quot;, &quot;-dcq&quot;, NULL
        }, 1, &quot;x-gzip&quot;
    },
    /*
     * XXX pcat does not work, cause I don&#039;t know how to make it read stdin,
     * so we use gzip
     */
    {
        &quot;\037\036&quot;, 2, {
            &quot;gzip&quot;, &quot;-dcq&quot;, NULL
        }, 0, &quot;x-gzip&quot;
    },
};

#define ncompr (sizeof(compr) / sizeof(compr[0]))

static int zmagic(request_rec *r, unsigned char *buf, apr_size_t nbytes)
{
    unsigned char *newbuf;
    int newsize;
    int i;

    for (i = 0; i &lt; ncompr; i++) {
        if (nbytes &lt; compr[i].maglen)
            continue;
        if (memcmp(buf, compr[i].magic, compr[i].maglen) == 0)
            break;
    }

    if (i == ncompr)
        return 0;

    if ((newsize = uncompress(r, i, &amp;newbuf, HOWMANY)) &gt; 0) {
        /* set encoding type in the request record */
        r-&gt;content_encoding = compr[i].encoding;

        newbuf[newsize-1] = &#039;\0&#039;;  /* null-terminate uncompressed data */
        /* Try to detect the content type of the uncompressed data */
        if (tryit(r, newbuf, newsize, 0) != OK) {
            return 0;
        }
    }
    return 1;
}


struct uncompress_parms {
    request_rec *r;
    int method;
};

static int create_uncompress_child(struct uncompress_parms *parm, apr_pool_t *cntxt,
                                   apr_file_t **pipe_in)
{
    int rc = 1;
    const char *new_argv[4];
    request_rec *r = parm-&gt;r;
    apr_pool_t *child_context = cntxt;
    apr_procattr_t *procattr;
    apr_proc_t *procnew;

    /* XXX missing 1.3 logic:
     *
     * what happens when !compr[parm-&gt;method].silent?
     * Should we create the err pipe, read it, and copy to the log?
     */

    if ((apr_procattr_create(&amp;procattr, child_context) != APR_SUCCESS) ||
        (apr_procattr_io_set(procattr, APR_FULL_BLOCK,
                           APR_FULL_BLOCK, APR_NO_PIPE)   != APR_SUCCESS) ||
        (apr_procattr_dir_set(procattr,
                              ap_make_dirstr_parent(r-&gt;pool, r-&gt;filename)) != APR_SUCCESS) ||
        (apr_procattr_cmdtype_set(procattr, APR_PROGRAM_PATH) != APR_SUCCESS)) {
        /* Something bad happened, tell the world. */
        ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_ENOPROC, r, APLOGNO(01551)
               &quot;couldn&#039;t setup child process: %s&quot;, r-&gt;filename);
    }
    else {
        new_argv[0] = compr[parm-&gt;method].argv[0];
        new_argv[1] = compr[parm-&gt;method].argv[1];
        new_argv[2] = r-&gt;filename;
        new_argv[3] = NULL;

        procnew = apr_pcalloc(child_context, sizeof(*procnew));
        rc = apr_proc_create(procnew, compr[parm-&gt;method].argv[0],
                               new_argv, NULL, procattr, child_context);

        if (rc != APR_SUCCESS) {
            /* Bad things happened. Everyone should have cleaned up. */
            ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_ENOPROC, r, APLOGNO(01552)
                          MODNAME &quot;: could not execute `%s&#039;.&quot;,
                          compr[parm-&gt;method].argv[0]);
        }
        else {
            apr_pool_note_subprocess(child_context, procnew, APR_KILL_AFTER_TIMEOUT);
            *pipe_in = procnew-&gt;out;
        }
    }

    return (rc);
}

static int uncompress(request_rec *r, int method,
                      unsigned char **newch, apr_size_t n)
{
    struct uncompress_parms parm;
    apr_file_t *pipe_out = NULL;
    apr_pool_t *sub_context;
    apr_status_t rv;

    parm.r = r;
    parm.method = method;

    /* We make a sub_pool so that we can collect our child early, otherwise
     * there are cases (i.e. generating directory indices with mod_autoindex)
     * where we would end up with LOTS of zombies.
     */
    if (apr_pool_create(&amp;sub_context, r-&gt;pool) != APR_SUCCESS)
        return -1;
    apr_pool_tag(sub_context, &quot;magic_uncompress&quot;);

    if ((rv = create_uncompress_child(&amp;parm, sub_context, &amp;pipe_out)) != APR_SUCCESS) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01553)
                    MODNAME &quot;: couldn&#039;t spawn uncompress process: %s&quot;, r-&gt;uri);
        return -1;
    }

    *newch = (unsigned char *) apr_palloc(r-&gt;pool, n);
    rv = apr_file_read(pipe_out, *newch, &amp;n);
    if (n == 0) {
        apr_pool_destroy(sub_context);
        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01554)
            MODNAME &quot;: read failed from uncompress of %s&quot;, r-&gt;filename);
        return -1;
    }
    apr_pool_destroy(sub_context);
    return n;
}

/*
 * is_tar() -- figure out whether file is a tar archive.
 *
 * Stolen (by author of file utility) from the public domain tar program: Public
 * Domain version written 26 Aug 1985 John Gilmore (ihnp4!hoptoad!gnu).
 *
 * @(#)list.c 1.18 9/23/86 Public Domain - gnu $Id: mod_mime_magic.c,v 1.7
 * 1997/06/24 00:41:02 ikluft Exp ikluft $
 *
 * Comments changed and some code/comments reformatted for file command by Ian
 * Darwin.
 */

#define isodigit(c) (((unsigned char)(c) &gt;= &#039;0&#039;) &amp;&amp; ((unsigned char)(c) &lt;= &#039;7&#039;))

/*
 * Return 0 if the checksum is bad (i.e., probably not a tar archive), 1 for
 * old UNIX tar file, 2 for Unix Std (POSIX) tar file.
 */

static int is_tar(unsigned char *buf, apr_size_t nbytes)
{
    register union record *header = (union record *) buf;
    register int i;
    register long sum, recsum;
    register char *p;

    if (nbytes &lt; sizeof(union record))
               return 0;

    recsum = from_oct(8, header-&gt;header.chksum);

    sum = 0;
    p = header-&gt;charptr;
    for (i = sizeof(union record); --i &gt;= 0;) {
        /*
         * We can&#039;t use unsigned char here because of old compilers, e.g. V7.
         */
        sum += 0xFF &amp; *p++;
    }

    /* Adjust checksum to count the &quot;chksum&quot; field as blanks. */
    for (i = sizeof(header-&gt;header.chksum); --i &gt;= 0;)
        sum -= 0xFF &amp; header-&gt;header.chksum[i];
    sum += &#039; &#039; * sizeof header-&gt;header.chksum;

    if (sum != recsum)
        return 0;   /* Not a tar archive */

    if (0 == strcmp(header-&gt;header.magic, TMAGIC))
        return 2;   /* Unix Standard tar archive */

    return 1;       /* Old fashioned tar archive */
}


/*
 * Quick and dirty octal conversion.
 *
 * Result is -1 if the field is invalid (all blank, or nonoctal).
 */
static long from_oct(int digs, char *where)
{
    register long value;

    while (apr_isspace(*where)) {  /* Skip spaces */
        where++;
        if (--digs &lt;= 0)
            return -1;  /* All blank field */
    }
    value = 0;
    while (digs &gt; 0 &amp;&amp; isodigit(*where)) {  /* Scan til nonoctal */
        value = (value &lt;&lt; 3) | (*where++ - &#039;0&#039;);
        --digs;
    }

    if (digs &gt; 0 &amp;&amp; *where &amp;&amp; !apr_isspace(*where))
        return -1;  /* Ended on non-space/nul */

    return value;
}

/*
 * Check for file-revision suffix
 *
 * This is for an obscure document control system used on an intranet.
 * The web representation of each file&#039;s revision has an @1, @2, etc
 * appended with the revision number.  This needs to be stripped off to
 * find the file suffix, which can be recognized by sending the name back
 * through a sub-request.  The base file name (without the @num suffix)
 * must exist because its type will be used as the result.
 */
static int revision_suffix(request_rec *r)
{
    int suffix_pos, result;
    char *sub_filename;
    request_rec *sub;

#if MIME_MAGIC_DEBUG
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01555)
                MODNAME &quot;: revision_suffix checking %s&quot;, r-&gt;filename);
#endif /* MIME_MAGIC_DEBUG */

    /* check for recognized revision suffix */
    suffix_pos = strlen(r-&gt;filename) - 1;
    if (!apr_isdigit(r-&gt;filename[suffix_pos])) {
        return 0;
    }
    while (suffix_pos &gt;= 0 &amp;&amp; apr_isdigit(r-&gt;filename[suffix_pos]))
        suffix_pos--;
    if (suffix_pos &lt; 0 || r-&gt;filename[suffix_pos] != &#039;@&#039;) {
        return 0;
    }

    /* perform sub-request for the file name without the suffix */
    result = 0;
    sub_filename = apr_pstrndup(r-&gt;pool, r-&gt;filename, suffix_pos);
#if MIME_MAGIC_DEBUG
    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01556)
                MODNAME &quot;: subrequest lookup for %s&quot;, sub_filename);
#endif /* MIME_MAGIC_DEBUG */
    sub = ap_sub_req_lookup_file(sub_filename, r, NULL);

    /* extract content type/encoding/language from sub-request */
    if (sub-&gt;content_type) {
        ap_set_content_type_ex(r, apr_pstrdup(r-&gt;pool, sub-&gt;content_type), 1);
#if MIME_MAGIC_DEBUG
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01557)
                    MODNAME &quot;: subrequest %s got %s&quot;,
                    sub_filename, r-&gt;content_type);
#endif /* MIME_MAGIC_DEBUG */
        if (sub-&gt;content_encoding)
            r-&gt;content_encoding =
                apr_pstrdup(r-&gt;pool, sub-&gt;content_encoding);
        if (sub-&gt;content_languages) {
            int n;
            r-&gt;content_languages = apr_array_copy(r-&gt;pool,
                                                  sub-&gt;content_languages);
            for (n = 0; n &lt; r-&gt;content_languages-&gt;nelts; ++n) {
                char **lang = ((char **)r-&gt;content_languages-&gt;elts) + n;
                *lang = apr_pstrdup(r-&gt;pool, *lang);
            }
        }
        result = 1;
    }

    /* clean up */
    ap_destroy_sub_req(sub);

    return result;
}

/*
 * initialize the module
 */
static int magic_init(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *main_server)
{
    int result;
    magic_server_config_rec *conf;
    magic_server_config_rec *main_conf;
    server_rec *s;
#if MIME_MAGIC_DEBUG
    struct magic *m, *prevm;
#endif /* MIME_MAGIC_DEBUG */

    main_conf = ap_get_module_config(main_server-&gt;module_config, &amp;mime_magic_module);
    for (s = main_server; s; s = s-&gt;next) {
        conf = ap_get_module_config(s-&gt;module_config, &amp;mime_magic_module);
        if (conf-&gt;magicfile == NULL &amp;&amp; s != main_server) {
            /* inherits from the parent */
            *conf = *main_conf;
        }
        else if (conf-&gt;magicfile) {
            result = apprentice(s, p);
            if (result == -1)
                return OK;
#if MIME_MAGIC_DEBUG
            prevm = 0;
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01558)
                        MODNAME &quot;: magic_init 1 test&quot;);
            for (m = conf-&gt;magic; m; m = m-&gt;next) {
                if (apr_isprint((((unsigned long) m) &gt;&gt; 24) &amp; 255) &amp;&amp;
                    apr_isprint((((unsigned long) m) &gt;&gt; 16) &amp; 255) &amp;&amp;
                    apr_isprint((((unsigned long) m) &gt;&gt; 8) &amp; 255) &amp;&amp;
                    apr_isprint(((unsigned long) m) &amp; 255)) {
                    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01559)
                                MODNAME &quot;: magic_init 1: POINTER CLOBBERED! &quot;
                                &quot;m=\&quot;%c%c%c%c\&quot; line=%d&quot;,
                                (((unsigned long) m) &gt;&gt; 24) &amp; 255,
                                (((unsigned long) m) &gt;&gt; 16) &amp; 255,
                                (((unsigned long) m) &gt;&gt; 8) &amp; 255,
                                ((unsigned long) m) &amp; 255,
                                prevm ? prevm-&gt;lineno : -1);
                    break;
                }
                prevm = m;
            }
#endif
        }
    }
    return OK;
}

/*
 * Find the Content-Type from any resource this module has available
 */

static int magic_find_ct(request_rec *r)
{
    int result;
    magic_server_config_rec *conf;

    /* the file has to exist */
    if (r-&gt;finfo.filetype == APR_NOFILE || !r-&gt;filename) {
        return DECLINED;
    }

    /* was someone else already here? */
    if (r-&gt;content_type) {
        return DECLINED;
    }

    conf = ap_get_module_config(r-&gt;server-&gt;module_config, &amp;mime_magic_module);
    if (!conf || !conf-&gt;magic) {
        return DECLINED;
    }

    /* initialize per-request info */
    if (!magic_set_config(r)) {
        return HTTP_INTERNAL_SERVER_ERROR;
    }

    /* try excluding file-revision suffixes */
    if (revision_suffix(r) != 1) {
        /* process it based on the file contents */
        if ((result = magic_process(r)) != OK) {
            return result;
        }
    }

    /* if we have any results, put them in the request structure */
    return magic_rsl_to_request(r);
}

static void register_hooks(apr_pool_t *p)
{
    static const char * const aszPre[]={ &quot;mod_mime.c&quot;, NULL };

    /* mod_mime_magic should be run after mod_mime, if at all. */

    ap_hook_type_checker(magic_find_ct, aszPre, NULL, APR_HOOK_MIDDLE);
    ap_hook_post_config(magic_init, NULL, NULL, APR_HOOK_FIRST);
}

/*
 * Apache API module interface
 */

AP_DECLARE_MODULE(mime_magic) =
{
    STANDARD20_MODULE_STUFF,
    NULL,                      /* dir config creator */
    NULL,                      /* dir merger --- default is to override */
    create_magic_server_config,        /* server config */
    merge_magic_server_config, /* merge server config */
    mime_magic_cmds,           /* command apr_table_t */
    register_hooks              /* register hooks */
};
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Fmetadata'>🔙 Back</a></p>