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