Data Model Default Parameter Action Implementations

Collaboration diagram for Data Model Default Parameter Action Implementations:

Functions
amxd_status_t	amxd_action_param_read (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter read action implementation. More...
amxd_status_t	amxd_action_param_read_hidden_value (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter read action implementation for hidden values. More...
amxd_status_t	amxd_action_param_write (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter write action implementation. More...
amxd_status_t	amxd_action_param_validate (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter validate action implementation. More...
amxd_status_t	amxd_action_param_check_range (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default check range parameter validate action implementation. More...
amxd_status_t	amxd_action_param_check_minimum (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default check minimum parameter validate action implementation. More...
amxd_status_t	amxd_action_param_check_maximum (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default check maximum parameter validate action implementation. More...
amxd_status_t	amxd_action_param_check_enum (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default check enum parameter validate action implementation. More...
amxd_status_t	amxd_action_param_check_is_in (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default check is in parameter validate action implementation. More...
amxd_status_t	amxd_action_param_describe (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter describe action implementation. More...
amxd_status_t	amxd_action_param_destroy (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
	Default parameter destroy action implementation. More...

Detailed Description

Function Documentation

amxd_action_param_check_enum()

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

Default check enum parameter validate action implementation.

This default implementation checks if the new value is in a list of allowed values.

The allowed value must be defined in as a list variant which contains all possible values. The variant pointer must be set as the priv data.

If the new value is a comma or space separated string of values, then each value must be in the list of possible values.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	A pointer to a variant, containing the a variant list of allowed values

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type or not an allowed values)

Definition at line 369 of file amxd_action_param_validate.c.

                                                       {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* data = (amxc_var_t*) priv;
    const amxc_llist_t* values = NULL;
    amxc_var_t check_value;
 
    amxc_var_init(&check_value);
    when_true_status(amxc_var_type_of(data) != AMXC_VAR_ID_LIST,
                     exit,
                     status = amxd_status_invalid_type);
 
    status = amxd_action_describe_action(reason, retval, "check_enum", priv);
    when_true(status == amxd_status_ok, exit);
 
    status = amxd_action_param_validate(object, param, reason, args, retval, priv);
    when_failed(status, exit);
 
    when_true_status(is_key_in_template(object, param), exit, status = amxd_status_ok);
 
    amxc_var_convert(&check_value, args, amxd_param_get_type(param));
    values = amxc_var_constcast(amxc_llist_t, data);
    when_false_status(is_value_in(&check_value, values),
                      exit,
                      status = amxd_status_invalid_value);
 
exit:
    amxc_var_clean(&check_value);
    return status;
}

amxd_action_param_check_is_in()

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

Default check is in parameter validate action implementation.

This default implementation checks if the new value is in a list of possible values. The list of possible values is fetched from a parameter in the local data model. The referenced parameter path is provided as a string variant. The pointer to the string variant is provided as the private data.

If the referenced parameter, that contains the list of valid values, is an empty string, any value is accepted.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	A pointer to a string variant, containing the path to a parameter that contains the list of possible values (as a csv or ssv string)

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type or not an allowed values)

Definition at line 404 of file amxd_action_param_validate.c.

                                                        {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* data = (amxc_var_t*) priv;
    amxc_var_t* ref_value = NULL;
    amxc_llist_t* values = NULL;
    amxc_var_t check_value;
 
    amxc_var_init(&check_value);
    when_true_status(amxc_var_type_of(data) != AMXC_VAR_ID_CSTRING,
                     exit,
                     status = amxd_status_invalid_type);
 
    status = amxd_action_describe_action(reason, retval, "check_is_in", priv);
    when_true(status == amxd_status_ok, exit);
 
    status = amxd_action_param_validate(object, param, reason, args, retval, priv);
    when_failed(status, exit);
 
    when_true_status(is_key_in_template(object, param), exit, status = amxd_status_ok);
 
    ref_value = amxd_resolve_param_ref(object, data);
    when_true_status(ref_value == NULL &&
                     amxd_object_get_type(object) == amxd_object_template,
                     exit, status = amxd_status_ok);
    when_null_status(ref_value, exit, status = amxd_status_invalid_value);
    when_true_status(is_string_empty(ref_value), exit, status = amxd_status_ok);
 
    amxc_var_convert(&check_value, args, amxd_param_get_type(param));
    values = amxc_var_dyncast(amxc_llist_t, ref_value);
    when_false_status(is_value_in(&check_value, values),
                      exit,
                      status = amxd_status_invalid_value);
 
exit:
    amxc_var_clean(&check_value);
    amxc_llist_delete(&values, variant_list_it_free);
    return status;
}

amxd_action_param_check_maximum()

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

Default check maximum parameter validate action implementation.

This default implementation checks if the new value is equal or lower than a maximum value.

The maximum value must be defined in a variant which must be convertible to int64. The variant pointer must be set as the priv data.

It is allowed to use local parameter references as maximum value. A local parameter reference is a full path to a parameter in the local data model. When local parameter reference is used, the value of the referenced parameter is used as maximum.

If the parameter, for which the new value must be validate, is of the type string (or ssv string or csv string), the length of the new value (as a string) must be at less or equal to the maximum.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	A pointer to a variant, containing the maximum value

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type or higher then maximum)

Definition at line 335 of file amxd_action_param_validate.c.

                                                          {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* data = (amxc_var_t*) priv;
    const char* name = "check_maximum";
 
    when_null_status(param, exit, status = amxd_status_parameter_not_found);
    when_null_status(data, exit, status = amxd_status_invalid_value);
 
    if((amxc_var_type_of(&param->value) == AMXC_VAR_ID_CSTRING) ||
       (amxc_var_type_of(&param->value) == AMXC_VAR_ID_CSV_STRING) ||
       (amxc_var_type_of(&param->value) == AMXC_VAR_ID_SSV_STRING)) {
        name = "check_maximum_length";
    }
 
    status = amxd_action_describe_action(reason, retval, name, priv);
    when_true(status == amxd_status_ok, exit);
 
    status = amxd_action_param_validate(object, param, reason, args, retval, priv);
    when_failed(status, exit);
 
    when_true_status(is_key_in_template(object, param), exit, status = amxd_status_ok);
 
    status = amxd_param_check_maximum(param, data, args);
    when_failed(status, exit);
 
exit:
    return status;
}

amxd_action_param_check_minimum()

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

Default check minimum parameter validate action implementation.

This default implementation checks if the new value is equal or higher than a minimum value.

The minimum value must be defined in a variant which must be convertible to int64. The variant pointer must be set as the priv data.

It is allowed to use local parameter references as minimum value. A local parameter reference is a full path to a parameter in the local data model. When local parameter reference is used, the value of the referenced parameter is used as minimum.

If the parameter, for which the new value must be validated, is of the type string (or ssv string or csv string), the length of the new value (as a string) must be at least equal to the minimum.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	A pointer to a variant, containing the minimum value

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type or below minimum)

Definition at line 302 of file amxd_action_param_validate.c.

                                                          {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* data = (amxc_var_t*) priv;
    const char* name = "check_minimum";
 
    when_null_status(param, exit, status = amxd_status_parameter_not_found);
    when_null_status(data, exit, status = amxd_status_invalid_value);
 
    if((amxc_var_type_of(&param->value) == AMXC_VAR_ID_CSTRING) ||
       (amxc_var_type_of(&param->value) == AMXC_VAR_ID_CSV_STRING) ||
       (amxc_var_type_of(&param->value) == AMXC_VAR_ID_SSV_STRING)) {
        name = "check_minimum_length";
    }
    status = amxd_action_describe_action(reason, retval, name, priv);
    when_true(status == amxd_status_ok, exit);
 
    status = amxd_action_param_validate(object, param, reason, args, retval, priv);
    when_failed(status, exit);
 
    when_true_status(is_key_in_template(object, param), exit, status = amxd_status_ok);
 
    status = amxd_param_check_minimum(param, data, args);
    when_failed(status, exit);
 
exit:
    return status;
}

amxd_action_param_check_range()

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

Default check range parameter validate action implementation.

This default implementation checks if the new value fits in the defined range.

The range must be defined in a variant which must be either a htable variant or a list variant. The variant pointer must be set as the priv data.

When the variant is a htable variant, the minimum value must be set in the htable using key "min" and the maximum value must be set in the htable using key "max".

When the variant is a list variant, the first value must be the minimum value and the second value must be maximum value.

It is allowed to use local parameter references as minimum or maximum values. A local parameter reference is a full path to a parameter in the local data model. When local parameter references are used, the value of the referenced parameter is used as minimum or maximum.

The minimum and maximum are included in the range.

If the parameter, for which the new value must be validated, is of the type string (or ssv string or csv string), the length of the new value (as a string) must be in the range defined.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	A pointer to a variant, containing the minimum and maximum value

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type or out of range)

Definition at line 262 of file amxd_action_param_validate.c.

                                                        {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* data = (amxc_var_t*) priv;
    amxc_var_t* min_var = NULL;
    amxc_var_t* max_var = NULL;
 
    if(amxc_var_type_of(data) == AMXC_VAR_ID_HTABLE) {
        min_var = amxc_var_get_key(data, "min", AMXC_VAR_FLAG_DEFAULT);
        max_var = amxc_var_get_key(data, "max", AMXC_VAR_FLAG_DEFAULT);
    } else if(amxc_var_type_of(data) == AMXC_VAR_ID_LIST) {
        min_var = amxc_var_get_path(data, "0", AMXC_VAR_FLAG_DEFAULT);
        max_var = amxc_var_get_path(data, "1", AMXC_VAR_FLAG_DEFAULT);
    } else {
        status = amxd_status_invalid_type;
        goto exit;
    }
 
    status = amxd_action_describe_action(reason, retval, "check_range", priv);
    when_true(status == amxd_status_ok, exit);
 
    status = amxd_action_param_validate(object, param, reason, args, retval, priv);
    when_failed(status, exit);
 
    when_true_status(is_key_in_template(object, param), exit, status = amxd_status_ok);
 
    status = amxd_param_check_minimum(param, min_var, args);
    when_failed(status, exit);
 
    status = amxd_param_check_maximum(param, max_var, args);
    when_failed(status, exit);
 
exit:
    return status;
}

amxd_action_param_describe()

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

Default parameter describe action implementation.

This action is mainly invoked for introspection purposes. It will create an htable variant, containing all the parameter attributes, user flags, parameter name, parameter type id and parameter type name.

In most cases, unless no-param-value is set in the arguments, the parameter value is available as well.

For this action the args must be NULL or a htable variant and may contain the following parameters in the htable:

• no-param-value - boolean

When no-param-value is set to true, the parameter value is not provided in the returned htable variant.

The resulting htable variant will be set in the retval. The retval htable will contain:

• the parameter attributes (attributes) as a htable variant, in which each attribute is represented as a boolean value, where the key is the name of the attribute, and the value is a boolean, set to true if the attribute is set for the parameter.
• the parameter user flags ('flags') as a list variant, in which each user flag is represented as a string variant.
• the name of the parameter (name) as a string variant
• the parameter type id (type_id) as an integer
• the parameter type name (type_name) as a string
• the parameter value (value), a variant with the same type as the parameter definition

Example of a retval:

{
    attributes = {
        counter = false,
        instance = false,
        key = false,
        mutable = false,
        persistent = false
        private = false,
        protected = false,
        read-only = false,
        template = false,
        unique = false,
        volatile = false,
    },
    flags = [
    ],
    name = "Configured",
    type_id = 12
    type_name = "bool",
    value = true,
}

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_describe or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	NULL or a variant that is a htable variant
retval	The parameter describe result, which is a htable variant.
priv	Not used in the parameter describe action

Returns

• amxd_status_ok if successful.
• amxd_status_function_not_implemented if called for the wrong reason

amxd_action_param_destroy()

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

Default parameter destroy action implementation.

This action is invoked when the parameter is removed from the data model. This action should never fail, it should either return amxd_status_ok or amxd_status_function_not_implemented if called for the wrong reason.

The parameter pointer becomes invalid when returning from this action implementation, as it will be deleted from memory and removed from the data model.

When adding private data to the parameter pointer, this action provides you with the possiblity to do some clean-up (like deleting the private data).

The default implementation is doing nothing.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_destroy or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	Not used in the parameter destroy action
retval	Not used in the parameter destroy action
priv	Not used in the parameter destroy action

Returns

• amxd_status_ok if successful.
• amxd_status_function_not_implemented if called for the wrong reason

amxd_action_param_read()

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

Default parameter read action implementation.

Fetches the value of a parameter in the data model. The value must be set in the retval variant and must be of the same type as the parameter.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_read or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	Not used in the parameter read action
retval	A variant that must be filled with the current value of the parameter
priv	An opaque pointer (user data), that is added when the action callback was set. This pointer can be NULL.

Returns

• amxd_status_ok if successful.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_unknown_error if an error occured

amxd_action_param_read_hidden_value()

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

Default parameter read action implementation for hidden values.

This parameter read action implementation will always return an empty string as the parameters value, unless the access is protected or private.

This parameter read action can be used for TR181 parameters where the value never can be read (for public access).

Examples of such parameters in TR181:

• Device.WiFi.AccessPoint.{i}.Security.WEPKey
• Device.WiFi.AccessPoint.{i}.Security.PreSharedKey
• Device.WiFi.AccessPoint.{i}.WPS.PIN
• Device.PPP.Interface.{i}.Password

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_read or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	Not used in the parameter read action
retval	A variant that must be filled with the current value of the parameter
priv	An opaque pointer (user data), that is added when the action callback was set. This pointer can be NULL.

Returns

• amxd_status_ok if successful.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_unknown_error if an error occured

Definition at line 87 of file amxd_action_param_read.c.

                                                              {
    amxd_status_t status = amxd_status_unknown_error;
    amxd_dm_access_t access = amxd_dm_access_public;
 
    when_null(param, exit);
    when_null(retval, exit);
    when_true_status(reason != action_param_read,
                     exit,
                     status = amxd_status_function_not_implemented);
 
 
    access = (amxd_dm_access_t) GET_UINT32(args, "access");
    if(access > amxd_dm_access_public) {
        status = amxd_action_param_read(object, param, reason, args, retval, priv);
    } else {
        amxc_var_set(cstring_t, retval, "");
        status = amxd_status_ok;
    }
 
exit:
    return status;
}

amxd_action_param_validate()

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

Default parameter validate action implementation.

This default implementation will only check if the new value can be converted to the parameter type.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_validate or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be validated
retval	Not used in the parameter validate action
priv	An opaque pointer (user data), that is added when the action callback was set. This pointer can be NULL.

Returns

• amxd_status_ok if the new value is valid.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (null variant or it can not be converted to the parameter type)

amxd_action_param_write()

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

Default parameter write action implementation.

Sets the value of a parameter in the data model. The value that must be set is available in the args variant.

This default implementation checks:

• that the parameter is writable
• the new value doesn't create duplicates in multi-instance objects (for key parameters or unique parameters in instance objects)
• the new value can be converted to the type of the parameter

It will also set the read-only parameter if the parameter is an immutable key parameter. So an immutable key parameter can be set once.

Parameters

object	The data model object that contains the parameter on which the action is invoked.
param	The parameter on which the action is invoked
reason	The action reason. This should be action_param_write or action_any If the reason is any other action, status amxd_status_function_not_implemented must be returned.
args	The value that must be set
retval	Not used in the parameter write action
priv	An opaque pointer (user data), that is added when the action callback was set. This pointer can be NULL.

Returns

• amxd_status_ok if successful.
• amxd_status_function_not_implemented if called for the wrong reason
• amxd_status_invalid_value if an invalid value is provided (the new value can not be converted to the parameter type or the new value causes a duplicate instance)
• amxd_status_invalid_attr if the parameter is not writable