Quellcode-Bibliothek mod_dumpio.c Sprache: C

/* 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 "License"); 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 "AS IS" 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.
*/

/*
* Originally written @ Covalent by Jim Jagielski
*/

/*
* mod_dumpio.c:
*  Think of this as a filter sniffer for Apache 2.x. It logs
*  all filter data right before and after it goes out on the
*  wire (BUT right before SSL encoded or after SSL decoded).
*  It can produce a *huge* amount of data.
*/

#include "httpd.h"
#include "http_connection.h"
#include "http_config.h"
#include "http_core.h"
#include "http_log.h"
#include "apr_strings.h"

module AP_MODULE_DECLARE_DATA dumpio_module ;

typedef struct dumpio_conf_t {
    int enable_input;
    int enable_output;
} dumpio_conf_t;

/* consider up to 80 additional characters, and factor the longest
* line length of all \xNN sequences; log_error cannot record more
* than MAX_STRING_LEN characters.
*/
#define dumpio_MAX_STRING_LEN (MAX_STRING_LEN / 4 - 80)

/*
* Workhorse function: simply log to the current error_log
* info about the data in the bucket as well as the data itself
*/
static void dumpit(ap_filter_t *f, apr_bucket *b, dumpio_conf_t *ptr)
{
    conn_rec *c = f->c;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c,
                  "mod_dumpio: %s (%s-%s): %" APR_SIZE_T_FMT " bytes",
                  f->frec->name,
                  (APR_BUCKET_IS_METADATA(b)) ? "metadata" : "data",
                  b->type->name,
                  b->length) ;

    if (!(APR_BUCKET_IS_METADATA(b)))
    {
#if APR_CHARSET_EBCDIC
        char xlatebuf[dumpio_MAX_STRING_LEN + 1];
#endif
        const char *buf;
        apr_size_t nbytes;
        apr_status_t rv = apr_bucket_read(b, &buf, &nbytes, APR_BLOCK_READ);

        if (rv == APR_SUCCESS)
        {
            while (nbytes)
            {
                apr_size_t logbytes = nbytes;
                if (logbytes > dumpio_MAX_STRING_LEN)
                    logbytes = dumpio_MAX_STRING_LEN;
                nbytes -= logbytes;

#if APR_CHARSET_EBCDIC
                memcpy(xlatebuf, buf, logbytes);
                ap_xlate_proto_from_ascii(xlatebuf, logbytes);
                xlatebuf[logbytes] = '\0';
                ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c,
                              "mod_dumpio: %s (%s-%s): %s", f->frec->name,
                              (APR_BUCKET_IS_METADATA(b)) ? "metadata" : "data",
                              b->type->name, xlatebuf);
#else
                /* XXX: Seriously flawed; we do not pay attention to embedded
                 * \0's in the request body, these should be escaped; however,
                 * the logging function already performs a significant amount
                 * of escaping, and so any escaping would be double-escaped.
                 * The coding solution is to throw away the current logic
                 * within ap_log_error, and introduce new vformatter %-escapes
                 * for escaping text, and for binary text (fixed len strings).
                 */
                ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c,
                              "mod_dumpio: %s (%s-%s): %.*s", f->frec->name,
                              (APR_BUCKET_IS_METADATA(b)) ? "metadata" : "data",
                              b->type->name, (int)logbytes, buf);
#endif
                buf += logbytes;
            }
        }
        else {
            ap_log_cerror(APLOG_MARK, APLOG_TRACE7, rv, c,
                          "mod_dumpio: %s (%s-%s): %s", f->frec->name,
                          (APR_BUCKET_IS_METADATA(b)) ? "metadata" : "data",
                          b->type->name, "error reading data");
        }
    }
}

#define whichmode( mode ) \
( (( mode ) == AP_MODE_READBYTES) ? "readbytes" : \
   (( mode ) == AP_MODE_GETLINE) ? "getline" : \
   (( mode ) == AP_MODE_EATCRLF) ? "eatcrlf" : \
   (( mode ) == AP_MODE_SPECULATIVE) ? "speculative" : \
   (( mode ) == AP_MODE_EXHAUSTIVE) ? "exhaustive" : \
   (( mode ) == AP_MODE_INIT) ? "init" : "unknown" \
)

static int dumpio_input_filter (ap_filter_t *f, apr_bucket_brigade *bb,
    ap_input_mode_t mode, apr_read_type_e block, apr_off_t readbytes)
{

    apr_bucket *b;
    apr_status_t ret;
    conn_rec *c = f->c;
    dumpio_conf_t *ptr = f->ctx;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c,
                  "mod_dumpio: %s [%s-%s] %" APR_OFF_T_FMT " readbytes",
                  f->frec->name,
                  whichmode(mode),
                  ((block) == APR_BLOCK_READ) ? "blocking" : "nonblocking",
                  readbytes);

    ret = ap_get_brigade(f->next, bb, mode, block, readbytes);

    if (ret == APR_SUCCESS) {
        for (b = APR_BRIGADE_FIRST(bb); b != APR_BRIGADE_SENTINEL(bb); b = APR_BUCKET_NEXT(b)) {
          dumpit(f, b, ptr);
        }
    }
    else {
        ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c,
                      "mod_dumpio: %s - %d", f->frec->name, ret) ;
        return ret;
    }

    return APR_SUCCESS ;
}

static int dumpio_output_filter (ap_filter_t *f, apr_bucket_brigade *bb)
{
    apr_bucket *b;
    conn_rec *c = f->c;
    dumpio_conf_t *ptr = f->ctx;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE7, 0, c, "mod_dumpio: %s", f->frec->name);

    for (b = APR_BRIGADE_FIRST(bb); b != APR_BRIGADE_SENTINEL(bb); b = APR_BUCKET_NEXT(b)) {
        /*
         * If we ever see an EOS, make sure to FLUSH.
         */
        if (APR_BUCKET_IS_EOS(b)) {
            apr_bucket *flush = apr_bucket_flush_create(f->c->bucket_alloc);
            APR_BUCKET_INSERT_BEFORE(b, flush);
        }
        dumpit(f, b, ptr);
    }

    return ap_pass_brigade(f->next, bb) ;
}

static int dumpio_pre_conn(conn_rec *c, void *csd)
{
    dumpio_conf_t *ptr;

    if (!APLOGctrace7(c)) {
        /* Nothing to do below TRACE7 */
        return DECLINED;
    }

    ptr = (dumpio_conf_t *) ap_get_module_config(c->base_server->module_config,
                                                 &dumpio_module);

    if (ptr->enable_input)
        ap_add_input_filter("DUMPIO_IN", ptr, NULL, c);
    if (ptr->enable_output)
        ap_add_output_filter("DUMPIO_OUT", ptr, NULL, c);
    return OK;
}

static void dumpio_register_hooks(apr_pool_t *p)
{
/*
* We know that SSL is CONNECTION + 5
*/
  ap_register_output_filter("DUMPIO_OUT", dumpio_output_filter,
        NULL, AP_FTYPE_CONNECTION + 3) ;

  ap_register_input_filter("DUMPIO_IN", dumpio_input_filter,
        NULL, AP_FTYPE_CONNECTION + 3) ;

  ap_hook_pre_connection(dumpio_pre_conn, NULL, NULL, APR_HOOK_MIDDLE);
}

static void *dumpio_create_sconfig(apr_pool_t *p, server_rec *s)
{
    dumpio_conf_t *ptr = apr_pcalloc(p, sizeof *ptr);
    ptr->enable_input = 0;
    ptr->enable_output = 0;
    return ptr;
}

static const char *dumpio_enable_input(cmd_parms *cmd, void *dummy, int arg)
{
    dumpio_conf_t *ptr = ap_get_module_config(cmd->server->module_config,
                                              &dumpio_module);

    ptr->enable_input = arg;
    return NULL;
}

static const char *dumpio_enable_output(cmd_parms *cmd, void *dummy, int arg)
{
    dumpio_conf_t *ptr = ap_get_module_config(cmd->server->module_config,
                                              &dumpio_module);

    ptr->enable_output = arg;
    return NULL;
}

static const command_rec dumpio_cmds[] = {
    AP_INIT_FLAG("DumpIOInput", dumpio_enable_input, NULL,
                 RSRC_CONF, "Enable I/O Dump on Input Data"),
    AP_INIT_FLAG("DumpIOOutput", dumpio_enable_output, NULL,
                 RSRC_CONF, "Enable I/O Dump on Output Data"),
    { NULL }
};

AP_DECLARE_MODULE(dumpio) = {
        STANDARD20_MODULE_STUFF,
        NULL,                   /* create per-dir    config structures */
        NULL,                   /* merge  per-dir    config structures */
        dumpio_create_sconfig,  /* create per-server config structures */
        NULL,                   /* merge  per-server config structures */
        dumpio_cmds,            /* table of config file commands       */
        dumpio_register_hooks   /* register hooks                      */
};

quality90%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.7Bemerkung: ¤

*Bot Zugriff

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.