Runtime

Functions
amxc_var_t *	amxrt_get_config (void)
	Gets the htable variant containing the configuration options. More...
amxo_parser_t *	amxrt_get_parser (void)
	Gets runtime odl parser. More...
amxd_dm_t *	amxrt_get_dm (void)
	Gets the runtime data model storage. More...
void	amxrt_new (void)
	Create the ambiorix runtime. More...
int	amxrt (int argc, char *argv[], amxrt_arg_fn_t fn)
	This function can create full ambiorix application (data model provider or client). More...
int	amxrt_init (int argc, char *argv[], amxrt_arg_fn_t fn)
	Initializes the ambiorix runtime. More...
int	amxrt_register_or_wait (void)
	Register the data model or wait for required data model objects. More...
int	amxrt_run (void)
	Starts the event loop. More...
void	amxrt_stop (void)
	Stops the runtime. More...
void	amxrt_delete (void)
	Clean-up ambiorix runtime. More...
int	amxrt_load_odl_files (int argc, char *argv[], int index)
	Load odls files mentioned on the command line or the default odl file. More...
int	amxrt_connect (void)
	Connects to all bus sockets. More...
void	amxrt_enable_syssigs (amxc_var_t *syssigs)
	Enables system signals that should be monitored by the eventloop. More...
int	amxrt_config_init (int argc, char *argv[], int *index, amxrt_arg_fn_t fn)
	Initializes the default runtime configuration. More...
void	amxrt_config_scan_backend_dirs (void)
	Scan backend directories for available backends. More...
void	amxrt_config_read_env_var (const char *var_name, const char *config_name, int32_t var_type)
	Helper function to read an environment variable and add it's value to the runtime configuration. More...
int	amxrt_dm_save_load_main (int reason, amxd_dm_t *dm, amxo_parser_t *parser)
	The data model auto load and save module. More...

Detailed Description

The ambiorix runtime library can be used to easily create a stand-alone data model provider application or data model client.

The runtime library provides:

• an ambiorix configuration environment (htable variant)
• an odl parser (can be used to read and write odl files)
• a data model storage
• command line argument parsing
• an event loop implementation

The simplest possible way to use this library is in this example code:

#include <amxrt/amxrt.h>
 
  int main(in argc, char* argv[]) {
      int retval = 0;
      amxrt_new();
      retval = amxrt(argc, argv, NULL);
      amxrt_delete();
      return retval;
  }

The above example can also be written as follows:

#include <amxrt/amxrt.h>
 
  int main(in argc, char* argv[]) {
      int retval = 0;
 
      amxrt_new();
      retval = amxrt_init(argc, argv, fn);
      when_failed(retval, leave);
      retval = amxrt_register_or_wait();
      when_failed(retval, leave);
      retval = amxrt_run();
 
  leave:
      amxrt_stop();
      amxrt_delete();
      return retval;
  }

This gives you to possibility to perform other tasks in between.

Function Documentation

amxrt()

int amxrt	(	int	argc,
		char *	argv[],
		amxrt_arg_fn_t	fn
	)

This function can create full ambiorix application (data model provider or client).

Typically this function is called from your main. Optionally a command line option handler can be added.

This function will create and start the event loop, and therefor will only return when the event loop has stopped. The event loop can be stopped by calling amxrt_el_stop. Typically this is done from within an event handler.

By default following signals are being monitored and handled:

• SIGINT - when triggered the eventloop is stopped
• SIGTERM - when triggered the eventloop is stopped
• SIGALRM - used for ambiorix timers (amxp_timer_t)

Note

When using this function an odl file must be loaded (can be an empty one or an odl file that only contains configuration). If no odl file was loaded this function will return with an error.

This function will call the following function (in this order):

• amxrt_init
• amxrt_register_or_wait
• amxrt_run - this will start the event loop, the function will continue when the event loop has been stopped
• amxrt_stop

Example of usage:

#include <stdio.h>
 
#include <amxrt/amxrt.h>
 
  static int amxrt_handle_cmd_line_arg(amxc_var_t* config,
                                       int arg_id,
                                       UNUSED const char* value) {
      int rv = -1;
      const char* name = GET_CHAR(amxrt_get_config(), "name");
      switch(arg_id) {
         case 'V': {
             printf("%s %d.%d.%d\n", name, 1, 2, 3);
         }
         break;
         default:
             rv = -2;
         break;
      }
 
      return rv;
  }
 
  int main(int argc, char* argv[]) {
      int retval = 0;
 
      amxrt_new();
      amxrt_cmd_line_add_option(0, 'V', "version", no_argument, "Print version", NULL);
      retval = amxrt(argc, argv, amxrt_handle_cmd_line_arg);
      amxrt_delete();
 
      return retval;
  }

Parameters

argc	the number of arguments available
argv	the vector containing the commandline arguments
fn	(optional) a pointer to a callback function to handle the option or NULL

Returns

Non zero indicates an error, 0 will indicate that the event loop has stopped without any error.

Definition at line 334 of file amxrt.c.

                                                     {
    int retval = 0;
 
    retval = amxrt_init(argc, argv, fn);
    when_failed(retval, leave);
    retval = amxrt_register_or_wait();
    when_failed(retval, leave);
    retval = amxrt_run();
 
leave:
    amxrt_stop();
    return retval;
}

amxrt_config_init()

int amxrt_config_init	(	int	argc,
		char *	argv[],
		int *	index,
		amxrt_arg_fn_t	fn
	)

Initializes the default runtime configuration.

Sets the default values for all default configuration options.

Also uses the command line option parser and if needed adapts the configuration accordingly.

Parameters

argc	the number of arguments available
argv	the vector containing the commandline arguments
index	pointer to an integer, will be set to the first command line argument that is not an option.
fn	(optional) a pointer to a callback function to handle the option or NULL

Returns

returns 0 if no error occured.

Definition at line 217 of file amxrt_config.c.

                                                                             {
    int retval = 0;
    char* base_name = NULL;
    amxo_parser_t* parser = amxrt_get_parser();
 
    amxrt_config_read_env_vars();
 
    amxrt_config_set_default_dirs(parser);
 
    base_name = strdup(basename(argv[0]));
    when_null_status(base_name, exit, retval = -1);
    for(int i = strlen(base_name) - 1; i > 0; i--) {
        if(base_name[i] == '.') {
            base_name[i] = 0;
        }
    }
    amxc_var_add_key(cstring_t, &parser->config, AMXRT_COPT_NAME, base_name);
 
    *index = amxrt_cmd_line_parse(argc, argv, fn);
    if(*index < 0) {
        retval = *index;
        *index = argc;
    }
 
exit:
    free(base_name);
    return retval;
}

amxrt_config_read_env_var()

void amxrt_config_read_env_var	(	const char *	var_name,
		const char *	config_name,
		int32_t	var_type
	)

Helper function to read an environment variable and add it's value to the runtime configuration.

As envrionment variables values can only be fetched as strings, a type must be provided to which the value must be converted. The value will be stored using this type in the runtime configuration.

Parameters

var_name	The environment variable name.
config_name	The runtime configuration option name
var_type	The variant type, this is the type how the value will be stored

Definition at line 264 of file amxrt_config.c.

                                                 {
    const char* env = getenv(var_name);
    amxc_var_t* config = amxrt_get_config();
    amxc_var_t* coption = GET_ARG(config, config_name);
    amxc_var_t var_env;
 
    amxc_var_init(&var_env);
 
    if(env == NULL) {
        goto exit;
    }
 
    amxc_var_set(cstring_t, &var_env, env);
 
    if(coption == NULL) {
        coption = amxc_var_add_new_key(config, config_name);
        amxc_var_set_type(coption, var_type);
    }
 
    switch(var_type) {
    case AMXC_VAR_ID_LIST: {
        amxc_string_t* str_env = amxc_var_take(amxc_string_t, &var_env);
        amxc_llist_t parts;
        amxc_llist_init(&parts);
        amxc_string_split_to_llist(str_env, &parts, ';');
        amxc_llist_for_each(it, (&parts)) {
            amxc_string_t* part = amxc_string_from_llist_it(it);
            amxc_var_add(cstring_t, coption, amxc_string_get(part, 0));
            amxc_string_delete(&part);
        }
        amxc_llist_clean(&parts, amxc_string_list_it_free);
        amxc_string_delete(&str_env);
    }
    break;
    default: {
        amxc_var_convert(coption, &var_env, var_type);
    }
    break;
    }
 
exit:
    amxc_var_clean(&var_env);
    return;
}

amxrt_config_scan_backend_dirs()

void amxrt_config_scan_backend_dirs

(

void

)

Scan backend directories for available backends.

When auto-detection (configuration option "auto-detect") is enabled, all directories in the configuration option "backend-dir" are scanned for valid shared object files. Each found shared object file is added to the list of possible backends that can be used.

When auto-detection is disabled this function will do nothing.

Definition at line 246 of file amxrt_config.c.

                                          {
    amxo_parser_t* parser = amxrt_get_parser();
 
    if(amxc_var_constcast(bool, GET_ARG(&parser->config, AMXRT_COPT_AUTO_DETECT))) {
        amxc_var_t* backends = GET_ARG(&parser->config, AMXRT_COPT_BACKENDS);
        amxc_var_t* dirs = GET_ARG(&parser->config, AMXRT_COPT_BACKENDS_DIR);
        if(amxc_var_type_of(dirs) == AMXC_VAR_ID_LIST) {
            amxc_var_for_each(dir, dirs) {
                const char* path = GET_CHAR(dir, NULL);
                amxp_dir_scan(path, "d_name matches '.*\\.so'", false, amxrt_config_add_backend, backends);
            }
        } else {
            const char* path = GET_CHAR(&parser->config, AMXRT_COPT_BACKENDS_DIR);
            amxp_dir_scan(path, "d_name matches '.*\\.so'", false, amxrt_config_add_backend, backends);
        }
    }
}

amxrt_connect()

int amxrt_connect

(

void

)

Connects to all bus sockets.

When auto-detect is enabled the ambiorix runtime will check if the well known linux domain bus sockets exists and they will be added to the "uris" config.

Using command line option "-u" extra sockets can be added. It is also possible to define the sockets that needs to be opened in the config section of an odl file.

The supported config options are:

• "uris" - used to connect on and register the data model of the application
• "data-uris" - used to connect on, but the data model is not registered on these sockets. " "listen" - creates a listening socket, other applications can connect on these.

Returns

Non zero indicates an error

Definition at line 488 of file amxrt.c.

                        {
    int retval = 0;
 
    retval = amxrt_connection_load_backends(&rt.parser.config);
    when_failed(retval, leave);
 
    amxrt_connection_detect_sockets(&rt.parser.config);
 
    // Daemonize before opening sockets
    // Some bus systems requires this.
    // Daemonizing (going to background) changes process id, sometimes the process id
    // is used in the initial handshake
    if(amxc_var_constcast(bool, GET_ARG(&rt.parser.config, AMXRT_COPT_DAEMON))) {
        retval = daemon(1, 0);
        when_failed(retval, leave);
    }
 
    retval = amxrt_connection_connect_all(&rt.parser);
    when_failed(retval, leave);
    retval = amxrt_connection_listen_all(&rt.parser);
    when_failed(retval, leave);
    retval = amxrt_apply_process_settings(&rt.parser);
    when_failed(retval, leave);
 
leave:
    return retval;
}

amxrt_delete()

void amxrt_delete

(

void

)

Clean-up ambiorix runtime.

All open sockets will be closed and all loaded backends will be unloaded.

This function is typically called just before the application exits.

Definition at line 378 of file amxrt.c.

                        {
    amxd_dm_clean(&rt.dm);
    amxo_resolver_import_close_all();
    amxb_be_remove_all();
 
    amxrt_cmd_line_options_reset();
    amxc_var_clean(&rt.forced_options);
 
    amxo_parser_clean(&rt.parser);
}

amxrt_dm_save_load_main()

int amxrt_dm_save_load_main	(	int	reason,
		amxd_dm_t *	dm,
		amxo_parser_t *	parser
	)

The data model auto load and save module.

The ambiorix runtime library embeds a module that can be used to automatically load and save the data model.

To make use of this module, it's entry point must be registered. Registering of the entry point can be done by calling amxo_parser_add_entry_point.

Note

This function should not be called directly.

Example:

amxo_parser_t* parser = amxrt_get_parser();
amxo_parser_add_entry_point(parser, amxrt_dm_save_load_main);

This function will be called when the entry points are invoked. See amxrt_register_or_wait and amxrt_stop.

This module needs configuration, see the readme for more information

Parameters

reason	the reason why the entry point is called.
dm	the data model pointer
parser	the odl parser

Returns

returns 0 if no error occured.

Definition at line 457 of file amxrt_save_load.c.

                                                                              {
    int retval = 0;
 
    when_false(amxrt_is_odl_storage_enabled(parser), exit);
 
    switch(reason) {
    case 0: // START
        retval = amxrt_odl_save_load_init(dm, parser);
        break;
    case 1: // STOP
        amxrt_odl_save_load_cleanup(dm, parser);
        break;
    }
 
exit:
    return retval;
}

amxrt_enable_syssigs()

void amxrt_enable_syssigs

(

amxc_var_t *

syssigs

)

Enables system signals that should be monitored by the eventloop.

The default implementation of the event loop will only monitor

• SIGINT - when triggered the eventloop is stopped
• SIGTERM - when triggered the eventloop is stopped
• SIGALRM - used for ambiorix timers (amxp_timer_t)

If other signals needs to be monitored, a list variant must be created, containing the identifiers of the signals and passed to this function.

Parameters

syssigs

list variant containing the signal identifiers.

Definition at line 516 of file amxrt.c.

                                               {
    if(amxc_var_type_of(syssigs) == AMXC_VAR_ID_LIST) {
        amxc_var_for_each(var, syssigs) {
            uint32_t sigid = amxc_var_dyncast(uint32_t, var);
            if((sigid != 0) &&
               ( sigid != SIGALRM) &&
               ( sigid != SIGTERM) &&
               ( sigid != SIGINT)) {
                amxp_syssig_enable(sigid, true);
            }
        }
    } else {
        uint32_t sigid = amxc_var_dyncast(uint32_t, syssigs);
        if((sigid != 0) &&
           ( sigid != SIGALRM) &&
           ( sigid != SIGTERM) &&
           ( sigid != SIGINT)) {
            amxp_syssig_enable(sigid, true);
        }
    }
}

amxrt_get_config()

amxc_var_t* amxrt_get_config

(

void

)

Gets the htable variant containing the configuration options.

Returns

The htable variant containing the configuration options.

Definition at line 301 of file amxrt.c.

                                   {
    return &rt.parser.config;
}

amxrt_get_dm()

amxd_dm_t* amxrt_get_dm

(

void

)

Gets the runtime data model storage.

Returns

The amxd_dm_t pointer where the data model is stored.

Definition at line 309 of file amxrt.c.

                              {
    return &rt.dm;
}

amxrt_get_parser()

amxo_parser_t* amxrt_get_parser

(

void

)

Gets runtime odl parser.

To manually read the odl files using the parser use any of the libamxo functions.

Example:

amxo_parser_t* odl_parser = amxrt_get_parser();
amxd_dm_t* dm = amxrt_get_dm();
amxd_object_t* root = amxd_dm_get_root(dm);
 
amxo_parser_parse_file(parser, "/tmp/my_definition.odl", root);

Returns

The runtime odl parser.

Definition at line 305 of file amxrt.c.

                                      {
    return &rt.parser;
}

amxrt_init()

int amxrt_init	(	int	argc,
		char *	argv[],
		amxrt_arg_fn_t	fn
	)

Initializes the ambiorix runtime.

This function will:

1. parse the command line options
2. set the default ambiorix config options
3. load the odl files (if any)
4. add the automatic load and save modules entrypoint amxo_parser_add_entry_point
5. load the ambiorix back-ends
6. connects to all sockets
7. enable all system signals that needs to be monitored
8. create an event loop

The odl file files that are loaded can be passed as command line arguments after the command line options. If no odls are provided at command line the runtime will try to load the default odl file for the application, using the applications name (argv[0]). The default that it will try to load is "/etc/amx/<appname>/<appname>.odl". If no odl files are provided and the default doesn't exist, this function will continue without an error.

The (bus) back-ends loaded can be specified using command line option -B or added in one of the odl files in the config section with config name "backends", which must be a list of backend shared objects that must be loaded. If auto-detection is turned on (this is the default), all shared objects that are valid ambiorix back-ends will be loaded from the back-end directory (by default this is "/usr/bin/mods/amxb"). The default back-end directory can be changed in a odl file config section with config name "backend-dir" or on the command line with "-o backend-dir=<thedir>".

The sockets that the run-time needs to connect to can be specified with commandline option -u or in an odl config section with config name "uris" or "data-uris", both configuration settings must be a list of uris. The difference between uris and data-uris is that when the application has a data model available it will only be registered using the sockets that are mentioned in the "uris".

Parameters

argc	the number of arguments available
argv	the vector containing the commandline arguments
fn	(optional) a pointer to a callback function to handle the option or NULL

Returns

Non zero indicates an error

Definition at line 348 of file amxrt.c.

                                                          {
    int retval = 0;
    int index = 0;
    amxc_var_t* syssigs = NULL;
    amxo_parser_t* parser = amxrt_get_parser();
 
    amxc_var_set_type(&rt.forced_options, AMXC_VAR_ID_HTABLE);
    retval = amxrt_config_init(argc, argv, &index, fn);
    when_failed_status(retval, leave, retval = 10);
    retval = amxrt_load_odl_files(argc, argv, index);
    when_failed_status(retval, leave, retval = 11);
    amxrt_config_scan_backend_dirs();
 
    amxo_parser_add_entry_point(parser, amxrt_dm_save_load_main);
 
    retval = amxrt_connect();
    when_failed_status(retval, leave, retval = 12);
 
    syssigs = GET_ARG(&rt.parser.config, "system-signals");
    if(syssigs != NULL) {
        amxrt_enable_syssigs(syssigs);
    }
 
    retval = amxrt_el_create();
    when_failed_status(retval, leave, retval = -13);
 
leave:
    return retval;
}

amxrt_load_odl_files()

int amxrt_load_odl_files	(	int	argc,
		char *	argv[],
		int	index
	)

Load odls files mentioned on the command line or the default odl file.

By default odl files can be specified after the command line options. This function will load these odl files.

If no odl files are specified at the command line, the default odl file will be loaded. The application name (Argv[0]) will be used to find the default odl file.

The default odl file is "/etc/amx/<appname>/<appname>.odl".

If no odl files are defined at the commandline and the default odl file does't exist, nothing is loaded an no error is thrown.

This function will also scan the default mib dir for the application. If a mib dir is available and contains mib definitions, these are not loaded by default. Mib definitions will be loaded when needed.

Parameters

argc	the number of arguments available
argv	the vector containing the commandline arguments
index	should be set to the first command line that is not an option

Returns

Non zero indicates an error

Definition at line 466 of file amxrt.c.

                                                            {
    int retval = 0;
    amxd_object_t* root = NULL;
    bool dm_eventing_enabled = false;
 
    dm_eventing_enabled = GET_BOOL(&rt.parser.config, AMXRT_COPT_EVENT);
    amxp_sigmngr_enable(&rt.dm.sigmngr, dm_eventing_enabled);
    root = amxd_dm_get_root(&rt.dm);
    retval = amxrt_parse_odl_string(&rt.parser, root);
    when_failed(retval, leave);
    retval = amxrt_parse_odl_files(&rt.parser, argc, argv, index, root);
    when_failed(retval, leave);
    retval = amxrt_parse_odl_extensions(&rt.parser, root);
    when_failed(retval, leave);
 
    amxo_parser_scan_mib_dirs(&rt.parser, NULL);
    amxp_sigmngr_enable(&rt.dm.sigmngr, true);
 
leave:
    return retval;
}

amxrt_new()

void amxrt_new

(

void

)

Create the ambiorix runtime.

This function must be called before any other amxrt function.

This function creates:

• an odl parser, can be fetched using amxrt_get_parser
• a data model, can be fetched using amxrt_get_datamodel
• an empty config, can be fetched using amxrt_get_config

This function is typically called as first in the main.

When done with the ambiorix run time, call amxrt_delete

Definition at line 313 of file amxrt.c.

                     {
    amxd_dm_init(&rt.dm);
    amxo_parser_init(&rt.parser);
    amxc_llist_init(&rt.event_sources);
    amxc_llist_init(&rt.cmd_line_args);
    rt.usage_doc = "[OPTIONS] <odl files>";
 
    // command line options given with -F are stored here and can not be overwritten
    // by odl config section options
    amxc_var_init(&rt.forced_options);
    amxc_var_set_type(&rt.forced_options, AMXC_VAR_ID_HTABLE);
 
    amxrt_config_add_options(&rt.parser);
 
    amxp_sigmngr_add_signal(NULL, "config:changed");
    amxp_sigmngr_add_signal(NULL, "wait:done");
    amxp_sigmngr_add_signal(NULL, "wait:cancel");
 
    amxrt_cmd_line_add_default_options();
}

amxrt_register_or_wait()

int amxrt_register_or_wait

(

void

)

Register the data model or wait for required data model objects.

When the application has a data model available, it can be registered using this function. As soon as the data model is registered, the application becomes a data model provider.

If required objects are defined (using odl files with "requires" or using command line option -R), then this function will wait until these objects become available on the used bus systems before registering the data model.

The wait can only be fulfilled when an eventloop is running, as it needs event handling.

When registering of the data model succeeded, the entry-points of the loaded modules/plugins are called with reason AMXO_START (0).

Returns

Non zero indicates an error

Definition at line 389 of file amxrt.c.

                                 {
    int retval = 0;
    amxc_var_t* req = NULL;
    const amxc_llist_t* lreq = NULL;
 
    req = GET_ARG(&rt.parser.config, AMXRT_COPT_REQUIRES);
    lreq = amxc_var_constcast(amxc_llist_t, req);
 
    if((lreq == NULL) || amxc_llist_is_empty(lreq)) {
        retval = amxrt_register(&rt.parser, &rt.dm);
        when_failed_status(retval, leave, retval = -14);
        amxrt_handle_events(&rt.dm, &rt.parser);
    } else {
        if(GET_BOOL(&rt.parser.config, AMXRT_COPT_SUSPEND)) {
            amxp_sigmngr_suspend(&rt.dm.sigmngr);
        }
        amxp_slot_connect(NULL, "wait:done", NULL, amxrt_wait_done, NULL);
        amxc_var_for_each(path, req) {
            const char* txt_path = GET_CHAR(path, NULL);
            if(amxd_dm_findf(&rt.dm, "%s", txt_path) == NULL) {
                amxrt_print_message("RunTime - Waiting for required object '%s'", txt_path);
                retval = amxb_wait_for_object(txt_path);
                if(retval != AMXB_STATUS_OK) {
                    amxrt_print_error("RunTime - Waiting failed for object '%s'", txt_path);
                    break;
                }
            }
        }
    }
 
    when_failed_status(retval, leave, retval = -14);
 
leave:
    return retval;
}

amxrt_run()

int amxrt_run

(

void

)

Starts the event loop.

This function just calls amxrt_el_start. This function returns when the event loop is stopped or when starting the event loop fails.

Returns

0 when the event loop stopped, any other value indicates that starting the event loop failed.

Definition at line 425 of file amxrt.c.

                    {
    int retval = 0;
 
    if(GET_BOOL(&rt.parser.config, AMXRT_COPT_DUMP_CONFIG)) {
        amxrt_print_configuration();
    }
    if(GET_BOOL(&rt.parser.config, AMXRT_COPT_DUMP_CAPS)) {
        amxrt_caps_dump();
    }
 
    amxrt_el_start();
 
    return retval;
}

amxrt_stop()

void amxrt_stop

(

void

)

Stops the runtime.

Only call this function when the event loop has stopped, never call this method in event handlers. Call amxrt_el_stop instead and call this function after the call that starts the event loop.

This function will teardown the ambiorix runtime:

1. destroys the event loop
2. call the entry points of loaded modules/plugins in reverse order with reason AMXO_STOP
3. resets the backend configurations
4. removes the pid file.
5. closes the syslog (if it was opened)

This function is typically called when the event loop is stopped and the application is going to be closed.

Definition at line 440 of file amxrt.c.

                      {
    amxo_parser_t* parser = amxrt_get_parser();
    amxd_dm_t* dm = amxrt_get_dm();
    char* name = amxc_var_dyncast(cstring_t, GET_ARG(&parser->config, AMXRT_COPT_NAME));
    amxc_var_t* req = GET_ARG(&parser->config, AMXRT_COPT_REQUIRES);
 
    amxrt_el_destroy();
 
    amxo_parser_stop_synchronize(parser);
 
    if((req == NULL) || amxc_llist_is_empty(amxc_var_constcast(amxc_llist_t, req))) {
        amxo_parser_rinvoke_entry_points(parser, dm, AMXO_STOP);
    }
 
    amxb_set_config(NULL);
 
    amxrt_remove_pid_file(name);
 
    if(GET_BOOL(&parser->config, AMXRT_COPT_LOG) &&
       ( GET_CHAR(&parser->config, AMXRT_COPT_NAME) != NULL)) {
        closelog();
    }
 
    free(name);
}