/*

* ModSecurity for Apache 2.x, http://www.modsecurity.org/

* Copyright (c) 2004-2013 Trustwave Holdings, Inc. (http://www.trustwave.com/)

*

* 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

*

* If any of the files related to licensing are missing or if you have any

* other questions related to licensing please contact Trustwave Holdings, Inc.

* directly using the email address security@modsecurity.org.

*/

#include <ctype.h>

#include "re.h"

#if defined(WITH_LUA)

#include "msc_lua.h"

#endif

static const char *const severities[] = {

    "EMERGENCY",

    "ALERT",

    "CRITICAL",

    "ERROR",

    "WARNING",

    "NOTICE",

    "INFO",

    "DEBUG",

    NULL,

};

static int fetch_target_exception(msre_rule *rule, modsec_rec *msr, msre_var *var, const char *exceptions);

static apr_status_t msre_parse_targets(msre_ruleset *ruleset, const char *text,

    apr_array_header_t *arr, char **error_msg);

static char *msre_generate_target_string(apr_pool_t *pool, msre_rule *rule);

static msre_var *msre_create_var(msre_ruleset *ruleset, const char *name, const char *param,

    modsec_rec *msr, char **error_msg);

static msre_action *msre_create_action(msre_engine *engine, apr_pool_t *mp, const char *name,

    const char *param, char **error_msg);

static apr_status_t msre_rule_process(msre_rule *rule, modsec_rec *msr);

/* -- Actions, variables, functions and operator functions ----------------- */

/**

 * \brief Remove rule targets to be processed

 *

 * \param rule Pointer to the rule

 * \param msr ModSecurity transaction resource

 * \param var Pointer to target structure.

 * \param targets Exception list.

 */

static int fetch_target_exception(msre_rule *rule, modsec_rec *msr, msre_var *var, const char *exceptions)   {

    const char *targets = NULL;

    char *savedptr = NULL, *target = NULL;

    char *c = NULL, *name = NULL, *value = NULL;

    char *variable = NULL, *myvar = NULL;

    char *myvalue = NULL, *myname = NULL;

    int match = 0;

    if(msr == NULL)

        return 0;

    if(var == NULL)

        return 0;

    if(rule == NULL)

        return 0;

    if(rule->actionset == NULL)

        return 0;

    if(rule->actionset->id !=NULL)    {

        myvar = apr_pstrdup(msr->mp, var->name);

        c = strchr(myvar,':');

        if(c != NULL) {

            myname = apr_strtok(myvar,":",&myvalue);

        } else {

            myname = myvar;

        }

        match = 0;

        targets = apr_pstrdup(msr->mp, exceptions);

        if(targets != NULL) {

            if (msr->txcfg->debuglog_level >= 9) {

                msr_log(msr, 9, "fetch_target_exception: Found exception target list [%s] for rule id %s", targets, rule->actionset->id);

            }

            target = apr_strtok((char *)targets, ",", &savedptr);

            while(target != NULL)   {

                variable = apr_pstrdup(msr->mp, target);

                c = strchr(variable,':');

                if(c != NULL) {

                    name = apr_strtok(variable,":",&value);

                } else {

                    name = variable;

                    value = NULL;

                }

                if((strlen(myname) == strlen(name)) &&

                        (strncasecmp(myname, name,strlen(myname)) == 0))   {

                    if(value != NULL && myvalue != NULL)  {

                        if((strlen(myvalue) == strlen(value)) &&

                                strncasecmp(myvalue,value,strlen(myvalue)) == 0) {

                            if (msr->txcfg->debuglog_level >= 9) {

                                msr_log(msr, 9, "fetch_target_exception: Target %s will not be processed.", target);

                            }

                            match = 1;

                        }

                    } else if (value == NULL && myvalue == NULL)    {

                        if (msr->txcfg->debuglog_level >= 9) {

                            msr_log(msr, 9, "fetch_target_exception: Target %s will not be processed.", target);

                        }

                        match = 1;

                    } else if (value == NULL && myvalue != NULL)   {

                        if (msr->txcfg->debuglog_level >= 9) {

                            msr_log(msr, 9, "fetch_target_exception: Target %s will not be processed.", target);

                        }

                        match = 1;

                    }

                }

                target = apr_strtok(NULL, ",", &savedptr);

            }

        } else  {

            if (msr->txcfg->debuglog_level >= 9) {

                msr_log(msr, 9, "fetch_target_exception: No exception target found for rule id %s.", rule->actionset->id);

            }

        }

    }

    if(match == 1)

        return 1;

    return 0;

}

/**

 * \brief Update target for all matching rules in set, in any phase

 *

 * \param msr ModSecurity transaction resource

 * \param ruleset Pointer to set of rules to modify

 * \param re Pointer to exception object describing which rules to modify

 * \param p2 Pointer to configuration option TARGET

 * \param p3 Pointer to configuration option REPLACED_TARGET

 */

char *msre_ruleset_rule_update_target_matching_exception(modsec_rec *msr, msre_ruleset *ruleset, rule_exception *re, const char *p2, const char *p3) {

    char *err;

    if(ruleset == NULL)

        return NULL;

    if(p2 == NULL)  {

        return apr_psprintf(ruleset->mp, "Trying to update without a target");

    }

    if (NULL != (err = msre_ruleset_phase_rule_update_target_matching_exception(msr, ruleset, re, ruleset->phase_request_headers, p2, p3)))

        return err;

    if (NULL != (err = msre_ruleset_phase_rule_update_target_matching_exception(msr, ruleset, re, ruleset->phase_request_body, p2, p3)))

        return err;

    if (NULL != (err = msre_ruleset_phase_rule_update_target_matching_exception(msr, ruleset, re, ruleset->phase_response_headers, p2, p3)))

        return err;

    if (NULL != (err = msre_ruleset_phase_rule_update_target_matching_exception(msr, ruleset, re, ruleset->phase_response_body, p2, p3)))

        return err;

    if (NULL != (err = msre_ruleset_phase_rule_update_target_matching_exception(msr, ruleset, re, ruleset->phase_logging, p2, p3)))

        return err;

    /* Everything worked! */

    return NULL;

}

/**

 * \brief Update target for all matching rules in set for a specific phase

 *

 * \param msr ModSecurity transaction resource

 * \param ruleset Pointer to set of rules to modify

 * \param re Pointer to exception object describing which rules to modify

 * \param phase_arr Pointer to phase that should be edited

 * \param p2 Pointer to configuration option TARGET

 * \param p3 Pointer to configuration option REPLACED_TARGET

 *

 * \todo Figure out error checking

 */

char *msre_ruleset_phase_rule_update_target_matching_exception(modsec_rec *msr, msre_ruleset *ruleset, rule_exception *re,

        apr_array_header_t *phase_arr, const char *p2,

        const char *p3)

{

    msre_rule **rules;

    int i, j, mode;

    char *err;

    j = 0;

    mode = 0;

    rules = (msre_rule **)phase_arr->elts;

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

        msre_rule *rule = (msre_rule *)rules[i];

        if (mode == 0) { /* Looking for next rule. */

            if (msre_ruleset_rule_matches_exception(rule, re)) {

                err = update_rule_target_ex(NULL, ruleset, rule, p2, p3);

                if (err) return err;

                if (rule->actionset->is_chained) mode = 2; /* Match all rules in this chain. */

            } else {

                if (rule->actionset->is_chained) mode = 1; /* Skip all rules in this chain. */

            }

        } else { /* Handling rule that is part of a chain. */

            if (mode == 2) { /* We want to change the rule. */

                err = update_rule_target_ex(msr, ruleset, rule, p2, p3);

                if (err) return err;

            }

            if ((rule->actionset == NULL)||(rule->actionset->is_chained == 0)) mode = 0;

        }

    }

    return NULL;

}

char *update_rule_target_ex(modsec_rec *msr, msre_ruleset *ruleset, msre_rule *rule, const char *p2,

        const char *p3)   {

    msre_var **targets = NULL;

    const char *current_targets = NULL;

    char *my_error_msg = NULL, *target = NULL;

    char *p = NULL, *savedptr = NULL;

    unsigned int is_negated = 0, is_counting = 0;

    int name_len = 0, value_len = 0;

    char *name = NULL, *value = NULL;

    char *opt = NULL, *param = NULL;

    char *target_list = NULL, *replace = NULL;

    int i, rc, match = 0, var_appended = 0;

    if(rule != NULL)    {

        target_list = strdup(p2);

        if(target_list == NULL)

            return apr_psprintf(ruleset->mp, "Error to update target - memory allocation");;

        if(p3 != NULL)  {

            replace = strdup(p3);

            if(replace == NULL) {

                free(target_list);

                target_list = NULL;

                return apr_psprintf(ruleset->mp, "Error to update target - memory allocation");;

            }

        }

        if(replace != NULL) {

            opt = strchr(replace,'!');

            if(opt != NULL)  {

                *opt = '\0';

                opt++;

                param = opt;

                is_negated = 1;

            } else if ((opt = strchr(replace,'&')) != NULL)  {

                *opt = '\0';

                opt++;

                param = opt;

                is_counting = 1;

            } else  {

                param = replace;

            }

            opt = strchr(param,':');

            if(opt != NULL) {

                name = apr_strtok(param,":",&value);

            } else {

                name = param;

            }

            if(apr_table_get(ruleset->engine->variables, name) == NULL)   {

                if(target_list != NULL)

                    free(target_list);

                if(replace != NULL)

                    free(replace);

                if(msr) {

                    msr_log(msr, 9, "Error to update target - [%s] is not valid target", name);

                }

                return apr_psprintf(ruleset->mp, "Error to update target - [%s] is not valid target", name);

            }

            name_len = strlen(name);

            if(value != NULL)

                value_len = strlen(value);

            if(msr) {

                msr_log(msr, 9, "Trying to replace by variable name [%s] value [%s]", name, value);

            }

#if !defined(MSC_TEST)

            else {

                ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, " ModSecurity: Trying to replace by variable name [%s] value [%s]", name, value);

            }

#endif

            targets = (msre_var **)rule->targets->elts;

            // TODO need a good way to remove the element from array, maybe change array by tables or rings

            for (i = 0; i < rule->targets->nelts; i++) {

                if((strlen(targets[i]->name) == strlen(name)) &&

                        (strncasecmp(targets[i]->name,name,strlen(targets[i]->name)) == 0) &&

                        (targets[i]->is_negated == is_negated) &&

                        (targets[i]->is_counting == is_counting))    {

                    if(value != NULL && targets[i]->param != NULL)  {

                        if((strlen(targets[i]->param) == strlen(value)) &&

                                strncasecmp(targets[i]->param,value,strlen(targets[i]->param)) == 0) {

                            memset(targets[i]->name,0,strlen(targets[i]->name));

                            memset(targets[i]->param,0,strlen(targets[i]->param));

                            targets[i]->is_counting = 0;

                            targets[i]->is_negated = 1;

                            match = 1;

                        }

                    } else if (value == NULL && targets[i]->param == NULL){

                        memset(targets[i]->name,0,strlen(targets[i]->name));

                        targets[i]->is_counting = 0;

                        targets[i]->is_negated = 1;

                        match = 1;

                    } else

                        continue;

                }

            }

        }

        p = apr_strtok(target_list, ",", &savedptr);

        while(p != NULL) {

            if(replace != NULL) {

                if(match == 1)  {

                    rc = msre_parse_targets(ruleset, p, rule->targets, &my_error_msg);

                    if (rc < 0) {

                        if(msr) {

                            msr_log(msr, 9, "Error parsing rule targets to replace variable");

                        }

#if !defined(MSC_TEST)

                        else {

                            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, " ModSecurity: Error parsing rule targets to replace variable");

                        }

#endif

                        goto end;

                    }

                    if(msr) {

                        msr_log(msr, 9, "Successfully replaced variable");

                    }

#if !defined(MSC_TEST)

                    else {

                        ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, " ModSecurity: Successfully replaced variable");

                    }

#endif

                var_appended = 1;

                } else  {

                    if(msr) {

                        msr_log(msr, 9, "Cannot find variable to replace");

                    }

#if !defined(MSC_TEST)

                    else {

                        ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, " ModSecurity: Cannot find varibale to replace");

                    }

#endif

                    goto end;

                }

            } else {

                target = strdup(p);

                if(target == NULL)

                    return NULL;

                is_negated = is_counting = 0;

                param = name = value = NULL;

                opt = strchr(target,'!');

                if(opt != NULL)  {

                    *opt = '\0';

                    opt++;

                    param = opt;

                    is_negated = 1;

                } else if ((opt = strchr(target,'&')) != NULL)  {

                    *opt = '\0';

                    opt++;

                    param = opt;

                    is_counting = 1;

                } else  {

                    param = target;

                }

                opt = strchr(param,':');

                if(opt != NULL) {

                    name = apr_strtok(param,":",&value);

                } else {

                    name = param;

                }

                if(apr_table_get(ruleset->engine->variables, name) == NULL)   {

                    if(target_list != NULL)

                        free(target_list);

                    if(replace != NULL)

                        free(replace);

                    if(msr) {

                        msr_log(msr, 9, "Error to update target - [%s] is not valid target", name);

                    }

                    return apr_psprintf(ruleset->mp, "Error to update target - [%s] is not valid target", name);

                }

                name_len = strlen(name);

                if(value != NULL)

                    value_len = strlen(value);

                if(msr) {

                    msr_log(msr, 9, "Trying to append variable name [%s] value [%s]", name, value);

                }

#if !defined(MSC_TEST)

                else {

                    ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, " ModSecurity: Trying to append variable name [%s] value [%s]", name, value);

                }

#endif

                match = 0;

                targets = (msre_var **)rule->targets->elts;

                for (i = 0; i < rule->targets->nelts; i++) {

                    if((strlen(targets[i]->name) == strlen(name)) &&

                            (strncasecmp(targets[i]->name,name,strlen(targets[i]->name)) == 0) &&

                            (targets[i]->is_negated == is_negated) &&

                            (targets[i]->is_counting == is_counting))    {

                        if(value != NULL && targets[i]->param != NULL)  {

                            if((strlen(targets[i]->param) == strlen(value)) &&

                                    strncasecmp(targets[i]->param,value,strlen(targets[i]->param)) == 0) {

                                match = 1;

                            }

                        } else if (value == NULL && targets[i]->param == NULL){

                            match = 1;

                        } else

                            continue;

                    }

                }

                if(target != NULL)  {

                    free(target);

                    target = NULL;

                }

                if(match == 0 ) {

                    rc = msre_parse_targets(ruleset, p, rule->targets, &my_error_msg);

                    if (rc < 0) {

                        if(msr) {

                            msr_log(msr, 9, "Error parsing rule targets to append variable");

                        }

#if !defined(MSC_TEST)

                        else {

                            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, " ModSecurity: Error parsing rule targets to append variable");

                        }

#endif

                        goto end;

                    }

                    var_appended = 1;

                } else {

                    if(msr) {

                        msr_log(msr, 9, "Skipping variable, already appended");

                    }

#if !defined(MSC_TEST)

                    else {

                        ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, " ModSecurity: Skipping variable, already appended");

                    }

#endif

                }

            }

            p = apr_strtok(NULL,",",&savedptr);

        }

        if(var_appended == 1)  {

            current_targets = msre_generate_target_string(ruleset->mp, rule);

            rule->unparsed = msre_rule_generate_unparsed(ruleset->mp, rule, current_targets, NULL, NULL);

            rule->p1 = apr_pstrdup(ruleset->mp, current_targets);

            if(msr) {

                msr_log(msr, 9, "Successfully appended variable");

            }

#if !defined(MSC_TEST)

            else {

                ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, " ModSecurity: Successfully appended variable");

            }

#endif

        }

    }

end:

    if(target_list != NULL) {

        free(target_list);

        target_list = NULL;

    }

    if(replace != NULL) {

        free(replace);

        replace = NULL;

    }

    if(target != NULL)  {

        free(target);

        target = NULL;

    }

    return NULL;

}

int msre_ruleset_rule_matches_exception(msre_rule *rule, rule_exception *re)   {

    int match = 0;

    /* Only remove non-placeholder rules */

    if (rule->placeholder == RULE_PH_NONE) {

        switch(re->type) {

            case RULE_EXCEPTION_REMOVE_ID :

                if ((rule->actionset != NULL)&&(rule->actionset->id != NULL)) {

                    int ruleid = atoi(rule->actionset->id);

                    if (rule_id_in_range(ruleid, re->param)) {

                        match = 1;

                    }

                }

                break;

            case RULE_EXCEPTION_REMOVE_MSG :

                if ((rule->actionset != NULL)&&(rule->actionset->msg != NULL)) {

                    char *my_error_msg = NULL;

                    int rc = msc_regexec(re->param_data,

                            rule->actionset->msg, strlen(rule->actionset->msg),

                            &my_error_msg);

                    if (rc >= 0) {

                        match = 1;

                    }

                }

                break;

            case RULE_EXCEPTION_REMOVE_TAG :

                if ((rule->actionset != NULL)&&(apr_is_empty_table(rule->actionset->actions) == 0)) {

                    char *my_error_msg = NULL;

                    const apr_array_header_t *tarr = NULL;

                    const apr_table_entry_t *telts = NULL;

                    int act;

                    tarr = apr_table_elts(rule->actionset->actions);

                    telts = (const apr_table_entry_t*)tarr->elts;

                    for (act = 0; act < tarr->nelts; act++) {

                        msre_action *action = (msre_action *)telts[act].val;

                        if((action != NULL) && (action->metadata != NULL) && (strcmp("tag", action->metadata->name) == 0))  {

                            int rc = msc_regexec(re->param_data,

                                    action->param, strlen(action->param),

                                    &my_error_msg);

                            if (rc >= 0)    {

                                match = 1;

                            }

                        }

                    }

                }

                break;

        }

    }

    return match;

}

/**

 * Remove actions with the same cardinality group from the actionset.

 */

static void msre_actionset_cardinality_fixup(msre_actionset *actionset, msre_action *action) {

    const apr_array_header_t *tarr = NULL;

    const apr_table_entry_t *telts = NULL;

    int i;

    if ((actionset == NULL) || (action == NULL)) return;

    tarr = apr_table_elts(actionset->actions);

    telts = (const apr_table_entry_t*)tarr->elts;

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

        msre_action *target = (msre_action *)telts[i].val;

        if (target->metadata->cardinality_group == action->metadata->cardinality_group) {

            apr_table_unset(actionset->actions, target->metadata->name);

        }

    }

}

static char *msre_generate_target_string(apr_pool_t *pool, msre_rule *rule)  {

    char *target_str = NULL;

    msre_var **targets = NULL;

    int i = 0;

    targets = (msre_var **)rule->targets->elts;

    for (i = 0; i < rule->targets->nelts; i++) {

        if(targets[i]->name != NULL && strlen(targets[i]->name) > 0)    {

            target_str = apr_pstrcat(pool,

                    (target_str == NULL) ? "" : apr_psprintf(pool, "%s|", target_str),

                    (targets[i]->is_negated == 0) ? "" : "!",

                    (targets[i]->is_counting == 0) ? "" : "&",

                    (targets[i]->name == NULL) ? "" : targets[i]->name,

                    (targets[i]->param == NULL) ? "" : apr_psprintf(pool, ":%s", targets[i]->param),

                    NULL);

        }

    }

    return target_str;

}

/**

 * Generate an action string from an actionset.

 */

static char *msre_actionset_generate_action_string(apr_pool_t *pool, const msre_actionset *actionset)  {

    const apr_array_header_t *tarr = NULL;

    const apr_table_entry_t *telts = NULL;

    char *actions = NULL;

    int chain;

    int i;

    if (actionset == NULL) return NULL;

    chain = ((actionset->rule != NOT_SET_P) && actionset->rule->chain_starter) ? 1 : 0;

    tarr = apr_table_elts(actionset->actions);

    telts = (const apr_table_entry_t*)tarr->elts;

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

        msre_action *action = (msre_action *)telts[i].val;

        int use_quotes = 0;

        if (chain) {

            /* Skip some actions that are not used in a chain. */

            if (   (action->metadata->type == ACTION_DISRUPTIVE)

                    || (action->metadata->type == ACTION_METADATA)

                    || (strcmp("log", action->metadata->name) == 0)

                    || (strcmp("auditlog", action->metadata->name) == 0)

                    || (strcmp("nolog", action->metadata->name) == 0)

                    || (strcmp("noauditlog", action->metadata->name) == 0)

                    || (strcmp("severity", action->metadata->name) == 0)

                    || (strcmp("ver", action->metadata->name) == 0)

                    || (strcmp("maturity", action->metadata->name) == 0)

                    || (strcmp("accuracy", action->metadata->name) == 0)

                    || (strcmp("tag", action->metadata->name) == 0)

                    || (strcmp("phase", action->metadata->name) == 0)) 

            {

                continue;

            }

        }

        /* Check if we need any quotes */

        if (action->param != NULL) {

            int j;

            for(j = 0; action->param[j] != '\0'; j++) {

                if (isspace(action->param[j])) {

                    use_quotes = 1;

                    break;

                }

            }

            if (j == 0) use_quotes = 1;

        }

        actions = apr_pstrcat(pool,

                (actions == NULL) ? "" : actions,

                (actions == NULL) ? "" : ",",

                action->metadata->name,

                (action->param == NULL) ? "" : ":",

                (use_quotes) ? "'" : "",

                (action->param == NULL) ? "" : action->param,

                (use_quotes) ? "'" : "",

                NULL);

    }

    return actions;

}

/**

 * Add an action to an actionset.

 */

static void msre_actionset_action_add(msre_actionset *actionset, msre_action *action)

{

    msre_action *add_action = action;

    if ((actionset == NULL)) return;

    /**

     * The "block" action is just a placeholder for the parent action.

     */

    if ((actionset->parent_intercept_action_rec != NULL) && (actionset->parent_intercept_action_rec != NOT_SET_P) && (strcmp("block", action->metadata->name) == 0) && (strcmp("block", action->metadata->name) == 0)) {

        /* revert back to parent */

        actionset->intercept_action = actionset->parent_intercept_action;

        add_action = actionset->parent_intercept_action_rec;

    }

    if ((add_action == NULL)) return;

    if (add_action->metadata->cardinality_group != ACTION_CGROUP_NONE) {

        msre_actionset_cardinality_fixup(actionset, add_action);

    }

    if (add_action->metadata->cardinality == ACTION_CARDINALITY_ONE) {

        /* One action per actionlist. */

        apr_table_setn(actionset->actions, add_action->metadata->name, (void *)add_action);

    } else {

        /* Multiple actions per actionlist. */

        apr_table_addn(actionset->actions, add_action->metadata->name, (void *)add_action);

    }

}

/**

 * Creates msre_var instances (rule variables) out of the

 * given text string and places them into the supplied table.

 */

static apr_status_t msre_parse_targets(msre_ruleset *ruleset, const char *text,

        apr_array_header_t *arr, char **error_msg)

{

    const apr_array_header_t *tarr;

    const apr_table_entry_t *telts;

    apr_table_t *vartable;

    unsigned int count = 0;

    apr_status_t rc;

    msre_var *var;

    int i;

    if (text == NULL) return -1;

    /* Extract name & value pairs first */

    vartable = apr_table_make(ruleset->mp, 10);

    if (vartable == NULL) return -1;

    rc = msre_parse_generic(ruleset->mp, text, vartable, error_msg);

    if (rc < 0) return rc;

    /* Loop through the table and create variables */

    tarr = apr_table_elts(vartable);

    telts = (const apr_table_entry_t*)tarr->elts;

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

        var = msre_create_var(ruleset, telts[i].key, telts[i].val, NULL, error_msg);

        if (var == NULL) return -1;

        *(msre_var **)apr_array_push(arr) = var;

        count++;

    }

    return count;

}

/**

 * Creates msre_action instances by parsing the given string, placing

 * them into the supplied array.

 */

static apr_status_t msre_parse_actions(msre_engine *engine, apr_pool_t *mp, msre_actionset *actionset,

        const char *text, char **error_msg)

{

    const apr_array_header_t *tarr;

    const apr_table_entry_t *telts;

    apr_table_t *vartable;

    unsigned int count = 0;

    apr_status_t rc;

    msre_action *action;

    int i;

    if (error_msg == NULL) {

        return -1;

    }

    *error_msg = NULL;

    if (text == NULL) {

        *error_msg = apr_psprintf(mp, "Internal error: " \

            "msre_parse_actions, variable text is NULL");

        return -1;

    }

    /* Extract name & value pairs first */

    vartable = apr_table_make(mp, 10);

    if (vartable == NULL) {

        *error_msg = apr_psprintf(mp, "Internal error: " \

            "msre_parse_actions, failed to create vartable");

        return -1;

    }

    rc = msre_parse_generic(mp, text, vartable, error_msg);

    if (rc < 0) {

        if (*error_msg == NULL)

            *error_msg = apr_psprintf(mp, "Internal error: " \

                "msre_parse_actions, msre_parse_generic failed. Return " \

                "code: %d", rc);

        return rc;

    }

    /* Loop through the table and create actions */

    tarr = apr_table_elts(vartable);

    telts = (const apr_table_entry_t*)tarr->elts;

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

        /* Create action. */

        action = msre_create_action(engine, mp, telts[i].key, telts[i].val, error_msg);

        if (action == NULL) {

            if (*error_msg == NULL)

                *error_msg = apr_psprintf(mp, "Internal error: " \

                    "msre_parse_actions, msre_create_action failed.");

            return -1;

        }

        /* Initialise action (option). */

        if (action->metadata->init != NULL) {

            action->metadata->init(engine, mp, actionset, action);

        }

        msre_actionset_action_add(actionset, action);

        count++;

    }

    return count;

}

/**

 * Locates variable metadata given the variable name.

 */

msre_var_metadata *msre_resolve_var(msre_engine *engine, const char *name)

{

    return (msre_var_metadata *)apr_table_get(engine->variables, name);

}

/**

 * Locates action metadata given the action name.

 */

static msre_action_metadata *msre_resolve_action(msre_engine *engine, const char *name)

{

    return (msre_action_metadata *)apr_table_get(engine->actions, name);

}

/**

 * Creates a new variable instance given the variable name

 * and an (optional) parameter.

 */

msre_var *msre_create_var_ex(apr_pool_t *pool, msre_engine *engine, const char *name, const char *param,

        modsec_rec *msr, char **error_msg)

{

    const char *varparam = param;

    msre_var *var = apr_pcalloc(pool, sizeof(msre_var));

    if (var == NULL) return NULL;

    if (error_msg == NULL) return NULL;

    *error_msg = NULL;

    /* Handle negation and member counting */

    if (name[0] == '!') {

        var->is_negated = 1;

        var->name = (char *)name + 1;

    }

    else

        if (name[0] == '&') {

            var->is_counting = 1;

            var->name = (char *)name + 1;

        }

        else {