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