res_clialiases: Fix crash when reloading and re-aliasing an alias that is in use.
[asterisk/asterisk.git] / res / res_clialiases.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2008, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief CLI Aliases
22  *
23  * \author\verbatim Joshua Colp <jcolp@digium.com> \endverbatim
24  * 
25  * This module provides the capability to create aliases to other
26  * CLI commands.
27  */
28
29 /*! \li \ref res_clialiases.c uses the configuration file \ref cli_aliases.conf
30  * \addtogroup configuration_file Configuration Files
31  */
32
33 /*! 
34  * \page cli_aliases.conf cli_aliases.conf
35  * \verbinclude cli_aliases.conf.sample
36  */
37
38 /*** MODULEINFO
39         <support_level>core</support_level>
40  ***/
41
42 #include "asterisk.h"
43
44 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
45
46 #include "asterisk/module.h"
47 #include "asterisk/config.h"
48 #include "asterisk/cli.h"
49 #include "asterisk/astobj2.h"
50
51 /*! Maximum number of buckets for CLI aliases */
52 #define MAX_ALIAS_BUCKETS 53
53
54 /*! Configuration file used for this application */
55 static const char config_file[] = "cli_aliases.conf";
56
57 struct cli_alias {
58         struct ast_cli_entry cli_entry; /*!< Actual CLI structure used for this alias */
59         char *alias;                    /*!< CLI Alias */
60         char *real_cmd;                 /*!< Actual CLI command it is aliased to */
61 };
62
63 static struct ao2_container *cli_aliases;
64
65 /*! \brief Hashing function used for aliases */
66 static int alias_hash_cb(const void *obj, const int flags)
67 {
68         const struct cli_alias *alias = obj;
69         return ast_str_hash(alias->cli_entry.command);
70 }
71
72 /*! \brief Comparison function used for aliases */
73 static int alias_cmp_cb(void *obj, void *arg, int flags)
74 {
75         const struct cli_alias *alias0 = obj, *alias1 = arg;
76
77         return (alias0->cli_entry.command == alias1->cli_entry.command ? CMP_MATCH | CMP_STOP : 0);
78 }
79
80 /*! \brief Callback for unregistering an alias */
81 static int alias_unregister_cb(void *obj, void *arg, int flags)
82 {
83         struct cli_alias *alias = obj;
84
85         /* Unregister the CLI entry from the core */
86         ast_cli_unregister(&alias->cli_entry);
87
88         /* We can determine if this worked or not by looking at the cli_entry itself */
89         return !alias->cli_entry.command ? CMP_MATCH : 0;
90 }
91
92 /*! \brief Callback for finding an alias based on name */
93 static int alias_name_cb(void *obj, void *arg, int flags)
94 {
95         struct cli_alias *alias = obj;
96         char *name = arg;
97
98         return !strcmp(alias->alias, name) ? CMP_MATCH | CMP_STOP : 0;
99 }
100
101 /*! \brief Function which passes through an aliased CLI command to the real one */
102 static char *cli_alias_passthrough(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
103 {
104         struct cli_alias *alias;
105         struct cli_alias tmp = {
106                 .cli_entry.command = e->command,
107         };
108         char *generator;
109         const char *line;
110
111         /* Try to find the alias based on the CLI entry */
112         if (!(alias = ao2_find(cli_aliases, &tmp, OBJ_POINTER))) {
113                 return 0;
114         }
115
116         switch (cmd) {
117         case CLI_INIT:
118                 ao2_ref(alias, -1);
119                 return NULL;
120         case CLI_GENERATE:
121                 line = a->line;
122                 line += (strlen(alias->alias));
123                 if (!strncasecmp(alias->alias, alias->real_cmd, strlen(alias->alias))) {
124                         generator = NULL;
125                 } else if (!ast_strlen_zero(a->word)) {
126                         struct ast_str *real_cmd = ast_str_alloca(strlen(alias->real_cmd) + strlen(line) + 1);
127                         ast_str_append(&real_cmd, 0, "%s%s", alias->real_cmd, line);
128                         generator = ast_cli_generator(ast_str_buffer(real_cmd), a->word, a->n);
129                 } else {
130                         generator = ast_cli_generator(alias->real_cmd, a->word, a->n);
131                 }
132                 ao2_ref(alias, -1);
133                 return generator;
134         }
135
136         /* If they gave us extra arguments we need to construct a string to pass in */
137         if (a->argc != e->args) {
138                 struct ast_str *real_cmd = ast_str_alloca(2048);
139                 int i;
140
141                 ast_str_append(&real_cmd, 0, "%s", alias->real_cmd);
142
143                 /* Add the additional arguments that have been passed in */
144                 for (i = e->args + 1; i <= a->argc; i++) {
145                         ast_str_append(&real_cmd, 0, " %s", a->argv[i - 1]);
146                 }
147
148                 ast_cli_command(a->fd, ast_str_buffer(real_cmd));
149         } else {
150                 ast_cli_command(a->fd, alias->real_cmd);
151         }
152
153         ao2_ref(alias, -1);
154
155         return CLI_SUCCESS;
156 }
157
158 /*! \brief CLI Command to display CLI Aliases */
159 static char *alias_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
160 {
161 #define FORMAT "%-50.50s %-50.50s\n"
162         struct cli_alias *alias;
163         struct ao2_iterator i;
164
165         switch (cmd) {
166         case CLI_INIT:
167                 e->command = "cli show aliases";
168                 e->usage =
169                         "Usage: cli show aliases\n"
170                         "       Displays a list of aliased CLI commands.\n";
171                 return NULL;
172         case CLI_GENERATE:
173                 return NULL;
174         }
175
176         ast_cli(a->fd, FORMAT, "Alias Command", "Real Command");
177
178         i = ao2_iterator_init(cli_aliases, 0);
179         for (; (alias = ao2_iterator_next(&i)); ao2_ref(alias, -1)) {
180                 ast_cli(a->fd, FORMAT, alias->alias, alias->real_cmd);
181         }
182         ao2_iterator_destroy(&i);
183
184         return CLI_SUCCESS;
185 #undef FORMAT
186 }
187
188 /*! \brief CLI commands to interact with things */
189 static struct ast_cli_entry cli_alias[] = {
190         AST_CLI_DEFINE(alias_show, "Show CLI command aliases"),
191 };
192
193 /*! \brief Function called to load or reload the configuration file */
194 static void load_config(int reload)
195 {
196         struct ast_config *cfg = NULL;
197         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
198         struct cli_alias *alias;
199         struct ast_variable *v, *v1;
200
201         if (!(cfg = ast_config_load(config_file, config_flags)) || cfg == CONFIG_STATUS_FILEINVALID) {
202                 ast_log(LOG_ERROR, "res_clialiases configuration file '%s' not found\n", config_file);
203                 return;
204         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
205                 return;
206         }
207
208         /* Destroy any existing CLI aliases */
209         if (reload) {
210                 ao2_callback(cli_aliases, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, alias_unregister_cb, NULL);
211         }
212
213         for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
214                 if (strcmp(v->name, "template")) {
215                         ast_log(LOG_WARNING, "%s is not a correct option in [%s]\n", v->name, "general");
216                         continue;
217                 }
218                 /* Read in those there CLI aliases */
219                 for (v1 = ast_variable_browse(cfg, v->value); v1; v1 = v1->next) {
220                         struct cli_alias *existing = ao2_callback(cli_aliases, 0, alias_name_cb, (char*)v1->name);
221
222                         if (existing) {
223                                 ast_log(LOG_WARNING, "Alias '%s' could not be unregistered and has been retained\n",
224                                         existing->alias);
225                                 ao2_ref(existing, -1);
226                                 continue;
227                         }
228
229                         if (!(alias = ao2_alloc((sizeof(*alias) + strlen(v1->name) + strlen(v1->value) + 2), NULL))) {
230                                 continue;
231                         }
232                         alias->alias = ((char *) alias) + sizeof(*alias);
233                         alias->real_cmd = ((char *) alias->alias) + strlen(v1->name) + 1;
234                         strcpy(alias->alias, v1->name);
235                         strcpy(alias->real_cmd, v1->value);
236                         alias->cli_entry.handler = cli_alias_passthrough;
237                         alias->cli_entry.command = alias->alias;
238                         alias->cli_entry.usage = "Aliased CLI Command\n";
239
240                         if (ast_cli_register(&alias->cli_entry)) {
241                                 ao2_ref(alias, -1);
242                                 continue;
243                         }
244                         ao2_link(cli_aliases, alias);
245                         ast_verb(2, "Aliased CLI command '%s' to '%s'\n", v1->name, v1->value);
246                         ao2_ref(alias, -1);
247                 }
248         }
249
250         ast_config_destroy(cfg);
251
252         return;
253 }
254
255 /*! \brief Function called to reload the module */
256 static int reload_module(void)
257 {
258         load_config(1);
259         return 0;
260 }
261
262 /*! \brief Function called to unload the module */
263 static int unload_module(void)
264 {
265         ao2_callback(cli_aliases, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, alias_unregister_cb, NULL);
266
267         if (ao2_container_count(cli_aliases)) {
268                 ast_log(LOG_ERROR, "Could not unregister all CLI aliases\n");
269                 return -1;
270         }
271
272         ao2_ref(cli_aliases, -1);
273
274         ast_cli_unregister_multiple(cli_alias, ARRAY_LEN(cli_alias));
275
276         return 0;
277 }
278
279 /*!
280  * \brief Load the module
281  *
282  * Module loading including tests for configuration or dependencies.
283  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
284  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
285  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the 
286  * configuration file or other non-critical problem return 
287  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
288  */
289 static int load_module(void)
290 {
291         if (!(cli_aliases = ao2_container_alloc(MAX_ALIAS_BUCKETS, alias_hash_cb, alias_cmp_cb))) {
292                 return AST_MODULE_LOAD_DECLINE;
293         }
294
295         load_config(0);
296
297         ast_cli_register_multiple(cli_alias, ARRAY_LEN(cli_alias));
298
299         return AST_MODULE_LOAD_SUCCESS;
300 }
301
302 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "CLI Aliases",
303                 .load = load_module,
304                 .unload = unload_module,
305                 .reload = reload_module,
306                 );