Add module support level to ast_module_info structure. Print it in CLI "module show" .
[asterisk/asterisk.git] / res / res_sorcery_memory.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 In-Memory 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_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include <regex.h>
36
37 #include "asterisk/module.h"
38 #include "asterisk/sorcery.h"
39 #include "asterisk/astobj2.h"
40
41 /*! \brief Number of buckets for sorcery objects */
42 #define OBJECT_BUCKETS 53
43
44 static void *sorcery_memory_open(const char *data);
45 static int sorcery_memory_create(const struct ast_sorcery *sorcery, void *data, void *object);
46 static void *sorcery_memory_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
47 static void *sorcery_memory_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
48 static void sorcery_memory_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
49                                              const struct ast_variable *fields);
50 static void sorcery_memory_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
51 static int sorcery_memory_update(const struct ast_sorcery *sorcery, void *data, void *object);
52 static int sorcery_memory_delete(const struct ast_sorcery *sorcery, void *data, void *object);
53 static void sorcery_memory_close(void *data);
54
55 static struct ast_sorcery_wizard memory_object_wizard = {
56         .name = "memory",
57         .open = sorcery_memory_open,
58         .create = sorcery_memory_create,
59         .retrieve_id = sorcery_memory_retrieve_id,
60         .retrieve_fields = sorcery_memory_retrieve_fields,
61         .retrieve_multiple = sorcery_memory_retrieve_multiple,
62         .retrieve_regex = sorcery_memory_retrieve_regex,
63         .update = sorcery_memory_update,
64         .delete = sorcery_memory_delete,
65         .close = sorcery_memory_close,
66 };
67
68 /*! \brief Structure used for fields comparison */
69 struct sorcery_memory_fields_cmp_params {
70         /*! \brief Pointer to the sorcery structure */
71         const struct ast_sorcery *sorcery;
72
73         /*! \brief Pointer to the fields to check */
74         const struct ast_variable *fields;
75
76         /*! \brief Regular expression for checking object id */
77         regex_t *regex;
78
79         /*! \brief Optional container to put object into */
80         struct ao2_container *container;
81 };
82
83 /*! \brief Hashing function for sorcery objects */
84 static int sorcery_memory_hash(const void *obj, const int flags)
85 {
86         const char *id = obj;
87
88         return ast_str_hash(flags & OBJ_KEY ? id : ast_sorcery_object_get_id(obj));
89 }
90
91 /*! \brief Comparator function for sorcery objects */
92 static int sorcery_memory_cmp(void *obj, void *arg, int flags)
93 {
94         const char *id = arg;
95
96         return !strcmp(ast_sorcery_object_get_id(obj), flags & OBJ_KEY ? id : ast_sorcery_object_get_id(arg)) ? CMP_MATCH | CMP_STOP : 0;
97 }
98
99 static int sorcery_memory_create(const struct ast_sorcery *sorcery, void *data, void *object)
100 {
101         ao2_link(data, object);
102         return 0;
103 }
104
105 static int sorcery_memory_fields_cmp(void *obj, void *arg, int flags)
106 {
107         const struct sorcery_memory_fields_cmp_params *params = arg;
108         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
109         RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
110
111         if (params->regex) {
112                 /* If a regular expression has been provided see if it matches, otherwise move on */
113                 if (!regexec(params->regex, ast_sorcery_object_get_id(obj), 0, NULL, 0)) {
114                         ao2_link(params->container, obj);
115                 }
116                 return 0;
117         } else if (params->fields &&
118             (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
119              (ast_sorcery_changeset_create(objset, params->fields, &diff)) ||
120              diff)) {
121                 /* If we can't turn the object into an object set OR if differences exist between the fields
122                  * passed in and what are present on the object they are not a match.
123                  */
124                 return 0;
125         }
126
127         if (params->container) {
128                 ao2_link(params->container, obj);
129
130                 /* As multiple objects are being returned keep going */
131                 return 0;
132         } else {
133                 /* Immediately stop and return, we only want a single object */
134                 return CMP_MATCH | CMP_STOP;
135         }
136 }
137
138 static void *sorcery_memory_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
139 {
140         struct sorcery_memory_fields_cmp_params params = {
141                 .sorcery = sorcery,
142                 .fields = fields,
143                 .container = NULL,
144         };
145
146         /* If no fields are present return nothing, we require *something* */
147         if (!fields) {
148                 return NULL;
149         }
150
151         return ao2_callback(data, 0, sorcery_memory_fields_cmp, &params);
152 }
153
154 static void *sorcery_memory_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
155 {
156         return ao2_find(data, id, OBJ_KEY);
157 }
158
159 static void sorcery_memory_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
160 {
161         struct sorcery_memory_fields_cmp_params params = {
162                 .sorcery = sorcery,
163                 .fields = fields,
164                 .container = objects,
165         };
166
167         ao2_callback(data, 0, sorcery_memory_fields_cmp, &params);
168 }
169
170 static void sorcery_memory_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
171 {
172         regex_t expression;
173         struct sorcery_memory_fields_cmp_params params = {
174                 .sorcery = sorcery,
175                 .container = objects,
176                 .regex = &expression,
177         };
178
179         if (regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
180                 return;
181         }
182
183         ao2_callback(data, 0, sorcery_memory_fields_cmp, &params);
184         regfree(&expression);
185 }
186
187 static int sorcery_memory_update(const struct ast_sorcery *sorcery, void *data, void *object)
188 {
189         RAII_VAR(void *, existing, NULL, ao2_cleanup);
190
191         ao2_lock(data);
192
193         if (!(existing = ao2_find(data, ast_sorcery_object_get_id(object), OBJ_KEY | OBJ_UNLINK))) {
194                 ao2_unlock(data);
195                 return -1;
196         }
197
198         ao2_link(data, object);
199
200         ao2_unlock(data);
201
202         return 0;
203 }
204
205 static int sorcery_memory_delete(const struct ast_sorcery *sorcery, void *data, void *object)
206 {
207         RAII_VAR(void *, existing, ao2_find(data, ast_sorcery_object_get_id(object), OBJ_KEY | OBJ_UNLINK), ao2_cleanup);
208
209         return existing ? 0 : -1;
210 }
211
212 static void *sorcery_memory_open(const char *data)
213 {
214         return ao2_container_alloc(OBJECT_BUCKETS, sorcery_memory_hash, sorcery_memory_cmp);
215 }
216
217 static void sorcery_memory_close(void *data)
218 {
219         ao2_ref(data, -1);
220 }
221
222 static int load_module(void)
223 {
224         if (ast_sorcery_wizard_register(&memory_object_wizard)) {
225                 return AST_MODULE_LOAD_DECLINE;
226         }
227
228         return AST_MODULE_LOAD_SUCCESS;
229 }
230
231 static int unload_module(void)
232 {
233         ast_sorcery_wizard_unregister(&memory_object_wizard);
234         return 0;
235 }
236
237 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery In-Memory Object Wizard",
238         .support_level = AST_MODULE_SUPPORT_CORE,
239         .load = load_module,
240         .unload = unload_module,
241         .load_pri = AST_MODPRI_REALTIME_DRIVER,
242 );