092cc41c8db4a19e4b5f666dcbe207be155d1bf4
[asterisk/asterisk.git] / res / res_sorcery_config.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, 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 /*!
20  * \file
21  *
22  * \brief Sorcery Configuration File Object Wizard
23  *
24  * \author Joshua Colp <jcolp@digium.com>
25  */
26
27 /*** MODULEINFO
28         <support_level>core</support_level>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_REGISTER_FILE()
34
35 #include <regex.h>
36
37 #include "asterisk/module.h"
38 #include "asterisk/sorcery.h"
39 #include "asterisk/astobj2.h"
40 #include "asterisk/config.h"
41 #include "asterisk/uuid.h"
42 #include "asterisk/hashtab.h"
43
44 /*! \brief Structure for storing configuration file sourced objects */
45 struct sorcery_config {
46         /*! \brief UUID for identifying us when opening a configuration file */
47         char uuid[AST_UUID_STR_LEN];
48
49         /*! \brief Objects retrieved from the configuration file */
50         struct ao2_global_obj objects;
51
52         /*! \brief Any specific variable criteria for considering a defined category for this object */
53         struct ast_variable *criteria;
54
55         /*! \brief Number of buckets to use for objects */
56         unsigned int buckets;
57
58         /*! \brief Enable file level integrity instead of object level */
59         unsigned int file_integrity:1;
60
61         /*! \brief Filename of the configuration file */
62         char filename[];
63 };
64
65 /*! \brief Structure used for fields comparison */
66 struct sorcery_config_fields_cmp_params {
67         /*! \brief Pointer to the sorcery structure */
68         const struct ast_sorcery *sorcery;
69
70         /*! \brief Pointer to the fields to check */
71         const struct ast_variable *fields;
72
73         /*! \brief Regular expression for checking object id */
74         regex_t *regex;
75
76         /*! \brief Optional container to put object into */
77         struct ao2_container *container;
78 };
79
80 static void *sorcery_config_open(const char *data);
81 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type);
82 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type);
83 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
84 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
85 static void sorcery_config_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
86                                              const struct ast_variable *fields);
87 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
88 static void sorcery_config_close(void *data);
89
90 static struct ast_sorcery_wizard config_object_wizard = {
91         .name = "config",
92         .open = sorcery_config_open,
93         .load = sorcery_config_load,
94         .reload = sorcery_config_reload,
95         .retrieve_id = sorcery_config_retrieve_id,
96         .retrieve_fields = sorcery_config_retrieve_fields,
97         .retrieve_multiple = sorcery_config_retrieve_multiple,
98         .retrieve_regex = sorcery_config_retrieve_regex,
99         .close = sorcery_config_close,
100 };
101
102 /*! \brief Destructor function for sorcery config */
103 static void sorcery_config_destructor(void *obj)
104 {
105         struct sorcery_config *config = obj;
106
107         ao2_global_obj_release(config->objects);
108         ast_rwlock_destroy(&config->objects.lock);
109         ast_variables_destroy(config->criteria);
110 }
111
112 /*! \brief Hashing function for sorcery objects */
113 static int sorcery_config_hash(const void *obj, const int flags)
114 {
115         const char *id = obj;
116
117         return ast_str_hash(flags & OBJ_KEY ? id : ast_sorcery_object_get_id(obj));
118 }
119
120 /*! \brief Comparator function for sorcery objects */
121 static int sorcery_config_cmp(void *obj, void *arg, int flags)
122 {
123         const char *id = arg;
124
125         return !strcmp(ast_sorcery_object_get_id(obj), flags & OBJ_KEY ? id : ast_sorcery_object_get_id(arg)) ? CMP_MATCH | CMP_STOP : 0;
126 }
127
128 static int sorcery_config_fields_cmp(void *obj, void *arg, int flags)
129 {
130         const struct sorcery_config_fields_cmp_params *params = arg;
131         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
132         RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
133
134         if (params->regex) {
135                 /* If a regular expression has been provided see if it matches, otherwise move on */
136                 if (!regexec(params->regex, ast_sorcery_object_get_id(obj), 0, NULL, 0)) {
137                         ao2_link(params->container, obj);
138                 }
139                 return 0;
140         } else if (params->fields &&
141             (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
142              (ast_sorcery_changeset_create(objset, params->fields, &diff)) ||
143              diff)) {
144                 /* If we can't turn the object into an object set OR if differences exist between the fields
145              * passed in and what are present on the object they are not a match.
146              */
147                 return 0;
148         }
149
150         if (params->container) {
151                 ao2_link(params->container, obj);
152
153                 /* As multiple objects are being returned keep going */
154                 return 0;
155         } else {
156                 /* Immediately stop and return, we only want a single object */
157                 return CMP_MATCH | CMP_STOP;
158         }
159 }
160
161 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
162 {
163         struct sorcery_config *config = data;
164         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
165         struct sorcery_config_fields_cmp_params params = {
166                 .sorcery = sorcery,
167                 .fields = fields,
168                 .container = NULL,
169         };
170
171         /* If no fields are present return nothing, we require *something*, same goes if no objects exist yet */
172         if (!objects || !fields) {
173                 return NULL;
174         }
175
176         return ao2_callback(objects, 0, sorcery_config_fields_cmp, &params);
177 }
178
179 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
180 {
181         struct sorcery_config *config = data;
182         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
183
184         return objects ? ao2_find(objects, id, OBJ_KEY) : NULL;
185 }
186
187 static void sorcery_config_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
188 {
189         struct sorcery_config *config = data;
190         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
191         struct sorcery_config_fields_cmp_params params = {
192                 .sorcery = sorcery,
193                 .fields = fields,
194                 .container = objects,
195         };
196
197         if (!config_objects) {
198                 return;
199         }
200         ao2_callback(config_objects, 0, sorcery_config_fields_cmp, &params);
201 }
202
203 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
204 {
205         struct sorcery_config *config = data;
206         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
207         regex_t expression;
208         struct sorcery_config_fields_cmp_params params = {
209                 .sorcery = sorcery,
210                 .container = objects,
211                 .regex = &expression,
212         };
213
214         if (!config_objects || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
215                 return;
216         }
217
218         ao2_callback(config_objects, 0, sorcery_config_fields_cmp, &params);
219         regfree(&expression);
220 }
221
222 /*! \brief Internal function which determines if criteria has been met for considering an object set applicable */
223 static int sorcery_is_criteria_met(struct ast_variable *objset, struct ast_variable *criteria)
224 {
225         RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
226
227         return (!criteria || (!ast_sorcery_changeset_create(objset, criteria, &diff) && !diff)) ? 1 : 0;
228 }
229
230 static void sorcery_config_internal_load(void *data, const struct ast_sorcery *sorcery, const char *type, unsigned int reload)
231 {
232         struct sorcery_config *config = data;
233         struct ast_flags flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
234         struct ast_config *cfg = ast_config_load2(config->filename, config->uuid, flags);
235         struct ast_category *category = NULL;
236         RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
237         const char *id = NULL;
238         unsigned int buckets = 0;
239
240         if (!cfg) {
241                 ast_log(LOG_ERROR, "Unable to load config file '%s'\n", config->filename);
242                 return;
243         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
244                 ast_debug(1, "Config file '%s' was unchanged\n", config->filename);
245                 return;
246         } else if (cfg == CONFIG_STATUS_FILEINVALID) {
247                 ast_log(LOG_ERROR, "Contents of config file '%s' are invalid and cannot be parsed\n", config->filename);
248                 return;
249         }
250
251         if (!config->buckets) {
252                 while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
253
254                         /* If given criteria has not been met skip the category, it is not applicable */
255                         if (!sorcery_is_criteria_met(ast_category_first(category), config->criteria)) {
256                                 continue;
257                         }
258
259                         buckets++;
260                 }
261
262                 /* Determine the optimal number of buckets */
263                 while (buckets && !ast_is_prime(buckets)) {
264                         /* This purposely goes backwards to ensure that the container doesn't have a ton of
265                          * empty buckets for objects that will never get added.
266                          */
267                         buckets--;
268                 }
269
270                 if (!buckets) {
271                         buckets = 1;
272                 }
273         } else {
274                 buckets = config->buckets;
275         }
276
277         ast_debug(2, "Using bucket size of '%d' for objects of type '%s' from '%s'\n",
278                 buckets, type, config->filename);
279
280         if (!(objects = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, buckets,
281                 sorcery_config_hash, sorcery_config_cmp))) {
282                 ast_log(LOG_ERROR, "Could not create bucket for new objects from '%s', keeping existing objects\n",
283                         config->filename);
284                 ast_config_destroy(cfg);
285                 return;
286         }
287
288         while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
289                 RAII_VAR(void *, obj, NULL, ao2_cleanup);
290                 id = ast_category_get_name(category);
291
292                 /* If given criteria has not been met skip the category, it is not applicable */
293                 if (!sorcery_is_criteria_met(ast_category_first(category), config->criteria)) {
294                         continue;
295                 }
296
297                 /*  Confirm an object with this id does not already exist in the bucket.
298                  *  If it exists, however, the configuration is invalid so stop
299                  *  processing and destroy it. */
300                 obj = ao2_find(objects, id, OBJ_KEY);
301
302                 if (obj) {
303                         ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains a duplicate object: '%s' of type '%s'\n",
304                                 config->filename, id, type);
305                         ast_config_destroy(cfg);
306                         return;
307                 }
308
309                 if (!(obj = ast_sorcery_alloc(sorcery, type, id)) ||
310                     ast_sorcery_objectset_apply(sorcery, obj, ast_category_first(category))) {
311
312                         if (config->file_integrity) {
313                                 ast_log(LOG_ERROR, "Config file '%s' could not be loaded due to error with object '%s' of type '%s'\n",
314                                         config->filename, id, type);
315                                 ast_config_destroy(cfg);
316                                 return;
317                         } else {
318                                 ast_log(LOG_ERROR, "Could not create an object of type '%s' with id '%s' from configuration file '%s'\n",
319                                         type, id, config->filename);
320                         }
321
322                         ao2_cleanup(obj);
323
324                         /* To ensure we don't lose the object that already exists we retrieve it from the old objects container and add it to the new one */
325                         if (!(obj = sorcery_config_retrieve_id(sorcery, data, type, id))) {
326                                 continue;
327                         }
328
329                         ast_log(LOG_NOTICE, "Retaining existing configuration for object of type '%s' with id '%s'\n", type, id);
330                 }
331
332                 ao2_link(objects, obj);
333         }
334
335         ao2_global_obj_replace_unref(config->objects, objects);
336         ast_config_destroy(cfg);
337 }
338
339 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type)
340 {
341         sorcery_config_internal_load(data, sorcery, type, 0);
342 }
343
344 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type)
345 {
346         sorcery_config_internal_load(data, sorcery, type, 1);
347 }
348
349 static void *sorcery_config_open(const char *data)
350 {
351         char *tmp;
352         char *filename;
353         char *option;
354         struct sorcery_config *config;
355
356         if (ast_strlen_zero(data)) {
357                 return NULL;
358         }
359
360         tmp = ast_strdupa(data);
361         filename = strsep(&tmp, ",");
362
363         if (ast_strlen_zero(filename) || !(config = ao2_alloc_options(sizeof(*config) + strlen(filename) + 1, sorcery_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
364                 return NULL;
365         }
366
367         ast_uuid_generate_str(config->uuid, sizeof(config->uuid));
368
369         ast_rwlock_init(&config->objects.lock);
370         strcpy(config->filename, filename);
371
372         while ((option = strsep(&tmp, ","))) {
373                 char *name = strsep(&option, "="), *value = option;
374
375                 if (!strcasecmp(name, "buckets")) {
376                         if (sscanf(value, "%30u", &config->buckets) != 1) {
377                                 ast_log(LOG_ERROR, "Unsupported bucket size of '%s' used for configuration file '%s', defaulting to automatic determination\n",
378                                         value, filename);
379                         }
380                 } else if (!strcasecmp(name, "integrity")) {
381                         if (!strcasecmp(value, "file")) {
382                                 config->file_integrity = 1;
383                         } else if (!strcasecmp(value, "object")) {
384                                 config->file_integrity = 0;
385                         } else {
386                                 ast_log(LOG_ERROR, "Unsupported integrity value of '%s' used for configuration file '%s', defaulting to 'object'\n",
387                                         value, filename);
388                         }
389                 } else if (!strcasecmp(name, "criteria")) {
390                         char *field = strsep(&value, "=");
391                         struct ast_variable *criteria = ast_variable_new(field, value, "");
392
393                         if (criteria) {
394                                 criteria->next = config->criteria;
395                                 config->criteria = criteria;
396                         } else {
397                                 /* This is fatal since not following criteria would potentially yield invalid objects */
398                                 ast_log(LOG_ERROR, "Could not create criteria entry of field '%s' with value '%s' for configuration file '%s'\n",
399                                         field, value, filename);
400                                 ao2_ref(config, -1);
401                                 return NULL;
402                         }
403                 } else {
404                         ast_log(LOG_ERROR, "Unsupported option '%s' used for configuration file '%s'\n", name, filename);
405                 }
406         }
407
408         return config;
409 }
410
411 static void sorcery_config_close(void *data)
412 {
413         struct sorcery_config *config = data;
414
415         ao2_ref(config, -1);
416 }
417
418 static int load_module(void)
419 {
420         if (ast_sorcery_wizard_register(&config_object_wizard)) {
421                 return AST_MODULE_LOAD_DECLINE;
422         }
423
424         return AST_MODULE_LOAD_SUCCESS;
425 }
426
427 static int unload_module(void)
428 {
429         ast_sorcery_wizard_unregister(&config_object_wizard);
430         return 0;
431 }
432
433 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Configuration File Object Wizard",
434         .support_level = AST_MODULE_SUPPORT_CORE,
435         .load = load_module,
436         .unload = unload_module,
437         .load_pri = AST_MODPRI_REALTIME_DRIVER,
438 );