mod_mime_magic.c revision adb8ad10ffc20ed06ec6cfab6cd7933ab429ea7d
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg/* ====================================================================
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * The Apache Software License, Version 1.1
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * Copyright (c) 2000-2001 The Apache Software Foundation. All rights
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * reserved.
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * Redistribution and use in source and binary forms, with or without
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * modification, are permitted provided that the following conditions
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * are met:
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * 1. Redistributions of source code must retain the above copyright
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * notice, this list of conditions and the following disclaimer.
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * 2. Redistributions in binary form must reproduce the above copyright
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * notice, this list of conditions and the following disclaimer in
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * the documentation and/or other materials provided with the
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * distribution.
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
7190e58eec40192c9719d2f2593471eda14e7e7cfuankg * 3. The end-user documentation included with the redistribution,
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * if any, must include the following acknowledgment:
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * "This product includes software developed by the
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * Apache Software Foundation (http://www.apache.org/)."
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * Alternately, this acknowledgment may appear in the software itself,
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * if and wherever such third-party acknowledgments normally appear.
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * 4. The names "Apache" and "Apache Software Foundation" must
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * not be used to endorse or promote products derived from this
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * software without prior written permission. For written
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * permission, please contact apache@apache.org.
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg *
95ca7cc2aa11b41497ffab3a1003bc09d24b6bc1fuankg * 5. Products derived from this software may not be called "Apache",
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * nor may "Apache" appear in their name, without prior written
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * permission of the Apache Software Foundation.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
70953fb44a7140fe206c3a5f011e24209c8c5c6abnicholes * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * SUCH DAMAGE.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * ====================================================================
0662ed52e814f8f08ef0e09956413a792584eddffuankg *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * This software consists of voluntary contributions made by many
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * individuals on behalf of the Apache Software Foundation. For more
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * information on the Apache Software Foundation, please see
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * <http://www.apache.org/>.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Portions of this software are based upon public domain software
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * originally written at the National Center for Supercomputing Applications,
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * University of Illinois, Urbana-Champaign.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * mod_mime_magic: MIME type lookup via file magic numbers
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Copyright (c) 1996-1997 Cisco Systems, Inc.
70953fb44a7140fe206c3a5f011e24209c8c5c6abnicholes *
70953fb44a7140fe206c3a5f011e24209c8c5c6abnicholes * This software was submitted by Cisco Systems to the Apache Software Foundation in July
8d6e239d0e0aa0593fd93b4fef193d8c51b61b3cfuankg * 1997. Future revisions and derivatives of this source code must
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * acknowledge Cisco Systems as the original contributor of this module.
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * All other licensing and usage conditions are those of the Apache Software Foundation.
b387b9d37fc71c534f4718777454a8f5a1169017fuankg *
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * Some of this code is derived from the free version of the file command
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * originally posted to comp.sources.unix. Copyright info for that program
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * is included below as required.
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * ---------------------------------------------------------------------------
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * - Copyright (c) Ian F. Darwin, 1987. Written by Ian F. Darwin.
b387b9d37fc71c534f4718777454a8f5a1169017fuankg *
8d6e239d0e0aa0593fd93b4fef193d8c51b61b3cfuankg * This software is not subject to any license of the American Telephone and
8d6e239d0e0aa0593fd93b4fef193d8c51b61b3cfuankg * Telegraph Company or of the Regents of the University of California.
bfd312b5e6b4bf7113ef8f655b044f93f5c18f28fuankg *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Permission is granted to anyone to use this software for any purpose on any
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * computer system, and to alter it and redistribute it freely, subject to
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * the following restrictions:
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * 1. The author is not responsible for the consequences of use of this
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * software, no matter how awful, even if they arise from flaws in it.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg * 2. The origin of this software must not be misrepresented, either by
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * explicit claim or by omission. Since few users ever read sources, credits
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * must appear in the documentation.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * 3. Altered versions must be plainly marked as such, and must not be
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * misrepresented as being the original software. Since few users ever read
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * sources, credits must appear in the documentation.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * 4. This notice may not be removed or altered.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * -------------------------------------------------------------------------
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * For compliance with Mr Darwin's terms: this has been very significantly
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * modified from the free "file" command.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - all-in-one file for compilation convenience when moving from one
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * version of Apache to the next.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - Memory allocation is done through the Apache API's apr_pool_t structure.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - All functions have had necessary Apache API request or server
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * structures passed to them where necessary to call other Apache API
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * routines. (i.e. usually for logging, files, or memory allocation in
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * itself or a called function.)
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - struct magic has been converted from an array to a single-ended linked
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * list because it only grows one record at a time, it's only accessed
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * sequentially, and the Apache API has no equivalent of realloc().
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - Functions have been changed to get their parameters from the server
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * configuration instead of globals. (It should be reentrant now but has
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * not been tested in a threaded environment.)
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - Places where it used to print results to stdout now saves them in a
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * list where they're used to set the MIME type in the Apache request
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * record.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * - Command-line flags have been removed since they will never be used here.
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Ian Kluft <ikluft@cisco.com>
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Engineering Information Framework
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Central Engineering
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Cisco Systems, Inc.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * San Jose, CA, USA
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Initial installation July/August 1996
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Misc bug fixes May 1997
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Submission to Apache Software Foundation July 1997
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "apr.h"
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg#include "apr_strings.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "apr_lib.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define APR_WANT_STRFUNC
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "apr_want.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#if APR_HAVE_UNISTD_H
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include <unistd.h>
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#endif
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "ap_config.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "httpd.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "http_config.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "http_request.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "http_core.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "http_log.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "http_protocol.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include "util_script.h"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/* ### this isn't set by configure? does anybody set this? */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#ifdef HAVE_UTIME_H
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#include <utime.h>
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#endif
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * data structures and related constants
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define MODNAME "mod_mime_magic"
6c080a25f5991f40225209541c989d7e76c4a39dbnicholes#define MIME_MAGIC_DEBUG 0
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define MIME_BINARY_UNKNOWN "application/octet-stream"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define MIME_TEXT_UNKNOWN "text/plain"
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define MAXMIMESTRING 256
b387b9d37fc71c534f4718777454a8f5a1169017fuankg
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes/* HOWMANY must be at least 4096 to make gzip -dcq work */
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes#define HOWMANY 4096
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes/* SMALL_HOWMANY limits how much work we do to figure out text files */
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes#define SMALL_HOWMANY 1024
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes#define MAXDESC 50 /* max leng of text description */
036436f4f4cdcd76186c0058891216545967043bbnicholes#define MAXstring 64 /* max leng of "string" types */
41022996c916eb4ab2ec3204eb491b64779eb100bnicholes
41022996c916eb4ab2ec3204eb491b64779eb100bnicholesstruct magic {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes struct magic *next; /* link to next entry */
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg int lineno; /* line number from magic file */
0662ed52e814f8f08ef0e09956413a792584eddffuankg
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes short flag;
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg#define INDIR 1 /* if '>(...)' appears, */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define UNSIGNED 2 /* comparison is unsigned */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes short cont_level; /* level of ">" */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes struct {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char type; /* byte short long */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes long offset; /* offset from indirection */
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg } in;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes long offset; /* offset to magic number */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned char reln; /* relation (0=eq, '>'=gt, etc) */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char type; /* int, short, long or string. */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char vallen; /* length of string value, if any */
0662ed52e814f8f08ef0e09956413a792584eddffuankg#define BYTE 1
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define SHORT 2
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define LONG 4
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define STRING 5
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define DATE 6
0662ed52e814f8f08ef0e09956413a792584eddffuankg#define BESHORT 7
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define BELONG 8
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define BEDATE 9
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define LESHORT 10
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define LELONG 11
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define LEDATE 12
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes union VALUETYPE {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned char b;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned short h;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned long l;
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg char s[MAXstring];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned char hs[2]; /* 2 bytes of a fixed-endian "short" */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned char hl[4]; /* 2 bytes of a fixed-endian "long" */
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg } value; /* either number or string */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned long mask; /* mask before comparison with value */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char nospflag; /* supress space character */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg /* NOTE: this string is suspected of overrunning - find it! */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char desc[MAXDESC]; /* description */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes};
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * data structures for tar file recognition
b387b9d37fc71c534f4718777454a8f5a1169017fuankg * --------------------------------------------------------------------------
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Header file for public domain tar (tape archive) program.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * @(#)tar.h 1.20 86/10/29 Public Domain. Created 25 August 1985 by John
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Gilmore, ihnp4!hoptoad!gnu.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Header block on tape.
ea23d28432dc58e3ac7072dbcaf3d979dcb54c08fuankg *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * I'm going to use traditional DP naming conventions here. A "block" is a big
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * chunk of stuff that we do I/O on. A "record" is a piece of info that we
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * care about. Typically many "record"s fit into a "block".
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define RECORDSIZE 512
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define NAMSIZ 100
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define TUNMLEN 32
d5ef50bb5810983012435957be0680bde34d1e44fuankg#define TGNMLEN 32
d5ef50bb5810983012435957be0680bde34d1e44fuankg
d5ef50bb5810983012435957be0680bde34d1e44fuankgunion record {
d5ef50bb5810983012435957be0680bde34d1e44fuankg char charptr[RECORDSIZE];
d5ef50bb5810983012435957be0680bde34d1e44fuankg struct header {
d5ef50bb5810983012435957be0680bde34d1e44fuankg char name[NAMSIZ];
d5ef50bb5810983012435957be0680bde34d1e44fuankg char mode[8];
d5ef50bb5810983012435957be0680bde34d1e44fuankg char uid[8];
d5ef50bb5810983012435957be0680bde34d1e44fuankg char gid[8];
d5ef50bb5810983012435957be0680bde34d1e44fuankg char size[12];
d5ef50bb5810983012435957be0680bde34d1e44fuankg char mtime[12];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char chksum[8];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char linkflag;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char linkname[NAMSIZ];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char magic[8];
56ab8639aed4d3b2f031d9c1160c5f40af01bdebjerenkrantz char uname[TUNMLEN];
286fed73f9d1474652034465d4048247c6e7341fbnicholes char gname[TGNMLEN];
be88e49281c5becee364ab9c6a0576f9b9844e0fbnicholes char devmajor[8];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char devminor[8];
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes } header;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes};
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
56ab8639aed4d3b2f031d9c1160c5f40af01bdebjerenkrantz/* The magic field is filled with this if uname and gname are valid. */
56ab8639aed4d3b2f031d9c1160c5f40af01bdebjerenkrantz#define TMAGIC "ustar " /* 7 chars and a null */
56ab8639aed4d3b2f031d9c1160c5f40af01bdebjerenkrantz
56ab8639aed4d3b2f031d9c1160c5f40af01bdebjerenkrantz/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * file-function prototypes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int ascmagic(request_rec *, unsigned char *, apr_size_t);
f7d723f1ad88ed006c6caf4c2c6604b7c59dd172bnicholesstatic int is_tar(unsigned char *, apr_size_t);
f7d723f1ad88ed006c6caf4c2c6604b7c59dd172bnicholesstatic int softmagic(request_rec *, unsigned char *, apr_size_t);
4f935de4900dc064a1e145be5e48f6af77ac24fcbnicholesstatic void tryit(request_rec *, unsigned char *, apr_size_t, int);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int zmagic(request_rec *, unsigned char *, apr_size_t);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int getvalue(server_rec *, struct magic *, char **);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int hextoint(int);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic char *getstr(server_rec *, char *, char *, int, int *);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int parse(server_rec *, apr_pool_t *p, char *, int);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
e961abd49ab1b184b356f63591d37083a5651451bnicholesstatic int match(request_rec *, unsigned char *, apr_size_t);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int mget(request_rec *, union VALUETYPE *, unsigned char *,
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes struct magic *, apr_size_t);
5f2aaa2483c4526d7930df4a0e5844c1b7b6c9c0fuankgstatic int mcheck(request_rec *, union VALUETYPE *, struct magic *);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic void mprint(request_rec *, union VALUETYPE *, struct magic *);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int uncompress(request_rec *, int,
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes unsigned char **, apr_size_t);
440cda576ca9ff6476e4a04bdb253c5023da15eejerenkrantzstatic long from_oct(int, char *);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic int fsmagic(request_rec *r, const char *fn);
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * includes for ASCII substring recognition formerly "names.h" in file
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * command
4a59e9d628fb857a45d516ad1cdc2a3499427e97fuankg *
6f2fa094a76c27135a9825ca9492f9db0a1a3bc9bnicholes * Original notes: names and types used by ascmagic in file(1). These tokens are
a400161a259d6d9fd47a47fd9a4bb413fd85e3bcsf * here because they can appear anywhere in the first HOWMANY bytes, while
a400161a259d6d9fd47a47fd9a4bb413fd85e3bcsf * tokens in /etc/magic must appear at fixed offsets into the file. Don't
a400161a259d6d9fd47a47fd9a4bb413fd85e3bcsf * make HOWMANY too high unless you have a very fast CPU.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
91f672664302529bb620e3265cccd861661d258cbnicholes/* these types are used to index the apr_table_t 'types': keep em in sync! */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/* HTML inserted in first because this is a web server module now */
3163ad7b2076b0f6961dc1a1ddaa06b240eecb7cjorton#define L_HTML 0 /* HTML */
62c14b2cab42c51bee08809b7f22e34edb48fb56fuankg#define L_C 1 /* first and foremost on UNIX */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_FORT 2 /* the oldest one */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_MAKE 3 /* Makefiles */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_PLI 4 /* PL/1 */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_MACH 5 /* some kinda assembler */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_ENG 6 /* English */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes#define L_PAS 7 /* Pascal */
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes#define L_MAIL 8 /* Electronic mail */
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes#define L_NEWS 9 /* Usenet Netnews */
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes
ce22ce4743d79a889dca64df4459c598e2c188c7fuankgstatic char *types[] =
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes{
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes "text/html", /* HTML */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "text/plain", /* "c program text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "text/plain", /* "fortran program text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "text/plain", /* "make commands text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "text/plain", /* "pl/1 program text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "text/plain", /* "assembler program text", */
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "text/plain", /* "English text", */
cf7ca2f9eaa6523fefcccba4287b91637391fb51fuankg "text/plain", /* "pascal program text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "message/rfc822", /* "mail text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "message/news", /* "news text", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "application/binary", /* "can't happen error on names.h/types", */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes 0
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes};
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholesstatic struct names {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes char *name;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes short type;
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes} names[] = {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes /* These must be sorted by eye for optimal hit rate */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes /* Add to this list only after substantial meditation */
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<html>", L_HTML
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<HTML>", L_HTML
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<head>", L_HTML
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<HEAD>", L_HTML
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<title>", L_HTML
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "<TITLE>", L_HTML
fd6ce1276bdbefbd3c32049553c10c41beb5ed15fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
8d6e239d0e0aa0593fd93b4fef193d8c51b61b3cfuankg "<h1>", L_HTML
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes "<H1>", L_HTML
e76fdcdfb8994ad70776526f50fa013b3e9a6033bnicholes },
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes {
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes "<!--", L_HTML
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg },
9558e9fdb620dd6f42ca93beac6c3ab734086706bnicholes {
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg "<!DOCTYPE HTML", L_HTML
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "/*", L_C
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes }, /* must precede "The", "the", etc. */
fd6ce1276bdbefbd3c32049553c10c41beb5ed15fuankg {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "#include", L_C
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg },
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "char", L_C
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "The", L_ENG
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "the", L_ENG
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "double", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "extern", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "float", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "real", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg {
ea23d28432dc58e3ac7072dbcaf3d979dcb54c08fuankg "struct", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg {
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg "union", L_C
8492a2583e10c69f40de92f9d5da884b64d9f379fuankg },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "CFLAGS", L_MAKE
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "LDFLAGS", L_MAKE
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "all:", L_MAKE
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg {
0662ed52e814f8f08ef0e09956413a792584eddffuankg ".PRECIOUS", L_MAKE
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
b65ed0988706147773876bc16386d4a8ce942392fuankg /*
8d6e239d0e0aa0593fd93b4fef193d8c51b61b3cfuankg * Too many files of text have these words in them. Find another way to
25b3aa26ee94824bb1e9ff2631aa1588b37e5f72fuankg * recognize Fortrash.
b819d97849e89dad276b0e079414a1012aa1ead4fuankg */
b819d97849e89dad276b0e079414a1012aa1ead4fuankg#ifdef NOTDEF
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "subroutine", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "function", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "block", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "common", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "dimension", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "integer", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "data", L_FORT
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
00d1c0c914426a97022d8205a875c48b211001c2fuankg#endif /* NOTDEF */
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg ".ascii", L_MACH
e6dd71992459d05a676b98b7963423dc5dc1e24aminfrin },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
078e5d9e9c559a4375522ad4709eec6cfb6f3352rjung ".asciiz", L_MACH
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg ".byte", L_MACH
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
0f7cc4b1d3c42262bcdced99f682778963e83ea7bnicholes ".even", L_MACH
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg ".globl", L_MACH
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "clr", L_MACH
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "(input,", L_PAS
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "dcl", L_PLI
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "Received:", L_MAIL
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg ">From", L_MAIL
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "Return-Path:", L_MAIL
b819d97849e89dad276b0e079414a1012aa1ead4fuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg "Cc:", L_MAIL
273e1eccdc9e5b94f1e3e13e3ffca7360b6f461fbnicholes },
b387b9d37fc71c534f4718777454a8f5a1169017fuankg {
b387b9d37fc71c534f4718777454a8f5a1169017fuankg "Newsgroups:", L_NEWS
0662ed52e814f8f08ef0e09956413a792584eddffuankg },
b819d97849e89dad276b0e079414a1012aa1ead4fuankg {
b819d97849e89dad276b0e079414a1012aa1ead4fuankg "Path:", L_NEWS
273e1eccdc9e5b94f1e3e13e3ffca7360b6f461fbnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes "Organization:", L_NEWS
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes },
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes {
8410c53aaf5e0372a19d5f4d2bc696b9c609ce3cbnicholes NULL, 0
8410c53aaf5e0372a19d5f4d2bc696b9c609ce3cbnicholes }
bfd312b5e6b4bf7113ef8f655b044f93f5c18f28fuankg};
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes
398f7be4e4ef696ddf6803a26e9c2c0589f090d2fuankg#define NNAMES ((sizeof(names)/sizeof(struct names)) - 1)
398f7be4e4ef696ddf6803a26e9c2c0589f090d2fuankg
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes/*
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * Result String List (RSL)
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes *
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * The file(1) command prints its output. Instead, we store the various
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes * "printed" strings in a list (allocating memory as we go) and concatenate
0662ed52e814f8f08ef0e09956413a792584eddffuankg * them at the end when we finally know how much space they'll need.
bb2b38cd44b032118359afbc743efbea12f48e61bnicholes */
0662ed52e814f8f08ef0e09956413a792584eddffuankg
25b3aa26ee94824bb1e9ff2631aa1588b37e5f72fuankgtypedef struct magic_rsl_s {
ce22ce4743d79a889dca64df4459c598e2c188c7fuankg 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;
unsigned suf_recursion; /* recursion depth in suffix check */
} magic_req_rec;
/*
* configuration functions - called by Apache API routines
*/
module 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->magicfile = add->magicfile ? add->magicfile : base->magicfile;
new->magic = NULL;
new->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->server->module_config,
&mime_magic_module);
if (!conf) {
return MODNAME ": server structure not allocated";
}
conf->magicfile = arg;
return NULL;
}
/*
* configuration file commands - exported to Apache API
*/
static const command_rec mime_magic_cmds[] =
{
AP_INIT_TAKE1("MimeMagicFile", set_magicfile, NULL, RSRC_CONF,
"Path to MIME Magic file (in file(1) format)"),
{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'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->pool,
sizeof(magic_req_rec));
req_dat->head = req_dat->tail = (magic_rsl *) NULL;
ap_set_module_config(r->request_config, &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 "str" */
static int magic_rsl_add(request_rec *r, char *str)
{
magic_req_rec *req_dat = (magic_req_rec *)
ap_get_module_config(r->request_config, &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_NOERRNO | APLOG_ERR, APR_EINVAL, r,
MODNAME ": request config should not be NULL");
if (!(req_dat = magic_set_config(r))) {
/* failure */
return -1;
}
}
/* allocate the list entry */
rsl = (magic_rsl *) apr_palloc(r->pool, sizeof(magic_rsl));
/* fill it */
rsl->str = str;
rsl->next = (magic_rsl *) NULL;
/* append to the list */
if (req_dat->head && req_dat->tail) {
req_dat->tail->next = rsl;
req_dat->tail = rsl;
}
else {
req_dat->head = req_dat->tail = rsl;
}
/* success */
return 0;
}
/* RSL hook for puts-type functions */
static int magic_rsl_puts(request_rec *r, 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, strdup(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't do this much */
str[0] = c;
str[1] = '\0';
return magic_rsl_add(r, 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->request_config, &mime_magic_module);
/* allocate the result string */
result = (char *) apr_palloc(r->pool, len + 1);
/* loop through and collect the string */
res_pos = 0;
for (frag = req_dat->head, cur_frag = 0;
frag->next;
frag = frag->next, cur_frag++) {
/* loop to the first fragment */
if (cur_frag < start_frag)
continue;
/* loop through and collect chars */
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;
}
}
}
}
/* clean up and return */
result[res_pos] = 0;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": rsl_strdup() %d chars: %s", 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 */
magic_rsl *frag; /* list-traversal pointer */
rsl_states state;
magic_req_rec *req_dat = (magic_req_rec *)
ap_get_module_config(r->request_config, &mime_magic_module);
/* check if we have a result */
if (!req_dat || !req_dat->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->head, cur_frag = 0;
frag && frag->next;
frag = frag->next, cur_frag++) {
/* loop through the characters in the fragment */
for (cur_pos = 0; frag->str[cur_pos]; cur_pos++) {
if (apr_isspace(frag->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're done */
frag = req_dat->tail;
break;
}
else {
/* should not be possible */
/* abandon malfunctioning module */
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": bad state %d (ws)", state);
return DECLINED;
}
/* NOTREACHED */
}
else if (state == rsl_type &&
frag->str[cur_pos] == '/') {
/* 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_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": bad state %d (ns)", state);
return DECLINED;
}
/* NOTREACHED */
}
/* NOTREACHED */
}
}
/* if we ended prior to state rsl_subtype, we had incomplete info */
if (state != rsl_subtype && state != rsl_separator &&
state != rsl_encoding) {
/* defer to other modules */
return DECLINED;
}
/* save the info in the request record */
if (state == rsl_subtype || state == rsl_encoding ||
state == rsl_encoding) {
char *tmp;
tmp = rsl_strdup(r, type_frag, type_pos, type_len);
/* XXX: this could be done at config time I'm sure... but I'm
* confused by all this magic_rsl stuff. -djg */
ap_content_type_tolower(tmp);
r->content_type = tmp;
}
if (state == rsl_encoding) {
char *tmp;
tmp = rsl_strdup(r, encoding_frag,
encoding_pos, encoding_len);
/* XXX: this could be done at config time I'm sure... but I'm
* confused by all this magic_rsl stuff. -djg */
ap_str_tolower(tmp);
r->content_encoding = tmp;
}
/* detect memory allocation errors */
if (!r->content_type ||
(state == rsl_encoding && !r->content_encoding)) {
return HTTP_INTERNAL_SERVER_ERROR;
}
/* success! */
return OK;
}
/*
* magic_process - process input file r Apache API request record
* (formerly called "process" 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 '\0' */
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->filename))) {
case DONE:
magic_rsl_putchar(r, '\n');
return OK;
case OK:
break;
default:
/* fatal error, bail out */
return result;
}
if (apr_file_open(&fd, r->filename, APR_READ, APR_OS_DEFAULT, r->pool) != APR_SUCCESS) {
/* We can't open it, but we were able to stat it. */
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
MODNAME ": can't read `%s'", r->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, &nbytes)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, result, r,
MODNAME ": read failed: %s", r->filename);
return HTTP_INTERNAL_SERVER_ERROR;
}
if (nbytes == 0)
magic_rsl_puts(r, MIME_TEXT_UNKNOWN);
else {
buf[nbytes++] = '\0'; /* null-terminate it */
tryit(r, buf, nbytes, 1);
}
(void) apr_file_close(fd);
(void) magic_rsl_putchar(r, '\n');
return OK;
}
static void 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;
}
/*
* try tests in /etc/magic (or surrogate magic file)
*/
if (softmagic(r, buf, nb) == 1)
return;
/*
* try known keywords, check for ascii-ness too.
*/
if (ascmagic(r, buf, nb) == 1)
return;
/*
* abandon hope, all ye who remain here
*/
magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
}
#define EATAB {while (apr_isspace((unsigned char) *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->module_config, &mime_magic_module);
const char *fname = ap_server_root_relative(p, conf->magicfile);
result = apr_file_open(&f, fname, APR_READ | APR_BUFFERED, APR_OS_DEFAULT, p);
if (result != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, result, s,
MODNAME ": can't read magic file %s", fname);
return -1;
}
/* set up the magic list (empty) */
conf->magic = conf->last = NULL;
/* parse it */
for (lineno = 1; apr_file_gets(line, BUFSIZ, f) == APR_SUCCESS; lineno++) {
int ws_offset;
/* delete newline */
if (line[0]) {
line[strlen(line) - 1] = '\0';
}
/* skip leading whitespace */
ws_offset = 0;
while (line[ws_offset] && apr_isspace(line[ws_offset])) {
ws_offset++;
}
/* skip blank lines */
if (line[ws_offset] == 0) {
continue;
}
/* comment, do not parse */
if (line[ws_offset] == '#')
continue;
#if MIME_MAGIC_DEBUG
/* if we get here, we'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_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": apprentice conf=%x file=%s m=%s m->next=%s last=%s",
conf,
conf->magicfile ? conf->magicfile : "NULL",
conf->magic ? "set" : "NULL",
(conf->magic && conf->magic->next) ? "set" : "NULL",
conf->last ? "set" : "NULL");
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": apprentice read %d lines, %d rules, %d errors",
lineno, rule, errs);
#endif
#if MIME_MAGIC_DEBUG
prevm = 0;
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": apprentice test");
for (m = conf->magic; m; m = m->next) {
if (apr_isprint((((unsigned long) m) >> 24) & 255) &&
apr_isprint((((unsigned long) m) >> 16) & 255) &&
apr_isprint((((unsigned long) m) >> 8) & 255) &&
apr_isprint(((unsigned long) m) & 255)) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": apprentice: POINTER CLOBBERED! "
"m=\"%c%c%c%c\" line=%d",
(((unsigned long) m) >> 24) & 255,
(((unsigned long) m) >> 16) & 255,
(((unsigned long) m) >> 8) & 255,
((unsigned long) m) & 255,
prevm ? prevm->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->flag & UNSIGNED))
switch (m->type) {
/*
* Do not remove the casts below. They are vital. When later
* compared with the data, the sign extension must have happened.
*/
case 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_NOERRNO | APLOG_ERR, 0, s,
MODNAME ": can't happen: m->type=%d", m->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->module_config, &mime_magic_module);
/* allocate magic structure entry */
m = (struct magic *) apr_pcalloc(p, sizeof(struct magic));
/* append to linked list */
m->next = NULL;
if (!conf->magic || !conf->last) {
conf->magic = conf->last = m;
}
else {
conf->last->next = m;
conf->last = m;
}
/* set values in magic structure */
m->flag = 0;
m->cont_level = 0;
m->lineno = lineno;
while (*l == '>') {
++l; /* step over */
m->cont_level++;
}
if (m->cont_level != 0 && *l == '(') {
++l; /* step over */
m->flag |= INDIR;
}
/* get offset, then skip over it */
m->offset = (int) strtol(l, &t, 0);
if (l == t) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, serv,
MODNAME ": offset %s invalid", l);
}
l = t;
if (m->flag & INDIR) {
m->in.type = LONG;
m->in.offset = 0;
/*
* read [.lbs][+-]nnnnn)
*/
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:
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, serv,
MODNAME ": indirect offset type %c invalid", *l);
break;
}
l++;
}
s = l;
if (*l == '+' || *l == '-')
l++;
if (apr_isdigit((unsigned char) *l)) {
m->in.offset = strtol(l, &t, 0);
if (*s == '-')
m->in.offset = -m->in.offset;
}
else
t = l;
if (*t++ != ')') {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, serv,
MODNAME ": missing ')' in indirect offset");
}
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 == 'u') {
++l;
m->flag |= UNSIGNED;
}
/* get type, skip it */
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 {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, serv,
MODNAME ": type %s invalid", l);
return -1;
}
/* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
if (*l == '&') {
++l;
m->mask = signextend(serv, m, strtol(l, &l, 0));
}
else
m->mask = ~0L;
EATAB;
switch (*l) {
case '>':
case '<':
/* Old-style anding: "0 byte &0x80 dynamically linked" */
case '&':
case '^':
case '=':
m->reln = *l;
++l;
break;
case '!':
if (m->type != STRING) {
m->reln = *l;
++l;
break;
}
/* FALL THROUGH */
default:
if (*l == 'x' && apr_isspace((unsigned char) l[1])) {
m->reln = *l;
++l;
goto GetDesc; /* Bill The Cat */
}
m->reln = '=';
break;
}
EATAB;
if (getvalue(serv, m, &l))
return -1;
/*
* now get last part - the description
*/
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;
strncpy(m->desc, l, sizeof(m->desc) - 1);
m->desc[sizeof(m->desc) - 1] = '\0';
#if MIME_MAGIC_DEBUG
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, serv,
MODNAME ": parse line=%d m=%x next=%x cont=%d desc=%s",
lineno, m, m->next, m->cont_level, m->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->type == STRING) {
*p = getstr(s, *p, m->value.s, sizeof(m->value.s), &slen);
m->vallen = slen;
}
else if (m->reln != 'x')
m->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 "p", 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++) != '\0') {
if (apr_isspace((unsigned char) c))
break;
if (p >= pmax) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, serv,
MODNAME ": 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;
/* \ and up to 3 octal digits */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
val = c - '0';
c = *s++; /* try for 2 */
if (c >= '0' && c <= '7') {
val = (val << 3) | (c - '0');
c = *s++; /* try for 3 */
if (c >= '0' && c <= '7')
val = (val << 3) | (c - '0');
else
--s;
}
else
--s;
*p++ = (char) val;
break;
/* \x and up to 3 hex digits */
case 'x':
val = 'x'; /* Default if no digits */
c = hextoint(*s++); /* Get next char */
if (c >= 0) {
val = c;
c = hextoint(*s++);
if (c >= 0) {
val = (val << 4) + c;
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;
}
/* Single hex char to int; -1 if not a hex char. */
static int hextoint(int c)
{
if (apr_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;
}
/*
* return DONE to indicate it's been handled
* return OK to indicate it'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->finfo.filetype) {
case APR_DIR:
magic_rsl_puts(r, DIR_MAGIC_TYPE);
return DONE;
case APR_CHR:
/*
* (void) magic_rsl_printf(r,"character special (%d/%d)",
* major(sb->st_rdev), minor(sb->st_rdev));
*/
(void) magic_rsl_puts(r, MIME_BINARY_UNKNOWN);
return DONE;
case APR_BLK:
/*
* (void) magic_rsl_printf(r,"block special (%d/%d)",
* major(sb->st_rdev), minor(sb->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,"fifo (named pipe)");
*/
(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_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": broken symlink (%s)", 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_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": invalid file type %d.", r->finfo.filetype);
return HTTP_INTERNAL_SERVER_ERROR;
}
/*
* regular file, check next possibility
*/
if (r->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'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're seeing.
*
* Continuations at the current level are processed as, if we see one, there'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->server->module_config, &mime_magic_module);
struct magic *m;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": match conf=%x file=%s m=%s m->next=%s last=%s",
conf,
conf->magicfile ? conf->magicfile : "NULL",
conf->magic ? "set" : "NULL",
(conf->magic && conf->magic->next) ? "set" : "NULL",
conf->last ? "set" : "NULL");
#endif
#if MIME_MAGIC_DEBUG
for (m = conf->magic; m; m = m->next) {
if (apr_isprint((((unsigned long) m) >> 24) & 255) &&
apr_isprint((((unsigned long) m) >> 16) & 255) &&
apr_isprint((((unsigned long) m) >> 8) & 255) &&
apr_isprint(((unsigned long) m) & 255)) {
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": match: POINTER CLOBBERED! "
"m=\"%c%c%c%c\"",
(((unsigned long) m) >> 24) & 255,
(((unsigned long) m) >> 16) & 255,
(((unsigned long) m) >> 8) & 255,
((unsigned long) m) & 255);
break;
}
}
#endif
for (m = conf->magic; m; m = m->next) {
#if MIME_MAGIC_DEBUG
rule_counter++;
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": line=%d desc=%s", m->lineno, m->desc);
#endif
/* check if main entry matches */
if (!mget(r, &p, s, m, nbytes) ||
!mcheck(r, &p, m)) {
struct magic *m_cont;
/*
* main entry didn't match, flush its continuations
*/
if (!m->next || (m->next->cont_level == 0)) {
continue;
}
m_cont = m->next;
while (m_cont && (m_cont->cont_level != 0)) {
#if MIME_MAGIC_DEBUG
rule_counter++;
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": line=%d mc=%x mc->next=%x cont=%d desc=%s",
m_cont->lineno, m_cont,
m_cont->next, m_cont->cont_level,
m_cont->desc);
#endif
/*
* this trick allows us to keep *m in sync when the continue
* advances the pointer
*/
m = m_cont;
m_cont = m_cont->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_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": rule matched, line=%d type=%d %s",
m->lineno, m->type,
(m->type == STRING) ? m->value.s : "");
#endif
/* print the match */
mprint(r, &p, m);
/*
* If we printed something, we'll need to print a blank before we
* print something else.
*/
if (m->desc[0])
need_separator = 1;
/* and any continuations that match */
cont_level++;
/*
* while (m && m->next && m->next->cont_level != 0 && ( m = m->next
* ))
*/
m = m->next;
while (m && (m->cont_level != 0)) {
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": match line=%d cont=%d type=%d %s",
m->lineno, m->cont_level, m->type,
(m->type == STRING) ? m->value.s : "");
#endif
if (cont_level >= m->cont_level) {
if (cont_level > m->cont_level) {
/*
* We're at the end of the level "cont_level"
* continuations.
*/
cont_level = m->cont_level;
}
if (mget(r, &p, s, m, nbytes) &&
mcheck(r, &p, m)) {
/*
* This continuation matched. Print its message, with a
* blank before it if the previous item printed and this
* item isn't empty.
*/
/* space if previous printed */
if (need_separator
&& (m->nospflag == 0)
&& (m->desc[0] != '\0')
) {
(void) magic_rsl_putchar(r, ' ');
need_separator = 0;
}
mprint(r, &p, m);
if (m->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->next;
}
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": matched after %d rules", rule_counter);
#endif
return 1; /* all through */
}
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": failed after %d rules", rule_counter);
#endif
return 0; /* no match at all */
}
static void mprint(request_rec *r, 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(r, m->desc, m->value.s);
}
else {
(void) magic_rsl_printf(r, m->desc, p->s);
}
return;
case DATE:
case BEDATE:
case LEDATE:
/* XXX: not multithread safe */
pp = ctime((time_t *) & p->l);
if ((rt = strchr(pp, '\n')) != NULL)
*rt = '\0';
(void) magic_rsl_printf(r, m->desc, pp);
return;
default:
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": invalid m->type (%d) in mprint().",
m->type);
return;
}
v = signextend(r->server, m, v) & m->mask;
(void) magic_rsl_printf(r, m->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->type) {
case BYTE:
case SHORT:
case LONG:
case DATE:
return 1;
case STRING:
/* Null terminate and eat the return */
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:
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": invalid type %d in mconvert().", m->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->offset;
if (offset + sizeof(union VALUETYPE) > nbytes)
return 0;
memcpy(p, s + offset, sizeof(union VALUETYPE));
if (!mconvert(r, 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 + sizeof(union VALUETYPE) > 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->value.l;
register unsigned long v;
int matched;
if ((m->value.s[0] == 'x') && (m->value.s[1] == '\0')) {
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": 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;
/*
* What we want here is: v = strncmp(m->value.s, p->s, m->vallen);
* but ignoring any nulls. bcmp doesn't give -/+/0 and isn't
* universally available anyway.
*/
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:
/* bogosity, pretend that it just wasn't a match */
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": invalid type %d in mcheck().", m->type);
return 0;
}
v = signextend(r->server, m, v) & m->mask;
switch (m->reln) {
case 'x':
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%lu == *any* = 1", v);
#endif
matched = 1;
break;
case '!':
matched = v != l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%lu != %lu = %d", v, l, matched);
#endif
break;
case '=':
matched = v == l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%lu == %lu = %d", v, l, matched);
#endif
break;
case '>':
if (m->flag & UNSIGNED) {
matched = v > l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%lu > %lu = %d", v, l, matched);
#endif
}
else {
matched = (long) v > (long) l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%ld > %ld = %d", v, l, matched);
#endif
}
break;
case '<':
if (m->flag & UNSIGNED) {
matched = v < l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%lu < %lu = %d", v, l, matched);
#endif
}
else {
matched = (long) v < (long) l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"%ld < %ld = %d", v, l, matched);
#endif
}
break;
case '&':
matched = (v & l) == l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"((%lx & %lx) == %lx) = %d", v, l, l, matched);
#endif
break;
case '^':
matched = (v & l) != l;
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
"((%lx & %lx) != %lx) = %d", v, l, l, matched);
#endif
break;
default:
/* bogosity, pretend it didn't match */
matched = 0;
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_ERR, 0, r,
MODNAME ": mcheck: can't happen: invalid relation %d.",
m->reln);
break;
}
return matched;
}
/* an optimization over plain strcmp() */
#define STREQ(a, b) (*(a) == *(b) && 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[HOWMANY + 1]; /* one extra for terminating '\0' */
char *token;
register struct names *p;
int small_nbytes;
/* these are easy, do them first */
/*
* for troff, look for . + letter + letter or .\"; this must be done to
* disambiguate tar archives' ./file and other trash from real troff
* input.
*/
if (*buf == '.') {
unsigned char *tp = buf + 1;
while (apr_isspace(*tp))
++tp; /* skip leading whitespace */
if ((apr_isalnum(*tp) || *tp == '\\') &&
(apr_isalnum(*(tp + 1)) || *tp == '"')) {
magic_rsl_puts(r, "application/x-troff");
return 1;
}
}
if ((*buf == 'c' || *buf == 'C') && apr_isspace(*(buf + 1))) {
/* Fortran */
magic_rsl_puts(r, "text/plain");
return 1;
}
/* look for tokens from names.h - this is expensive!, so we'll limit
* ourselves to only SMALL_HOWMANY bytes */
small_nbytes = (nbytes > SMALL_HOWMANY) ? SMALL_HOWMANY : nbytes;
/* make a copy of the buffer here because strtok() will destroy it */
s = (unsigned char *) memcpy(nbuf, buf, small_nbytes);
s[small_nbytes] = '\0';
has_escapes = (memchr(s, '\033', small_nbytes) != NULL);
/* XXX: not multithread safe */
while ((token = strtok((char *) s, " \t\n\r\f")) != NULL) {
s = NULL; /* make strtok() keep on tokin' */
for (p = names; p < names + NNAMES; p++) {
if (STREQ(p->name, token)) {
magic_rsl_puts(r, types[p->type]);
if (has_escapes)
magic_rsl_puts(r, " (with escape sequences)");
return 1;
}
}
}
switch (is_tar(buf, nbytes)) {
case 1:
/* V7 tar archive */
magic_rsl_puts(r, "application/x-tar");
return 1;
case 2:
/* POSIX tar archive */
magic_rsl_puts(r, "application/x-tar");
return 1;
}
/* all else fails, but it is ascii... */
if (has_escapes) {
/* text with escape sequences */
/* we leave this open for further differentiation later */
magic_rsl_puts(r, "text/plain");
}
else {
/* plain text */
magic_rsl_puts(r, "text/plain");
}
return 1;
}
/*
* 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 struct {
char *magic;
int maglen;
char *argv[3];
int silent;
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
*/
{
"\037\235", 2, {
"gzip", "-dcq", NULL
}, 0, "x-compress"
},
{
"\037\213", 2, {
"gzip", "-dcq", NULL
}, 1, "x-gzip"
},
/*
* XXX pcat does not work, cause I don't know how to make it read stdin,
* so we use gzip
*/
{
"\037\036", 2, {
"gzip", "-dcq", NULL
}, 0, "x-gzip"
},
};
static int 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 < ncompr; i++) {
if (nbytes < 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, &newbuf, nbytes)) > 0) {
tryit(r, newbuf, newsize, 0);
/* set encoding type in the request record */
r->content_encoding = compr[i].encoding;
}
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];
const char *const *env;
request_rec *r = parm->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->method].silent?
* Should we create the err pipe, read it, and copy to the log?
*/
env = (const char *const *)ap_create_environment(child_context, r->subprocess_env);
if ((apr_procattr_create(&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, r->filename) != APR_SUCCESS) ||
(apr_procattr_cmdtype_set(procattr, APR_PROGRAM) != APR_SUCCESS)) {
/* Something bad happened, tell the world. */
ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_ENOPROC, r,
"couldn't setup child process: %s", r->filename);
}
else {
new_argv[0] = compr[parm->method].argv[0];
new_argv[1] = compr[parm->method].argv[1];
new_argv[2] = r->filename;
new_argv[3] = NULL;
procnew = apr_pcalloc(child_context, sizeof(*procnew));
rc = apr_proc_create(procnew, compr[parm->method].argv[0],
new_argv, env, 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,
MODNAME ": could not execute `%s'.",
compr[parm->method].argv[0]);
}
else {
apr_pool_note_subprocess(child_context, procnew, kill_after_timeout);
*pipe_in = procnew->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 indicies with mod_autoindex)
* where we would end up with LOTS of zombies.
*/
if (apr_pool_create(&sub_context, r->pool) != APR_SUCCESS)
return -1;
if ((rv = create_uncompress_child(&parm, sub_context, &pipe_out)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
MODNAME ": couldn't spawn uncompress process: %s", r->uri);
return -1;
}
*newch = (unsigned char *) apr_palloc(r->pool, n);
rv = apr_file_read(pipe_out, *newch, &n);
if (n == 0) {
apr_pool_destroy(sub_context);
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
MODNAME ": read failed %s", r->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) ( ((c) >= '0') && ((c) <= '7') )
/*
* 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 < sizeof(union record))
return 0;
recsum = from_oct(8, header->header.chksum);
sum = 0;
p = header->charptr;
for (i = sizeof(union record); --i >= 0;) {
/*
* We can't use unsigned char here because of old compilers, e.g. V7.
*/
sum += 0xFF & *p++;
}
/* Adjust checksum to count the "chksum" field as blanks. */
for (i = sizeof(header->header.chksum); --i >= 0;)
sum -= 0xFF & header->header.chksum[i];
sum += ' ' * sizeof header->header.chksum;
if (sum != recsum)
return 0; /* Not a tar archive */
if (0 == strcmp(header->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 <= 0)
return -1; /* All blank field */
}
value = 0;
while (digs > 0 && isodigit(*where)) { /* Scan til nonoctal */
value = (value << 3) | (*where++ - '0');
--digs;
}
if (digs > 0 && *where && !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'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_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": revision_suffix checking %s", r->filename);
#endif /* MIME_MAGIC_DEBUG */
/* check for recognized revision suffix */
suffix_pos = strlen(r->filename) - 1;
if (!apr_isdigit(r->filename[suffix_pos])) {
return 0;
}
while (suffix_pos >= 0 && apr_isdigit(r->filename[suffix_pos]))
suffix_pos--;
if (suffix_pos < 0 || r->filename[suffix_pos] != '@') {
return 0;
}
/* perform sub-request for the file name without the suffix */
result = 0;
sub_filename = apr_pstrndup(r->pool, r->filename, suffix_pos);
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": subrequest lookup for %s", 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->content_type) {
r->content_type = apr_pstrdup(r->pool, sub->content_type);
#if MIME_MAGIC_DEBUG
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, r,
MODNAME ": subrequest %s got %s",
sub_filename, r->content_type);
#endif /* MIME_MAGIC_DEBUG */
if (sub->content_encoding)
r->content_encoding =
apr_pstrdup(r->pool, sub->content_encoding);
if (sub->content_language)
r->content_language =
apr_pstrdup(r->pool, sub->content_language);
result = 1;
}
/* clean up */
ap_destroy_sub_req(sub);
return result;
}
/*
* initialize the module
*/
static void 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->module_config, &mime_magic_module);
for (s = main_server; s; s = s->next) {
conf = ap_get_module_config(s->module_config, &mime_magic_module);
if (conf->magicfile == NULL && s != main_server) {
/* inherits from the parent */
*conf = *main_conf;
}
else if (conf->magicfile) {
result = apprentice(s, p);
if (result == -1)
return;
#if MIME_MAGIC_DEBUG
prevm = 0;
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": magic_init 1 test");
for (m = conf->magic; m; m = m->next) {
if (apr_isprint((((unsigned long) m) >> 24) & 255) &&
apr_isprint((((unsigned long) m) >> 16) & 255) &&
apr_isprint((((unsigned long) m) >> 8) & 255) &&
apr_isprint(((unsigned long) m) & 255)) {
ap_log_error(APLOG_MARK, APLOG_NOERRNO | APLOG_DEBUG, 0, s,
MODNAME ": magic_init 1: POINTER CLOBBERED! "
"m=\"%c%c%c%c\" line=%d",
(((unsigned long) m) >> 24) & 255,
(((unsigned long) m) >> 16) & 255,
(((unsigned long) m) >> 8) & 255,
((unsigned long) m) & 255,
prevm ? prevm->lineno : -1);
break;
}
prevm = m;
}
#endif
}
}
}
/*
* 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->finfo.filetype == 0 || !r->filename) {
return DECLINED;
}
/* was someone else already here? */
if (r->content_type) {
return DECLINED;
}
conf = ap_get_module_config(r->server->module_config, &mime_magic_module);
if (!conf || !conf->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[]={ "mod_mime.c", 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
*/
module mime_magic_module =
{
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 */
};