Exemplo n.º 1
0
ib_status_t ib_config_register_directive(ib_engine_t *ib,
                                         const char *name,
                                         ib_dirtype_t type,
                                         ib_void_fn_t fn_config,
                                         ib_config_cb_blkend_fn_t fn_blkend,
                                         void *cbdata)
{
    IB_FTRACE_INIT(ib_conf_register_directive);
    ib_dirmap_init_t *rec;
    ib_status_t rc;

    rec = (ib_dirmap_init_t *)ib_mpool_alloc(ib->config_mp, sizeof(*rec));
    if (rec == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    rec->name = name;
    rec->type = type;
    rec->cb._init = fn_config;
    rec->fn_blkend = fn_blkend;
    rec->cbdata = cbdata;

    rc = ib_hash_set(ib->dirmap, rec->name, (void *)rec);

    IB_FTRACE_RET_STATUS(rc);
}
Exemplo n.º 2
0
ib_status_t ib_provider_define(ib_engine_t *ib,
                               const char *type,
                               ib_provider_register_fn_t fn_reg,
                               void *api)
{
    IB_FTRACE_INIT(ib_provider_define);
    ib_status_t rc;
    ib_provider_def_t *prd;
    char *type_copy;

    /* Create the provider definition. */
    prd = (ib_provider_def_t *)ib_mpool_calloc(ib->config_mp, 1, sizeof(*prd));
    if (prd == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    prd->mp = ib->config_mp;
    prd->fn_reg = fn_reg;
    prd->api = api;

    /* Copy the type. */
    type_copy = (char *)ib_mpool_alloc(prd->mp, strlen(type) + 1);
    if (type_copy == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    strcpy(type_copy, type);
    prd->type = (const char *)type_copy;

    rc = ib_hash_set(ib->apis, type, prd);
    if (rc != IB_OK) {
        IB_FTRACE_RET_STATUS(rc);
    }

    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 3
0
/**
 * Perf Event Start Event Callback.
 *
 * On a connection started event we register connection
 * counters for the connection.
 *
 * @param[in] ib IronBee object.
 * @param[in] event Event type.
 * @param[in] connp Connection object.
 * @param[in] cbdata Callback data: actually an perf_info_t describing the
 *            event.
 */
static ib_status_t mod_perf_stats_reg_conn_counter(
     ib_engine_t *ib,
     ib_state_event_type_t event_type,
     ib_conn_t *connp,
     void *cbdata
)
{
    IB_FTRACE_INIT();

    perf_info_t *perf_info;
    event_info_t *eventp = (event_info_t *)cbdata;
    int cevent = eventp->number;
    int rc;
    int event;

    perf_info = ib_mpool_alloc(connp->mp, sizeof(*perf_info) * IB_STATE_EVENT_NUM);

    for (event = 0; event < IB_STATE_EVENT_NUM; ++event) {
        if ((eventp->cbdata_type == IB_CBDATA_NONE) ||
            (eventp->cbdata_type == IB_CBDATA_CONN_DATA_T)) {
            ib_log_error(ib, "Cannot collect stats for:%d name:%s cbdata_type: %d",
                         eventp->number, eventp->name, eventp->cbdata_type);
        }
        else {
            perf_info_t *perfp = &perf_info[event];

            /* Does this event match conn_started_event?
             * If so we should init counters for this event.
             */
            if (event == cevent) {
                perfp->call_cnt = 1;
                perfp->start_usec = ib_clock_get_time();
            }
            else {
                perfp->call_cnt = 0;
                perfp->start_usec = 0;
            }

            /* Setup other defaults */
            perfp->number = event;
            perfp->name = ib_state_event_name((ib_state_event_type_t)event);
            perfp->cbdata_type = ib_state_event_cbdata_type(event);
            perfp->max_usec = 0;
            perfp->total_usec = 0;
            perfp->stop_usec = 0;

            ib_log_debug(ib, "Perf callback registered %s (%d) (%d)",
                         perfp->name, perfp->number, perfp->cbdata_type);
        }
    }

    rc = ib_hash_set(connp->data, "MOD_PERF_STATS" ,perf_info);
    if (rc != IB_OK) {
        ib_log_debug(ib, "Failed to store perf stats in connection data: %s", ib_status_to_string(rc));
        IB_FTRACE_RET_STATUS(rc);
    }
    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 4
0
ib_status_t ib_action_register(
    ib_engine_t            *ib,
    const char             *name,
    ib_flags_t              flags,
    ib_action_create_fn_t   fn_create,
    void                   *cbdata_create,
    ib_action_destroy_fn_t  fn_destroy,
    void                   *cbdata_destroy,
    ib_action_execute_fn_t  fn_execute,
    void                   *cbdata_execute
)
{
    IB_FTRACE_INIT();
    ib_hash_t *action_hash = ib->actions;
    ib_mpool_t *pool = ib_engine_pool_main_get(ib);
    ib_status_t rc;
    char *name_copy;
    ib_action_t *act;

    rc = ib_hash_get(action_hash, &act, name);
    if (rc == IB_OK) {
        /* name already is registered */
        IB_FTRACE_RET_STATUS(IB_EINVAL);
    }

    name_copy = ib_mpool_strdup(pool, name);
    if (name_copy == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }

    act = (ib_action_t *)ib_mpool_alloc(pool, sizeof(*act));
    if (act == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    act->name           = name_copy;
    act->flags          = flags;
    act->fn_create      = fn_create;
    act->cbdata_create  = cbdata_create;
    act->fn_destroy     = fn_destroy;
    act->cbdata_destroy = cbdata_destroy;
    act->fn_execute     = fn_execute;
    act->cbdata_execute = cbdata_execute;

    rc = ib_hash_set(action_hash, name_copy, act);

    IB_FTRACE_RET_STATUS(rc);
}
Exemplo n.º 5
0
static ib_status_t cpy_psntsfw_cfg(
    ib_engine_t                *ib,
    ib_mpool_t                 *mp,
    ib_mpool_t                 *local_mp,
    const ib_persist_fw_cfg_t  *persist_fw_src,
    ib_persist_fw_cfg_t       **persist_fw_dst
)
{
    assert(ib != NULL);
    assert(mp != NULL);
    assert(local_mp != NULL);
    assert(persist_fw_src != NULL);
    assert(persist_fw_dst != NULL);

    ib_list_t      *list = NULL;
    ib_list_node_t *list_node;
    ib_status_t     rc;
    ib_persist_fw_cfg_t *persist_fw_out;

    rc = ib_persist_fw_cfg_create(mp, &persist_fw_out);
    if (rc != IB_OK) {
        ib_log_error(ib, "Failed to create new persist_fw_cfg.");
        return rc;
    }

    rc = ib_list_create(&list, local_mp);
    if (rc != IB_OK) {
        return rc;
    }

    /* Copy the src store hash to the dst store hash. */
    if (ib_hash_size(persist_fw_src->stores) > 0) {
        rc = ib_hash_get_all(persist_fw_src->stores, list);
        if (rc != IB_OK) {
            ib_log_error(ib, "Failed to get entries from hash.");
            return rc;
        }
        IB_LIST_LOOP(list, list_node) {
            ib_persist_fw_store_t *store =
                (ib_persist_fw_store_t *)ib_list_node_data_const(list_node);
            rc = ib_hash_set(persist_fw_out->stores, store->name, store);
            if (rc != IB_OK) {
                ib_log_error(ib, "Failed to set store %s", store->name);
                return rc;
            }
        }
Exemplo n.º 6
0
Arquivo: tfn.c Projeto: niq/ironbee
ib_status_t ib_tfn_create(ib_engine_t *ib,
                          const char *name,
                          ib_tfn_fn_t transform,
                          void *fndata,
                          ib_tfn_t **ptfn)
{
    IB_FTRACE_INIT(ib_tfn_create);
    ib_status_t rc;
    ib_tfn_t *tfn;
    char *name_copy;
    size_t name_len = strlen(name) + 1;

    name_copy = (char *)ib_mpool_alloc(ib->mp, name_len);
    if (name_copy == NULL) {
        if (ptfn != NULL) {
            *ptfn = NULL;
        }
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    memcpy(name_copy, name, name_len);

    tfn = (ib_tfn_t *)ib_mpool_alloc(ib->mp, sizeof(*tfn));
    if (tfn == NULL) {
        if (ptfn != NULL) {
            *ptfn = NULL;
        }
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    tfn->name = name_copy;
    tfn->transform = transform;
    tfn->fndata = fndata;

    rc = ib_hash_set(ib->tfns, name_copy, tfn);
    if (rc != IB_OK) {
        if (ptfn != NULL) {
            *ptfn = NULL;
        }
        IB_FTRACE_RET_STATUS(rc);
    }

    if (ptfn != NULL) {
        *ptfn = tfn;
    }

    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 7
0
ib_status_t ib_config_register_directives(ib_engine_t *ib,
                                          const ib_dirmap_init_t *init)
{
    IB_FTRACE_INIT(ib_conf_register_directives);
    const ib_dirmap_init_t *rec = init;
    ib_status_t rc;

    while ((rec != NULL) && (rec->name != NULL)) {
        rc = ib_hash_set(ib->dirmap, rec->name, (void *)rec);
        if (rc != IB_OK) {
            IB_FTRACE_RET_STATUS(rc);
        }

        rec++;
    }

    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 8
0
ib_status_t ib_action_register(
    ib_engine_t            *ib,
    const char             *name,
    ib_action_create_fn_t   fn_create,
    void                   *cbdata_create,
    ib_action_destroy_fn_t  fn_destroy,
    void                   *cbdata_destroy,
    ib_action_execute_fn_t  fn_execute,
    void                   *cbdata_execute
)
{
    ib_hash_t *action_hash = ib->actions;
    ib_mpool_t *pool = ib_engine_pool_main_get(ib);
    ib_status_t rc;
    char *name_copy;
    ib_action_t *act;

    rc = ib_hash_get(action_hash, &act, name);
    if (rc == IB_OK) {
        /* name already is registered */
        return IB_EINVAL;
    }

    name_copy = ib_mpool_strdup(pool, name);
    if (name_copy == NULL) {
        return IB_EALLOC;
    }

    act = (ib_action_t *)ib_mpool_alloc(pool, sizeof(*act));
    if (act == NULL) {
        return IB_EALLOC;
    }
    act->name           = name_copy;
    act->fn_create      = fn_create;
    act->cbdata_create  = cbdata_create;
    act->fn_destroy     = fn_destroy;
    act->cbdata_destroy = cbdata_destroy;
    act->fn_execute     = fn_execute;
    act->cbdata_execute = cbdata_execute;

    rc = ib_hash_set(action_hash, name_copy, act);

    return rc;
}
Exemplo n.º 9
0
Arquivo: pcre.c Projeto: niubl/ironbee
/**
 * Create the per-transaction data for use with the dfa operator.
 *
 * @param[in] m PCRE module.
 * @param[in,out] tx Transaction to store the value in.
 * @param[in] cpatt_data Compiled pattern data
 * @param[in] id The operator identifier used to get it's workspace.
 * @param[out] workspace Created.
 *
 * @returns
 *   - IB_OK on success.
 *   - IB_EALLOC on an allocation error.
 */
static
ib_status_t alloc_dfa_tx_data(
    const ib_module_t          *m,
    ib_tx_t                    *tx,
    const modpcre_cpat_data_t  *cpatt_data,
    const char                 *id,
    dfa_workspace_t           **workspace
)
{
    assert(tx);
    assert(tx->mp);
    assert(id);
    assert(workspace);

    ib_hash_t *hash;
    ib_status_t rc;
    dfa_workspace_t *ws;
    size_t size;

    *workspace = NULL;
    rc = get_or_create_operator_data_hash(m, tx, &hash);
    if (rc != IB_OK) {
        return rc;
    }

    ws = (dfa_workspace_t *)ib_mpool_alloc(tx->mp, sizeof(*ws));
    if (ws == NULL) {
        return IB_EALLOC;
    }

    ws->wscount = cpatt_data->dfa_ws_size;
    size = sizeof(*(ws->workspace)) * (ws->wscount);
    ws->workspace = (int *)ib_mpool_alloc(tx->mp, size);
    if (ws->workspace == NULL) {
        return IB_EALLOC;
    }

    rc = ib_hash_set(hash, id, ws);
    if (rc == IB_OK) {
        *workspace = ws;
    }

    return rc;
}
Exemplo n.º 10
0
/**
 * Get or create an ib_hash_t inside of @c tx->data for storing dfa rule data.
 *
 * The hash is stored at the key @c MODULE_DATA_STR.
 *
 * @param[in] tx The transaction containing @c tx->data which holds
 *            the @a rule_data object.
 * @param[out] rule_data The fetched or created rule data hash. This is set
 *             to NULL on failure.
 *
 * @return
 *   - IB_OK on success.
 *   - IB_EALLOC on allocation failure
 */
static ib_status_t get_or_create_rule_data_hash(ib_tx_t *tx,
                                                ib_hash_t **rule_data)
{
    IB_FTRACE_INIT();

    assert(tx);
    assert(tx->mp);

    ib_status_t rc;

    /* Get or create the hash that contains the rule data. */
    rc = ib_hash_get(tx->data, rule_data, MODULE_DATA_STR);

    if (rc == IB_OK && *rule_data != NULL) {
        ib_log_debug2_tx(tx,
                         "Found rule data hash in tx data named "
                         MODULE_DATA_STR);
        IB_FTRACE_RET_STATUS(IB_OK);
    }

    ib_log_debug2_tx(tx, "Rule data hash did not exist in tx data.");
    ib_log_debug2_tx(tx, "Creating rule data hash " MODULE_DATA_STR);

    rc = ib_hash_create(rule_data, tx->mp);
    if (rc != IB_OK) {
        ib_log_debug2_tx(tx,
                         "Failed to create hash " MODULE_DATA_STR ": %d", rc);
        IB_FTRACE_RET_STATUS(rc);
    }

    rc = ib_hash_set(tx->data, MODULE_DATA_STR, *rule_data);
    if (rc != IB_OK) {
        ib_log_debug2_tx(tx,
                         "Failed to store hash " MODULE_DATA_STR ": %d", rc);
        *rule_data = NULL;
    }

    ib_log_debug2_tx(tx,
                     "Returning rule hash " MODULE_DATA_STR " at %p.",
                     *rule_data);

    IB_FTRACE_RET_STATUS(rc);

}
Exemplo n.º 11
0
/**
 * Function exported to enable a module to register an ident provider
 *
 * @param engine Engine to register with
 * @param name Provider name (referenced in IdentType directive)
 * @param provider The identity provider
 * @return status
 */
ib_status_t ib_ident_provider_register(ib_engine_t *engine,
                                       const char *name,
                                       ib_ident_provider_t *provider)
{
    ident_cfg_t *cfg;
    ib_status_t rc;
    ib_module_t *m;

    rc = ib_engine_module_get(engine, MODULE_NAME_STR, &m);
    assert((rc == IB_OK) && (m != NULL));
    rc = ib_context_module_config(ib_context_main(engine), m, &cfg);
    assert((rc == IB_OK) && (cfg != NULL));

    if (cfg->providers == NULL) {
        rc = ib_hash_create(&cfg->providers, ib_engine_mm_main_get(engine));
        assert((rc == IB_OK) && (cfg->providers != NULL));
    }

    return ib_hash_set(cfg->providers, name, provider);
}
Exemplo n.º 12
0
ib_status_t ib_cfgmap_init(ib_cfgmap_t *cm,
                           const void *base,
                           const ib_cfgmap_init_t *init,
                           int usedefaults)
{
    IB_FTRACE_INIT(ib_cfgmap_init);
    ib_cfgmap_init_t *rec = (ib_cfgmap_init_t *)init;
    ib_field_t *f;
    ib_status_t rc;

    /* Add tree entries that just point into the base structure. */
    ib_util_log_debug(9, "Initializing: t=%p init=%p", cm, init);
    while (rec->name != NULL) {
        void *val = (void *)(((uint8_t *)base) + rec->offset);

        ib_util_log_debug(9, "INIT: %s type=%d base=%p offset=%d dlen=%d %p",
                          rec->name, rec->type, base,
                          (int)rec->offset, (int)rec->dlen, val);

        /* Copy the default value if required. */
        if (usedefaults) {
            memcpy(val, &rec->defval, rec->dlen);
        }

        /* Create a field with data that points to the base+offset. */
        rc = ib_field_createn(&f, cm->mp, rec->name, rec->type, val);
        if (rc != IB_OK) {
            IB_FTRACE_RET_STATUS(rc);
        }

        /* Add the field. */
        rc = ib_hash_set(cm->hash, rec->name, (void *)f);
        if (rc != IB_OK) {
            IB_FTRACE_RET_STATUS(rc);
        }

        rec++;
    }

    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 13
0
ib_status_t ib_action_register(
    ib_engine_t       *ib,
    const ib_action_t *action
)
{
    assert(ib != NULL);
    assert(action != NULL);

    ib_status_t rc;
    ib_hash_t *action_hash = ib->actions;

    rc = ib_hash_get(action_hash, NULL, action->name);
    if (rc == IB_OK) {
        /* Already exists. */
        return IB_EINVAL;
    }

    rc = ib_hash_set(action_hash, ib_action_name(action), (void *)action);

    return rc;
}
Exemplo n.º 14
0
/**
 * Create the per-transaction data for use with the dfa operator.
 *
 * @param[in,out] tx Transaction to store the value in.
 * @param[in] id The operator identifier used to get it's workspace.
 * @param[out] workspace Created.
 *
 * @returns
 *   - IB_OK on success.
 *   - IB_EALLOC on an allocation error.
 */
static ib_status_t alloc_dfa_tx_data(ib_tx_t *tx,
                                     const char *id,
                                     dfa_workspace_t **workspace)
{
    IB_FTRACE_INIT();

    assert(tx);
    assert(tx->mp);
    assert(id);
    assert(workspace);

    ib_hash_t *rule_data;
    ib_status_t rc;

    rc = get_or_create_rule_data_hash(tx, &rule_data);
    if (rc != IB_OK) {
        IB_FTRACE_RET_STATUS(rc);
    }

    *workspace = (dfa_workspace_t *)ib_mpool_alloc(tx->mp, sizeof(**workspace));
    if (*workspace == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }

    (*workspace)->wscount = WORKSPACE_SIZE_DEFAULT;
    (*workspace)->workspace =
        (int *)ib_mpool_alloc(tx->mp,
                             sizeof(*((*workspace)->workspace)) *
                                (*workspace)->wscount);
    if ((*workspace)->workspace == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }

    rc = ib_hash_set(rule_data, id, *workspace);
    if (rc != IB_OK) {
        *workspace = NULL;
    }

    IB_FTRACE_RET_STATUS(rc);
}
Exemplo n.º 15
0
ib_status_t ib_tfn_register(
    ib_engine_t    *ib,
    const ib_tfn_t *tfn
)
{
    assert(ib  != NULL);
    assert(tfn != NULL);

    ib_status_t rc;

    rc = ib_hash_get(ib->tfns, NULL, ib_tfn_name(tfn));
    if (rc != IB_ENOENT) {
        /* Already exists. */
        return IB_EINVAL;
    }

    rc = ib_hash_set(ib->tfns, ib_tfn_name(tfn), (void *)tfn);
    if (rc != IB_OK) {
        return rc;
    }

    return IB_OK;
}
Exemplo n.º 16
0
ib_status_t ib_tfn_register(ib_engine_t *ib,
                            const char *name,
                            ib_tfn_fn_t fn_execute,
                            ib_flags_t flags,
                            void *fndata)
{
    assert(ib != NULL);
    assert(name != NULL);
    assert(fn_execute != NULL);

    ib_hash_t *tfn_hash = ib->tfns;
    ib_status_t rc;
    ib_tfn_t *tfn;
    char *name_copy;

    name_copy = ib_mpool_strdup(ib->mp, name);
    if (name_copy == NULL) {
        return IB_EALLOC;
    }

    tfn = (ib_tfn_t *)ib_mpool_alloc(ib->mp, sizeof(*tfn));
    if (tfn == NULL) {
        return IB_EALLOC;
    }
    tfn->name = name_copy;
    tfn->fn_execute = fn_execute;
    tfn->tfn_flags = flags;
    tfn->fndata = fndata;

    rc = ib_hash_set(tfn_hash, name_copy, tfn);
    if (rc != IB_OK) {
        return rc;
    }

    return IB_OK;
}
Exemplo n.º 17
0
ib_status_t ib_cfgmap_init(ib_cfgmap_t *cm,
                           void *base,
                           const ib_cfgmap_init_t *init)
{
    ib_cfgmap_init_t *rec = (ib_cfgmap_init_t *)init;
    ib_field_t *f;
    ib_status_t rc;

    /* Add tree entries that just point into the base structure. */
    ib_util_log_debug("Initializing: t=%p init=%p", cm, init);
    cm->base = base;
    while (rec->name != NULL) {
        if (rec->fn_set != NULL && rec->fn_get != NULL) {
            ib_util_log_debug("INIT: %s type=%d set=%p/%p get=%p/%p",
                              rec->name, rec->type,
                              rec->fn_set, rec->cbdata_set,
                              rec->fn_get, rec->cbdata_get);

            ib_cfgmap_handlers_data_t *data =
                (ib_cfgmap_handlers_data_t *)ib_mpool_alloc(
                    cm->mp,
                    sizeof(*data)
                );
            if (data == NULL) {
                return IB_EALLOC;
            }
            data->base = base;
            data->init = rec;

            rc = ib_field_create_dynamic(
                &f,
                cm->mp,
                rec->name, strlen(rec->name),
                rec->type,
                ib_cfgmap_handle_get, data,
                ib_cfgmap_handle_set, data
            );
            if (rc != IB_OK) {
                return rc;
            }
        }
        else {
            if (rec->fn_get != NULL || rec->fn_set != NULL) {
                return IB_EINVAL;
            }

            void *val = (void *)(((uint8_t *)base) + rec->offset);

            ib_util_log_debug("INIT: %s type=%d base=%p offset=%d dlen=%d %p",
                              rec->name, rec->type, base,
                              (int)rec->offset, (int)rec->dlen, val);

            /* Create a field with data that points to the base+offset. */
            rc = ib_field_create_alias(
                &f,
                cm->mp,
                rec->name, strlen(rec->name),
                rec->type,
                val
            );
            if (rc != IB_OK) {
                return rc;
            }
        }

        /* Add the field. */
        rc = ib_hash_set(cm->hash, rec->name, (void *)f);
        if (rc != IB_OK) {
            return rc;
        }

        ++rec;
    }

    return IB_OK;
}
Exemplo n.º 18
0
ib_status_t ib_provider_register(ib_engine_t *ib,
                                 const char *type,
                                 const char *key,
                                 ib_provider_t **ppr,
                                 void *iface,
                                 ib_provider_inst_init_fn_t fn_init)
{
    IB_FTRACE_INIT();
    char *pr_key;
    ib_status_t rc;
    ib_provider_def_t *prd;
    ib_provider_t *pr;

    if (ppr != NULL) {
        *ppr = NULL;
    }

    /* Get the API, if any */
    rc = ib_hash_get(ib->apis, &prd, type);
    if (rc != IB_OK) {
        ib_log_error(ib,
                     "Error registering provider \"%s\": "
                     "Unknown provider type \"%s\"",
                     key, type);
        IB_FTRACE_RET_STATUS(rc);
    }

    /* Create the provider. */
    pr = (ib_provider_t *)ib_mpool_calloc(prd->mp, 1, sizeof(*pr));
    if (pr == NULL) {
        IB_FTRACE_RET_STATUS(IB_EALLOC);
    }
    pr->ib = ib;
    pr->mp = prd->mp;
    pr->type = prd->type;
    pr->iface = iface;
    pr->api = prd->api;
    pr->fn_init = fn_init;

    if (ppr != NULL) {
        *ppr = pr;
    }

    /* Register. */
    /// @todo Hash of hash?  Hash of list?
    pr_key = (char *)ib_mpool_alloc(ib->mp, strlen(type) + strlen(key) + 2);
    memcpy(pr_key, type, strlen(type));
    pr_key[strlen(type)] = '.';
    memcpy(pr_key + strlen(type) + 1, key, strlen(key));
    pr_key[strlen(type) + strlen(key) + 1] = '\0';
    rc = ib_hash_set(ib->providers, pr_key, pr);
    if (rc != IB_OK) {
        IB_FTRACE_RET_STATUS(rc);
    }

    /* If available, call the registration callback,
     * de-registering on failure.
     */
    if (prd->fn_reg != NULL) {
        rc = prd->fn_reg(ib, pr);
        if (rc != IB_OK) {
            ib_hash_remove(ib->providers, NULL, pr_key);
        }
        IB_FTRACE_RET_STATUS(rc);
    }

    IB_FTRACE_RET_STATUS(IB_OK);
}
Exemplo n.º 19
0
static
ib_status_t sqli_dir_fingerprint_set(
    ib_cfgparser_t *cp,
    const char     *directive_name,
    const char     *set_name,
    const char     *set_path,
    void           *cbdata
)
{
    assert(cp             != NULL);
    assert(directive_name != NULL);
    assert(set_name       != NULL);
    assert(set_path       != NULL);

    ib_status_t             rc;
    ib_context_t           *ctx = NULL;
    ib_module_t            *m   = NULL;
    sqli_module_config_t   *cfg = NULL;
    sqli_fingerprint_set_t *ps  = NULL;
    ib_mm_t                 mm;
    char                   *abs_set_path = NULL;

    rc = ib_cfgparser_context_current(cp, &ctx);
    assert(rc  == IB_OK);
    assert(ctx != NULL);

    if (ctx != ib_context_main(cp->ib)) {
        ib_cfg_log_error(cp,
            "%s: Only valid at main context.", directive_name
        );
        return IB_EINVAL;
    }

    if (strcmp("default", set_name) == 0) {
        ib_cfg_log_error(cp,
            "%s: default is a reserved set name.", directive_name
        );
        return IB_EINVAL;
    }

    mm = ib_engine_mm_main_get(cp->ib);

    rc = ib_engine_module_get(
        ib_context_get_engine(ctx),
        MODULE_NAME_STR,
        &m
    );
    assert(rc == IB_OK);

    rc = ib_context_module_config(ctx, m, &cfg);
    assert(rc == IB_OK);

    if (cfg->fingerprint_sets == NULL) {
        rc = ib_hash_create(&cfg->fingerprint_sets, mm);
        assert(rc == IB_OK);
    }
    assert(cfg->fingerprint_sets != NULL);

    rc = ib_hash_get(cfg->fingerprint_sets, NULL, set_name);
    if (rc == IB_OK) {
        ib_cfg_log_error(cp,
            "%s: Duplicate fingerprint set definition: %s",
            directive_name, set_name
        );
        return IB_EINVAL;
    }
    assert(rc == IB_ENOENT);

    abs_set_path = ib_util_relative_file(
        ib_engine_mm_config_get(cp->ib),
        ib_cfgparser_curr_file(cp),
        set_path
    );
    if (abs_set_path == NULL) {
        return IB_EALLOC;
    }

    rc = sqli_create_fingerprint_set_from_file(&ps, abs_set_path, mm);
    if (rc != IB_OK) {
        ib_cfg_log_error(cp,
            "%s: Failure to load fingerprint set from file: %s",
            directive_name, abs_set_path
        );
        return IB_EINVAL;
    }
    assert(ps != NULL);

    rc = ib_hash_set(cfg->fingerprint_sets, ib_mm_strdup(mm, set_name), ps);
    assert(rc == IB_OK);

    return IB_OK;
}
Exemplo n.º 20
0
/**
 * Load a eudoxus pattern so it can be used in rules.
 *
 * The filename should point to a compiled automata. If a relative path is
 * given, it will be loaded relative to the current configuration file.
 *
 * @param[in] cp Configuration parser.
 * @param[in] name Directive name.
 * @param[in] pattern_name Name to associate with the pattern.
 * @param[in] filename Filename to load.
 * @param[in] cbdata Callback data (unused)
 * @return
 * - IB_OK on success.
 * - IB_EEXIST if the pattern has already been defined.
 * - IB_EINVAL if there was an error loading the automata.
 */
static
ib_status_t load_eudoxus_pattern_param2(ib_cfgparser_t *cp,
                                        const char *name,
                                        const char *pattern_name,
                                        const char *filename,
                                        void *cbdata)
{
    ib_engine_t *ib;
    ib_status_t rc;
    const char *automata_file;
    ia_eudoxus_result_t ia_rc;
    ib_hash_t *eudoxus_pattern_hash;
    ia_eudoxus_t *eudoxus;
    const ee_config_t* config;
    ib_mm_t mm_tmp;
    void *tmp;

    assert(cp != NULL);
    assert(cp->ib != NULL);
    assert(pattern_name != NULL);
    assert(filename != NULL);

    mm_tmp = ib_engine_mm_temp_get(cp->ib);
    ib = cp->ib;
    config = ee_get_config(ib);
    assert(config != NULL);

    eudoxus_pattern_hash = config->eudoxus_pattern_hash;
    assert(eudoxus_pattern_hash != NULL);

    /* Check if the pattern name is already in use */
    rc = ib_hash_get(eudoxus_pattern_hash, &tmp, pattern_name);
    if (rc == IB_OK) {
        ib_log_error(cp->ib,
                     MODULE_NAME_STR ": Pattern named \"%s\" already defined",
                     pattern_name);
        return IB_EEXIST;
    }

    automata_file = ib_util_relative_file(mm_tmp, cp->curr->file, filename);

    if (access(automata_file, R_OK) != 0) {
        ib_log_error(cp->ib,
                     MODULE_NAME_STR ": Error accessing eudoxus automata file: %s.",
                     automata_file);

        return IB_EINVAL;
    }

    ia_rc = ia_eudoxus_create_from_path(&eudoxus, automata_file);
    if (ia_rc != IA_EUDOXUS_OK) {
        ib_log_error(cp->ib,
                     MODULE_NAME_STR ": Error loading eudoxus automata file[%d]: %s.",
                     ia_rc, automata_file);
        return IB_EINVAL;
    }

    rc = ib_hash_set(eudoxus_pattern_hash, pattern_name, eudoxus);
    if (rc != IB_OK) {
        ia_eudoxus_destroy(eudoxus);
        return rc;
    }

    return IB_OK;
}