amxo_parser_priv.h File Reference

#include <sys/resource.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <libgen.h>
#include <ctype.h>
#include <dlfcn.h>
#include <unistd.h>
#include <dirent.h>
#include <syslog.h>
#include <amxc/amxc_macros.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_common.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_expression.h>
#include <amxd/amxd_object_event.h>
#include <amxd/amxd_parameter.h>
#include <amxd/amxd_action.h>
#include <amxd/amxd_path.h>
#include <amxo/amxo.h>
#include <amxs/amxs.h>

Go to the source code of this file.

Data Structures
struct	_event
struct	_amxo_txt
struct	_amxo_txt_regexp
struct	_amxo_res_data

Typedefs
typedef enum _amxo_parser_attr	amxo_parser_attr_t
typedef enum _amxo_action	amxo_action_t
typedef enum _event_id	event_id_t
typedef struct _event	event_t
typedef struct _amxo_txt	amxo_txt_t
typedef struct _amxo_txt_regexp	amxo_txt_regexp_t
typedef struct _amxo_res_data	amxo_res_data_t

Enumerations
enum	amxo_parser_tokens_t {   token_include , token_optional_include , token_conditional_include , token_post_include ,   token_import , token_config , token_define , token_populate ,   token_object , token_mib , token_keyword , token_eof ,   token_requires }
enum	_amxo_parser_attr {   attr_readonly , attr_persistent , attr_private , attr_template ,   attr_instance , attr_variable , attr_in , attr_out ,   attr_mandatory , attr_strict , attr_key , attr_unique ,   attr_protected , attr_mutable , attr_asynchronous }
enum	_amxo_action {   amxo_action_invalid = -1 , action_all = 0 , action_read , action_write ,   action_validate , action_list , action_describe , action_add_inst ,   action_del_inst , action_destroy , action_translate , action_apply ,   action_max = action_apply }
enum	_event_id { event_none , event_instance_add , event_object_change }

Functions
PRIVATE void	amxo_parser_free_event (amxc_llist_it_t *it)
PRIVATE void	amxo_ftab_fn_free (const char *key, amxc_htable_it_t *it)
PRIVATE void	amxo_parser_del_mib_info (const char *key, amxc_htable_it_t *it)
PRIVATE ssize_t	amxo_parser_fd_reader (amxo_parser_t *parser, char *buf, size_t max_size)
PRIVATE int	amxo_parser_parse_file_impl (amxo_parser_t *parser, const char *file_path, amxd_object_t *object)
PRIVATE void	amxo_parser_child_init (amxo_parser_t *parser)
PRIVATE void	amxo_parser_create_lex (amxo_parser_t *parser)
PRIVATE void	amxo_parser_destroy_lex (amxo_parser_t *parser)
PRIVATE void	amxo_parser_msg (amxo_parser_t *parser, const char *format,...) __attribute__((format(printf
PRIVATE void PRIVATE int	amxo_parser_printf (amxo_parser_t *parser, const char *format,...) __attribute__((format(printf
PRIVATE void PRIVATE int PRIVATE bool	amxo_parser_find (amxo_parser_t *parser, const amxc_llist_t *dirs, const char *file_path, char **full_path)
PRIVATE bool	amxo_parser_check_attr (amxo_parser_t *pctx, int64_t attributes, int64_t bitmask)
PRIVATE bool	amxo_parser_set_param_attrs (amxo_parser_t *pctx, uint64_t attr, bool enable)
PRIVATE bool	amxo_parser_set_param_flags (amxo_parser_t *pctx, amxc_var_t *flags)
PRIVATE bool	amxo_parser_set_object_attrs (amxo_parser_t *pctx, uint64_t attr, bool enable)
PRIVATE int	amxo_parser_create_object (amxo_parser_t *pctx, const char *name, int64_t attr_bitmask, amxd_object_type_t type)
PRIVATE bool	amxo_parser_add_instance (amxo_parser_t *pctx, uint32_t index, const char *name, amxc_var_t *params)
PRIVATE bool	amxo_parser_push_object (amxo_parser_t *pctx, const char *name)
PRIVATE bool	amxo_parser_pop_object (amxo_parser_t *pctx)
PRIVATE bool	amxo_parser_push_param (amxo_parser_t *pctx, const char *name, int64_t attr_bitmask, uint32_t type)
PRIVATE int	amxo_parser_set_param (amxo_parser_t *pctx, const char *name, amxc_var_t *value)
PRIVATE bool	amxo_parser_pop_param (amxo_parser_t *pctx)
PRIVATE int	amxo_parser_push_func (amxo_parser_t *pctx, const char *name, int64_t attr_bitmask, uint32_t type)
PRIVATE bool	amxo_parser_set_function_flags (amxo_parser_t *pctx, amxc_var_t *flags)
PRIVATE void	amxo_parser_pop_func (amxo_parser_t *pctx)
PRIVATE bool	amxo_parser_add_arg (amxo_parser_t *pctx, const char *name, int64_t attr_bitmask, uint32_t type, amxc_var_t *def_value)
PRIVATE bool	amxo_parser_set_counter (amxo_parser_t *pctx, const char *param_name)
PRIVATE int	amxo_parser_subscribe_path (amxo_parser_t *pctx, const char *event, bool event_is_regexp, const char *path, bool path_is_regexp)
PRIVATE int	amxo_parser_subscribe (amxo_parser_t *pctx, const char *event, bool event_is_regexp, const char *full_expr)
PRIVATE int	amxo_parser_subscribe_object (amxo_parser_t *pctx, const char *event, bool event_is_regexp, const char *full_expr)
PRIVATE int	amxo_parser_add_post_include (amxo_parser_t *pctx, const char *file_path)
PRIVATE int	amxo_parser_include (amxo_parser_t *pctx, const char *file_path)
PRIVATE amxc_htable_t *	amxo_parser_get_resolvers (void)
PRIVATE int	amxo_parser_resolve_internal (amxo_parser_t *parser, const char *fn_name, amxo_fn_type_t type, const char *data)
PRIVATE void	amxo_resolver_import_clean (amxo_parser_t *parser, void *priv)
PRIVATE int	amxo_parser_resolve (amxo_parser_t *parser, const char *resolver_name, const char *func_name, amxo_fn_type_t type, const char *data)
PRIVATE void	amxo_parser_clean_resolvers (amxo_parser_t *parser)
PRIVATE void	amxo_parser_init_resolvers (amxo_parser_t *parser)
PRIVATE int	amxo_parser_call_entry_point (amxo_parser_t *pctx, const char *lib_name, const char *fn_name)
PRIVATE int	amxo_parser_set_action (amxo_parser_t *pctx, amxo_action_t action, const char *name, amxc_var_t *data)
PRIVATE amxo_action_t	amxo_parser_get_action_id (amxo_parser_t *pctx, const char *action_name)
PRIVATE void	amxo_parser_print (amxo_parser_t *pctx, const char *text)
PRIVATE bool	amxo_parser_add_mib (amxo_parser_t *pctx, const char *mib_name)
PRIVATE bool	amxo_parser_no_resolve (amxo_parser_t *parser)
PRIVATE bool	amxo_parser_check_config (amxo_parser_t *pctx, const char *path, const char *check)
PRIVATE void	amxo_parser_resolve_value (amxo_parser_t *pctx, amxc_string_t *value)
PRIVATE void	amxo_parser_del_sync_data (amxc_llist_it_t *it)
PRIVATE void	amxo_parser_pop_sync_item (amxo_parser_t *pctx)
PRIVATE int	amxo_parser_push_sync_ctx (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction)
PRIVATE int	amxo_parser_push_sync_template (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction, const char *name)
PRIVATE int	amxo_parser_push_sync_object (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction)
PRIVATE int	amxo_parser_push_sync_parameter (amxo_parser_t *pctx, const char *param_a, const char *param_b, int direction)
PRIVATE int	amxo_parser_start_sync (amxc_llist_it_t *it)
PRIVATE void	amxo_parser_stop_sync (amxc_llist_it_t *it)
PRIVATE amxs_sync_entry_type_t	amxo_parser_get_sync_type (amxo_parser_t *pctx)
PRIVATE bool	amxo_parser_is_sync_item (amxo_parser_t *pctx)
PRIVATE amxd_status_t	amxo_parser_sync_set_translator (amxo_parser_t *pctx, amxs_translation_cb_t cb)
PRIVATE amxd_status_t	amxo_parser_sync_set_action (amxo_parser_t *pctx, amxs_action_cb_t cb)
PRIVATE bool	amxo_parser_sync_item_contains_entries (amxo_parser_t *pctx)
PRIVATE void	amxo_parser_sync_remove_invalid (amxo_parser_t *pctx)
PRIVATE int	amxo_parser_sync_update_flags (int direction)
PRIVATE amxs_sync_ctx_t *	amxo_parser_sync_get (const char *sync_template)

Typedef Documentation

amxo_action_t

typedef enum _amxo_action amxo_action_t

amxo_parser_attr_t

typedef enum _amxo_parser_attr amxo_parser_attr_t

amxo_res_data_t

typedef struct _amxo_res_data amxo_res_data_t

amxo_txt_regexp_t

typedef struct _amxo_txt_regexp amxo_txt_regexp_t

amxo_txt_t

typedef struct _amxo_txt amxo_txt_t

event_id_t

typedef enum _event_id event_id_t

event_t

typedef struct _event event_t

Enumeration Type Documentation

_amxo_action

enum _amxo_action

Enumerator
amxo_action_invalid
action_all
action_read
action_write
action_validate
action_list
action_describe
action_add_inst
action_del_inst
action_destroy
action_translate
action_apply
action_max

Definition at line 128 of file amxo_parser_priv.h.

                          {
    amxo_action_invalid = -1,
    action_all = 0,
    action_read,
    action_write,
    action_validate,
    action_list,
    action_describe,
    action_add_inst,
    action_del_inst,
    action_destroy,
    action_translate,
    action_apply,
    action_max = action_apply
} amxo_action_t;

_amxo_parser_attr

enum _amxo_parser_attr

Enumerator
attr_readonly
attr_persistent
attr_private
attr_template
attr_instance
attr_variable
attr_in
attr_out
attr_mandatory
attr_strict
attr_key
attr_unique
attr_protected
attr_mutable
attr_asynchronous

Definition at line 110 of file amxo_parser_priv.h.

                               {
    attr_readonly,
    attr_persistent,
    attr_private,
    attr_template,
    attr_instance,
    attr_variable,
    attr_in,
    attr_out,
    attr_mandatory,
    attr_strict,
    attr_key,
    attr_unique,
    attr_protected,
    attr_mutable,
    attr_asynchronous,
} amxo_parser_attr_t;

_event_id

enum _event_id

Enumerator
event_none
event_instance_add
event_object_change

Definition at line 144 of file amxo_parser_priv.h.

                       {
    event_none,
    event_instance_add,
    event_object_change
} event_id_t;

amxo_parser_tokens_t

enum amxo_parser_tokens_t

Enumerator
token_include
token_optional_include
token_conditional_include
token_post_include
token_import
token_config
token_define
token_populate
token_object
token_mib
token_keyword
token_eof
token_requires

Definition at line 93 of file amxo_parser_priv.h.

{
    token_include,
    token_optional_include,
    token_conditional_include,
    token_post_include,
    token_import,
    token_config,
    token_define,
    token_populate,
    token_object,
    token_mib,
    token_keyword,
    token_eof,
    token_requires,
};

Function Documentation

amxo_ftab_fn_free()

PRIVATE void amxo_ftab_fn_free	(	const char *	key,
		amxc_htable_it_t *	it
	)

amxo_parser_add_arg()

PRIVATE bool amxo_parser_add_arg	(	amxo_parser_t *	pctx,
		const char *	name,
		int64_t	attr_bitmask,
		uint32_t	type,
		amxc_var_t *	def_value
	)

Definition at line 182 of file amxo_parser_dm_func_utils.c.

                                                {
    bool retval = false;
    int64_t aattrs = amxo_attr_2_arg_attr(attr_bitmask);
    if(!IS_BIT_SET(aattrs, amxd_aattr_in) &&
       !IS_BIT_SET(aattrs, amxd_aattr_out)) {
        aattrs |= 1 << amxd_aattr_in;
    }
 
    amxo_hooks_add_func_arg(pctx, name, aattrs, type, def_value);
 
    pctx->status = amxd_function_new_arg(pctx->func, name, type, def_value);
    if(pctx->status != amxd_status_ok) {
        amxo_parser_msg(pctx, "Failed to create/add function argument %s", name);
        goto exit;
    }
 
    amxd_function_arg_set_attrs(pctx->func, name, aattrs, true);
    retval = true;
 
exit:
    return retval;
}

amxo_parser_add_instance()

PRIVATE bool amxo_parser_add_instance	(	amxo_parser_t *	pctx,
		uint32_t	index,
		const char *	name,
		amxc_var_t *	params
	)

Definition at line 563 of file amxo_parser_dm_utils.c.

                                                  {
    amxd_object_t* object = NULL;
    amxd_object_t* parent_obj = pctx->object;
    bool retval = false;
    amxc_string_t res_name;
    amxc_string_init(&res_name, 0);
 
    if(amxc_string_set_resolved(&res_name, name, &pctx->config) > 0) {
        name = amxc_string_get(&res_name, 0);
    }
 
    pctx->status = amxd_object_add_instance(&object,
                                            parent_obj,
                                            name,
                                            index,
                                            params);
    object = amxd_parser_add_instance_msg(pctx, index, name, object, params);
    when_null(object, exit);
    when_failed(pctx->status, exit);
    amxo_hooks_add_instance(pctx, amxd_object_get_index(object),
                            amxd_object_get_name(object, AMXD_OBJECT_NAMED));
    amxc_astack_push(&pctx->object_stack, pctx->object);
    pctx->object = object;
    amxo_parser_push_event(pctx, event_instance_add);
    retval = true;
 
exit:
    amxc_string_clean(&res_name);
    amxc_var_delete(&params);
    return retval;
}

amxo_parser_add_mib()

PRIVATE bool amxo_parser_add_mib	(	amxo_parser_t *	pctx,
		const char *	mib_name
	)

Definition at line 843 of file amxo_parser_dm_utils.c.

                                               {
    bool retval = false;
    amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
    amxd_object_t* mib = NULL;
    amxc_string_t res_mib_name;
    amxc_string_init(&res_mib_name, 0);
 
    if(amxc_string_set_resolved(&res_mib_name, mib_name, &pctx->config) > 0) {
        mib_name = amxc_string_get(&res_mib_name, 0);
    }
 
    when_null(dm, exit);
 
    if(amxd_object_has_mib(pctx->object, mib_name)) {
        retval = true;
        goto exit;
    }
 
    mib = amxd_dm_get_mib(dm, mib_name);
    if(mib == NULL) {
        const char* file = amxo_parser_get_mib_file(pctx, mib_name);
        if(file != NULL) {
            amxo_parser_include(pctx, file);
            mib = amxd_dm_get_mib(dm, mib_name);
        }
        if(mib == NULL) {
            amxo_parser_msg(pctx, "MIB %s is not found", mib_name);
            pctx->status = amxd_status_object_not_found;
            goto exit;
        }
    }
 
    pctx->status = amxd_object_add_mib(pctx->object, mib_name);
    if(pctx->status != amxd_status_ok) {
        amxo_parser_msg(pctx,
                        "Failed to add MIB %s on object %s",
                        mib_name,
                        amxd_object_get_name(pctx->object, AMXD_OBJECT_NAMED));
        goto exit;
    }
 
    retval = true;
 
    amxo_hooks_add_mib(pctx, mib_name);
 
exit:
    amxc_string_clean(&res_mib_name);
    return retval;
}

amxo_parser_add_post_include()

PRIVATE int amxo_parser_add_post_include	(	amxo_parser_t *	pctx,
		const char *	file_path
	)

Definition at line 290 of file amxo_parser_include.c.

                                                                             {
    int retval = -1;
    char* full_path = NULL;
    amxc_var_t* incstack = NULL;
 
    retval = amxo_parser_check(pctx, file_path, &incstack, &full_path);
    when_failed(retval, exit);
 
    if(pctx->post_includes == NULL) {
        amxc_var_new(&pctx->post_includes);
        amxc_var_set_type(pctx->post_includes, AMXC_VAR_ID_LIST);
    }
 
    amxc_var_add(cstring_t, pctx->post_includes, full_path);
 
exit:
    amxc_var_delete(&incstack);
    free(full_path);
    return retval;
}

amxo_parser_call_entry_point()

PRIVATE int amxo_parser_call_entry_point	(	amxo_parser_t *	pctx,
		const char *	lib_name,
		const char *	fn_name
	)

Definition at line 172 of file amxo_parser_utils.c.

                                                      {
    int retval = -1;
    amxc_string_t data;
    amxc_string_init(&data, 0);
    amxc_string_setf(&data, "%s", lib_name);
 
    when_true_status(amxo_parser_no_resolve(pctx), exit, retval = 0);
 
    pctx->resolved_fn = NULL;
    retval = amxo_parser_resolve(pctx, "import", fn_name, amxo_function_ep, amxc_string_get(&data, 0));
    if(retval == 1) {
        amxo_parser_msg(pctx,
                        "No entry point \"%s\" found using \"%s\"",
                        fn_name,
                        "import");
        pctx->status = amxd_status_function_not_found;
    }
 
    if(pctx->resolved_fn != NULL) {
        amxo_entry_point_t fn = (amxo_entry_point_t) pctx->resolved_fn;
        retval = amxo_parser_add_entry_point(pctx, fn);
        amxc_string_delete(&pctx->resolved_fn_name);
    }
 
exit:
    amxc_string_clean(&data);
    return retval;
}

amxo_parser_check_attr()

PRIVATE bool amxo_parser_check_attr	(	amxo_parser_t *	pctx,
		int64_t	attributes,
		int64_t	bitmask
	)

Definition at line 499 of file amxo_parser_dm_utils.c.

                                             {
    bool retval = false;
    int attr_mask = ~bitmask;
 
    int check_attr = attributes | attr_mask;
    pctx->status = (check_attr != attr_mask) ? amxd_status_ok : amxd_status_invalid_attr;
    retval = (check_attr != attr_mask);
    if(!retval) {
        amxo_parser_msg(pctx, "Invalid attributes given");
    }
    return retval;
}

amxo_parser_check_config()

PRIVATE bool amxo_parser_check_config	(	amxo_parser_t *	pctx,
		const char *	path,
		const char *	check
	)

Definition at line 477 of file amxo_parser_dm_utils.c.

                                                 {
    amxc_var_t* option = amxc_var_get_path(&pctx->config,
                                           path,
                                           AMXC_VAR_FLAG_DEFAULT);
    const char* value = NULL;
    value = amxc_var_constcast(cstring_t, option);
 
    if(value == NULL) {
        value = "error";
    }
 
    return strcmp(value, check) == 0;
}

amxo_parser_child_init()

PRIVATE void amxo_parser_child_init

(

amxo_parser_t *

parser

)

Definition at line 181 of file amxo_parser_main.c.

                                                   {
    when_null(parser, exit);
 
    parser->fd = -1;
    parser->object = NULL;
    parser->param = NULL;
    parser->func = NULL;
    parser->status = amxd_status_ok;
    parser->resolved_fn = NULL;
    parser->resolvers = NULL;
    parser->include_stack = NULL;
    parser->hooks = NULL;
    parser->entry_points = NULL;
    parser->_unused_1 = NULL;
    parser->_unused_2 = NULL;
    parser->post_includes = NULL;
    parser->parent = NULL;
    parser->resolved_fn_name = NULL;
    parser->buffer_len = 0;
    parser->data = NULL;
    parser->sync_contexts = NULL;
 
    memset(parser->buffer, 0, 128);
    amxc_rbuffer_init(&parser->rbuffer, 0);
    amxc_string_init(&parser->msg, 0);
    amxc_astack_init(&parser->object_stack);
    amxc_llist_init(&parser->event_list);
    amxc_var_init(&parser->config);
    amxc_llist_init(&parser->global_config);
    amxc_htable_init(&parser->mibs, 5);
    amxc_llist_init(&parser->function_names);
 
    parser->file = "<unknown>";
 
exit:
    return;
}

amxo_parser_clean_resolvers()

PRIVATE void amxo_parser_clean_resolvers

(

amxo_parser_t *

parser

)

Definition at line 103 of file amxo_resolver_mngr.c.

                                                        {
    amxc_htable_it_t* hit_data = NULL;
    amxc_htable_it_t* hit_resolver = NULL;
 
    when_null(parser->resolvers, exit);
 
    hit_data = amxc_htable_get_first(parser->resolvers);
    while(hit_data) {
        const char* key = amxc_htable_it_get_key(hit_data);
        amxo_resolver_t* resolver = NULL;
        hit_resolver = amxc_htable_get(&resolvers, key);
        resolver = amxc_htable_it_get_data(hit_resolver, amxo_resolver_t, hit);
        if(resolver->clean != NULL) {
            resolver->clean(parser, resolver->priv);
        }
        hit_data = amxc_htable_get_first(parser->resolvers);
    }
 
exit:
    return;
}

amxo_parser_create_lex()

PRIVATE void amxo_parser_create_lex

(

amxo_parser_t *

parser

)

amxo_parser_create_object()

PRIVATE int amxo_parser_create_object	(	amxo_parser_t *	pctx,
		const char *	name,
		int64_t	attr_bitmask,
		amxd_object_type_t	type
	)

Definition at line 520 of file amxo_parser_dm_utils.c.

                                                       {
    amxd_object_t* object = NULL;
    amxc_string_t res_name;
    int64_t oattrs = amxo_attr_2_object_attr(attr_bitmask);
    int retval = -1;
    amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
 
    amxc_string_init(&res_name, 0);
 
    if(amxc_string_set_resolved(&res_name, name, &pctx->config) > 0) {
        name = amxc_string_get(&res_name, 0);
    }
 
    pctx->status = amxd_status_ok;
    if(type == amxd_object_mib) {
        object = amxd_dm_get_mib(dm, name);
    } else {
        object = amxd_object_findf(pctx->object, "%s", name);
    }
    if(object == NULL) {
        object = amxo_parser_new_object(pctx, dm, name, oattrs, type);
        when_null(object, exit);
    } else {
        retval = amxo_parser_can_update_object(pctx, name, type);
        when_true(retval < 0, exit);
        amxd_object_set_attrs(object, oattrs, true);
    }
 
    amxo_hooks_create_object(pctx, name, oattrs, type);
 
    amxc_astack_push(&pctx->object_stack, pctx->object);
    pctx->object = object;
    amxo_parser_push_event(pctx, event_none);
    retval = 0;
 
exit:
    amxc_string_clean(&res_name);
    return retval;
}

amxo_parser_del_mib_info()

PRIVATE void amxo_parser_del_mib_info	(	const char *	key,
		amxc_htable_it_t *	it
	)

amxo_parser_del_sync_data()

PRIVATE void amxo_parser_del_sync_data

(

amxc_llist_it_t *

it

)

Definition at line 183 of file amxo_parser_dm_sync_utils.c.

                                                    {
    amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
    when_null(data, exit);
 
    amxc_llist_it_take(it);
    amxc_htable_it_clean(&data->hit, NULL);
 
    when_null(data->entry, exit);
 
    switch(data->entry->type) {
    case amxs_sync_type_ctx:
        amxs_sync_ctx_delete(&data->entry);
        break;
    case amxs_sync_type_object:
        amxs_sync_object_delete(&data->entry);
        break;
    case amxs_sync_type_param:
        amxs_sync_param_delete(&data->entry);
        break;
    default:
        break;
    }
 
exit:
    free(data);
}

amxo_parser_destroy_lex()

PRIVATE void amxo_parser_destroy_lex

(

amxo_parser_t *

parser

)

amxo_parser_fd_reader()

PRIVATE ssize_t amxo_parser_fd_reader	(	amxo_parser_t *	parser,
		char *	buf,
		size_t	max_size
	)

Definition at line 104 of file amxo_parser_main.c.

                                                                                 {
    ssize_t result = 0;
    off_t offset = 0;
 
    errno = 0;
    result = read(parser->fd, buf, max_size - 1);
    if((result == -1) && (errno != EAGAIN)) {
        printf("Read failed %d\n", errno);
        goto exit;
    }
    errno = 0;
 
    buf[result] = 0;
    while(result - offset > 0 && buf[result - offset - 1] != '\n') {
        offset++;
    }
    if(result - offset > 0) {
        lseek(parser->fd, -offset, SEEK_CUR);
        result -= offset;
    }
 
exit:
    return result;
}

amxo_parser_find()

PRIVATE void PRIVATE int PRIVATE bool amxo_parser_find	(	amxo_parser_t *	parser,
		const amxc_llist_t *	dirs,
		const char *	file_path,
		char **	full_path
	)

Definition at line 256 of file amxo_parser_include.c.

                                        {
    bool retval = false;
 
    if(file_path[0] != '/') {
        amxc_string_t res_path;
        amxc_string_init(&res_path, 0);
        amxc_llist_for_each(it, dirs) {
            amxc_var_t* var_dir = amxc_var_from_llist_it(it);
            const char* dir = amxc_var_constcast(cstring_t, var_dir);
            if(amxc_string_set_resolved(&res_path, dir, &parser->config) > 0) {
                dir = amxc_string_get(&res_path, 0);
            }
 
            if(amxo_parser_exists(dir, file_path, full_path)) {
                break;
            }
            amxc_string_reset(&res_path);
        }
        amxc_string_clean(&res_path);
        when_null(*full_path, exit);
    } else {
        if(!amxo_parser_exists(NULL, file_path, full_path)) {
            goto exit;
        }
    }
    retval = true;
 
exit:
    return retval;
}

amxo_parser_free_event()

PRIVATE void amxo_parser_free_event

(

amxc_llist_it_t *

it

)

Definition at line 493 of file amxo_parser_dm_utils.c.

                                                 {
    event_t* e = amxc_container_of(it, event_t, it);
    amxc_var_clean(&e->data);
    free(e);
}

amxo_parser_get_action_id()

PRIVATE amxo_action_t amxo_parser_get_action_id	(	amxo_parser_t *	pctx,
		const char *	action_name
	)

Definition at line 203 of file amxo_parser_utils.c.

                                                                 {
    static const char* names[] = {
        "any",
        "read",
        "write",
        "validate",
        "list",
        "describe",
        "add-inst",
        "del-inst",
        "destroy",
        "translate",
        "apply"
    };
    amxo_action_t action_id = amxo_action_invalid;
    amxc_var_t* ca = GET_ARG(&pctx->config, "_current_action");
 
    for(int i = 0; i <= action_max; i++) {
        if(strcmp(action_name, names[i]) == 0) {
            action_id = (amxo_action_t) i;
            break;
        }
    }
 
    if(action_id < 0) {
        pctx->status = amxd_status_invalid_action;
        amxo_parser_msg(pctx,
                        "Invalid action name \"%s\"",
                        action_name);
    }
 
    if(ca == NULL) {
        amxc_var_add_key(uint32_t, &pctx->config, "_current_action", action_id);
    } else {
        amxc_var_set(uint32_t, ca, action_id);
    }
 
    return action_id;
}

amxo_parser_get_resolvers()

PRIVATE amxc_htable_t* amxo_parser_get_resolvers

(

void

)

Definition at line 99 of file amxo_resolver_mngr.c.

                                               {
    return &resolvers;
}

amxo_parser_get_sync_type()

PRIVATE amxs_sync_entry_type_t amxo_parser_get_sync_type

(

amxo_parser_t *

pctx

)

Definition at line 158 of file amxo_parser_dm_sync_utils.c.

                                                                      {
    amxs_sync_entry_type_t type = amxs_sync_type_invalid;
    amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
    when_null(sync_data, exit);
    when_null(sync_data->entry, exit);
 
    type = sync_data->entry->type;
 
exit:
    return type;
}

amxo_parser_include()

PRIVATE int amxo_parser_include	(	amxo_parser_t *	pctx,
		const char *	file_path
	)

Definition at line 311 of file amxo_parser_include.c.

                                                                    {
    int retval = -1;
    char* full_path = NULL;
    amxc_var_t* incstack = NULL;
    struct stat statbuf;
 
    retval = amxo_parser_check(pctx, file_path, &incstack, &full_path);
    when_failed(retval, exit);
 
    stat(full_path, &statbuf);
 
    if(S_ISDIR(statbuf.st_mode)) {
        retval = amxo_parser_include_dir(pctx, full_path);
    } else {
        retval = amxo_parser_include_file(pctx, full_path);
    }
 
exit:
    amxc_var_delete(&incstack);
    free(full_path);
    return retval;
}

amxo_parser_init_resolvers()

PRIVATE void amxo_parser_init_resolvers

(

amxo_parser_t *

parser

)

Definition at line 125 of file amxo_resolver_mngr.c.

                                                       {
    amxc_htable_for_each(hit, (&resolvers)) {
        amxo_resolver_t* resolver =
            amxc_htable_it_get_data(hit, amxo_resolver_t, hit);
        if(resolver->get != NULL) {
            resolver->get(parser, resolver->priv);
        }
    }
 
    return;
}

amxo_parser_is_sync_item()

PRIVATE bool amxo_parser_is_sync_item

(

amxo_parser_t *

pctx

)

Definition at line 170 of file amxo_parser_dm_sync_utils.c.

                                                   {
    amxs_sync_entry_type_t type = amxo_parser_get_sync_type(pctx);
    return (type == amxs_sync_type_object || type == amxs_sync_type_param);
}

amxo_parser_msg()

PRIVATE void amxo_parser_msg	(	amxo_parser_t *	parser,
		const char *	format,
			...
	)

amxo_parser_no_resolve()

PRIVATE bool amxo_parser_no_resolve

(

amxo_parser_t *

parser

)

Definition at line 87 of file amxo_parser_utils.c.

                                                   {
    amxc_var_t* var_resolve = GET_ARG(&parser->config, "odl-resolve");
    bool resolve = true;
 
    if(var_resolve != NULL) {
        resolve = amxc_var_dyncast(bool, var_resolve);
    }
 
    return !resolve;
}

amxo_parser_parse_file_impl()

PRIVATE int amxo_parser_parse_file_impl	(	amxo_parser_t *	parser,
		const char *	file_path,
		amxd_object_t *	object
	)

Definition at line 156 of file amxo_parser_main.c.

                                                       {
    int retval = -1;
    int fd = -1;
 
    fd = open(file_path, O_RDONLY);
    if(fd == -1) {
        retval = errno;
        if(errno == ENOENT) {
            amxo_parser_msg(parser, "File not found %s", file_path);
        } else {
            amxo_parser_msg(parser, "File open error 0x%8.8X", errno);
        }
        goto exit;
    }
    parser->file = file_path;
    retval = amxo_parser_parse_fd_internal(parser, fd, object);
    parser->file = NULL;
    close(fd);
 
exit:
    return retval;
}

amxo_parser_pop_func()

PRIVATE void amxo_parser_pop_func

(

amxo_parser_t *

pctx

)

Definition at line 172 of file amxo_parser_dm_func_utils.c.

                                               {
    amxd_object_fn_t fn = NULL;
    amxo_hooks_end_func(pctx);
    fn = (amxd_object_fn_t) pctx->resolved_fn;
    amxd_function_set_impl(pctx->func, fn);
    amxc_string_delete(&pctx->resolved_fn_name);
    pctx->func = NULL;
    pctx->resolved_fn = NULL;
}

amxo_parser_pop_object()

PRIVATE bool amxo_parser_pop_object

(

amxo_parser_t *

pctx

)

Definition at line 634 of file amxo_parser_dm_utils.c.

                                                 {
    bool retval = false;
    amxd_object_type_t type = amxd_object_get_type(pctx->object);
    const char* type_name = (type == amxd_object_mib) ? "mib" : "object";
    amxc_var_t args;
 
    pctx->status = amxd_object_validate(pctx->object, 0);
 
    amxc_var_init(&args);
    amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
 
    if(pctx->status != amxd_status_ok) {
        amxo_parser_msg(pctx, "%s %s validation failed",
                        type_name,
                        amxd_object_get_name(pctx->object, AMXD_OBJECT_NAMED));
        goto exit;
    }
 
    amxd_dm_invoke_action(pctx->object, NULL, action_object_write, &args, NULL);
    amxo_hooks_end_object(pctx);
 
    pctx->object = (amxd_object_t*) amxc_astack_pop(&pctx->object_stack);
 
    retval = true;
 
exit:
    amxc_var_clean(&args);
    return retval;
}

amxo_parser_pop_param()

PRIVATE bool amxo_parser_pop_param

(

amxo_parser_t *

pctx

)

Definition at line 348 of file amxo_parser_dm_param_utils.c.

                                                {
    bool retval = false;
    amxc_var_t value;
    amxc_var_init(&value);
 
    if(pctx->param != NULL) {
        amxc_var_copy(&value, &pctx->param->value);
        pctx->status = amxd_param_validate(pctx->param, &value);
        if(pctx->status != amxd_status_ok) {
            amxo_parser_msg(pctx, "Parameter %s validation failed",
                            amxd_param_get_name(pctx->param));
            goto exit;
        }
 
        amxo_hooks_end_param(pctx);
        pctx->param = NULL;
    }
    retval = true;
 
exit:
    amxc_var_clean(&value);
    return retval;
}

amxo_parser_pop_sync_item()

PRIVATE void amxo_parser_pop_sync_item

(

amxo_parser_t *

pctx

)

Definition at line 210 of file amxo_parser_dm_sync_utils.c.

                                                    {
    amxo_sync_data_t* data = NULL;
    when_null(pctx->sync_contexts, exit);
 
    data = amxo_parser_get_sync_data(pctx);
    amxc_llist_it_take(&data->it);
    free(data);
 
exit:
    return;
}

amxo_parser_print()

PRIVATE void amxo_parser_print	(	amxo_parser_t *	pctx,
		const char *	text
	)

Definition at line 244 of file amxo_parser_utils.c.

                                                              {
    amxc_string_t print_txt;
 
    amxc_string_init(&print_txt, 0);
 
    if(amxc_string_set_resolved(&print_txt, text, &pctx->config) > 0) {
        text = amxc_string_get(&print_txt, 0);
    }
 
    printf("%s (%s@%d)\n", text, pctx->file, pctx->line);
 
    amxc_string_clean(&print_txt);
}

amxo_parser_printf()

PRIVATE void PRIVATE int amxo_parser_printf	(	amxo_parser_t *	parser,
		const char *	format,
			...
	)

amxo_parser_push_func()

PRIVATE int amxo_parser_push_func	(	amxo_parser_t *	pctx,
		const char *	name,
		int64_t	attr_bitmask,
		uint32_t	type
	)

Definition at line 99 of file amxo_parser_dm_func_utils.c.

                                         {
    amxd_function_t* func = NULL;
    amxd_function_t* orig_func = NULL;
    int64_t fattrs = amxo_attr_2_func_attr(attr_bitmask);
    int retval = -1;
    amxc_string_t res_name;
    amxc_string_init(&res_name, 0);
 
    if(amxc_string_set_resolved(&res_name, name, &pctx->config) > 0) {
        name = amxc_string_get(&res_name, 0);
    }
 
    orig_func = amxd_object_get_function(pctx->object, name);
 
    pctx->status = amxd_function_new(&func, name, type, NULL);
    if(pctx->status != amxd_status_ok) {
        amxo_parser_msg(pctx, "Failed to create function %s", name);
        goto exit;
    }
 
    if(amxd_object_get_type(pctx->object) == amxd_object_instance) {
        fattrs |= SET_BIT(amxd_fattr_instance);
    }
 
    amxd_function_set_attrs(func, fattrs, true);
 
    if(orig_func != NULL) {
        if(amxd_function_get_owner(orig_func) == pctx->object) {
            amxd_function_delete(&orig_func);
        }
        amxo_parser_msg(pctx, "Overriding function %s", name);
        pctx->status = amxd_object_add_function(pctx->object, func);
        retval = 1;
    } else {
        pctx->status = amxd_object_add_function(pctx->object, func);
        retval = 0;
    }
 
    amxo_hooks_add_func(pctx, name, fattrs, type);
 
    pctx->func = func;
 
exit:
    amxc_string_clean(&res_name);
    return retval;
}

amxo_parser_push_object()

PRIVATE bool amxo_parser_push_object	(	amxo_parser_t *	pctx,
		const char *	name
	)

Definition at line 598 of file amxo_parser_dm_utils.c.

                                               {
    amxd_object_t* object = NULL;
    bool retval = false;
    amxc_string_t res_path;
    amxc_string_init(&res_path, 0);
 
    if(amxc_string_set_resolved(&res_path, path, &pctx->config) > 0) {
        path = amxc_string_get(&res_path, 0);
    }
 
    pctx->status = amxd_status_ok;
    object = amxd_object_findf(pctx->object, "%s", path);
    if(object == NULL) {
        char* parent_path = amxd_object_get_path(pctx->object, AMXD_OBJECT_NAMED);
        amxo_parser_msg(pctx,
                        "Object %s not found (start searching from \"%s\")",
                        path,
                        parent_path == NULL ? "root" : parent_path);
        free(parent_path);
        pctx->status = amxd_status_object_not_found;
        goto exit;
    }
 
    amxo_hooks_select_object(pctx, path);
 
    amxc_astack_push(&pctx->object_stack, pctx->object);
    pctx->object = object;
    amxo_parser_push_event(pctx, event_object_change);
    retval = true;
 
exit:
    amxc_string_clean(&res_path);
    return retval;
}

amxo_parser_push_param()

PRIVATE bool amxo_parser_push_param	(	amxo_parser_t *	pctx,
		const char *	name,
		int64_t	attr_bitmask,
		uint32_t	type
	)

Definition at line 292 of file amxo_parser_dm_param_utils.c.

                                           {
    amxd_param_t* param = NULL;
    int64_t pattrs = amxo_attr_2_param_attr(attr_bitmask);
    bool retval = false;
    amxc_string_t res_name;
    amxc_string_init(&res_name, 0);
 
    amxo_parser_set_event(pctx, event_none);
 
    if(amxc_string_set_resolved(&res_name, name, &pctx->config) > 0) {
        name = amxc_string_get(&res_name, 0);
    }
 
    pctx->status = amxd_status_ok;
    param = amxd_object_get_param_def(pctx->object, name);
    if(param == NULL) {
        retval = amxo_parser_add_param(pctx, name, pattrs, type);
    } else {
        retval = amxo_parser_update_param(pctx, param, name, type);
    }
 
    amxc_string_clean(&res_name);
    return retval;
}

amxo_parser_push_sync_ctx()

PRIVATE int amxo_parser_push_sync_ctx	(	amxo_parser_t *	pctx,
		const char *	path_a,
		const char *	path_b,
		int	direction
	)

Definition at line 222 of file amxo_parser_dm_sync_utils.c.

                                             {
    amxs_status_t status = amxs_status_unknown_error;
    amxc_string_t res_path_a;
    amxc_string_t res_path_b;
    amxd_dm_t* dm_a = NULL;
    amxd_dm_t* dm_b = NULL;
    amxo_sync_data_t* data =
        (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
 
    amxc_string_init(&res_path_a, 0);
    amxc_string_init(&res_path_b, 0);
    when_null(data, exit);
 
    if(amxc_string_set_resolved(&res_path_a, path_a, &pctx->config) > 0) {
        path_a = amxc_string_get(&res_path_a, 0);
    }
    if(amxc_string_set_resolved(&res_path_b, path_b, &pctx->config) > 0) {
        path_b = amxc_string_get(&res_path_b, 0);
    }
 
    status = amxs_sync_ctx_new(&data->entry, path_a, path_b, direction);
    if(status != 0) {
        amxo_parser_msg(pctx, MSG_CREATION_FAILED,
                        path_a, path_b, direction, status);
        amxo_parser_sync_set_status(pctx, status);
        data->entry = NULL;
        goto exit;
    }
 
    if((direction & AMXS_SYNC_ONLY_A_TO_B) == 0) {
        dm_a = amxo_parser_get_sync_dm(pctx, path_a);
    }
    if((direction & AMXS_SYNC_ONLY_B_TO_A) == 0) {
        dm_b = amxo_parser_get_sync_dm(pctx, path_b);
    }
 
    status = amxs_sync_ctx_set_local_dm(data->entry, dm_a, dm_b);
    if(status != 0) {
        amxo_parser_msg(pctx, MSG_SET_DM_FAILED,
                        path_a, path_b, direction, status);
        amxo_parser_sync_set_status(pctx, status);
        goto exit;
    }
 
    if(pctx->sync_contexts == NULL) {
        amxc_llist_new(&pctx->sync_contexts);
    }
    amxc_llist_append(pctx->sync_contexts, &data->it);
 
exit:
    if(status != 0) {
        if(data != NULL) {
            amxo_parser_del_sync_data(&data->it);
        }
    }
    amxc_string_clean(&res_path_a);
    amxc_string_clean(&res_path_b);
    return status;
}

amxo_parser_push_sync_object()

PRIVATE int amxo_parser_push_sync_object	(	amxo_parser_t *	pctx,
		const char *	path_a,
		const char *	path_b,
		int	direction
	)

Definition at line 320 of file amxo_parser_dm_sync_utils.c.

                                                {
    amxs_status_t status = amxs_status_unknown_error;
    amxc_string_t res_a;
    amxc_string_t res_b;
    amxo_sync_data_t* data = NULL;
 
    amxc_string_init(&res_a, 0);
    amxc_string_init(&res_b, 0);
 
    data = (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
    when_null(data, exit);
 
    if(amxc_string_set_resolved(&res_a, path_a, &pctx->config) > 0) {
        path_a = amxc_string_get(&res_a, 0);
    }
    if(amxc_string_set_resolved(&res_b, path_b, &pctx->config) > 0) {
        path_b = amxc_string_get(&res_b, 0);
    }
 
    status = amxs_sync_object_new_copy(&data->entry, path_a, path_b, direction);
    when_failed_status(status, exit, data->entry = NULL);
 
    status = amxo_parser_sync_add_item(pctx, data,
                                       amxs_sync_ctx_add_object,
                                       amxs_sync_object_add_object);
 
exit:
    if(status != 0) {
        amxo_parser_msg(pctx, MSG_CREATION_FAILED,
                        path_a, path_b, direction, status);
        amxo_parser_sync_set_status(pctx, status);
        if(data != NULL) {
            amxs_sync_object_delete(&data->entry);
        }
        free(data);
    }
    amxc_string_clean(&res_a);
    amxc_string_clean(&res_b);
    return status;
}

amxo_parser_push_sync_parameter()

PRIVATE int amxo_parser_push_sync_parameter	(	amxo_parser_t *	pctx,
		const char *	param_a,
		const char *	param_b,
		int	direction
	)

Definition at line 364 of file amxo_parser_dm_sync_utils.c.

                                                   {
    amxs_status_t status = amxs_status_unknown_error;
    amxc_string_t res_a;
    amxc_string_t res_b;
    amxo_sync_data_t* data = NULL;
 
    amxc_string_init(&res_a, 0);
    amxc_string_init(&res_b, 0);
 
    data = (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
    when_null(data, exit);
 
    if(amxc_string_set_resolved(&res_a, param_a, &pctx->config) > 0) {
        param_a = amxc_string_get(&res_a, 0);
    }
    if(amxc_string_set_resolved(&res_b, param_b, &pctx->config) > 0) {
        param_b = amxc_string_get(&res_b, 0);
    }
 
    status = amxs_sync_param_new_copy(&data->entry, param_a, param_b, direction);
    when_failed_status(status, exit, data->entry = NULL);
 
    status = amxo_parser_sync_add_item(pctx,
                                       data,
                                       amxs_sync_ctx_add_param,
                                       amxs_sync_object_add_param);
 
exit:
    if(status != 0) {
        amxo_parser_msg(pctx, MSG_CREATION_FAILED,
                        param_a, param_b, direction, status);
        amxo_parser_sync_set_status(pctx, status);
        if(data != NULL) {
            amxs_sync_param_delete(&data->entry);
        }
        free(data);
    }
    amxc_string_clean(&res_a);
    amxc_string_clean(&res_b);
    return status;
}

amxo_parser_push_sync_template()

PRIVATE int amxo_parser_push_sync_template	(	amxo_parser_t *	pctx,
		const char *	path_a,
		const char *	path_b,
		int	direction,
		const char *	name
	)

Definition at line 285 of file amxo_parser_dm_sync_utils.c.

                                                     {
    int status = amxs_status_unknown_error;
    amxd_path_t path;
    amxo_sync_data_t* data = NULL;
    amxd_path_init(&path, NULL);
 
    status = amxo_parser_push_sync_ctx(pctx, path_a, path_b, direction);
    when_failed(status, exit);
 
    data = amxo_parser_get_sync_data(pctx);
    status = amxs_status_invalid_type;
    amxd_path_setf(&path, false, "%s", data->entry->a);
    when_true(amxd_path_is_instance_path(&path), exit);
    when_false(amxd_path_is_supported_path(&path) || amxd_path_is_object_path(&path), exit);
    amxd_path_setf(&path, false, "%s", data->entry->b);
    when_true(amxd_path_is_instance_path(&path), exit);
    when_false(amxd_path_is_supported_path(&path) || amxd_path_is_object_path(&path), exit);
    status = amxs_status_ok;
 
    amxc_htable_insert(&sync_templates, name, &data->hit);
 
exit:
    if(status != 0) {
        if(data != NULL) {
            amxo_parser_del_sync_data(&data->it);
        }
    }
    amxd_path_clean(&path);
    return status;
}

amxo_parser_resolve()

PRIVATE int amxo_parser_resolve	(	amxo_parser_t *	parser,
		const char *	resolver_name,
		const char *	func_name,
		amxo_fn_type_t	type,
		const char *	data
	)

Definition at line 63 of file amxo_resolver_mngr.c.

                                          {
    int retval = -1;
    amxo_resolver_t* resolver = NULL;
    amxc_htable_it_t* hit = NULL;
    amxc_string_t res_name;
    amxc_string_init(&res_name, 0);
 
    if(amxc_string_set_resolved(&res_name, resolver_name, &parser->config) > 0) {
        resolver_name = amxc_string_get(&res_name, 0);
    }
 
    hit = amxc_htable_get(&resolvers, resolver_name);
    when_null(hit, exit);
 
    parser->status = amxd_status_ok;
    resolver = amxc_htable_it_get_data(hit, amxo_resolver_t, hit);
    parser->resolved_fn = resolver->resolve(parser,
                                            func_name,
                                            type,
                                            data,
                                            resolver->priv);
    if(parser->status == amxd_status_ok) {
        retval = parser->resolved_fn == NULL ? 1 : 0;
    } else {
        retval = -2;
    }
 
exit:
    amxc_string_clean(&res_name);
    return retval;
}

amxo_parser_resolve_internal()

PRIVATE int amxo_parser_resolve_internal	(	amxo_parser_t *	parser,
		const char *	fn_name,
		amxo_fn_type_t	type,
		const char *	data
	)

Definition at line 124 of file amxo_parser_utils.c.

                                                   {
    int retval = -1;
    char* name = NULL;
    const char* res_data = NULL;
 
    when_true_status(amxo_parser_no_resolve(pctx), exit, retval = 0);
 
    if((data == NULL) || (data[0] == '\0')) {
        amxo_parser_msg(pctx, "Resolver name must be provide (is empty)");
        pctx->status = amxd_status_invalid_name;
        goto exit;
    }
 
    name = amxo_parser_get_resolver_name(data);
    if((name == NULL) || (name[0] == '\0')) {
        amxo_parser_msg(pctx, "Resolver name must be provide (is empty)");
        pctx->status = amxd_status_invalid_name;
        goto exit;
    }
    res_data = data + strlen(name);
    while(isspace(res_data[0]) || res_data[0] == ':') {
        res_data++;
    }
 
    pctx->resolved_fn = NULL;
    retval = amxo_parser_resolve(pctx, name, fn_name, type, res_data);
    if(retval == -1) {
        pctx->status = amxd_status_invalid_name;
        amxo_parser_msg(pctx, "No function resolver found with name \"%s\"", name);
    } else if(retval == 1) {
        pctx->status = amxd_status_function_not_found;
        amxo_parser_msg(pctx,
                        "No function implemention found for \"%s\" using \"%s\"",
                        fn_name,
                        name);
    } else if(retval == 0) {
        amxc_string_new(&pctx->resolved_fn_name, 0);
        amxc_string_set(pctx->resolved_fn_name, fn_name);
    }
 
exit:
    free(name);
    return retval;
}

amxo_parser_resolve_value()

PRIVATE void amxo_parser_resolve_value	(	amxo_parser_t *	pctx,
		amxc_string_t *	value
	)

Definition at line 258 of file amxo_parser_utils.c.

                                                                          {
    amxc_string_trim(value, NULL);
    amxc_string_resolve(value, &pctx->config);
}

amxo_parser_set_action()

PRIVATE int amxo_parser_set_action	(	amxo_parser_t *	pctx,
		amxo_action_t	action,
		const char *	name,
		amxc_var_t *	data
	)

Definition at line 813 of file amxo_parser_dm_utils.c.

                                             {
 
    int retval = -1;
    bool resolve = !amxo_parser_no_resolve(pctx);
    pctx->status = amxd_status_ok;
 
    if((pctx->sync_contexts != NULL) && amxo_parser_is_sync_item(pctx)) {
        retval = amxo_parser_set_sync_action(pctx, action, name, data);
    } else if(pctx->param != NULL) {
        retval = amxo_parser_set_param_action(pctx, action, name, data);
    } else {
        retval = amxo_parser_set_object_action(pctx, action, name, data);
    }
 
    if((pctx->resolved_fn == NULL) && resolve) {
        retval = 1;
        pctx->status = amxd_status_file_not_found;
        amxo_parser_msg(pctx, "Action %d not set - no function resolved", action);
    }
 
    amxc_string_delete(&pctx->resolved_fn_name);
    if((retval != 0) || !resolve) {
        amxc_var_delete(&data);
    }
    return retval;
}

amxo_parser_set_counter()

PRIVATE bool amxo_parser_set_counter	(	amxo_parser_t *	pctx,
		const char *	param_name
	)

Definition at line 664 of file amxo_parser_dm_utils.c.

                                                     {
    bool retval = false;
    amxc_string_t res_param_name;
    amxc_string_init(&res_param_name, 0);
 
    if(amxc_string_set_resolved(&res_param_name, param_name, &pctx->config) > 0) {
        param_name = amxc_string_get(&res_param_name, 0);
    }
 
    pctx->status = amxd_object_set_counter(pctx->object, param_name);
    if(pctx->status != amxd_status_ok) {
        char* path = amxd_object_get_path(pctx->object, AMXD_OBJECT_NAMED);
        amxo_parser_msg(pctx,
                        "Failed to to set instance counter %s on %s",
                        param_name,
                        path);
        pctx->status = amxd_status_duplicate;
        free(path);
        goto exit;
    }
 
    amxo_hooks_set_counter(pctx, param_name);
 
    retval = true;
 
exit:
    amxc_string_clean(&res_param_name);
    return retval;
}

amxo_parser_set_function_flags()

PRIVATE bool amxo_parser_set_function_flags	(	amxo_parser_t *	pctx,
		amxc_var_t *	flags
	)

Definition at line 149 of file amxo_parser_dm_func_utils.c.

                                                                            {
    const amxc_htable_t* ht_flags = NULL;
 
    when_null(flags, exit);
    when_true(amxc_var_type_of(flags) != AMXC_VAR_ID_HTABLE, exit);
 
    ht_flags = amxc_var_constcast(amxc_htable_t, flags);
    amxc_htable_for_each(it, ht_flags) {
        const char* flag_name = amxc_htable_it_get_key(it);
        amxc_var_t* flag = amxc_var_from_htable_it(it);
        if(amxc_var_dyncast(bool, flag)) {
            amxd_function_set_flag(pctx->func, flag_name);
        } else {
            amxd_function_unset_flag(pctx->func, flag_name);
        }
    }
 
    amxc_var_delete(&flags);
 
exit:
    return true;
}

amxo_parser_set_object_attrs()

PRIVATE bool amxo_parser_set_object_attrs	(	amxo_parser_t *	pctx,
		uint64_t	attr,
		bool	enable
	)

Definition at line 514 of file amxo_parser_dm_utils.c.

                                                                                   {
    int64_t oattrs = amxo_attr_2_object_attr(attr);
    amxd_object_set_attrs(pctx->object, oattrs, enable);
    return true;
}

amxo_parser_set_param()

PRIVATE int amxo_parser_set_param	(	amxo_parser_t *	pctx,
		const char *	name,
		amxc_var_t *	value
	)

Definition at line 320 of file amxo_parser_dm_param_utils.c.

                                             {
    amxd_param_t* param = NULL;
    int retval = -1;
    char* parent_path = amxd_object_get_path(pctx->object, AMXD_OBJECT_NAMED);
    amxc_string_t res_name;
    amxc_string_init(&res_name, 0);
 
    if(amxc_string_set_resolved(&res_name, name, &pctx->config) > 0) {
        name = amxc_string_get(&res_name, 0);
    }
 
    pctx->status = amxd_status_ok;
    param = pctx->param == NULL ? amxd_object_get_param_def(pctx->object, name) : pctx->param;
    if(param == NULL) {
        param = amxo_parser_check_param(pctx, name, parent_path, value, &retval);
    }
    if(param != NULL) {
        amxo_parser_data_event(pctx, param);
        retval = amxo_parser_set_param_value(pctx, parent_path, name, param, value);
    }
 
    amxc_string_clean(&res_name);
    free(parent_path);
    return retval;
}

amxo_parser_set_param_attrs()

PRIVATE bool amxo_parser_set_param_attrs	(	amxo_parser_t *	pctx,
		uint64_t	attr,
		bool	enable
	)

Definition at line 263 of file amxo_parser_dm_param_utils.c.

                                                                                  {
    int64_t pattrs = amxo_attr_2_param_attr(attr);
    amxd_param_set_attrs(pctx->param, pattrs, enable);
    return true;
}

amxo_parser_set_param_flags()

PRIVATE bool amxo_parser_set_param_flags	(	amxo_parser_t *	pctx,
		amxc_var_t *	flags
	)

Definition at line 269 of file amxo_parser_dm_param_utils.c.

                                                                         {
    const amxc_htable_t* ht_flags = NULL;
 
    when_null(flags, exit);
    when_true(amxc_var_type_of(flags) != AMXC_VAR_ID_HTABLE, exit);
 
    ht_flags = amxc_var_constcast(amxc_htable_t, flags);
    amxc_htable_for_each(it, ht_flags) {
        const char* flag_name = amxc_htable_it_get_key(it);
        amxc_var_t* flag = amxc_var_from_htable_it(it);
        if(amxc_var_dyncast(bool, flag)) {
            amxd_param_set_flag(pctx->param, flag_name);
        } else {
            amxd_param_unset_flag(pctx->param, flag_name);
        }
    }
 
    amxc_var_delete(&flags);
 
exit:
    return true;
}

amxo_parser_start_sync()

PRIVATE int amxo_parser_start_sync

(

amxc_llist_it_t *

it

)

Definition at line 464 of file amxo_parser_dm_sync_utils.c.

                                                {
    int status = -1;
    amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
    when_null(data, exit);
    when_null(data->entry, exit);
    when_false(data->entry->type == amxs_sync_type_ctx, exit);
 
    if(amxc_htable_it_get_key(&data->hit) == NULL) {
        if(!amxs_sync_ctx_is_started(data->entry)) {
            status = amxs_sync_ctx_start_sync(data->entry);
        }
    } else {
        status = 0;
    }
 
exit:
    return status;
}

amxo_parser_stop_sync()

PRIVATE void amxo_parser_stop_sync

(

amxc_llist_it_t *

it

)

Definition at line 483 of file amxo_parser_dm_sync_utils.c.

                                                {
    amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
    when_null(data, exit);
    when_null(data->entry, exit);
    when_false(data->entry->type == amxs_sync_type_ctx, exit);
 
    if(amxc_htable_it_get_key(&data->hit) == NULL) {
        amxs_sync_ctx_stop_sync(data->entry);
    }
 
exit:
    return;
}

amxo_parser_subscribe()

PRIVATE int amxo_parser_subscribe	(	amxo_parser_t *	pctx,
		const char *	event,
		bool	event_is_regexp,
		const char *	full_expr
	)

Definition at line 738 of file amxo_parser_dm_utils.c.

                                                 {
    int retval = 1;
    amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
    amxp_slot_fn_t fn = (amxp_slot_fn_t) pctx->resolved_fn;
 
    when_true_status(amxo_parser_no_resolve(pctx), exit, retval = 0);
    when_null(dm, exit);
 
    if(pctx->resolved_fn == NULL) {
        amxo_parser_msg(pctx,
                        "No event subscription created - no function was resolved");
        pctx->status = amxd_status_ok;
        goto exit;
    }
 
    if(full_expr != NULL) {
        amxc_string_t res_expr;
        amxc_string_init(&res_expr, 0);
        if(amxc_string_set_resolved(&res_expr, full_expr, &pctx->config) > 0) {
            full_expr = amxc_string_get(&res_expr, 0);
        }
        retval = amxo_parser_connect(pctx, &dm->sigmngr, event, event_is_regexp, full_expr, fn);
        amxc_string_clean(&res_expr);
    } else {
        retval = amxo_parser_connect(pctx, &dm->sigmngr, event, event_is_regexp, NULL, fn);
    }
 
exit:
    return retval;
}

amxo_parser_subscribe_object()

PRIVATE int amxo_parser_subscribe_object	(	amxo_parser_t *	pctx,
		const char *	event,
		bool	event_is_regexp,
		const char *	full_expr
	)

Definition at line 772 of file amxo_parser_dm_utils.c.

                                                        {
    int retval = 1;
    amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
    amxp_slot_fn_t fn = (amxp_slot_fn_t) pctx->resolved_fn;
    amxc_string_t path_expr;
 
    amxc_string_init(&path_expr, 0);
 
    when_true_status(amxo_parser_no_resolve(pctx), exit, retval = 0);
    when_null(dm, exit);
 
    if(pctx->resolved_fn == NULL) {
        amxo_parser_msg(pctx,
                        "No event subscription created - no function was resolved");
        pctx->status = amxd_status_ok;
        goto exit;
    }
 
    amxo_parser_build_path_expr(pctx->object, &path_expr);
    if((full_expr != NULL) && (*full_expr != 0)) {
        if(amxc_string_is_empty(&path_expr)) {
            amxc_string_set(&path_expr, full_expr);
        } else {
            amxc_string_appendf(&path_expr, " && (%s)", full_expr);
        }
    }
    retval = amxo_parser_connect(pctx,
                                 &dm->sigmngr,
                                 event,
                                 event_is_regexp,
                                 amxc_string_get(&path_expr, 0),
                                 fn);
 
exit:
    amxc_string_clean(&path_expr);
    return retval;
}

amxo_parser_subscribe_path()

PRIVATE int amxo_parser_subscribe_path	(	amxo_parser_t *	pctx,
		const char *	event,
		bool	event_is_regexp,
		const char *	path,
		bool	path_is_regexp
	)

Definition at line 695 of file amxo_parser_dm_utils.c.

                                                    {
    int retval = 1;
    amxc_string_t res_path;
    amxc_string_t expression;
    const char* expr = NULL;
    amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
    amxp_slot_fn_t fn = (amxp_slot_fn_t) pctx->resolved_fn;
 
    amxc_string_init(&expression, 0);
    amxc_string_init(&res_path, 0);
 
    when_true_status(amxo_parser_no_resolve(pctx), exit, retval = 0);
    when_null(dm, exit);
 
    if(pctx->resolved_fn == NULL) {
        amxo_parser_msg(pctx,
                        "No event subscription created - no function was resolved");
        pctx->status = amxd_status_ok;
        goto exit;
    }
 
    if(amxc_string_set_resolved(&res_path, path, &pctx->config) > 0) {
        path = amxc_string_get(&res_path, 0);
    }
    if(path_is_regexp) {
        amxc_string_appendf(&expression, "object matches \"%s\" || path matches \"%s\"", path, path);
    } else {
        amxc_string_appendf(&expression, "object starts with \"%s\" || path starts with \"%s\"", path, path);
    }
    expr = amxc_string_get(&expression, 0);
    retval = amxo_parser_connect(pctx, &dm->sigmngr, event, event_is_regexp, expr, fn);
 
exit:
    amxc_string_clean(&expression);
    amxc_string_clean(&res_path);
 
    return retval;
}

amxo_parser_sync_get()

PRIVATE amxs_sync_ctx_t* amxo_parser_sync_get

(

const char *

sync_template

)

Definition at line 526 of file amxo_parser_dm_sync_utils.c.

                                                                 {
    amxs_sync_ctx_t* ctx = NULL;
    amxo_sync_data_t* sync_data = NULL;
    amxc_htable_it_t* hit = amxc_htable_get(&sync_templates, sync_template);
 
    when_null(hit, exit);
    sync_data = amxc_container_of(hit, amxo_sync_data_t, hit);
 
    ctx = sync_data->entry;
 
exit:
    return ctx;
}

amxo_parser_sync_item_contains_entries()

PRIVATE bool amxo_parser_sync_item_contains_entries

(

amxo_parser_t *

pctx

)

Definition at line 447 of file amxo_parser_dm_sync_utils.c.

                                                                 {
    bool retval = false;
    amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
    when_null(sync_data, exit);
    when_null(sync_data->entry, exit);
 
    retval = true;
    if(amxc_llist_is_empty(&sync_data->entry->entries)) {
        amxo_parser_msg(pctx, MSG_MUST_CONTAIN_SYNC_ENTRIES);
        pctx->status = amxd_status_invalid_action;
        retval = false;
    }
 
exit:
    return retval;
}

amxo_parser_sync_remove_invalid()

PRIVATE void amxo_parser_sync_remove_invalid

(

amxo_parser_t *

pctx

)

Definition at line 497 of file amxo_parser_dm_sync_utils.c.

                                                          {
    when_null(pctx, exit);
    when_null(pctx->sync_contexts, exit);
 
    amxc_llist_for_each_reverse(it, pctx->sync_contexts) {
        amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
        switch(data->entry->type) {
        case amxs_sync_type_param:
        case amxs_sync_type_object:
            amxo_parser_del_sync_data(it);
            break;
        case amxs_sync_type_ctx:
            if(amxc_llist_is_empty(&data->entry->entries)) {
                amxo_parser_del_sync_data(it);
            }
            break;
        default:
            break;
        }
    }
 
    if(amxc_llist_is_empty(pctx->sync_contexts)) {
        amxc_llist_delete(&pctx->sync_contexts, NULL);
    }
 
exit:
    return;
}

amxo_parser_sync_set_action()

PRIVATE amxd_status_t amxo_parser_sync_set_action	(	amxo_parser_t *	pctx,
		amxs_action_cb_t	cb
	)

Definition at line 428 of file amxo_parser_dm_sync_utils.c.

                                                               {
    amxd_status_t status = amxd_status_unknown_error;
    amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
    when_null(sync_data, exit);
    when_null(sync_data->entry, exit);
 
    if(amxs_sync_entry_is_batch_param(sync_data->entry)) {
        amxo_parser_msg(pctx, MSG_BATCH_PARAM_WITH_CB);
        pctx->status = amxd_status_invalid_action;
    } else {
        sync_data->entry->action_cb = cb;
        status = amxd_status_ok;
    }
 
exit:
    return status;
}

amxo_parser_sync_set_translator()

PRIVATE amxd_status_t amxo_parser_sync_set_translator	(	amxo_parser_t *	pctx,
		amxs_translation_cb_t	cb
	)

Definition at line 409 of file amxo_parser_dm_sync_utils.c.

                                                                        {
    amxd_status_t status = amxd_status_unknown_error;
    amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
    when_null(sync_data, exit);
    when_null(sync_data->entry, exit);
 
    if(amxs_sync_entry_is_batch_param(sync_data->entry)) {
        amxo_parser_msg(pctx, MSG_BATCH_PARAM_WITH_CB);
        pctx->status = amxd_status_invalid_action;
    } else {
        sync_data->entry->translation_cb = cb;
        status = amxd_status_ok;
    }
 
exit:
    return status;
}

amxo_parser_sync_update_flags()

PRIVATE int amxo_parser_sync_update_flags

(

int

direction

)

Definition at line 175 of file amxo_parser_dm_sync_utils.c.

                                                 {
    if((direction & AMXS_SYNC_ONLY_B_TO_A) == AMXS_SYNC_ONLY_B_TO_A) {
        direction |= AMXS_SYNC_INIT_B;
    }
 
    return direction;
}

amxo_resolver_import_clean()

PRIVATE void amxo_resolver_import_clean	(	amxo_parser_t *	parser,
		void *	priv
	)