Fix a bug caused by using sizeof(pointer) instead of sizeof(the struct)
[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
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include "asterisk/module.h"
35 #include "asterisk/config.h"
36 #include "asterisk/cli.h"
37 #include "asterisk/astobj2.h"
38
39 /*! Maximum number of buckets for CLI aliases */
40 #define MAX_ALIAS_BUCKETS 53
41
42 /*! Configuration file used for this application */
43 static const char config_file[] = "cli_aliases.conf";
44
45 struct cli_alias {
46         struct ast_cli_entry cli_entry; /*!< Actual CLI structure used for this alias */
47         char *alias;                    /*!< CLI Alias */
48         char *real_cmd;                 /*!< Actual CLI command it is aliased to */
49         unsigned int marked:1;          /*!< Bit to indicate whether this CLI alias is marked for destruction or not */
50 };
51
52 static struct ao2_container *cli_aliases;
53
54 /*! \brief Hashing function used for aliases */
55 static int alias_hash_cb(const void *obj, const int flags)
56 {
57         const struct cli_alias *alias = obj;
58         return ast_str_hash(alias->cli_entry.command);
59 }
60
61 /*! \brief Comparison function used for aliases */
62 static int alias_cmp_cb(void *obj, void *arg, void *data, int flags)
63 {
64         const struct cli_alias *alias0 = obj, *alias1 = arg;
65
66         return (alias0->cli_entry.command == alias1->cli_entry.command ? CMP_MATCH | CMP_STOP : 0);
67 }
68
69 /*! \brief Destruction function used for aliases */
70 static void alias_destroy(void *obj)
71 {
72         struct cli_alias *alias = obj;
73
74         /* Unregister the CLI entry from the core */
75         ast_cli_unregister(&alias->cli_entry);
76
77         return;
78 }
79
80 /*! \brief Function which passes through an aliased CLI command to the real one */
81 static char *cli_alias_passthrough(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
82 {
83         struct cli_alias *alias;
84         struct cli_alias tmp = {
85                 .cli_entry.command = e->command,
86         };
87         char *generator;
88         const char *line;
89
90         /* Try to find the alias based on the CLI entry */
91         if (!(alias = ao2_find(cli_aliases, &tmp, NULL, OBJ_POINTER))) {
92                 return 0;
93         }
94
95         switch (cmd) {
96         case CLI_INIT:
97                 ao2_ref(alias, -1);
98                 return NULL;
99         case CLI_GENERATE:
100                 line = a->line;
101                 line += (strlen(alias->alias));
102                 if (!ast_strlen_zero(a->word)) {
103                         struct ast_str *real_cmd = ast_str_alloca(strlen(alias->real_cmd) + strlen(line) + 1);
104                         ast_str_append(&real_cmd, 0, "%s%s", alias->real_cmd, line);
105                         generator = ast_cli_generator(real_cmd->str, a->word, a->n);
106                 } else {
107                         generator = ast_cli_generator(alias->real_cmd, a->word, a->n);
108                 }
109                 ao2_ref(alias, -1);
110                 return generator;
111         }
112
113         /* If they gave us extra arguments we need to construct a string to pass in */
114         if (a->argc != e->args) {
115                 struct ast_str *real_cmd = ast_str_alloca(2048);
116                 int i;
117
118                 ast_str_append(&real_cmd, 0, "%s", alias->real_cmd);
119
120                 /* Add the additional arguments that have been passed in */
121                 for (i = e->args + 1; i <= a->argc; i++) {
122                         ast_str_append(&real_cmd, 0, " %s", a->argv[i - 1]);
123                 }
124
125                 ast_cli_command(a->fd, real_cmd->str);
126         } else {
127                 ast_cli_command(a->fd, alias->real_cmd);
128         }
129
130         ao2_ref(alias, -1);
131
132         return CLI_SUCCESS;
133 }
134
135 /*! \brief CLI Command to display CLI Aliases */
136 static char *alias_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
137 {
138 #define FORMAT "%-50.50s %-50.50s\n"
139         struct cli_alias *alias;
140         struct ao2_iterator i;
141
142         switch (cmd) {
143         case CLI_INIT:
144                 e->command = "cli show aliases";
145                 e->usage =
146                         "Usage: cli show aliases\n"
147                         "       Displays a list of aliased CLI commands.\n";
148                 return NULL;
149         case CLI_GENERATE:
150                 return NULL;
151         }
152
153         ast_cli(a->fd, FORMAT, "Alias Command", "Real Command");
154
155         i = ao2_iterator_init(cli_aliases, 0);
156
157         for (; (alias = ao2_iterator_next(&i)); ao2_ref(alias, -1)) {
158                 ast_cli(a->fd, FORMAT, alias->alias, alias->real_cmd);
159         }
160
161         return CLI_SUCCESS;
162 #undef FORMAT
163 }
164
165 /*! \brief CLI commands to interact with things */
166 static struct ast_cli_entry cli_alias[] = {
167         AST_CLI_DEFINE(alias_show, "Show CLI command aliases"),
168 };
169
170 /*! \brief Function called to mark an alias for destruction */
171 static int alias_mark(void *obj, void *arg, void *data, int flags)
172 {
173         struct cli_alias *alias = obj;
174         alias->marked = 1;
175         return 0;
176 }
177
178 /*! \brief Function called to see if an alias is marked for destruction */
179 static int alias_marked(void *obj, void *arg, void *data, int flags)
180 {
181         struct cli_alias *alias = obj;
182         return alias->marked ? CMP_MATCH : 0;
183 }
184
185 /*! \brief Function called to load or reload the configuration file */
186 static void load_config(int reload)
187 {
188         struct ast_config *cfg = NULL;
189         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
190         struct cli_alias *alias;
191         struct ast_variable *v, *v1;
192
193         if (!(cfg = ast_config_load(config_file, config_flags))) {
194                 ast_log(LOG_ERROR, "res_clialiases configuration file '%s' not found\n", config_file);
195                 return;
196         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
197                 return;
198         }
199
200         /* Mark CLI aliases for pruning */
201         if (reload) {
202                 ao2_callback(cli_aliases, OBJ_NODATA, alias_mark, NULL, NULL);
203         }
204
205         for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
206                 if (strcmp(v->name, "template")) {
207                         ast_log(LOG_WARNING, "%s is not a correct option in [%s]\n", v->name, "general");
208                         continue;
209                 }
210                 /* Read in those there CLI aliases */
211                 for (v1 = ast_variable_browse(cfg, v->value); v1; v1 = v1->next) {
212                         if (!(alias = ao2_alloc((sizeof(*alias) + strlen(v1->name) + strlen(v1->value) + 2), alias_destroy))) {
213                                 continue;
214                         }
215                         alias->alias = ((char *) alias) + sizeof(*alias);
216                         alias->real_cmd = ((char *) alias) + strlen(v1->name) + 1;
217                         strcpy(alias->alias, v1->name);
218                         strcpy(alias->real_cmd, v1->value);
219                         alias->cli_entry.handler = cli_alias_passthrough;
220                         alias->cli_entry.command = alias->alias;
221                         alias->cli_entry.usage = "Aliased CLI Command";
222
223                         ao2_link(cli_aliases, alias);
224                         ast_verbose(VERBOSE_PREFIX_2 "Aliased CLI command '%s' to '%s'\n", v1->name, v1->value);
225                         ao2_ref(alias, -1);
226                 }
227         }
228
229         /* Drop any CLI aliases that should no longer exist */
230         if (reload) {
231                 ao2_callback(cli_aliases, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE , alias_marked, NULL, NULL);
232         }
233
234         ast_config_destroy(cfg);
235
236         return;
237 }
238
239 /*! \brief Function called to reload the module */
240 static int reload_module(void)
241 {
242         load_config(1);
243         return 0;
244 }
245
246 /*! \brief Function called to unload the module */
247 static int unload_module(void)
248 {
249         ao2_ref(cli_aliases, -1);
250
251         ast_cli_unregister_multiple(cli_alias, ARRAY_LEN(cli_alias));
252
253         return 0;
254 }
255
256 /*! \brief Function called to load the module */
257 static int load_module(void)
258 {
259         if (!(cli_aliases = ao2_container_alloc(MAX_ALIAS_BUCKETS, alias_hash_cb, alias_cmp_cb))) {
260                 return AST_MODULE_LOAD_DECLINE;
261         }
262
263         load_config(0);
264
265         ast_cli_register_multiple(cli_alias, sizeof(cli_alias) / sizeof(struct ast_cli_entry));
266
267         return AST_MODULE_LOAD_SUCCESS;
268 }
269
270 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "CLI Aliases",
271                 .load = load_module,
272                 .unload = unload_module,
273                 .reload = reload_module,
274                 );