res_sorcery_realtime: Fix leak of sorcery object type.
[asterisk/asterisk.git] / res / res_sorcery_realtime.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 Realtime 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
40 /*! \brief They key field used to store the unique identifier for the object */
41 #define UUID_FIELD "id"
42
43 static void *sorcery_realtime_open(const char *data);
44 static int sorcery_realtime_create(const struct ast_sorcery *sorcery, void *data, void *object);
45 static void *sorcery_realtime_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
46 static void *sorcery_realtime_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
47 static void sorcery_realtime_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
48                                              const struct ast_variable *fields);
49 static void sorcery_realtime_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
50 static int sorcery_realtime_update(const struct ast_sorcery *sorcery, void *data, void *object);
51 static int sorcery_realtime_delete(const struct ast_sorcery *sorcery, void *data, void *object);
52 static void sorcery_realtime_close(void *data);
53
54 static struct ast_sorcery_wizard realtime_object_wizard = {
55         .name = "realtime",
56         .open = sorcery_realtime_open,
57         .create = sorcery_realtime_create,
58         .retrieve_id = sorcery_realtime_retrieve_id,
59         .retrieve_fields = sorcery_realtime_retrieve_fields,
60         .retrieve_multiple = sorcery_realtime_retrieve_multiple,
61         .retrieve_regex = sorcery_realtime_retrieve_regex,
62         .update = sorcery_realtime_update,
63         .delete = sorcery_realtime_delete,
64         .close = sorcery_realtime_close,
65 };
66
67 static int sorcery_realtime_create(const struct ast_sorcery *sorcery, void *data, void *object)
68 {
69         const char *family = data;
70         RAII_VAR(struct ast_variable *, fields, ast_sorcery_objectset_create(sorcery, object), ast_variables_destroy);
71         struct ast_variable *id = ast_variable_new(UUID_FIELD, ast_sorcery_object_get_id(object), "");
72
73         if (!fields || !id) {
74                 ast_variables_destroy(id);
75                 return -1;
76         }
77
78         /* Place the identifier at the front for sanity sake */
79         id->next = fields;
80         fields = id;
81
82         return (ast_store_realtime_fields(family, fields) <= 0) ? -1 : 0;
83 }
84
85 /*! \brief Internal helper function which returns a filtered objectset. 
86  *
87  * The following are filtered out of the objectset:
88  * \li The id field. This is returned to the caller in an out parameter.
89  * \li Fields that are not registered with sorcery.
90  *
91  * \param objectset Objectset to filter.
92  * \param[out] id The ID of the sorcery object, as found in the objectset.
93  * \param sorcery The sorcery instance that is requesting an objectset.
94  * \param type The object type
95  *
96  * \return The filtered objectset
97  */
98 static struct ast_variable *sorcery_realtime_filter_objectset(struct ast_variable *objectset, struct ast_variable **id,
99                 const struct ast_sorcery *sorcery, const char *type)
100 {
101         struct ast_variable *previous = NULL, *field = objectset;
102         struct ast_sorcery_object_type *object_type;
103
104         object_type = ast_sorcery_get_object_type(sorcery, type);
105         if (!object_type) {
106                 ast_log(LOG_WARNING, "Unknown sorcery object type %s. Expect errors\n", type);
107                 /* Continue since we still want to filter out the id */
108         }
109
110         while (field) {
111                 int remove_field = 0;
112                 int delete_field = 0;
113
114                 if (!strcmp(field->name, UUID_FIELD)) {
115                         *id = field;
116                         remove_field = 1;
117                 } else if (object_type &&
118                                 !ast_sorcery_is_object_field_registered(object_type, field->name)) {
119                         ast_debug(1, "Filtering out realtime field '%s' from retrieval\n", field->name);
120                         remove_field = 1;
121                         delete_field = 1;
122                 }
123
124                 if (remove_field) {
125                         struct ast_variable *removed;
126
127                         if (previous) {
128                                 previous->next = field->next;
129                         } else {
130                                 objectset = field->next;
131                         }
132
133                         removed = field;
134                         field = field->next;
135                         removed->next = NULL;
136                         if (delete_field) {
137                                 ast_variables_destroy(removed);
138                         }
139                 } else {
140                         previous = field;
141                         field = field->next;
142                 }
143         }
144
145         ao2_ref(object_type, -1);
146
147         return objectset;
148 }
149
150 static void *sorcery_realtime_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
151 {
152         const char *family = data;
153         RAII_VAR(struct ast_variable *, objectset, NULL, ast_variables_destroy);
154         RAII_VAR(struct ast_variable *, id, NULL, ast_variables_destroy);
155         void *object = NULL;
156
157         if (!(objectset = ast_load_realtime_fields(family, fields))) {
158                 return NULL;
159         }
160
161         objectset = sorcery_realtime_filter_objectset(objectset, &id, sorcery, type);
162
163         if (!id
164                 || !(object = ast_sorcery_alloc(sorcery, type, id->value))
165                 || ast_sorcery_objectset_apply(sorcery, object, objectset)) {
166                 return NULL;
167         }
168
169         return object;
170 }
171
172 static void *sorcery_realtime_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
173 {
174         RAII_VAR(struct ast_variable *, fields, ast_variable_new(UUID_FIELD, id, ""), ast_variables_destroy);
175
176         return sorcery_realtime_retrieve_fields(sorcery, data, type, fields);
177 }
178
179 static void sorcery_realtime_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
180 {
181         const char *family = data;
182         RAII_VAR(struct ast_config *, rows, NULL, ast_config_destroy);
183         RAII_VAR(struct ast_variable *, all, NULL, ast_variables_destroy);
184         struct ast_category *row = NULL;
185
186         if (!fields) {
187                 char field[strlen(UUID_FIELD) + 6], value[2];
188
189                 /* If no fields have been specified we want all rows, so trick realtime into doing it */
190                 snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD);
191                 snprintf(value, sizeof(value), "%%");
192
193                 if (!(all = ast_variable_new(field, value, ""))) {
194                         return;
195                 }
196
197                 fields = all;
198         }
199
200         if (!(rows = ast_load_realtime_multientry_fields(family, fields))) {
201                 return;
202         }
203
204         while ((row = ast_category_browse_filtered(rows, NULL, row, NULL))) {
205                 struct ast_variable *objectset = ast_category_detach_variables(row);
206                 RAII_VAR(struct ast_variable *, id, NULL, ast_variables_destroy);
207                 RAII_VAR(void *, object, NULL, ao2_cleanup);
208
209                 objectset = sorcery_realtime_filter_objectset(objectset, &id, sorcery, type);
210
211                 if (id && (object = ast_sorcery_alloc(sorcery, type, id->value)) && !ast_sorcery_objectset_apply(sorcery, object, objectset)) {
212                         ao2_link(objects, object);
213                 }
214
215                 ast_variables_destroy(objectset);
216         }
217 }
218
219 static void sorcery_realtime_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
220 {
221         char field[strlen(UUID_FIELD) + 6], value[strlen(regex) + 2];
222         RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
223
224         /* The realtime API provides no direct ability to do regex so for now we support a limited subset using pattern matching */
225         if (regex[0] != '^') {
226                 return;
227         }
228
229         snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD);
230         snprintf(value, sizeof(value), "%s%%", regex + 1);
231
232         if (!(fields = ast_variable_new(field, value, ""))) {
233                 return;
234         }
235
236         sorcery_realtime_retrieve_multiple(sorcery, data, type, objects, fields);
237 }
238
239 static int sorcery_realtime_update(const struct ast_sorcery *sorcery, void *data, void *object)
240 {
241         const char *family = data;
242         RAII_VAR(struct ast_variable *, fields, ast_sorcery_objectset_create(sorcery, object), ast_variables_destroy);
243
244         if (!fields) {
245                 return -1;
246         }
247
248         return (ast_update_realtime_fields(family, UUID_FIELD, ast_sorcery_object_get_id(object), fields) <= 0) ? -1 : 0;
249 }
250
251 static int sorcery_realtime_delete(const struct ast_sorcery *sorcery, void *data, void *object)
252 {
253         const char *family = data;
254
255         return (ast_destroy_realtime_fields(family, UUID_FIELD, ast_sorcery_object_get_id(object), NULL) <= 0) ? -1 : 0;
256 }
257
258 static void *sorcery_realtime_open(const char *data)
259 {
260         /* We require a prefix for family string generation, or else stuff could mix together */
261         if (ast_strlen_zero(data) || !ast_realtime_is_mapping_defined(data)) {
262                 return NULL;
263         }
264
265         return ast_strdup(data);
266 }
267
268 static void sorcery_realtime_close(void *data)
269 {
270         ast_free(data);
271 }
272
273 static int load_module(void)
274 {
275         if (ast_sorcery_wizard_register(&realtime_object_wizard)) {
276                 return AST_MODULE_LOAD_DECLINE;
277         }
278
279         return AST_MODULE_LOAD_SUCCESS;
280 }
281
282 static int unload_module(void)
283 {
284         ast_sorcery_wizard_unregister(&realtime_object_wizard);
285         return 0;
286 }
287
288 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Realtime Object Wizard",
289         .support_level = AST_MODULE_SUPPORT_CORE,
290         .load = load_module,
291         .unload = unload_module,
292         .load_pri = AST_MODPRI_REALTIME_DRIVER,
293 );