Stasis/ARI: Fix off-nominal path json memory leaks.
[asterisk/asterisk.git] / res / ari / resource_sounds.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@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 /*! \file
20  *
21  * \brief /api-docs/sounds.{format} implementation- Sound resources
22  *
23  * \author David M. Lee, II <dlee@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 #include "resource_sounds.h"
29 #include "asterisk/media_index.h"
30 #include "asterisk/sounds_index.h"
31 #include "asterisk/format.h"
32 #include "asterisk/format_cap.h"
33 #include "asterisk/json.h"
34
35 /*! \brief arguments that are necessary for adding format/lang pairs */
36 struct lang_format_info {
37         struct ast_json *format_list;   /*!< The embedded array to which format/lang pairs should be added */
38         const char *filename;           /*!< Name of the file for which to add format/lang pairs */
39         const char *format_filter;      /*!< Format filter provided in the request */
40 };
41
42 /*! \brief Add format/lang pairs to the array embedded in the sound object */
43 static int add_format_information_cb(void *obj, void *arg, int flags)
44 {
45         char *language = obj;
46         struct lang_format_info *args = arg;
47         int idx;
48         RAII_VAR(struct ast_format_cap *, cap, NULL, ao2_cleanup);
49         RAII_VAR(struct ast_media_index *, sounds_index, ast_sounds_get_index(), ao2_cleanup);
50
51         if (!sounds_index) {
52                 return CMP_STOP;
53         }
54
55         cap = ast_media_get_format_cap(sounds_index, args->filename, language);
56         if (!cap) {
57                 return CMP_STOP;
58         }
59
60         for (idx = 0; idx < ast_format_cap_count(cap); idx++) {
61                 struct ast_format *format = ast_format_cap_get_format(cap, idx);
62                 struct ast_json *lang_format_pair;
63
64                 if (!ast_strlen_zero(args->format_filter)
65                         && strcmp(args->format_filter, ast_format_get_name(format))) {
66                         ao2_ref(format, -1);
67                         continue;
68                 }
69
70                 lang_format_pair = ast_json_pack("{s: s, s: s}",
71                         "language", language,
72                         "format", ast_format_get_name(format));
73                 if (!lang_format_pair) {
74                         ao2_ref(format, -1);
75                         return CMP_STOP;
76                 }
77
78                 ast_json_array_append(args->format_list, lang_format_pair);
79                 ao2_ref(format, -1);
80         }
81
82         return 0;
83 }
84
85 /*! \brief Filter out all languages not matching the specified language */
86 static int filter_langs_cb(void *obj, void *arg, int flags)
87 {
88         char *lang_filter = arg;
89         char *lang = obj;
90         if (strcmp(lang, lang_filter)) {
91                 return CMP_MATCH;
92         }
93         return 0;
94 }
95
96 /*! \brief Generate a Sound structure as documented in sounds.json for the specified filename */
97 static struct ast_json *create_sound_blob(const char *filename,
98         struct ast_ari_sounds_list_args *args)
99 {
100         RAII_VAR(struct ast_json *, sound, NULL, ast_json_unref);
101         RAII_VAR(struct ao2_container *, languages, NULL, ao2_cleanup);
102         const char *description;
103         struct ast_json *format_lang_list;
104         struct lang_format_info info;
105         RAII_VAR(struct ast_media_index *, sounds_index, ast_sounds_get_index(), ao2_cleanup);
106
107         if (!sounds_index) {
108                 return NULL;
109         }
110
111         description = ast_media_get_description(sounds_index, filename, "en");
112         if (ast_strlen_zero(description)) {
113                 sound = ast_json_pack("{s: s, s: []}",
114                         "id", filename,
115                         "formats");
116         } else {
117                 sound = ast_json_pack("{s: s, s: s, s: []}",
118                         "id", filename,
119                         "text", description,
120                         "formats");
121         }
122         if (!sound) {
123                 return NULL;
124         }
125
126         format_lang_list = ast_json_object_get(sound, "formats");
127         if (!format_lang_list) {
128                 return NULL;
129         }
130
131         languages = ast_media_get_variants(sounds_index, filename);
132         if (!languages || !ao2_container_count(languages)) {
133                 return NULL;
134         }
135
136         /* filter requested languages */
137         if (args && !ast_strlen_zero(args->lang)) {
138                 char *lang_filter = ast_strdupa(args->lang);
139                 ao2_callback(languages, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, filter_langs_cb, lang_filter);
140                 if (!languages || !ao2_container_count(languages)) {
141                         return NULL;
142                 }
143         }
144
145         info.filename = filename;
146         info.format_list = format_lang_list;
147         info.format_filter = NULL;
148         if (args) {
149                 info.format_filter = args->format;
150         }
151         ao2_callback(languages, OBJ_NODATA, add_format_information_cb, &info);
152
153         /* no format/lang pairs for this sound so nothing to return */
154         if (!ast_json_array_size(format_lang_list)) {
155                 return NULL;
156         }
157
158         return ast_json_ref(sound);
159 }
160
161 /*! \brief Generate a Sound structure and append it to the output blob */
162 static int append_sound_cb(void *obj, void *arg, void *data, int flags)
163 {
164         struct ast_json *sounds_array = arg;
165         char *filename = obj;
166         struct ast_ari_sounds_list_args *args = data;
167         struct ast_json *sound_blob = create_sound_blob(filename, args);
168         if (!sound_blob) {
169                 return 0;
170         }
171
172         ast_json_array_append(sounds_array, sound_blob);
173         return 0;
174 }
175
176 void ast_ari_sounds_list(struct ast_variable *headers,
177         struct ast_ari_sounds_list_args *args,
178         struct ast_ari_response *response)
179 {
180         RAII_VAR(struct ao2_container *, sound_files, NULL, ao2_cleanup);
181         struct ast_json *sounds_blob;
182         RAII_VAR(struct ast_media_index *, sounds_index, ast_sounds_get_index(), ao2_cleanup);
183
184         if (!sounds_index) {
185                 ast_ari_response_error(response, 500, "Internal Error", "Sounds index not available");
186                 return;
187         }
188
189         sound_files = ast_media_get_media(sounds_index);
190         if (!sound_files) {
191                 ast_ari_response_error(response, 500, "Internal Error", "Allocation Error");
192                 return;
193         }
194
195         sounds_blob = ast_json_array_create();
196         if (!sounds_blob) {
197                 ast_ari_response_error(response, 500, "Internal Error", "Allocation Error");
198                 return;
199         }
200
201         ao2_callback_data(sound_files, OBJ_NODATA, append_sound_cb, sounds_blob, args);
202
203         if (!ast_json_array_size(sounds_blob)) {
204                 ast_ari_response_error(response, 404, "Not Found", "No sounds found that matched the query");
205                 ast_json_unref(sounds_blob);
206                 return;
207         }
208
209         ast_ari_response_ok(response, sounds_blob);
210 }
211
212 void ast_ari_sounds_get(struct ast_variable *headers,
213         struct ast_ari_sounds_get_args *args,
214         struct ast_ari_response *response)
215 {
216         struct ast_json *sound_blob;
217
218         sound_blob = create_sound_blob(args->sound_id, NULL);
219         if (!sound_blob) {
220                 ast_ari_response_error(response, 404, "Not Found", "Sound not found");
221                 return;
222         }
223
224         ast_ari_response_ok(response, sound_blob);
225 }