/* 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.

 */

#include "apr_strings.h"

#include "httpd.h"

#include "http_config.h"

#include "http_log.h"

#include "http_protocol.h"

#include "http_request.h"

#include "ap_expr.h"

extern module AP_MODULE_DECLARE_DATA log_debug_module;

typedef struct {

    ap_expr_info_t *msg_expr;

    ap_expr_info_t *condition;

    const char *hook;

} msg_entry;

typedef struct {

    apr_array_header_t *entries;

} log_debug_dirconf;

static const char *allhooks = "all";

static const char * const hooks[] = {

    "log_transaction",      /*  0 */

    "quick_handler",        /*  1 */

    "handler",              /*  2 */

    "translate_name",       /*  3 */

    "map_to_storage",       /*  4 */

    "fixups",               /*  5 */

    "type_checker",         /*  6 */

    "check_access",         /*  7 */

    "check_access_ex",      /*  8 */

    "check_authn",          /*  9 */

    "check_authz",          /* 10 */

    "insert_filter",        /* 11 */

    NULL

};

static void do_debug_log(request_rec *r, const char *hookname)

{

    log_debug_dirconf *dconf = ap_get_module_config(r->per_dir_config, &log_debug_module);

    int i;

    if (dconf->entries == NULL)

        return;

    for (i = 0; i < dconf->entries->nelts; i++) {

        const char *msg, *err;

        msg_entry *entry = APR_ARRAY_IDX(dconf->entries, i, msg_entry *);

        if (entry->hook != allhooks && entry->hook != hookname)

            continue;

        if (entry->condition) {

            int ret = ap_expr_exec(r, entry->condition, &err;;

            if (err) {

                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00640)

                              "Can't evaluate condition: %s", err);

                continue;

            }

            if (!ret)

                continue;

        }

        msg = ap_expr_str_exec(r, entry->msg_expr, &err;;

        if (err)

            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00641)

                          "Can't evaluate message expression: %s", err);

        if (APLOGrdebug(r))

            /* Intentional no APLOGNO */

            ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,

                           "%s (%s hook, %s:%d)",

                           msg, hookname, entry->msg_expr->filename,

                           entry->msg_expr->line_number);

        else

            /* Intentional no APLOGNO */

            ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,

                          "%s", msg);

    }

}

static int log_debug_log_transaction(request_rec *r)

{

    do_debug_log(r, hooks[0]);

    return DECLINED;

}

static int log_debug_quick_handler(request_rec *r, int lookup_uri)

{

    do_debug_log(r, hooks[1]);

    return DECLINED;

}

static int log_debug_handler(request_rec *r)

{

    do_debug_log(r, hooks[2]);

    return DECLINED;

}

static int log_debug_translate_name(request_rec *r)

{

    do_debug_log(r, hooks[3]);

    return DECLINED;

}

static int log_debug_map_to_storage(request_rec *r)

{

    do_debug_log(r, hooks[4]);

    return DECLINED;

}

static int log_debug_fixups(request_rec *r)

{

    do_debug_log(r, hooks[5]);

    return DECLINED;

}

static int log_debug_type_checker(request_rec *r)

{

    do_debug_log(r, hooks[6]);

    return DECLINED;

}

static int log_debug_check_access(request_rec *r)

{

    do_debug_log(r, hooks[7]);

    return DECLINED;

}

static int log_debug_check_access_ex(request_rec *r)

{

    do_debug_log(r, hooks[8]);

    return DECLINED;

}

static int log_debug_check_authn(request_rec *r)

{

    do_debug_log(r, hooks[9]);

    return DECLINED;

}

static int log_debug_check_authz(request_rec *r)

{

    do_debug_log(r, hooks[10]);

    return DECLINED;

}

static void log_debug_insert_filter(request_rec *r)

{

    do_debug_log(r, hooks[11]);

}

static void *log_debug_create_dconf(apr_pool_t *p, char *dirspec)

{

    log_debug_dirconf *dconf = apr_pcalloc(p, sizeof(log_debug_dirconf));

    return dconf;

}

static void *log_debug_merge_dconf(apr_pool_t *p, void *parent_conf, void *new_conf)

{

    log_debug_dirconf *merged = apr_pcalloc(p, sizeof(log_debug_dirconf));

    const log_debug_dirconf *parent = parent_conf;

    const log_debug_dirconf *new = new_conf;

    if (parent->entries == NULL)

        merged->entries = new->entries;

    else if (new->entries == NULL)

        merged->entries = parent->entries;

    else

        /* apr_array_append actually creates a new array */

        merged->entries = apr_array_append(p, parent->entries, new->entries);

    return merged;

}

static const char *cmd_log_message(cmd_parms *cmd, void *dconf_, const char *arg1,

                                   const char *arg2, const char *arg3)

{

    msg_entry *entry = apr_pcalloc(cmd->pool, sizeof(msg_entry));

    log_debug_dirconf *dconf = dconf_;

    int i, j;

    const char *err;

    const char *args[2];

    args[0] = arg2;

    args[1] = arg3;

    entry->msg_expr = ap_expr_parse_cmd(cmd, arg1, AP_EXPR_FLAG_STRING_RESULT|

                                                   AP_EXPR_FLAG_DONT_VARY,

                                        &err, NULL);

    if (err)

        return apr_psprintf(cmd->pool,

                            "Could not parse message expression '%s': %s",

                            arg1, err);

    for (i = 0; i < 2; i++) {

        if (args[i] == NULL)

            break;

        if (strncasecmp(args[i], "hook=", 5) == 0) {

            const char *name = args[i] + 5;

            j = 0;

            while (hooks[j]) {

                if (strcasecmp(hooks[j], name) == 0) {

                    entry->hook = hooks[j];

                    break;

                }

                j++;

            }

            if (entry->hook == NULL) {

                if (strcmp(name, "*") == 0 || strcasecmp(name, allhooks) == 0)

                    entry->hook = allhooks;

                else

                    return apr_psprintf(cmd->pool, "Invalid hook name: %s", name);

            }

        }

        else if (strncasecmp(args[i], "expr=", 5) == 0) {

            const char *expr = args[i] + 5;

            entry->condition = ap_expr_parse_cmd(cmd, expr,

                                                 AP_EXPR_FLAG_DONT_VARY,

                                                 &err, NULL);

            if (err)

                return apr_psprintf(cmd->pool,

                                    "Could not parse expression '%s': %s",

                                    expr, err);

        }

        else {

            return apr_psprintf(cmd->pool, "Invalid argument %s", args[i]);

        }

    }

    if (entry->hook == NULL)

        entry->hook = hooks[0];

    if (!dconf->entries)

        dconf->entries = apr_array_make(cmd->pool, 4, sizeof(msg_entry *));

    APR_ARRAY_PUSH(dconf->entries, msg_entry *) = entry;

    return NULL;

}

static const command_rec log_debug_cmds[] =

{

    AP_INIT_TAKE123("LogMessage", cmd_log_message, NULL, RSRC_CONF|ACCESS_CONF,

        "Log a debug message to the error log if this config block is used for "

        " a request"),

    {NULL}

};

static void register_hooks(apr_pool_t *p)

{

    ap_hook_log_transaction(log_debug_log_transaction, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_quick_handler(log_debug_quick_handler, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_handler(log_debug_handler, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_translate_name(log_debug_translate_name, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_map_to_storage(log_debug_map_to_storage, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_fixups(log_debug_fixups, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_type_checker(log_debug_type_checker, NULL, NULL, APR_HOOK_FIRST);

    ap_hook_check_access(log_debug_check_access, NULL, NULL, APR_HOOK_FIRST, AP_AUTH_INTERNAL_PER_URI);

    ap_hook_check_access_ex(log_debug_check_access_ex, NULL, NULL, APR_HOOK_FIRST, AP_AUTH_INTERNAL_PER_URI);

    ap_hook_check_authn(log_debug_check_authn, NULL, NULL, APR_HOOK_FIRST, AP_AUTH_INTERNAL_PER_URI);

    ap_hook_check_authz(log_debug_check_authz, NULL, NULL, APR_HOOK_FIRST, AP_AUTH_INTERNAL_PER_URI);

    ap_hook_insert_filter(log_debug_insert_filter, NULL, NULL, APR_HOOK_FIRST);

}

AP_DECLARE_MODULE(log_debug) =

{

    STANDARD20_MODULE_STUFF,

    log_debug_create_dconf,     /* create per-dir config */

    log_debug_merge_dconf,      /* merge per-dir config */

    NULL,                       /* server config */

    NULL,                       /* merge server config */

    log_debug_cmds,             /* command apr_table_t */

    register_hooks              /* register hooks */

};