amxd_object_instance.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_types.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_expression.h>
#include <amxd/amxd_action.h>
#include <amxd/amxd_dm.h>
#include "amxd_priv.h"
#include "amxd_dm_priv.h"
#include "amxd_object_priv.h"
#include "amxd_assert.h"

Go to the source code of this file.

Macros
#define	_GNU_SOURCE

Functions
static bool	amxd_template_has_instance (const amxd_object_t *const templ, const char *name)
static bool	amxd_template_has_index (const amxd_object_t *const templ, uint32_t index)
static amxd_status_t	amxd_object_check_instance_alias (amxd_object_t *const templ, amxc_var_t *templ_params, amxc_htable_t *values, uint32_t index, const char **name)
static amxd_status_t	amxd_object_instance_validate_id (amxd_object_t *templ, const char **name, uint32_t index, amxc_var_t *templ_params, amxc_var_t *values)
static amxd_status_t	amxd_object_instance_set_index_name (amxd_object_t *object, amxd_object_t *templ, const char *name, uint32_t index)
static amxd_status_t	amxd_object_instantiate (amxd_object_t **object, amxd_object_t *templ, const char *name, uint32_t index, amxc_var_t *templ_params, amxc_var_t *tmp_values)
static amxd_status_t	amxd_cleanup_max_instance (amxd_object_t *const object, UNUSED amxd_param_t *const param, amxd_action_t reason, UNUSED const amxc_var_t *const args, UNUSED amxc_var_t *const retval, void *priv)
static void	amxd_object_remove_max_instance_check (amxd_object_t *object, amxc_var_t *max_var)
static amxd_status_t	amxd_object_add_max_instance_check (amxd_object_t *object, uint32_t max)
amxd_status_t	amxd_object_new_instance (amxd_object_t **object, amxd_object_t *templ, const char *name, uint32_t index, amxc_var_t *values)
	Data model object constructor function. More...
amxd_status_t	amxd_object_set_max_instances (amxd_object_t *object, uint32_t max)

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxd_object_instance.c.

Function Documentation

amxd_cleanup_max_instance()

static amxd_status_t amxd_cleanup_max_instance ( amxd_object_t *const  object, UNUSED amxd_param_t *const  param, amxd_action_t  reason, UNUSED const amxc_var_t *const  args, UNUSED amxc_var_t *const  retval, void *  priv  )

static

Definition at line 286 of file amxd_object_instance.c.

                                                           {
    amxd_status_t status = amxd_status_ok;
    amxc_var_t* data = (amxc_var_t*) priv;
 
    // action private data must not be removed when the action is used
    // on derivced objects.
    // only remove action data when the action is owned by the object or
    // parameter on which the action is called.
    if(amxd_object_has_action_cb(object, reason, amxd_cleanup_max_instance)) {
        amxc_var_delete(&data);
        amxd_object_set_action_cb_data(object, reason, amxd_cleanup_max_instance, NULL);
    }
 
    return status;
}

amxd_object_add_max_instance_check()

static amxd_status_t amxd_object_add_max_instance_check ( amxd_object_t *  object, uint32_t  max  )

static

Definition at line 320 of file amxd_object_instance.c.

                                                                      {
    amxc_var_t* max_var = NULL;
    amxd_status_t retval = amxd_status_unknown_error;
 
    amxc_var_new(&max_var);
    amxc_var_set(uint32_t, max_var, max);
    retval = amxd_object_add_action_cb(object,
                                       action_object_add_inst,
                                       amxd_action_object_add_inst,
                                       max_var);
    when_failed_status(retval, exit, amxc_var_delete(&max_var));
    retval = amxd_object_add_action_cb(object,
                                       action_object_destroy,
                                       amxd_cleanup_max_instance,
                                       max_var);
    if(retval != amxd_status_ok) {
        amxd_object_remove_action_cb(object,
                                     action_object_add_inst,
                                     amxd_action_object_add_inst);
        amxc_var_delete(&max_var);
        goto exit;
    }
 
    retval = amxd_status_ok;
 
exit:
    return retval;
}

amxd_object_check_instance_alias()

static amxd_status_t amxd_object_check_instance_alias ( amxd_object_t *const  templ, amxc_var_t *  templ_params, amxc_htable_t *  values, uint32_t  index, const char **  name  )

static

Definition at line 115 of file amxd_object_instance.c.

                                                                         {
    amxd_status_t status = amxd_status_ok;
    amxc_var_t* alias = amxc_var_get_key(templ_params, "Alias", AMXC_VAR_FLAG_DEFAULT);
    amxc_htable_it_t* halias = amxc_htable_get(values, "Alias");
    const char* obj_name = amxd_object_get_name(templ, AMXD_OBJECT_NAMED);
    uint32_t new_index = index == 0 ? (templ->last_index + 1) : index;
    amxc_var_t* alias_var = NULL;
 
    when_null(alias, exit);
    when_true(!amxc_var_constcast(bool, GET_FIELD(alias, "attributes.key")), exit);
    when_true(!amxc_var_constcast(bool, GET_FIELD(alias, "attributes.unique")), exit);
 
    if(halias == NULL) {
        amxc_var_new(&alias_var);
        if((*name != NULL) && ((*name)[0] != 0)) {
            amxc_var_set(cstring_t, alias_var, *name);
        } else {
            amxc_string_t alias_name;
            amxc_string_init(&alias_name, 0);
            amxc_string_appendf(&alias_name, "cpe-%s-%d", obj_name, new_index);
            amxc_var_push(amxc_string_t, alias_var, &alias_name);
            amxc_string_clean(&alias_name);
        }
        amxc_htable_insert(values, "Alias", &alias_var->hit);
    } else {
        alias_var = amxc_var_from_htable_it(halias);
        if((amxc_var_type_of(alias_var) != AMXC_VAR_ID_CSTRING) &&
           ( amxc_var_type_of(alias_var) != AMXC_VAR_ID_SSV_STRING) &&
           ( amxc_var_type_of(alias_var) != AMXC_VAR_ID_CSV_STRING)) {
            status = amxd_status_invalid_value;
            goto exit;
        }
    }
 
    *name = amxc_var_constcast(cstring_t, alias_var);
    if(isdigit((*name)[0]) != 0) {
        status = amxd_status_invalid_name;
    }
    *name = "";
 
exit:
    return status;
}

amxd_object_instance_set_index_name()

static amxd_status_t amxd_object_instance_set_index_name ( amxd_object_t *  object, amxd_object_t *  templ, const char *  name, uint32_t  index  )

static

Definition at line 203 of file amxd_object_instance.c.

                                                                         {
    amxd_status_t retval = amxd_status_unknown_error;
    uint32_t index_try = 0;
    int size_needed = 0;
 
    if(index == 0) {
        while(amxd_template_has_index(templ, templ->last_index + 1)) {
            index_try++;
            templ->last_index++;
 
            if(index_try > 10) {
                goto exit;
            }
        }
        object->index = templ->last_index + 1;
    } else {
        object->index = index;
    }
 
    size_needed = snprintf(NULL, 0, "%" PRIu32, object->index);
    object->index_name = (char*) calloc(size_needed + 1, sizeof(char));
    when_null(object->index_name, exit);
    snprintf(object->index_name, size_needed + 1, "%" PRIu32, object->index);
    if(object->name == NULL) {
        if((name == NULL) || (name[0] == 0)) {
            object->name = strdup(object->index_name);
            when_null(object->name, exit);
        }
    }
    if(object->index > templ->last_index) {
        templ->last_index = object->index;
    }
 
    retval = amxd_status_ok;
 
exit:
    return retval;
}

amxd_object_instance_validate_id()

static amxd_status_t amxd_object_instance_validate_id ( amxd_object_t *  templ, const char **  name, uint32_t  index, amxc_var_t *  templ_params, amxc_var_t *  values  )

static

Definition at line 163 of file amxd_object_instance.c.

                                                                          {
    amxd_status_t retval = amxd_status_ok;
    amxp_expr_t* expr = NULL;
    amxc_htable_t* hvalues = (amxc_htable_t*) amxc_var_constcast(amxc_htable_t, values);
    bool has_matches = false;
 
    if(index != 0) {
        when_true_status(amxd_template_has_index(templ, index),
                         exit,
                         retval = amxd_status_duplicate);
    }
 
    retval = amxd_object_check_instance_alias(templ, templ_params, hvalues, index, name);
    when_true(retval != amxd_status_ok, exit);
 
    retval = amxd_object_build_key_expr(templ_params, &expr, hvalues);
    when_failed(retval, exit);
 
    has_matches = amxd_object_has_matching_instances(templ, expr);
    when_true_status(has_matches, exit, retval = amxd_status_duplicate);
 
 
    if((*name != NULL) && ((*name)[0] != 0)) {
        when_true_status(!amxd_name_is_valid(*name),
                         exit,
                         retval = amxd_status_invalid_name);
        when_true_status(amxd_template_has_instance(templ, *name),
                         exit,
                         retval = amxd_status_duplicate);
    }
 
exit:
    amxp_expr_delete(&expr);
    return retval;
}

amxd_object_instantiate()

static amxd_status_t amxd_object_instantiate ( amxd_object_t **  object, amxd_object_t *  templ, const char *  name, uint32_t  index, amxc_var_t *  templ_params, amxc_var_t *  tmp_values  )

static

Definition at line 245 of file amxd_object_instance.c.

                                                                     {
    amxd_status_t retval = amxd_status_unknown_error;
    uint32_t attrs = 0;
    amxd_param_t* counter = NULL;
 
    *object = (amxd_object_t*) calloc(1, sizeof(amxd_object_t));
    when_null((*object), exit);
    retval = amxd_object_init(*object, amxd_object_instance, name, templ_params, tmp_values);
    when_true(retval != amxd_status_ok, exit);
    retval = amxd_object_instance_set_index_name((*object), templ, name, index);
    when_true(retval != amxd_status_ok, exit);
    attrs = amxd_object_get_attrs(templ);
    amxd_object_set_attrs(*object, attrs, true);
 
    amxc_llist_append(&templ->instances, &(*object)->it);
    retval = amxd_object_copy_children((*object), templ);
    when_failed(retval, exit);
    retval = amxd_object_copy_params((*object), templ);
    when_failed(retval, exit);
    retval = amxd_object_copy_mib_names((*object), templ);
 
    counter = amxd_object_get_param_counter_by_counted_object(*object);
    when_null(counter, exit);
    amxd_param_counter_update(counter);
 
exit:
    if(*object != NULL) {
        if(retval != amxd_status_ok) {
            amxd_object_clean(*object);
            free(*object);
            *object = NULL;
        }
    }
    return retval;
}

amxd_object_remove_max_instance_check()

static void amxd_object_remove_max_instance_check ( amxd_object_t *  object, amxc_var_t *  max_var  )

static

Definition at line 307 of file amxd_object_instance.c.

                                                                       {
    if(max_var != NULL) {
        amxc_var_delete(&max_var);
        amxd_object_remove_action_cb(object,
                                     action_object_add_inst,
                                     amxd_action_object_add_inst);
        amxd_object_remove_action_cb(object,
                                     action_object_destroy,
                                     amxd_cleanup_max_instance);
    }
}

amxd_object_set_max_instances()

amxd_status_t amxd_object_set_max_instances	(	amxd_object_t *	object,
		uint32_t	max
	)

Definition at line 397 of file amxd_object_instance.c.

                                                          {
    amxd_status_t retval = amxd_status_unknown_error;
    amxc_var_t* max_var = NULL;
    uint32_t instances = 0;
    when_null(object, exit);
    when_true_status(object->type != amxd_object_template,
                     exit,
                     retval = amxd_status_invalid_type);
 
    instances = amxd_object_get_instance_count(object);
    when_true_status(max < instances, exit, retval = amxd_status_invalid_value);
 
    max_var =
        (amxc_var_t*) amxd_object_get_action_cb_data(object,
                                                     action_object_add_inst,
                                                     amxd_action_object_add_inst);
    if(max == UINT32_MAX) {
        amxd_object_remove_max_instance_check(object, max_var);
        retval = amxd_status_ok;
        goto exit;
    }
 
    if(max_var != NULL) {
        amxc_var_set(uint32_t, max_var, max);
    } else {
        retval = amxd_object_add_max_instance_check(object, max);
        when_failed(retval, exit);
    }
 
    retval = amxd_status_ok;
 
exit:
    return retval;
}

amxd_template_has_index()

static bool amxd_template_has_index ( const amxd_object_t *const  templ, uint32_t  index  )

static

Definition at line 95 of file amxd_object_instance.c.

                                                    {
    bool retval = false;
 
    if(index != 0) {
        amxc_llist_for_each(it, (&templ->instances)) {
            amxd_object_t* result = amxc_llist_it_get_data(it, amxd_object_t, it);
            if(result->index == index) {
                retval = true;
                break;
            }
        }
    } else {
        // index 0 is a special case, it can not be used as an index id
        // it is considered always available.
        retval = true;
    }
    return retval;
}

amxd_template_has_instance()

static bool amxd_template_has_instance ( const amxd_object_t *const  templ, const char *  name  )

static

Definition at line 78 of file amxd_object_instance.c.

                                                         {
    bool retval = false;
 
    amxc_llist_for_each(it, (&templ->instances)) {
        const char* n = NULL;
        amxd_object_t* result = amxc_llist_it_get_data(it, amxd_object_t, it);
        n = amxd_object_get_name(result, AMXD_OBJECT_NAMED);
        if(strcmp(n, name) == 0) {
            retval = true;
            break;
        }
    }
 
    return retval;
}