ARI: Add ability to raise arbitrary User Events
[asterisk/asterisk.git] / main / media_index.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Kinsey Moore <markster@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  * \brief Sound file format and description indexer.
21  */
22
23 #include "asterisk.h"
24
25 #include <dirent.h>
26 #include <sys/stat.h>
27
28 #include "asterisk/utils.h"
29 #include "asterisk/lock.h"
30 #include "asterisk/format.h"
31 #include "asterisk/format_cap.h"
32 #include "asterisk/media_index.h"
33 #include "asterisk/file.h"
34
35 /*** MODULEINFO
36         <support_level>core</support_level>
37  ***/
38
39 /*! \brief The number of buckets to be used for storing variant-keyed objects */
40 #define VARIANT_BUCKETS 7
41
42 /*! \brief The number of buckets to be used for storing media filename-keyed objects */
43 #define INDEX_BUCKETS 157
44
45 /*! \brief Structure to hold a list of the format variations for a media file for a specific variant */
46 struct media_variant {
47         AST_DECLARE_STRING_FIELDS(
48                 AST_STRING_FIELD(variant);      /*!< The variant this media is available in */
49                 AST_STRING_FIELD(description);  /*!< The description of the media */
50         );
51         struct ast_format_cap *formats; /*!< The formats this media is available in for this variant */
52 };
53
54 static void media_variant_destroy(void *obj)
55 {
56         struct media_variant *variant = obj;
57
58         ast_string_field_free_memory(variant);
59         variant->formats = ast_format_cap_destroy(variant->formats);
60 }
61
62 static struct media_variant *media_variant_alloc(const char *variant_str)
63 {
64         RAII_VAR(struct media_variant *, variant, ao2_alloc(sizeof(*variant), media_variant_destroy), ao2_cleanup);
65
66         if (!variant || ast_string_field_init(variant, 8)) {
67                 return NULL;
68         }
69
70         variant->formats = ast_format_cap_alloc(0);
71         if (!variant->formats) {
72                 return NULL;
73         }
74
75         ast_string_field_set(variant, variant, variant_str);
76
77         ao2_ref(variant, 1);
78         return variant;
79 }
80
81 static int media_variant_hash(const void *obj, const int flags)
82 {
83         const char *variant = (flags & OBJ_KEY) ? obj : ((struct media_variant*) obj)->variant;
84         return ast_str_case_hash(variant);
85 }
86
87 static int media_variant_cmp(void *obj, void *arg, int flags)
88 {
89         struct media_variant *opt1 = obj, *opt2 = arg;
90         const char *variant = (flags & OBJ_KEY) ? arg : opt2->variant;
91         return strcasecmp(opt1->variant, variant) ? 0 : CMP_MATCH | CMP_STOP;
92 }
93
94 /*! \brief Structure to hold information about a media file */
95 struct media_info {
96         AST_DECLARE_STRING_FIELDS(
97                 AST_STRING_FIELD(name);         /*!< The file name of the media */
98         );
99         struct ao2_container *variants; /*!< The variants for which this media is available */
100 };
101
102 static void media_info_destroy(void *obj)
103 {
104         struct media_info *info = obj;
105
106         ast_string_field_free_memory(info);
107         ao2_cleanup(info->variants);
108         info->variants = NULL;
109 }
110
111 static struct media_info *media_info_alloc(const char *name)
112 {
113         RAII_VAR(struct media_info *, info, ao2_alloc(sizeof(*info), media_info_destroy), ao2_cleanup);
114
115         if (!info || ast_string_field_init(info, 128)) {
116                 return NULL;
117         }
118
119         info->variants = ao2_container_alloc(VARIANT_BUCKETS, media_variant_hash, media_variant_cmp);
120         if (!info->variants) {
121                 return NULL;
122         }
123
124         ast_string_field_set(info, name, name);
125
126         ao2_ref(info, 1);
127         return info;
128 }
129
130 static int media_info_hash(const void *obj, const int flags)
131 {
132         const char *name = (flags & OBJ_KEY) ? obj : ((struct media_info*) obj)->name;
133         return ast_str_case_hash(name);
134 }
135
136 static int media_info_cmp(void *obj, void *arg, int flags)
137 {
138         struct media_info *opt1 = obj, *opt2 = arg;
139         const char *name = (flags & OBJ_KEY) ? arg : opt2->name;
140         return strcasecmp(opt1->name, name) ? 0 : CMP_MATCH | CMP_STOP;
141 }
142
143 struct ast_media_index {
144         AST_DECLARE_STRING_FIELDS(
145                 AST_STRING_FIELD(base_dir); /*!< Base directory for indexing */
146         );
147         struct ao2_container *index;            /*!< The index of media that has requested */
148         struct ao2_container *media_list_cache; /*!< Cache of filenames to prevent them from being regenerated so often */
149 };
150
151 static void media_index_dtor(void *obj)
152 {
153         struct ast_media_index *index = obj;
154         ao2_cleanup(index->index);
155         index->index = NULL;
156         ao2_cleanup(index->media_list_cache);
157         index->media_list_cache = NULL;
158         ast_string_field_free_memory(index);
159 }
160
161 struct ast_media_index *ast_media_index_create(const char *base_dir)
162 {
163         RAII_VAR(struct ast_media_index *, index, ao2_alloc(sizeof(*index), media_index_dtor), ao2_cleanup);
164         if (!index || ast_string_field_init(index, 64)) {
165                 return NULL;
166         }
167
168         ast_string_field_set(index, base_dir, base_dir);
169
170         index->index = ao2_container_alloc(INDEX_BUCKETS, media_info_hash, media_info_cmp);
171         if (!index->index) {
172                 return NULL;
173         }
174
175         ao2_ref(index, +1);
176         return index;
177 }
178
179 static struct media_variant *find_variant(struct ast_media_index *index, const char *filename, const char *variant)
180 {
181         RAII_VAR(struct media_info *, info, NULL, ao2_cleanup);
182
183         info = ao2_find(index->index, filename, OBJ_KEY);
184         if (!info) {
185                 return NULL;
186         }
187
188         return ao2_find(info->variants, variant, OBJ_KEY);
189 }
190
191 /*! \brief create the appropriate media_variant and any necessary structures */
192 static struct media_variant *alloc_variant(struct ast_media_index *index, const char *filename, const char *variant_str)
193 {
194         RAII_VAR(struct media_info *, info, NULL, ao2_cleanup);
195         RAII_VAR(struct media_variant *, variant, NULL, ao2_cleanup);
196
197         info = ao2_find(index->index, filename, OBJ_KEY);
198         if (!info) {
199                 /* This is the first time the index has seen this filename,
200                  * allocate and link */
201                 info = media_info_alloc(filename);
202                 if (!info) {
203                         return NULL;
204                 }
205
206                 ao2_link(index->index, info);
207         }
208
209         variant = ao2_find(info->variants, variant_str, OBJ_KEY);
210         if (!variant) {
211                 /* This is the first time the index has seen this variant for
212                  * this filename, allocate and link */
213                 variant = media_variant_alloc(variant_str);
214                 if (!variant) {
215                         return NULL;
216                 }
217
218                 ao2_link(info->variants, variant);
219         }
220
221         ao2_ref(variant, +1);
222         return variant;
223 }
224
225 const char *ast_media_get_description(struct ast_media_index *index, const char *filename, const char *variant_str)
226 {
227         RAII_VAR(struct media_variant *, variant, NULL, ao2_cleanup);
228         if (ast_strlen_zero(filename) || ast_strlen_zero(variant_str)) {
229                 return NULL;
230         }
231
232         variant = find_variant(index, filename, variant_str);
233         if (!variant) {
234                 return NULL;
235         }
236
237         return variant->description;
238 }
239
240 struct ast_format_cap *ast_media_get_format_cap(struct ast_media_index *index, const char *filename, const char *variant_str)
241 {
242         RAII_VAR(struct media_variant *, variant, NULL, ao2_cleanup);
243         if (ast_strlen_zero(filename) || ast_strlen_zero(variant_str)) {
244                 return NULL;
245         }
246
247         variant = find_variant(index, filename, variant_str);
248         if (!variant) {
249                 return NULL;
250         }
251
252         return ast_format_cap_dup(variant->formats);
253 }
254
255 /*! \brief Add the variant to the list of variants requested */
256 static int add_variant_cb(void *obj, void *arg, int flags)
257 {
258         struct media_variant *variant = obj;
259         struct ao2_container *variants= arg;
260         ast_str_container_add(variants, variant->variant);
261         return 0;
262 }
263
264 struct ao2_container *ast_media_get_variants(struct ast_media_index *index, const char *filename)
265 {
266         RAII_VAR(struct media_info *, info, NULL, ao2_cleanup);
267         RAII_VAR(struct ao2_container *, variants, NULL, ao2_cleanup);
268         if (!filename) {
269                 return NULL;
270         }
271
272         variants = ast_str_container_alloc(VARIANT_BUCKETS);
273         if (!variants) {
274                 return NULL;
275         }
276
277         info = ao2_find(index->index, filename, OBJ_KEY);
278         if (!info) {
279                 return NULL;
280         }
281
282         ao2_callback(info->variants, OBJ_NODATA, add_variant_cb, variants);
283
284         ao2_ref(variants, +1);
285         return variants;
286 }
287
288 /*! \brief Add the media_info's filename to the container of filenames requested */
289 static int add_media_cb(void *obj, void *arg, int flags)
290 {
291         struct media_info *info = obj;
292         struct ao2_container *media = arg;
293         ast_str_container_add(media, info->name);
294         return 0;
295 }
296
297 struct ao2_container *ast_media_get_media(struct ast_media_index *index)
298 {
299         RAII_VAR(struct ao2_container *, media, NULL, ao2_cleanup);
300
301         if (!index->media_list_cache) {
302                 media = ast_str_container_alloc(INDEX_BUCKETS);
303                 if (!media) {
304                         return NULL;
305                 }
306
307                 ao2_callback(index->index, OBJ_NODATA, add_media_cb, media);
308
309                 /* Ref to the cache */
310                 ao2_ref(media, +1);
311                 index->media_list_cache = media;
312         }
313
314         /* Ref to the caller */
315         ao2_ref(index->media_list_cache, +1);
316         return index->media_list_cache;
317 }
318
319 /*! \brief Update an index with new format/variant information */
320 static int update_file_format_info(struct ast_media_index *index, const char *filename, const char *variant_str, const struct ast_format *file_format)
321 {
322         RAII_VAR(struct media_variant *, variant, find_variant(index, filename, variant_str), ao2_cleanup);
323         if (!variant) {
324                 variant = alloc_variant(index, filename, variant_str);
325                 if (!variant) {
326                         return -1;
327                 }
328         }
329
330         ast_format_cap_add(variant->formats, file_format);
331         return 0;
332 }
333
334 /*! \brief Process a media file into the index */
335 static int process_media_file(struct ast_media_index *index, const char *variant, const char *subdir, const char *filename_stripped, const char *ext)
336 {
337         const struct ast_format *file_format;
338         const char *file_identifier = filename_stripped;
339         RAII_VAR(struct ast_str *, file_id_str, NULL, ast_free);
340
341         file_format = ast_get_format_for_file_ext(ext);
342         if (!file_format) {
343                 /* extension not registered */
344                 return 0;
345         }
346
347         /* handle updating the file information */
348         if (subdir) {
349                 file_id_str = ast_str_create(64);
350                 if (!file_id_str) {
351                         return -1;
352                 }
353
354                 ast_str_set(&file_id_str, 0, "%s/%s", subdir, filename_stripped);
355                 file_identifier = ast_str_buffer(file_id_str);
356         }
357
358         if (update_file_format_info(index, file_identifier, variant, file_format)) {
359                 return -1;
360         }
361         return 0;
362 }
363
364 /*!
365  * \brief Process a media description text file
366  *
367  * This currently processes core-sounds-*.txt and extra-sounds-*.txt, but will
368  * process others if present.
369  */
370 static int process_description_file(struct ast_media_index *index,
371         const char *subdir,
372         const char *variant_str,
373         const char *filename)
374 {
375         RAII_VAR(struct ast_str *, description_file_path, ast_str_create(64), ast_free);
376         RAII_VAR(struct ast_str *, cumulative_description, ast_str_create(64), ast_free);
377         char *file_id_persist = NULL;
378         int res = 0;
379         FILE *f = NULL;
380 #if defined(LOW_MEMORY)
381         char buf[256];
382 #else
383         char buf[2048];
384 #endif
385
386         if (!description_file_path || !cumulative_description) {
387                 return -1;
388         }
389
390         if (ast_strlen_zero(subdir)) {
391                 ast_str_set(&description_file_path, 0, "%s/%s/%s", index->base_dir, variant_str, filename);
392         } else {
393                 ast_str_set(&description_file_path, 0, "%s/%s/%s/%s", index->base_dir, variant_str, subdir, filename);
394         }
395         f = fopen(ast_str_buffer(description_file_path), "r");
396         if (!f) {
397                 ast_log(LOG_WARNING, "Could not open media description file '%s': %s\n", ast_str_buffer(description_file_path), strerror(errno));
398                 return -1;
399         }
400
401         while (!feof(f)) {
402                 char *file_identifier, *description;
403                 if (!fgets(buf, sizeof(buf), f)) {
404                         if (ferror(f)) {
405                                 ast_log(LOG_ERROR, "Error reading from file %s: %s\n", ast_str_buffer(description_file_path), strerror(errno));
406                         }
407                         continue;
408                 }
409
410                 /* Skip lines that are too long */
411                 if (strlen(buf) == sizeof(buf) - 1 && buf[sizeof(buf) - 1] != '\n') {
412                         ast_log(LOG_WARNING, "Line too long, skipping. It begins with: %.32s...\n", buf);
413                         while (fgets(buf, sizeof(buf), f)) {
414                                 if (strlen(buf) != sizeof(buf) - 1 || buf[sizeof(buf) - 1] == '\n') {
415                                         break;
416                                 }
417                         }
418                         if (ferror(f)) {
419                                 ast_log(LOG_ERROR, "Error reading from file %s: %s\n", ast_str_buffer(description_file_path), strerror(errno));
420                         }
421                         continue;
422                 }
423
424                 if (buf[0] == ';') {
425                         /* ignore comments */
426                         continue;
427                 }
428
429                 ast_trim_blanks(buf);
430                 description = buf;
431                 file_identifier = strsep(&description, ":");
432                 if (!description) {
433                         /* no ':' means this is a continuation */
434                         if (file_id_persist) {
435                                 ast_str_append(&cumulative_description, 0, "\n%s", file_identifier);
436                         }
437                         continue;
438                 } else {
439                         /* if there's text in cumulative_description, archive it and start anew */
440                         if (file_id_persist && !ast_strlen_zero(ast_str_buffer(cumulative_description))) {
441                                 RAII_VAR(struct media_variant *, variant, NULL, ao2_cleanup);
442
443                                 variant = find_variant(index, file_id_persist, variant_str);
444                                 if (!variant) {
445                                         variant = alloc_variant(index, file_id_persist, variant_str);
446                                         if (!variant) {
447                                                 res = -1;
448                                                 break;
449                                         }
450                                 }
451
452                                 ast_string_field_set(variant, description, ast_str_buffer(cumulative_description));
453
454                                 ast_str_reset(cumulative_description);
455                         }
456
457                         ast_free(file_id_persist);
458                         file_id_persist = ast_strdup(file_identifier);
459                         description = ast_skip_blanks(description);
460                         ast_str_set(&cumulative_description, 0, "%s", description);
461                 }
462         }
463
464         /* handle the last one */
465         if (file_id_persist && !ast_strlen_zero(ast_str_buffer(cumulative_description))) {
466                 RAII_VAR(struct media_variant *, variant, NULL, ao2_cleanup);
467
468                 variant = find_variant(index, file_id_persist, variant_str);
469                 if (!variant) {
470                         variant = alloc_variant(index, file_id_persist, variant_str);
471                 }
472
473                 if (variant) {
474                         ast_string_field_set(variant, description, ast_str_buffer(cumulative_description));
475                 } else {
476                         res = -1;
477                 }
478         }
479
480         ast_free(file_id_persist);
481         fclose(f);
482         return res;
483 }
484
485 /*! \brief process an individual file listing */
486 static int process_file(struct ast_media_index *index, const char *variant_str, const char *subdir, const char *filename)
487 {
488         RAII_VAR(char *, filename_stripped, ast_strdup(filename), ast_free);
489         char *ext;
490
491         if (!filename_stripped) {
492                 return -1;
493         }
494
495         ext = strrchr(filename_stripped, '.');
496         if (!ext) {
497                 /* file has no extension */
498                 return 0;
499         }
500
501         *ext++ = '\0';
502         if (!strcmp(ext, "txt")) {
503                 if (process_description_file(index, subdir, variant_str, filename)) {
504                         return -1;
505                 }
506         } else {
507                 if (process_media_file(index, variant_str, subdir, filename_stripped, ext)) {
508                         return -1;
509                 }
510         }
511         return 0;
512 }
513
514 /*! \brief internal function for updating the index, recursive */
515 static int media_index_update(struct ast_media_index *index,
516         const char *variant,
517         const char *subdir)
518 {
519         struct dirent* dent;
520         DIR* srcdir;
521         RAII_VAR(struct ast_str *, index_dir, ast_str_create(64), ast_free);
522         RAII_VAR(struct ast_str *, statfile, ast_str_create(64), ast_free);
523         int res = 0;
524
525         if (!index_dir) {
526                 return 0;
527         }
528
529         ast_str_set(&index_dir, 0, "%s", index->base_dir);
530         if (!ast_strlen_zero(variant)) {
531                 ast_str_append(&index_dir, 0, "/%s", variant);
532         }
533         if (!ast_strlen_zero(subdir)) {
534                 ast_str_append(&index_dir, 0, "/%s", subdir);
535         }
536
537         srcdir = opendir(ast_str_buffer(index_dir));
538         if (srcdir == NULL) {
539                 ast_log(LOG_ERROR, "Failed to open %s: %s\n", ast_str_buffer(index_dir), strerror(errno));
540                 return -1;
541         }
542
543         while((dent = readdir(srcdir)) != NULL) {
544                 struct stat st;
545
546                 if(!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) {
547                         continue;
548                 }
549
550                 ast_str_reset(statfile);
551                 ast_str_set(&statfile, 0, "%s/%s", ast_str_buffer(index_dir), dent->d_name);
552
553                 if (stat(ast_str_buffer(statfile), &st) < 0) {
554                         ast_log(LOG_WARNING, "Failed to stat %s: %s\n", ast_str_buffer(statfile), strerror(errno));
555                         continue;
556                 }
557
558                 if (S_ISDIR(st.st_mode)) {
559                         if (ast_strlen_zero(subdir)) {
560                                 res = media_index_update(index, variant, dent->d_name);
561                         } else {
562                                 RAII_VAR(struct ast_str *, new_subdir, ast_str_create(64), ast_free);
563                                 ast_str_set(&new_subdir, 0, "%s/%s", subdir, dent->d_name);
564                                 res = media_index_update(index, variant, ast_str_buffer(new_subdir));
565                         }
566
567                         if (res) {
568                                 break;
569                         }
570                         continue;
571                 }
572
573                 if (!S_ISREG(st.st_mode)) {
574                         continue;
575                 }
576
577                 if (process_file(index, variant, subdir, dent->d_name)) {
578                         res = -1;
579                         break;
580                 }
581         }
582
583         closedir(srcdir);
584         return res;
585 }
586
587 int ast_media_index_update(struct ast_media_index *index,
588         const char *variant)
589 {
590         return media_index_update(index, variant, NULL);
591 }
592