res_srtp: Add support for libsrtp2.1.
[asterisk/asterisk.git] / res / res_sorcery_astdb.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 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 Astdb 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/astdb.h"
38 #include "asterisk/json.h"
39
40 static void *sorcery_astdb_open(const char *data);
41 static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object);
42 static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
43 static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
44 static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
45                                              const struct ast_variable *fields);
46 static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
47 static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object);
48 static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object);
49 static void sorcery_astdb_close(void *data);
50
51 static struct ast_sorcery_wizard astdb_object_wizard = {
52         .name = "astdb",
53         .open = sorcery_astdb_open,
54         .create = sorcery_astdb_create,
55         .retrieve_id = sorcery_astdb_retrieve_id,
56         .retrieve_fields = sorcery_astdb_retrieve_fields,
57         .retrieve_multiple = sorcery_astdb_retrieve_multiple,
58         .retrieve_regex = sorcery_astdb_retrieve_regex,
59         .update = sorcery_astdb_update,
60         .delete = sorcery_astdb_delete,
61         .close = sorcery_astdb_close,
62 };
63
64 static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object)
65 {
66         RAII_VAR(struct ast_json *, objset, ast_sorcery_objectset_json_create(sorcery, object), ast_json_unref);
67         RAII_VAR(char *, value, NULL, ast_json_free);
68         const char *prefix = data;
69         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
70
71         if (!objset || !(value = ast_json_dump_string(objset))) {
72                 return -1;
73         }
74
75         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
76
77         return ast_db_put(family, ast_sorcery_object_get_id(object), value);
78 }
79
80 /*! \brief Internal helper function which returns a filtered objectset.
81  *
82  * The following are filtered out of the objectset:
83  * \li Fields that are not registered with sorcery.
84  *
85  * \param objectset Objectset to filter.
86  * \param sorcery The sorcery instance that is requesting an objectset.
87  * \param type The object type
88  *
89  * \return The filtered objectset
90  */
91 static struct ast_variable *sorcery_astdb_filter_objectset(struct ast_variable *objectset, const struct ast_sorcery *sorcery,
92         const char *type)
93 {
94         struct ast_variable *previous = NULL, *field = objectset;
95         struct ast_sorcery_object_type *object_type;
96
97         object_type = ast_sorcery_get_object_type(sorcery, type);
98         if (!object_type) {
99                 ast_log(LOG_WARNING, "Unknown sorcery object type %s. Expect errors\n", type);
100                 return objectset;
101         }
102
103         while (field) {
104                 struct ast_variable *removed;
105
106                 if (ast_sorcery_is_object_field_registered(object_type, field->name)) {
107                         previous = field;
108                         field = field->next;
109                         continue;
110                 }
111
112                 ast_debug(1, "Filtering out astdb field '%s' from retrieval\n", field->name);
113
114                 if (previous) {
115                         previous->next = field->next;
116                 } else {
117                         objectset = field->next;
118                 }
119
120                 removed = field;
121                 field = field->next;
122                 removed->next = NULL;
123
124                 ast_variables_destroy(removed);
125         }
126
127         ao2_cleanup(object_type);
128
129         return objectset;
130 }
131
132 /*! \brief Internal helper function which retrieves an object, or multiple objects, using fields for criteria */
133 static void *sorcery_astdb_retrieve_fields_common(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields, struct ao2_container *objects)
134 {
135         const char *prefix = data;
136         char family[strlen(prefix) + strlen(type) + 2];
137         RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
138         struct ast_db_entry *entry;
139
140         snprintf(family, sizeof(family), "%s/%s", prefix, type);
141
142         if (!(entries = ast_db_gettree(family, NULL))) {
143                 return NULL;
144         }
145
146         for (entry = entries; entry; entry = entry->next) {
147                 const char *key = entry->key + strlen(family) + 2;
148                 RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
149                 struct ast_json_error error;
150                 RAII_VAR(struct ast_variable *, existing, NULL, ast_variables_destroy);
151                 void *object = NULL;
152
153                 if (!(json = ast_json_load_string(entry->data, &error))) {
154                         return NULL;
155                 }
156
157                 if (ast_json_to_ast_variables(json, &existing) != AST_JSON_TO_AST_VARS_CODE_SUCCESS) {
158                         return NULL;
159                 }
160
161                 existing = sorcery_astdb_filter_objectset(existing, sorcery, type);
162
163                 if (fields && !ast_variable_lists_match(existing, fields, 0)) {
164                         continue;
165                 }
166
167                 if (!(object = ast_sorcery_alloc(sorcery, type, key)) ||
168                         ast_sorcery_objectset_apply(sorcery, object, existing)) {
169                         ao2_cleanup(object);
170                         return NULL;
171                 }
172
173                 if (!objects) {
174                         return object;
175                 }
176
177                 ao2_link(objects, object);
178                 ao2_cleanup(object);
179         }
180
181         return NULL;
182 }
183
184 static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
185 {
186         return sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, NULL);
187 }
188
189 static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
190 {
191         const char *prefix = data;
192         char family[strlen(prefix) + strlen(type) + 2];
193         RAII_VAR(char *, value, NULL, ast_free_ptr);
194         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
195         struct ast_json_error error;
196         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
197         void *object = NULL;
198
199         snprintf(family, sizeof(family), "%s/%s", prefix, type);
200
201         if (ast_db_get_allocated(family, id, &value)
202                 || !(json = ast_json_load_string(value, &error))
203                 || (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
204                 || !(objset = sorcery_astdb_filter_objectset(objset, sorcery, type))
205                 || !(object = ast_sorcery_alloc(sorcery, type, id))
206                 || ast_sorcery_objectset_apply(sorcery, object, objset)) {
207                 ast_debug(3, "Failed to retrieve object '%s' from astdb\n", id);
208                 ao2_cleanup(object);
209                 return NULL;
210         }
211
212         return object;
213 }
214
215 static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
216 {
217         sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, objects);
218 }
219
220 /*!
221  * \internal
222  * \brief Convert regex prefix pattern to astDB prefix pattern if possible.
223  *
224  * \param tree astDB prefix pattern buffer to fill.
225  * \param regex Extended regular expression with the start anchor character '^'.
226  *
227  * \note Since this is a helper function, the tree buffer is
228  * assumed to always be large enough.
229  *
230  * \retval 0 on success.
231  * \retval -1 on error.  regex is invalid.
232  */
233 static int make_astdb_prefix_pattern(char *tree, const char *regex)
234 {
235         const char *src;
236         char *dst;
237
238         for (dst = tree, src = regex + 1; *src; ++src) {
239                 if (*src == '\\') {
240                         /* Escaped regex char. */
241                         ++src;
242                         if (!*src) {
243                                 /* Invalid regex.  The caller escaped the string terminator. */
244                                 return -1;
245                         }
246                 } else if (*src == '$') {
247                         if (!src[1]) {
248                                 /* Remove the tail anchor character. */
249                                 *dst = '\0';
250                                 return 0;
251                         }
252                 } else if (strchr(".?*+{[(|", *src)) {
253                         /*
254                          * The regex is not a simple prefix pattern.
255                          *
256                          * XXX With more logic, it is possible to simply
257                          * use the current prefix pattern.  The last character
258                          * needs to be removed if possible when the current regex
259                          * token is "?*{".  Also the rest of the regex pattern
260                          * would need to be checked for subgroup/alternation.
261                          * Subgroup/alternation is too complex for a simple prefix
262                          * match.
263                          */
264                         dst = tree;
265                         break;
266                 }
267                 *dst++ = *src;
268         }
269         if (dst != tree) {
270                 *dst++ = '%';
271         }
272         *dst = '\0';
273         return 0;
274 }
275
276 static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
277 {
278         const char *prefix = data;
279         char family[strlen(prefix) + strlen(type) + 2];
280         char tree[strlen(regex) + 1];
281         RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
282         regex_t expression;
283         struct ast_db_entry *entry;
284
285         snprintf(family, sizeof(family), "%s/%s", prefix, type);
286
287         if (regex[0] == '^') {
288                 /*
289                  * For performance reasons, try to create an astDB prefix
290                  * pattern from the regex to reduce the number of entries
291                  * retrieved from astDB for regex to then match.
292                  */
293                 if (make_astdb_prefix_pattern(tree, regex)) {
294                         return;
295                 }
296         } else {
297                 tree[0] = '\0';
298         }
299
300         if (!(entries = ast_db_gettree(family, tree))
301                 || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
302                 return;
303         }
304
305         for (entry = entries; entry; entry = entry->next) {
306                 /* The key in the entry includes the family, so we need to strip it out for regex purposes */
307                 const char *key = entry->key + strlen(family) + 2;
308                 RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
309                 struct ast_json_error error;
310                 RAII_VAR(void *, object, NULL, ao2_cleanup);
311                 RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
312
313                 if (regexec(&expression, key, 0, NULL, 0)) {
314                         continue;
315                 } else if (!(json = ast_json_load_string(entry->data, &error))
316                         || (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
317                         || !(objset = sorcery_astdb_filter_objectset(objset, sorcery, type))
318                         || !(object = ast_sorcery_alloc(sorcery, type, key))
319                         || ast_sorcery_objectset_apply(sorcery, object, objset)) {
320                         regfree(&expression);
321                         return;
322                 }
323
324                 ao2_link(objects, object);
325         }
326
327         regfree(&expression);
328 }
329
330 static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object)
331 {
332         const char *prefix = data;
333         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2], value[2];
334
335         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
336
337         /* It is okay for the value to be truncated, we are only checking that it exists */
338         if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
339                 return -1;
340         }
341
342         /* The only difference between update and create is that for update the object must already exist */
343         return sorcery_astdb_create(sorcery, data, object);
344 }
345
346 static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object)
347 {
348         const char *prefix = data;
349         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
350         char value[2];
351
352         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
353
354         if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
355                 return -1;
356         }
357
358         return ast_db_del(family, ast_sorcery_object_get_id(object));
359 }
360
361 static void *sorcery_astdb_open(const char *data)
362 {
363         /* We require a prefix for family string generation, or else stuff could mix together */
364         if (ast_strlen_zero(data)) {
365                 return NULL;
366         }
367
368         return ast_strdup(data);
369 }
370
371 static void sorcery_astdb_close(void *data)
372 {
373         ast_free(data);
374 }
375
376 static int load_module(void)
377 {
378         if (ast_sorcery_wizard_register(&astdb_object_wizard)) {
379                 return AST_MODULE_LOAD_DECLINE;
380         }
381
382         return AST_MODULE_LOAD_SUCCESS;
383 }
384
385 static int unload_module(void)
386 {
387         ast_sorcery_wizard_unregister(&astdb_object_wizard);
388         return 0;
389 }
390
391 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Astdb Object Wizard",
392         .support_level = AST_MODULE_SUPPORT_CORE,
393         .load = load_module,
394         .unload = unload_module,
395         .load_pri = AST_MODPRI_REALTIME_DRIVER,
396 );