don't force the sounds to download... only when needed
[asterisk/asterisk.git] / build_tools / menuselect.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005 - 2006, Russell Bryant
5  *
6  * Russell Bryant <russell@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  * \author Russell Bryant <russell@digium.com>
23  * 
24  * \brief A menu-driven system for Asterisk module selection
25  */
26
27 #include "asterisk.h"
28
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <unistd.h>
33
34 #include "mxml/mxml.h"
35 #include "menuselect.h"
36
37 #include "asterisk/linkedlists.h"
38
39 #undef MENUSELECT_DEBUG
40
41 /*! The list of categories */
42 struct categories categories = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
43
44 /*!
45    We have to maintain a pointer to the root of the trees generated from reading
46    the build options XML files so that we can free it when we're done.  We don't
47    copy any of the information over from these trees. Our list is just a 
48    convenient mapping to the information contained in these lists with one
49    additional piece of information - whether the build option is enabled or not.
50 */
51 struct tree {
52         /*! the root of the tree */
53         mxml_node_t *root;
54         /*! for linking */
55         AST_LIST_ENTRY(tree) list;
56 };
57
58 /*! The list of trees from makeopts.xml files */
59 static AST_LIST_HEAD_NOLOCK_STATIC(trees, tree);
60
61 static const char * const makeopts_files[] = {
62         "makeopts.xml"
63 };
64
65 static char *output_makeopts = OUTPUT_MAKEOPTS_DEFAULT;
66
67 /*! This is set to 1 if menuselect.makeopts pre-existed the execution of this app */
68 static int existing_config = 0;
69
70 /*! This is set when the --check-deps argument is provided. */
71 static int check_deps = 0;
72
73 /*! Force a clean of the source tree */
74 static int force_clean = 0;
75
76 static int add_category(struct category *cat);
77 static int add_member(struct member *mem, struct category *cat);
78 static int parse_makeopts_xml(const char *makeopts_xml);
79 static int process_deps(void);
80 static int build_member_list(void);
81 static void mark_as_present(const char *member, const char *category);
82 static void process_prev_failed_deps(char *buf);
83 static int parse_existing_config(const char *infile);
84 static int generate_makeopts_file(void);
85 static void free_member_list(void);
86 static void free_trees(void);
87
88 /*! \brief return a pointer to the first non-whitespace character */
89 static inline char *skip_blanks(char *str)
90 {
91         if (!str)
92                 return NULL;
93
94         while (*str && *str < 33)
95                 str++;
96
97         return str;
98 }
99
100 /*! \brief Add a category to the category list, ensuring that there are no duplicates */
101 static int add_category(struct category *cat)
102 {
103         struct category *tmp;
104
105         AST_LIST_TRAVERSE(&categories, tmp, list) {
106                 if (!strcmp(tmp->name, cat->name)) {
107                         fprintf(stderr, "Category '%s' specified more than once!\n", cat->name);
108                         return -1;
109                 }
110         }
111         AST_LIST_INSERT_TAIL(&categories, cat, list);
112
113         return 0;
114 }
115
116 /*! \brief Add a member to the member list of a category, ensuring that there are no duplicates */
117 static int add_member(struct member *mem, struct category *cat)
118 {
119         struct member *tmp;
120
121         AST_LIST_TRAVERSE(&cat->members, tmp, list) {
122                 if (!strcmp(tmp->name, mem->name)) {
123                         fprintf(stderr, "Member '%s' already exists in category '%s', ignoring.\n", mem->name, cat->name);
124                         return -1;
125                 }
126         }
127         AST_LIST_INSERT_TAIL(&cat->members, mem, list);
128
129         return 0;
130 }
131
132 /*! \brief Parse an input makeopts file */
133 static int parse_makeopts_xml(const char *makeopts_xml)
134 {
135         FILE *f;
136         struct category *cat;
137         struct tree *tree;
138         struct member *mem;
139         struct depend *dep;
140         struct conflict *cnf;
141         mxml_node_t *cur;
142         mxml_node_t *cur2;
143         mxml_node_t *cur3;
144         mxml_node_t *menu;
145         const char *tmp;
146
147         if (!(f = fopen(makeopts_xml, "r"))) {
148                 fprintf(stderr, "Unable to open '%s' for reading!\n", makeopts_xml);
149                 return -1;
150         }
151
152         if (!(tree = calloc(1, sizeof(*tree)))) {
153                 fclose(f);
154                 return -1;
155         }
156
157         if (!(tree->root = mxmlLoadFile(NULL, f, MXML_OPAQUE_CALLBACK))) {
158                 fclose(f);
159                 free(tree);
160                 return -1;
161         }
162
163         AST_LIST_INSERT_HEAD(&trees, tree, list);
164
165         menu = mxmlFindElement(tree->root, tree->root, "menu", NULL, NULL, MXML_DESCEND);
166         for (cur = mxmlFindElement(menu, menu, "category", NULL, NULL, MXML_DESCEND);
167              cur;
168              cur = mxmlFindElement(cur, menu, "category", NULL, NULL, MXML_DESCEND))
169         {
170                 if (!(cat = calloc(1, sizeof(*cat))))
171                         return -1;
172
173                 cat->name = mxmlElementGetAttr(cur, "name");
174                 cat->displayname = mxmlElementGetAttr(cur, "displayname");
175                 if ((tmp = mxmlElementGetAttr(cur, "positive_output")))
176                         cat->positive_output = !strcasecmp(tmp, "yes");
177                 if ((tmp = mxmlElementGetAttr(cur, "force_clean_on_change")))
178                         cat->force_clean_on_change = !strcasecmp(tmp, "yes");
179
180                 if (add_category(cat)) {
181                         free(cat);
182                         continue;
183                 }
184
185                 for (cur2 = mxmlFindElement(cur, cur, "member", NULL, NULL, MXML_DESCEND);
186                      cur2;
187                      cur2 = mxmlFindElement(cur2, cur, "member", NULL, NULL, MXML_DESCEND))
188                 {
189                         if (!(mem = calloc(1, sizeof(*mem))))
190                                 return -1;
191                         
192                         mem->name = mxmlElementGetAttr(cur2, "name");
193                         mem->displayname = mxmlElementGetAttr(cur2, "displayname");
194                 
195                         if (!cat->positive_output)
196                                 mem->enabled = 1;
197         
198                         cur3 = mxmlFindElement(cur2, cur2, "defaultenabled", NULL, NULL, MXML_DESCEND);
199                         if (cur3 && cur3->child)
200                                 mem->defaultenabled = cur3->child->value.opaque;
201                         
202                         for (cur3 = mxmlFindElement(cur2, cur2, "depend", NULL, NULL, MXML_DESCEND);
203                              cur3 && cur3->child;
204                              cur3 = mxmlFindElement(cur3, cur2, "depend", NULL, NULL, MXML_DESCEND))
205                         {
206                                 if (!(dep = calloc(1, sizeof(*dep))))
207                                         return -1;
208                                 if (!strlen_zero(cur3->child->value.opaque)) {
209                                         dep->name = cur3->child->value.opaque;
210                                         AST_LIST_INSERT_HEAD(&mem->deps, dep, list);
211                                 } else
212                                         free(dep);
213                         }
214
215                         for (cur3 = mxmlFindElement(cur2, cur2, "conflict", NULL, NULL, MXML_DESCEND);
216                              cur3 && cur3->child;
217                              cur3 = mxmlFindElement(cur3, cur2, "conflict", NULL, NULL, MXML_DESCEND))
218                         {
219                                 if (!(cnf = calloc(1, sizeof(*cnf))))
220                                         return -1;
221                                 if (!strlen_zero(cur3->child->value.opaque)) {
222                                         cnf->name = cur3->child->value.opaque;
223                                         AST_LIST_INSERT_HEAD(&mem->conflicts, cnf, list);
224                                 } else
225                                         free(cnf);
226                         }
227
228                         if (add_member(mem, cat))
229                                 free(mem);
230                 }
231         }
232
233         fclose(f);
234
235         return 0;
236 }
237
238 /*! \brief Process dependencies against the input dependencies file */
239 static int process_deps(void)
240 {
241         struct category *cat;
242         struct member *mem;
243         struct depend *dep;
244         struct conflict *cnf;
245         FILE *f;
246         struct dep_file {
247                 char name[32];
248                 int met;
249                 AST_LIST_ENTRY(dep_file) list;
250         } *dep_file;
251         AST_LIST_HEAD_NOLOCK_STATIC(deps_file, dep_file);
252         char buf[80];
253         char *p;
254         int res = 0;
255
256         if (!(f = fopen(MENUSELECT_DEPS, "r"))) {
257                 fprintf(stderr, "Unable to open '%s' for reading!  Did you run ./configure ?\n", MENUSELECT_DEPS);
258                 return -1;
259         }
260
261         /* Build a dependency list from the file generated by configure */      
262         while (memset(buf, 0, sizeof(buf)), fgets(buf, sizeof(buf), f)) {
263                 p = buf;
264                 strsep(&p, "=");
265                 if (!p)
266                         continue;
267                 if (!(dep_file = calloc(1, sizeof(*dep_file))))
268                         break;
269                 strncpy(dep_file->name, buf, sizeof(dep_file->name) - 1);
270                 dep_file->met = atoi(p);
271                 AST_LIST_INSERT_TAIL(&deps_file, dep_file, list);
272         }
273
274         fclose(f);
275
276         /* Process dependencies of all modules */
277         AST_LIST_TRAVERSE(&categories, cat, list) {
278                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
279                         AST_LIST_TRAVERSE(&mem->deps, dep, list) {
280                                 mem->depsfailed = 1;
281                                 AST_LIST_TRAVERSE(&deps_file, dep_file, list) {
282                                         if (!strcasecmp(dep_file->name, dep->name)) {
283                                                 if (dep_file->met)
284                                                         mem->depsfailed = 0;
285                                                 break;
286                                         }
287                                 }
288                                 if (mem->depsfailed)
289                                         break; /* This dependency is not met, so we can stop now */
290                         }
291                 }
292         }
293
294         /* Process conflicts of all modules */
295         AST_LIST_TRAVERSE(&categories, cat, list) {
296                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
297                         AST_LIST_TRAVERSE(&mem->conflicts, cnf, list) {
298                                 mem->conflictsfailed = 0;
299                                 AST_LIST_TRAVERSE(&deps_file, dep_file, list) {
300                                         if (!strcasecmp(dep_file->name, cnf->name)) {
301                                                 if (dep_file->met)
302                                                         mem->conflictsfailed = 1;
303                                                 break;
304                                         }
305                                 }
306                                 if (mem->conflictsfailed)
307                                         break; /* This conflict was found, so we can stop now */
308                         }
309                 }
310         }
311
312         /* Free the dependency list we built from the file */
313         while ((dep_file = AST_LIST_REMOVE_HEAD(&deps_file, list)))
314                 free(dep_file);
315
316         return res;
317 }
318
319 /*! \brief Iterate through all of the input makeopts files and call the parse function on them */
320 static int build_member_list(void)
321 {
322         int i;
323         int res = -1;
324
325         for (i = 0; i < (sizeof(makeopts_files) / sizeof(makeopts_files[0])); i++) {
326                 if ((res = parse_makeopts_xml(makeopts_files[i]))) {
327                         fprintf(stderr, "Error parsing '%s'!\n", makeopts_files[i]);
328                         break;
329                 }
330         }
331
332         return res;
333 }
334
335 /*! \brief Given the string representation of a member and category, mark it as present in a given input file */
336 static void mark_as_present(const char *member, const char *category)
337 {
338         struct category *cat;
339         struct member *mem;
340
341         AST_LIST_TRAVERSE(&categories, cat, list) {
342                 if (strcmp(category, cat->name))
343                         continue;
344                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
345                         if (!strcmp(member, mem->name)) {
346                                 mem->enabled = cat->positive_output;
347                                 break;
348                         }
349                 }
350                 if (!mem)
351                         fprintf(stderr, "member '%s' in category '%s' not found, ignoring.\n", member, category);
352                 break;
353         }
354
355         if (!cat)
356                 fprintf(stderr, "category '%s' not found! Can't mark '%s' as disabled.\n", category, member);
357 }
358
359 /*! \brief Toggle a member of a category at the specified index to enabled/disabled */
360 void toggle_enabled(struct category *cat, int index)
361 {
362         struct member *mem;
363         int i = 0;
364
365         AST_LIST_TRAVERSE(&cat->members, mem, list) {
366                 if (i++ == index)
367                         break;
368         }
369
370         if (mem && !(mem->depsfailed || mem->conflictsfailed)) {
371                 mem->enabled = !mem->enabled;
372                 if (cat->force_clean_on_change)
373                         force_clean = 1;
374         }
375 }
376
377 /*! \brief Process a previously failed dependency
378  *
379  * If a module was previously disabled because of a failed dependency
380  * or a conflict, and not because the user selected it to be that way,
381  * then it needs to be re-enabled by default if the problem is no longer present.
382  */
383 static void process_prev_failed_deps(char *buf)
384 {
385         const char *cat_name, *mem_name;
386         struct category *cat;
387         struct member *mem;
388
389         cat_name = strsep(&buf, "=");
390         mem_name = strsep(&buf, "\n");
391
392         if (!cat_name || !mem_name)
393                 return;
394
395         AST_LIST_TRAVERSE(&categories, cat, list) {
396                 if (strcasecmp(cat->name, cat_name))
397                         continue;
398                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
399                         if (strcasecmp(mem->name, mem_name))
400                                 continue;
401
402                         if (!mem->depsfailed && !mem->conflictsfailed)
403                                 mem->enabled = 1;                       
404         
405                         break;
406                 }
407                 break;  
408         }
409
410         if (!cat || !mem)
411                 fprintf(stderr, "Unable to find '%s' in category '%s'\n", mem_name, cat_name);
412 }
413
414 /*! \brief Parse an existing output makeopts file and enable members previously selected */
415 static int parse_existing_config(const char *infile)
416 {
417         FILE *f;
418         char buf[2048];
419         char *category, *parse, *member;
420         int lineno = 0;
421
422         if (!(f = fopen(infile, "r"))) {
423 #ifdef MENUSELECT_DEBUG
424                 /* This isn't really an error, so only print the message in debug mode */
425                 fprintf(stderr, "Unable to open '%s' for reading existing config.\n", infile);
426 #endif  
427                 return -1;
428         }
429
430         while (fgets(buf, sizeof(buf), f)) {
431                 lineno++;
432
433                 if (strlen_zero(buf))
434                         continue;
435
436                 /* skip lines that are not for this tool */
437                 if (strncasecmp(buf, "MENUSELECT_", strlen("MENUSELECT_")))
438                         continue;
439
440                 parse = buf;
441                 parse = skip_blanks(parse);
442                 if (strlen_zero(parse))
443                         continue;
444
445                 /* Grab the category name */    
446                 category = strsep(&parse, "=");
447                 if (!parse) {
448                         fprintf(stderr, "Invalid string in '%s' at line '%d'!\n", output_makeopts, lineno);
449                         continue;
450                 }
451                 
452                 parse = skip_blanks(parse);
453         
454                 if (!strcasecmp(category, "MENUSELECT_DEPSFAILED")) {
455                         process_prev_failed_deps(parse);
456                         continue;
457                 }
458         
459                 while ((member = strsep(&parse, " \n"))) {
460                         member = skip_blanks(member);
461                         if (strlen_zero(member))
462                                 continue;
463                         mark_as_present(member, category);
464                 }
465         }
466
467         fclose(f);
468
469         return 0;
470 }
471
472 /*! \brief Create the output makeopts file that results from the user's selections */
473 static int generate_makeopts_file(void)
474 {
475         FILE *f;
476         struct category *cat;
477         struct member *mem;
478
479         if (!(f = fopen(output_makeopts, "w"))) {
480                 fprintf(stderr, "Unable to open build configuration file (%s) for writing!\n", output_makeopts);
481                 return -1;
482         }
483
484         /* Traverse all categories and members and output them as var/val pairs */
485         AST_LIST_TRAVERSE(&categories, cat, list) {
486                 fprintf(f, "%s=", cat->name);
487                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
488                         if ((!cat->positive_output && (!mem->enabled || mem->depsfailed || mem->conflictsfailed)) ||
489                             (cat->positive_output && mem->enabled && !mem->depsfailed && !mem->conflictsfailed))
490                                 fprintf(f, "%s ", mem->name);
491                 }
492                 fprintf(f, "\n");
493         }
494
495         /* Output which members were disabled because of failed dependencies or conflicts */
496         AST_LIST_TRAVERSE(&categories, cat, list) {
497                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
498                         if (mem->depsfailed || mem->conflictsfailed)
499                                 fprintf(f, "MENUSELECT_DEPSFAILED=%s=%s\n", cat->name, mem->name);
500                 }
501         }
502
503         fclose(f);
504
505         return 0;
506 }
507
508 #ifdef MENUSELECT_DEBUG
509 /*! \brief Print out all of the information contained in our tree */
510 static void dump_member_list(void)
511 {
512         struct category *cat;
513         struct member *mem;
514         struct depend *dep;
515         struct conflict *cnf;
516
517         AST_LIST_TRAVERSE(&categories, cat, list) {
518                 fprintf(stderr, "Category: '%s'\n", cat->name);
519                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
520                         fprintf(stderr, "   ==>> Member: '%s'  (%s)\n", mem->name, mem->enabled ? "Enabled" : "Disabled");
521                         AST_LIST_TRAVERSE(&mem->deps, dep, list)
522                                 fprintf(stderr, "      --> Depends on: '%s'\n", dep->name);
523                         if (!AST_LIST_EMPTY(&mem->deps))
524                                 fprintf(stderr, "      --> Dependencies Met: %s\n", mem->depsfailed ? "No" : "Yes");    
525                         AST_LIST_TRAVERSE(&mem->conflicts, cnf, list)
526                                 fprintf(stderr, "      --> Conflicts with: '%s'\n", cnf->name);
527                         if (!AST_LIST_EMPTY(&mem->conflicts))
528                                 fprintf(stderr, "      --> Conflicts Found: %s\n", mem->conflictsfailed ? "Yes" : "No");
529                 }
530         }
531 }
532 #endif
533
534 /*! \brief Free all categories and their members */
535 static void free_member_list(void)
536 {
537         struct category *cat;
538         struct member *mem;
539         struct depend *dep;
540         struct conflict *cnf;
541
542         while ((cat = AST_LIST_REMOVE_HEAD(&categories, list))) {
543                 while ((mem = AST_LIST_REMOVE_HEAD(&cat->members, list))) {
544                         while ((dep = AST_LIST_REMOVE_HEAD(&mem->deps, list)))
545                                 free(dep);
546                         while ((cnf = AST_LIST_REMOVE_HEAD(&mem->conflicts, list)))
547                                 free(cnf);
548                         free(mem);
549                 }
550                 free(cat);
551         }
552 }
553
554 /*! \brief Free all of the XML trees */
555 static void free_trees(void)
556 {
557         struct tree *tree;
558
559         while ((tree = AST_LIST_REMOVE_HEAD(&trees, list))) {
560                 mxmlDelete(tree->root);
561                 free(tree);
562         }
563 }
564
565 /*! \brief Enable/Disable all members of a category as long as dependencies have been met and no conflicts are found */
566 void set_all(struct category *cat, int val)
567 {
568         struct member *mem;
569
570         AST_LIST_TRAVERSE(&cat->members, mem, list) {
571                 if (!(mem->depsfailed || mem->conflictsfailed))
572                         mem->enabled = val;
573         }
574 }
575
576 int count_categories(void)
577 {
578         struct category *cat;
579         int count = 0;
580
581         AST_LIST_TRAVERSE(&categories, cat, list)
582                 count++;
583
584         return count;           
585 }
586
587 int count_members(struct category *cat)
588 {
589         struct member *mem;
590         int count = 0;
591
592         AST_LIST_TRAVERSE(&cat->members, mem, list)
593                 count++;
594
595         return count;           
596 }
597
598 /*! \brief Make sure an existing menuselect.makeopts disabled everything it should have */
599 static int sanity_check(void)
600 {
601         struct category *cat;
602         struct member *mem;
603
604         AST_LIST_TRAVERSE(&categories, cat, list) {
605                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
606                         if ((mem->depsfailed || mem->conflictsfailed) && mem->enabled) {
607                                 fprintf(stderr, "\n***********************************************************\n"
608                                                 "  The existing menuselect.makeopts file did not specify    \n"
609                                                 "  that '%s' should not be included.  However, either some  \n"
610                                                 "  dependencies for this module were not found or a         \n"
611                                                 "  conflict exists.                                         \n"
612                                                 "                                                           \n"
613                                                 "  Either run 'make menuselect' or remove the existing      \n"
614                                                 "  menuselect.makeopts file to resolve this issue.          \n"
615                                                 "***********************************************************\n\n", mem->name);
616                                 return -1;
617                         }
618                 }
619         }
620         return 0;       /* all good... */
621 }
622
623 /* \brief Set the forced default values if they exist */
624 static void process_defaults(void)
625 {
626         struct category *cat;
627         struct member *mem;
628
629         AST_LIST_TRAVERSE(&categories, cat, list) {
630                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
631                         if (!mem->defaultenabled)
632                                 continue;
633                         
634                         if (!strcasecmp(mem->defaultenabled, "yes"))
635                                 mem->enabled = 1;
636                         else if (!strcasecmp(mem->defaultenabled, "no"))
637                                 mem->enabled = 0;
638                         else
639                                 fprintf(stderr, "Invalid defaultenabled value for '%s' in category '%s'\n", mem->name, cat->name);      
640                 }
641         }
642
643 }
644
645 int main(int argc, char *argv[])
646 {
647         int res = 0;
648         unsigned int x;
649
650         /* Parse the input XML files to build the list of available options */
651         if ((res = build_member_list()))
652                 exit(res);
653         
654         /* Process module dependencies */
655         res = process_deps();
656         
657         /* The --check-deps option is used to ask this application to check to
658          * see if that an existing menuselect.makeopts file contails all of the
659          * modules that have dependencies that have not been met.  If this
660          * is not the case, an informative message will be printed to the
661          * user and the build will fail. */
662         for (x = 1; x < argc; x++) {
663                 if (!strcmp(argv[x], "--check-deps"))
664                         check_deps = 1;
665                 else {
666                         res = parse_existing_config(argv[x]);
667                         if (!res && !strcasecmp(argv[x], OUTPUT_MAKEOPTS_DEFAULT))
668                                 existing_config = 1;
669                         res = 0;
670                 }
671         }
672
673 #ifdef MENUSELECT_DEBUG
674         /* Dump the list produced by parsing the various input files */
675         dump_member_list();
676 #endif
677
678         if (!existing_config)
679                 process_defaults();
680         else if (check_deps)
681                 res = sanity_check();
682
683         /* Run the menu to let the user enable/disable options */
684         if (!check_deps && !res)
685                 res = run_menu();
686
687         /* Write out the menuselect.makeopts file if
688          * 1) menuselect was not executed with --check-deps
689          * 2) menuselect was executed with --check-deps but menuselect.makeopts
690          *    did not already exist.
691          */
692         if ((!check_deps || !existing_config) && !res)
693                 res = generate_makeopts_file();
694         
695         /* free everything we allocated */
696         free_trees();
697         free_member_list();
698
699         /* In some cases, such as modifying the CFLAGS for the build,
700          * a "make clean" needs to be forced.  Removing the .lastclean 
701          * file does this. */
702         if (force_clean)
703                 unlink(".lastclean");
704
705         exit(res);
706 }