Merge "res_pjsip_caller_id: Add "party" parameter to RPID header."
[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 #include <regex.h>
34
35 #include "asterisk/module.h"
36 #include "asterisk/sorcery.h"
37 #include "asterisk/astobj2.h"
38 #include "asterisk/config.h"
39 #include "asterisk/uuid.h"
40 #include "asterisk/hashtab.h"
41
42 /*! \brief Structure for storing configuration file sourced objects */
43 struct sorcery_config {
44         /*! \brief UUID for identifying us when opening a configuration file */
45         char uuid[AST_UUID_STR_LEN];
46
47         /*! \brief Objects retrieved from the configuration file */
48         struct ao2_global_obj objects;
49
50         /*! \brief Any specific variable criteria for considering a defined category for this object */
51         struct ast_variable *criteria;
52
53         /*! \brief An explicit name for the configuration section, with it there can be only one */
54         char *explicit_name;
55
56         /*! \brief Number of buckets to use for objects */
57         unsigned int buckets;
58
59         /*! \brief Enable file level integrity instead of object level */
60         unsigned int file_integrity:1;
61
62         /*! \brief Enable enforcement of a single configuration object of this type */
63         unsigned int single_object:1;
64
65         /*! \brief Filename of the configuration file */
66         char filename[];
67 };
68
69 /*! \brief Structure used for fields comparison */
70 struct sorcery_config_fields_cmp_params {
71         /*! \brief Pointer to the sorcery structure */
72         const struct ast_sorcery *sorcery;
73
74         /*! \brief Pointer to the fields to check */
75         const struct ast_variable *fields;
76
77         /*! \brief Regular expression for checking object id */
78         regex_t *regex;
79
80         /*! \brief Prefix for matching object id */
81         const char *prefix;
82
83         /*! \brief Prefix length in bytes for matching object id */
84         const size_t prefix_len;
85
86         /*! \brief Optional container to put object into */
87         struct ao2_container *container;
88 };
89
90 static void *sorcery_config_open(const char *data);
91 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type);
92 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type);
93 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
94 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
95 static void sorcery_config_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
96                                              const struct ast_variable *fields);
97 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
98 static void sorcery_config_retrieve_prefix(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *prefix, const size_t prefix_len);
99 static void sorcery_config_close(void *data);
100
101 static struct ast_sorcery_wizard config_object_wizard = {
102         .name = "config",
103         .open = sorcery_config_open,
104         .load = sorcery_config_load,
105         .reload = sorcery_config_reload,
106         .retrieve_id = sorcery_config_retrieve_id,
107         .retrieve_fields = sorcery_config_retrieve_fields,
108         .retrieve_multiple = sorcery_config_retrieve_multiple,
109         .retrieve_regex = sorcery_config_retrieve_regex,
110         .retrieve_prefix = sorcery_config_retrieve_prefix,
111         .close = sorcery_config_close,
112 };
113
114 /*! \brief Destructor function for sorcery config */
115 static void sorcery_config_destructor(void *obj)
116 {
117         struct sorcery_config *config = obj;
118
119         ao2_global_obj_release(config->objects);
120         ast_rwlock_destroy(&config->objects.lock);
121         ast_variables_destroy(config->criteria);
122         ast_free(config->explicit_name);
123 }
124
125 static int sorcery_config_fields_cmp(void *obj, void *arg, int flags)
126 {
127         const struct sorcery_config_fields_cmp_params *params = arg;
128         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
129
130         if (params->regex) {
131                 /* If a regular expression has been provided see if it matches, otherwise move on */
132                 if (!regexec(params->regex, ast_sorcery_object_get_id(obj), 0, NULL, 0)) {
133                         ao2_link(params->container, obj);
134                 }
135                 return 0;
136         } else if (params->prefix) {
137                 if (!strncmp(params->prefix, ast_sorcery_object_get_id(obj), params->prefix_len)) {
138                         ao2_link(params->container, obj);
139                 }
140                 return 0;
141         } else if (params->fields &&
142             (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
143              (!ast_variable_lists_match(objset, params->fields, 0)))) {
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         /* We want this object */
151         if (params->container) {
152                 /*
153                  * We are putting the found objects into the given container instead
154                  * of the normal container traversal return mechanism.
155                  */
156                 ao2_link(params->container, obj);
157                 return 0;
158         } else {
159                 return CMP_MATCH;
160         }
161 }
162
163 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
164 {
165         struct sorcery_config *config = data;
166         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
167         struct sorcery_config_fields_cmp_params params = {
168                 .sorcery = sorcery,
169                 .fields = fields,
170                 .container = NULL,
171         };
172
173         /* If no fields are present return nothing, we require *something*, same goes if no objects exist yet */
174         if (!objects || !fields) {
175                 return NULL;
176         }
177
178         return ao2_callback(objects, 0, sorcery_config_fields_cmp, &params);
179 }
180
181 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
182 {
183         struct sorcery_config *config = data;
184         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
185
186         return objects ? ao2_find(objects, id, OBJ_SEARCH_KEY) : NULL;
187 }
188
189 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)
190 {
191         struct sorcery_config *config = data;
192         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
193         struct sorcery_config_fields_cmp_params params = {
194                 .sorcery = sorcery,
195                 .fields = fields,
196                 .container = objects,
197         };
198
199         if (!config_objects) {
200                 return;
201         }
202
203         ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
204 }
205
206 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
207 {
208         struct sorcery_config *config = data;
209         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
210         regex_t expression;
211         struct sorcery_config_fields_cmp_params params = {
212                 .sorcery = sorcery,
213                 .container = objects,
214                 .regex = &expression,
215         };
216
217         if (ast_strlen_zero(regex)) {
218                 regex = ".";
219         }
220
221         if (!config_objects || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
222                 return;
223         }
224
225         ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
226         regfree(&expression);
227 }
228
229 static void sorcery_config_retrieve_prefix(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *prefix, const size_t prefix_len)
230 {
231         struct sorcery_config *config = data;
232         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
233         struct sorcery_config_fields_cmp_params params = {
234                 .sorcery = sorcery,
235                 .container = objects,
236                 .prefix = prefix,
237                 .prefix_len = prefix_len,
238         };
239
240         if (!config_objects) {
241                 return;
242         }
243
244         ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
245 }
246
247 /*! \brief Internal function which determines if a category matches based on explicit name */
248 static int sorcery_is_explicit_name_met(const struct ast_sorcery *sorcery, const char *type,
249         struct ast_category *category, struct sorcery_config *config)
250 {
251         struct ast_sorcery_object_type *object_type;
252         struct ast_variable *field;
253         int met = 1;
254
255         if (ast_strlen_zero(config->explicit_name) || strcmp(ast_category_get_name(category), config->explicit_name)) {
256                 return 0;
257         }
258
259         object_type = ast_sorcery_get_object_type(sorcery, type);
260         if (!object_type) {
261                 return 0;
262         }
263
264         /* We iterate the configured fields to see if we don't know any, if we don't then
265          * this is likely not for the given type and we skip it. If it actually is then criteria
266          * may pick it up in which case it would just get rejected as an invalid configuration later.
267          */
268         for (field = ast_category_first(category); field; field = field->next) {
269                 if (!ast_sorcery_is_object_field_registered(object_type, field->name)) {
270                         met = 0;
271                         break;
272                 }
273         }
274
275         ao2_ref(object_type, -1);
276
277         return met;
278 }
279
280 /*! \brief Internal function which determines if a category matches based on criteria */
281 static int sorcery_is_criteria_met(struct ast_category *category, struct sorcery_config *config)
282 {
283         RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
284
285         if (!config->criteria) {
286                 return 0;
287         }
288
289         return (!ast_sorcery_changeset_create(ast_category_first(category), config->criteria, &diff) && !diff) ? 1 : 0;
290 }
291
292 /*! \brief Internal function which determines if criteria has been met for considering an object set applicable */
293 static int sorcery_is_configuration_met(const struct ast_sorcery *sorcery, const char *type,
294         struct ast_category *category, struct sorcery_config *config)
295 {
296         if (!config->criteria && ast_strlen_zero(config->explicit_name)) {
297                 /* Nothing is configured to allow specific matching, so accept it! */
298                 return 1;
299         } else if (sorcery_is_explicit_name_met(sorcery, type, category, config)) {
300                 return 1;
301         } else if (sorcery_is_criteria_met(category, config)) {
302                 return 1;
303         } else {
304                 /* Nothing explicitly matched so reject */
305                 return 0;
306         }
307 }
308
309 static void sorcery_config_internal_load(void *data, const struct ast_sorcery *sorcery, const char *type, unsigned int reload)
310 {
311         struct sorcery_config *config = data;
312         struct ast_flags flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
313         struct ast_config *cfg = ast_config_load2(config->filename, config->uuid, flags);
314         struct ast_category *category = NULL;
315         RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
316         const char *id = NULL;
317         unsigned int buckets = 0;
318
319         if (!cfg) {
320                 ast_log(LOG_ERROR, "Unable to load config file '%s'\n", config->filename);
321                 return;
322         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
323                 ast_debug(1, "Config file '%s' was unchanged\n", config->filename);
324                 return;
325         } else if (cfg == CONFIG_STATUS_FILEINVALID) {
326                 ast_log(LOG_ERROR, "Contents of config file '%s' are invalid and cannot be parsed\n", config->filename);
327                 return;
328         }
329
330         if (!config->buckets) {
331                 while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
332
333                         /* If given configuration has not been met skip the category, it is not applicable */
334                         if (!sorcery_is_configuration_met(sorcery, type, category, config)) {
335                                 continue;
336                         }
337
338                         buckets++;
339                 }
340
341                 /* Determine the optimal number of buckets */
342                 while (buckets && !ast_is_prime(buckets)) {
343                         /* This purposely goes backwards to ensure that the container doesn't have a ton of
344                          * empty buckets for objects that will never get added.
345                          */
346                         buckets--;
347                 }
348
349                 if (!buckets) {
350                         buckets = 1;
351                 }
352         } else {
353                 buckets = config->buckets;
354         }
355
356         /* For single object configurations there can only ever be one bucket, if there's more than the single
357          * object requirement has been violated.
358          */
359         if (config->single_object && buckets > 1) {
360                 ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains more than one object of type '%s'\n",
361                         config->filename, type);
362                 ast_config_destroy(cfg);
363                 return;
364         }
365
366         ast_debug(2, "Using bucket size of '%d' for objects of type '%s' from '%s'\n",
367                 buckets, type, config->filename);
368
369         objects = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, buckets,
370                 ast_sorcery_object_id_hash, NULL, ast_sorcery_object_id_compare);
371         if (!objects) {
372                 ast_log(LOG_ERROR, "Could not create bucket for new objects from '%s', keeping existing objects\n",
373                         config->filename);
374                 ast_config_destroy(cfg);
375                 return;
376         }
377
378         while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
379                 RAII_VAR(void *, obj, NULL, ao2_cleanup);
380                 id = ast_category_get_name(category);
381
382                 /* If given configurationhas not been met skip the category, it is not applicable */
383                 if (!sorcery_is_configuration_met(sorcery, type, category, config)) {
384                         continue;
385                 }
386
387                 /*  Confirm an object with this id does not already exist in the bucket.
388                  *  If it exists, however, the configuration is invalid so stop
389                  *  processing and destroy it. */
390                 obj = ao2_find(objects, id, OBJ_SEARCH_KEY);
391                 if (obj) {
392                         ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains a duplicate object: '%s' of type '%s'\n",
393                                 config->filename, id, type);
394                         ast_config_destroy(cfg);
395                         return;
396                 }
397
398                 if (!(obj = ast_sorcery_alloc(sorcery, type, id)) ||
399                     ast_sorcery_objectset_apply(sorcery, obj, ast_category_first(category))) {
400
401                         if (config->file_integrity) {
402                                 ast_log(LOG_ERROR, "Config file '%s' could not be loaded due to error with object '%s' of type '%s'\n",
403                                         config->filename, id, type);
404                                 ast_config_destroy(cfg);
405                                 return;
406                         } else {
407                                 ast_log(LOG_ERROR, "Could not create an object of type '%s' with id '%s' from configuration file '%s'\n",
408                                         type, id, config->filename);
409                         }
410
411                         ao2_cleanup(obj);
412
413                         /* 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 */
414                         if (!(obj = sorcery_config_retrieve_id(sorcery, data, type, id))) {
415                                 continue;
416                         }
417
418                         ast_log(LOG_NOTICE, "Retaining existing configuration for object of type '%s' with id '%s'\n", type, id);
419                 }
420
421                 ao2_link(objects, obj);
422         }
423
424         ao2_global_obj_replace_unref(config->objects, objects);
425         ast_config_destroy(cfg);
426 }
427
428 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type)
429 {
430         sorcery_config_internal_load(data, sorcery, type, 0);
431 }
432
433 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type)
434 {
435         sorcery_config_internal_load(data, sorcery, type, 1);
436 }
437
438 static void *sorcery_config_open(const char *data)
439 {
440         char *tmp;
441         char *filename;
442         char *option;
443         struct sorcery_config *config;
444
445         if (ast_strlen_zero(data)) {
446                 return NULL;
447         }
448
449         tmp = ast_strdupa(data);
450         filename = strsep(&tmp, ",");
451
452         if (ast_strlen_zero(filename) || !(config = ao2_alloc_options(sizeof(*config) + strlen(filename) + 1, sorcery_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
453                 return NULL;
454         }
455
456         ast_uuid_generate_str(config->uuid, sizeof(config->uuid));
457
458         ast_rwlock_init(&config->objects.lock);
459         strcpy(config->filename, filename);
460
461         while ((option = strsep(&tmp, ","))) {
462                 char *name = strsep(&option, "="), *value = option;
463
464                 if (!strcasecmp(name, "buckets")) {
465                         if (sscanf(value, "%30u", &config->buckets) != 1) {
466                                 ast_log(LOG_ERROR, "Unsupported bucket size of '%s' used for configuration file '%s', defaulting to automatic determination\n",
467                                         value, filename);
468                         }
469                 } else if (!strcasecmp(name, "integrity")) {
470                         if (!strcasecmp(value, "file")) {
471                                 config->file_integrity = 1;
472                         } else if (!strcasecmp(value, "object")) {
473                                 config->file_integrity = 0;
474                         } else {
475                                 ast_log(LOG_ERROR, "Unsupported integrity value of '%s' used for configuration file '%s', defaulting to 'object'\n",
476                                         value, filename);
477                         }
478                 } else if (!strcasecmp(name, "criteria")) {
479                         char *field = strsep(&value, "=");
480                         struct ast_variable *criteria = ast_variable_new(field, value, "");
481
482                         if (criteria) {
483                                 criteria->next = config->criteria;
484                                 config->criteria = criteria;
485                         } else {
486                                 /* This is fatal since not following criteria would potentially yield invalid objects */
487                                 ast_log(LOG_ERROR, "Could not create criteria entry of field '%s' with value '%s' for configuration file '%s'\n",
488                                         field, value, filename);
489                                 ao2_ref(config, -1);
490                                 return NULL;
491                         }
492                 } else if (!strcasecmp(name, "explicit_name")) {
493                         ast_free(config->explicit_name);
494                         config->explicit_name = ast_strdup(value);
495                         if (ast_strlen_zero(config->explicit_name)) {
496                                 /* This is fatal since it could stop a configuration section from getting applied */
497                                 ast_log(LOG_ERROR, "Could not create explicit name entry of '%s' for configuration file '%s'\n",
498                                         value, filename);
499                                 ao2_ref(config, -1);
500                                 return NULL;
501                         }
502                 } else if (!strcasecmp(name, "single_object")) {
503                         if (ast_strlen_zero(value)) {
504                                 ast_log(LOG_ERROR, "Could not set single object value for configuration file '%s' as the value is empty\n",
505                                         filename);
506                                 ao2_ref(config, -1);
507                                 return NULL;
508                         }
509                         config->single_object = ast_true(value);
510                 } else {
511                         ast_log(LOG_ERROR, "Unsupported option '%s' used for configuration file '%s'\n", name, filename);
512                 }
513         }
514
515         return config;
516 }
517
518 static void sorcery_config_close(void *data)
519 {
520         struct sorcery_config *config = data;
521
522         ao2_ref(config, -1);
523 }
524
525 static int load_module(void)
526 {
527         if (ast_sorcery_wizard_register(&config_object_wizard)) {
528                 return AST_MODULE_LOAD_DECLINE;
529         }
530
531         return AST_MODULE_LOAD_SUCCESS;
532 }
533
534 static int unload_module(void)
535 {
536         ast_sorcery_wizard_unregister(&config_object_wizard);
537         return 0;
538 }
539
540 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Configuration File Object Wizard",
541         .support_level = AST_MODULE_SUPPORT_CORE,
542         .load = load_module,
543         .unload = unload_module,
544         .load_pri = AST_MODPRI_REALTIME_DRIVER,
545 );