1
2
3
4
5
6#include <sys/stat.h>
7#include <ctype.h>
8#include <errno.h>
9#include <fcntl.h>
10#include <limits.h>
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <time.h>
15#include <unistd.h>
16
17#define LKC_DIRECT_LINK
18#include "lkc.h"
19
20static void conf_warning(const char *fmt, ...)
21 __attribute__ ((format (printf, 1, 2)));
22
23static const char *conf_filename;
24static int conf_lineno, conf_warnings, conf_unsaved;
25
26#ifndef conf_defname
27const char conf_defname[] = "arch/$ARCH/defconfig";
28#endif
29
30#ifndef CONFIG_PREFIX
31#define CONFIG_PREFIX "CONFIG_"
32#endif
33
34static void conf_warning(const char *fmt, ...)
35{
36 va_list ap;
37 va_start(ap, fmt);
38 fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
39 vfprintf(stderr, fmt, ap);
40 fprintf(stderr, "\n");
41 va_end(ap);
42 conf_warnings++;
43}
44
45const char *conf_get_configname(void)
46{
47 char *name = getenv("KCONFIG_CONFIG");
48
49 return name ? name : ".config";
50}
51
52static char *conf_expand_value(const char *in)
53{
54 struct symbol *sym;
55 const char *src;
56 static char res_value[SYMBOL_MAXLENGTH];
57 char *dst, name[SYMBOL_MAXLENGTH];
58
59 res_value[0] = 0;
60 dst = name;
61 while ((src = strchr(in, '$'))) {
62 strncat(res_value, in, src - in);
63 src++;
64 dst = name;
65 while (isalnum(*src) || *src == '_')
66 *dst++ = *src++;
67 *dst = 0;
68 sym = sym_lookup(name, 0);
69 sym_calc_value(sym);
70 strcat(res_value, sym_get_string_value(sym));
71 in = src;
72 }
73 strcat(res_value, in);
74
75 return res_value;
76}
77
78char *conf_get_default_confname(void)
79{
80 struct stat buf;
81 static char fullname[PATH_MAX+1];
82 char *env, *name;
83
84 name = conf_expand_value(conf_defname);
85 env = getenv(SRCTREE);
86 if (env) {
87 sprintf(fullname, "%s/%s", env, name);
88 if (!stat(fullname, &buf))
89 return fullname;
90 }
91 return name;
92}
93
94int conf_read_simple(const char *name, int def)
95{
96 FILE *in = NULL;
97 char line[1024];
98 char *p, *p2;
99 struct symbol *sym;
100 int i, def_flags;
101
102 if (name) {
103 in = zconf_fopen(name);
104 } else {
105 struct property *prop;
106
107 name = conf_get_configname();
108 in = zconf_fopen(name);
109 if (in)
110 goto load;
111 sym_change_count++;
112 if (!sym_defconfig_list)
113 return 1;
114
115 for_all_defaults(sym_defconfig_list, prop) {
116 if (expr_calc_value(prop->visible.expr) == no ||
117 prop->expr->type != E_SYMBOL)
118 continue;
119 name = conf_expand_value(prop->expr->left.sym->name);
120 in = zconf_fopen(name);
121 if (in) {
122 printf(_("#\n"
123 "# using defaults found in %s\n"
124 "#\n"), name);
125 goto load;
126 }
127 }
128 }
129 if (!in)
130 return 1;
131
132load:
133 conf_filename = name;
134 conf_lineno = 0;
135 conf_warnings = 0;
136 conf_unsaved = 0;
137
138 def_flags = SYMBOL_DEF << def;
139 for_all_symbols(i, sym) {
140 sym->flags |= SYMBOL_CHANGED;
141 sym->flags &= ~(def_flags|SYMBOL_VALID);
142 if (sym_is_choice(sym))
143 sym->flags |= def_flags;
144 switch (sym->type) {
145 case S_INT:
146 case S_HEX:
147 case S_STRING:
148 if (sym->def[def].val)
149 free(sym->def[def].val);
150 default:
151 sym->def[def].val = NULL;
152 sym->def[def].tri = no;
153 }
154 }
155
156 while (fgets(line, sizeof(line), in)) {
157 conf_lineno++;
158 sym = NULL;
159 switch (line[0]) {
160 case '#':
161 if (line[1]!=' ' || memcmp(line + 2, CONFIG_PREFIX,
162 strlen(CONFIG_PREFIX))) {
163 continue;
164 }
165 p = strchr(line + 2 + strlen(CONFIG_PREFIX), ' ');
166 if (!p)
167 continue;
168 *p++ = 0;
169 if (strncmp(p, "is not set", 10))
170 continue;
171 if (def == S_DEF_USER) {
172 sym = sym_find(line + 2 + strlen(CONFIG_PREFIX));
173 if (!sym) {
174 conf_warning("trying to assign nonexistent symbol %s", line + 2 + strlen(CONFIG_PREFIX));
175 break;
176 }
177 } else {
178 sym = sym_lookup(line + 9, 0);
179 if (sym->type == S_UNKNOWN)
180 sym->type = S_BOOLEAN;
181 }
182 if (sym->flags & def_flags) {
183 conf_warning("trying to reassign symbol %s", sym->name);
184 break;
185 }
186 switch (sym->type) {
187 case S_BOOLEAN:
188 case S_TRISTATE:
189 sym->def[def].tri = no;
190 sym->flags |= def_flags;
191 break;
192 default:
193 ;
194 }
195 break;
196 case 'A' ... 'Z':
197 if (memcmp(line, CONFIG_PREFIX, strlen(CONFIG_PREFIX))) {
198 conf_warning("unexpected data");
199 continue;
200 }
201 p = strchr(line + strlen(CONFIG_PREFIX), '=');
202 if (!p)
203 continue;
204 *p++ = 0;
205 p2 = strchr(p, '\n');
206 if (p2) {
207 *p2-- = 0;
208 if (*p2 == '\r')
209 *p2 = 0;
210 }
211 if (def == S_DEF_USER) {
212 sym = sym_find(line + strlen(CONFIG_PREFIX));
213 if (!sym) {
214 conf_warning("trying to assign nonexistent symbol %s", line + 7);
215 break;
216 }
217 } else {
218 sym = sym_lookup(line + strlen(CONFIG_PREFIX), 0);
219 if (sym->type == S_UNKNOWN)
220 sym->type = S_OTHER;
221 }
222 if (sym->flags & def_flags) {
223 conf_warning("trying to reassign symbol %s", sym->name);
224 break;
225 }
226 switch (sym->type) {
227 case S_TRISTATE:
228 if (p[0] == 'm') {
229 sym->def[def].tri = mod;
230 sym->flags |= def_flags;
231 break;
232 }
233 case S_BOOLEAN:
234 if (p[0] == 'y') {
235 sym->def[def].tri = yes;
236 sym->flags |= def_flags;
237 break;
238 }
239 if (p[0] == 'n') {
240 sym->def[def].tri = no;
241 sym->flags |= def_flags;
242 break;
243 }
244 conf_warning("symbol value '%s' invalid for %s", p, sym->name);
245 break;
246 case S_OTHER:
247 if (*p != '"') {
248 for (p2 = p; *p2 && !isspace(*p2); p2++)
249 ;
250 sym->type = S_STRING;
251 goto done;
252 }
253 case S_STRING:
254 if (*p++ != '"')
255 break;
256 for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
257 if (*p2 == '"') {
258 *p2 = 0;
259 break;
260 }
261 memmove(p2, p2 + 1, strlen(p2));
262 }
263 if (!p2) {
264 conf_warning("invalid string found");
265 continue;
266 }
267 case S_INT:
268 case S_HEX:
269 done:
270 if (sym_string_valid(sym, p)) {
271 sym->def[def].val = strdup(p);
272 sym->flags |= def_flags;
273 } else {
274 conf_warning("symbol value '%s' invalid for %s", p, sym->name);
275 continue;
276 }
277 break;
278 default:
279 ;
280 }
281 break;
282 case '\r':
283 case '\n':
284 break;
285 default:
286 conf_warning("unexpected data");
287 continue;
288 }
289 if (sym && sym_is_choice_value(sym)) {
290 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
291 switch (sym->def[def].tri) {
292 case no:
293 break;
294 case mod:
295 if (cs->def[def].tri == yes) {
296 conf_warning("%s creates inconsistent choice state", sym->name);
297 cs->flags &= ~def_flags;
298 }
299 break;
300 case yes:
301 if (cs->def[def].tri != no) {
302 conf_warning("%s creates inconsistent choice state", sym->name);
303 cs->flags &= ~def_flags;
304 } else
305 cs->def[def].val = sym;
306 break;
307 }
308 cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
309 }
310 }
311 fclose(in);
312
313 if (modules_sym)
314 sym_calc_value(modules_sym);
315 return 0;
316}
317
318int conf_read(const char *name)
319{
320 struct symbol *sym;
321 struct property *prop;
322 struct expr *e;
323 int i, flags;
324
325 sym_change_count = 0;
326
327 if (conf_read_simple(name, S_DEF_USER))
328 return 1;
329
330 for_all_symbols(i, sym) {
331 sym_calc_value(sym);
332 if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
333 goto sym_ok;
334 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
335
336 switch (sym->type) {
337 case S_BOOLEAN:
338 case S_TRISTATE:
339 if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
340 break;
341 if (!sym_is_choice(sym))
342 goto sym_ok;
343 default:
344 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
345 goto sym_ok;
346 break;
347 }
348 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
349
350 goto sym_ok;
351 conf_unsaved++;
352
353 sym_ok:
354 if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
355 if (sym->visible == no)
356 sym->flags &= ~SYMBOL_DEF_USER;
357 switch (sym->type) {
358 case S_STRING:
359 case S_INT:
360 case S_HEX:
361 if (!sym_string_within_range(sym, sym->def[S_DEF_USER].val))
362 sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
363 default:
364 break;
365 }
366 }
367 if (!sym_is_choice(sym))
368 continue;
369 prop = sym_get_choice_prop(sym);
370 flags = sym->flags;
371 for (e = prop->expr; e; e = e->left.expr)
372 if (e->right.sym->visible != no)
373 flags &= e->right.sym->flags;
374 sym->flags &= flags | ~SYMBOL_DEF_USER;
375 }
376
377 sym_change_count += conf_warnings || conf_unsaved;
378
379 return 0;
380}
381
382struct menu *next_menu(struct menu *menu)
383{
384 if (menu->list) return menu->list;
385 do {
386 if (menu->next) {
387 menu = menu->next;
388 break;
389 }
390 } while ((menu = menu->parent));
391
392 return menu;
393}
394
395#define SYMBOL_FORCEWRITE (1<<31)
396
397int conf_write(const char *name)
398{
399 FILE *out;
400 struct symbol *sym;
401 struct menu *menu;
402 const char *basename;
403 char dirname[128], tmpname[128], newname[128];
404 int type, l, writetype;
405 const char *str;
406 time_t now;
407 int use_timestamp = 1;
408 char *env;
409
410 dirname[0] = 0;
411 if (name && name[0]) {
412 struct stat st;
413 char *slash;
414
415 if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
416 strcpy(dirname, name);
417 strcat(dirname, "/");
418 basename = conf_get_configname();
419 } else if ((slash = strrchr(name, '/'))) {
420 int size = slash - name + 1;
421 memcpy(dirname, name, size);
422 dirname[size] = 0;
423 if (slash[1])
424 basename = slash + 1;
425 else
426 basename = conf_get_configname();
427 } else
428 basename = name;
429 } else
430 basename = conf_get_configname();
431
432 sprintf(newname, "%s%s", dirname, basename);
433 env = getenv("KCONFIG_OVERWRITECONFIG");
434 if (!env || !*env) {
435 sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
436 out = fopen(tmpname, "w");
437 } else {
438 *tmpname = 0;
439 out = fopen(newname, "w");
440 }
441 if (!out)
442 return 1;
443
444 sym = sym_lookup("KCONFIG_VERSION", 0);
445 sym_calc_value(sym);
446 time(&now);
447 env = getenv("KCONFIG_NOTIMESTAMP");
448 if (env && *env)
449 use_timestamp = 0;
450
451 fprintf(out, _("#\n"
452 "# Automatically generated make config: don't edit\n"
453 "# "PROJECT_NAME" version: %s\n"
454 "%s%s"
455 "#\n"),
456 sym_get_string_value(sym),
457 use_timestamp ? "# " : "",
458 use_timestamp ? ctime(&now) : "");
459
460 if (!sym_change_count)
461 sym_clear_all_valid();
462
463
464 if (1) {
465 for (menu = rootmenu.list; menu; menu = next_menu(menu))
466 if (menu->sym) menu->sym->flags |= SYMBOL_FORCEWRITE;
467 writetype = SYMBOL_FORCEWRITE;
468
469
470
471 } else writetype = SYMBOL_WRITE;
472
473
474 menu = rootmenu.list;
475 while (menu) {
476 sym = menu->sym;
477 if (!sym) {
478 if (!menu_is_visible(menu))
479 goto next;
480 str = menu_get_prompt(menu);
481 fprintf(out, "\n"
482 "#\n"
483 "# %s\n"
484 "#\n", str);
485 } else if (!(sym->flags & SYMBOL_CHOICE)) {
486 sym_calc_value(sym);
487 if (!(sym->flags & writetype))
488 goto next;
489 sym->flags &= ~writetype;
490 type = sym->type;
491 if (type == S_TRISTATE) {
492 sym_calc_value(modules_sym);
493 if (modules_sym->curr.tri == no)
494 type = S_BOOLEAN;
495 }
496 switch (type) {
497 case S_BOOLEAN:
498 case S_TRISTATE:
499 switch (sym_get_tristate_value(sym)) {
500 case no:
501 fprintf(out, "# "CONFIG_PREFIX"%s is not set\n", sym->name);
502 break;
503 case mod:
504 fprintf(out, CONFIG_PREFIX"%s=m\n", sym->name);
505 break;
506 case yes:
507 fprintf(out, CONFIG_PREFIX"%s=y\n", sym->name);
508 break;
509 }
510 break;
511 case S_STRING:
512 str = sym_get_string_value(sym);
513 fprintf(out, CONFIG_PREFIX"%s=\"", sym->name);
514 while (1) {
515 l = strcspn(str, "\"\\");
516 if (l) {
517 fwrite(str, l, 1, out);
518 str += l;
519 }
520 if (!*str)
521 break;
522 fprintf(out, "\\%c", *str++);
523 }
524 fputs("\"\n", out);
525 break;
526 case S_HEX:
527 str = sym_get_string_value(sym);
528 if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
529 fprintf(out, CONFIG_PREFIX"%s=%s\n", sym->name, *str ? str : "0");
530 break;
531 }
532 case S_INT:
533 str = sym_get_string_value(sym);
534 fprintf(out, CONFIG_PREFIX"%s=%s\n", sym->name, *str ? str : "0");
535 break;
536 }
537 }
538
539 next:
540 if (writetype == SYMBOL_WRITE) {
541 if (menu->list) {
542 menu = menu->list;
543 continue;
544 }
545 if (menu->next)
546 menu = menu->next;
547 else while ((menu = menu->parent)) {
548 if (menu->next) {
549 menu = menu->next;
550 break;
551 }
552 }
553 } else
554 menu = next_menu(menu);
555 }
556 fclose(out);
557
558 if (*tmpname) {
559 strcat(dirname, basename);
560 strcat(dirname, ".old");
561 rename(newname, dirname);
562 if (rename(tmpname, newname))
563 return 1;
564 }
565
566 printf(_("#\n"
567 "# configuration written to %s\n"
568 "#\n"), newname);
569
570 sym_change_count = 0;
571
572 return 0;
573}
574
575int conf_split_config(void)
576{
577 char *name, path[128];
578 char *s, *d, c;
579 struct symbol *sym;
580 struct stat sb;
581 int res, i, fd;
582
583 name = getenv("KCONFIG_AUTOCONFIG");
584 if (!name)
585 name = "include/config/auto.conf";
586 conf_read_simple(name, S_DEF_AUTO);
587
588 if (chdir("include/config"))
589 return 1;
590
591 res = 0;
592 for_all_symbols(i, sym) {
593 sym_calc_value(sym);
594 if ((sym->flags & SYMBOL_AUTO) || !sym->name)
595 continue;
596 if (sym->flags & SYMBOL_WRITE) {
597 if (sym->flags & SYMBOL_DEF_AUTO) {
598
599
600
601
602 switch (sym->type) {
603 case S_BOOLEAN:
604 case S_TRISTATE:
605 if (sym_get_tristate_value(sym) ==
606 sym->def[S_DEF_AUTO].tri)
607 continue;
608 break;
609 case S_STRING:
610 case S_HEX:
611 case S_INT:
612 if (!strcmp(sym_get_string_value(sym),
613 sym->def[S_DEF_AUTO].val))
614 continue;
615 break;
616 default:
617 break;
618 }
619 } else {
620
621
622
623
624 switch (sym->type) {
625 case S_BOOLEAN:
626 case S_TRISTATE:
627 if (sym_get_tristate_value(sym) == no)
628 continue;
629 break;
630 default:
631 break;
632 }
633 }
634 } else if (!(sym->flags & SYMBOL_DEF_AUTO))
635
636 continue;
637
638
639
640
641
642
643
644 s = sym->name;
645 d = path;
646 while ((c = *s++)) {
647 c = tolower(c);
648 *d++ = (c == '_') ? '/' : c;
649 }
650 strcpy(d, ".h");
651
652
653 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
654 if (fd == -1) {
655 if (errno != ENOENT) {
656 res = 1;
657 break;
658 }
659
660
661
662
663 d = path;
664 while ((d = strchr(d, '/'))) {
665 *d = 0;
666 if (stat(path, &sb) && mkdir(path, 0755)) {
667 res = 1;
668 goto out;
669 }
670 *d++ = '/';
671 }
672
673 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
674 if (fd == -1) {
675 res = 1;
676 break;
677 }
678 }
679 close(fd);
680 }
681out:
682 if (chdir("../.."))
683 return 1;
684
685 return res;
686}
687
688int conf_write_autoconf(void)
689{
690 struct symbol *sym;
691 const char *str;
692 char *name;
693 FILE *out, *out_h;
694 time_t now;
695 int i, l;
696
697 sym_clear_all_valid();
698
699 file_write_dep("include/config/auto.conf.cmd");
700
701 if (conf_split_config())
702 return 1;
703
704 out = fopen(".tmpconfig", "w");
705 if (!out)
706 return 1;
707
708 out_h = fopen(".tmpconfig.h", "w");
709 if (!out_h) {
710 fclose(out);
711 return 1;
712 }
713
714 sym = sym_lookup("KCONFIG_VERSION", 0);
715 sym_calc_value(sym);
716 time(&now);
717 fprintf(out, "#\n"
718 "# Automatically generated make config: don't edit\n"
719 "# "PROJECT_NAME" version: %s\n"
720 "# %s"
721 "#\n",
722 sym_get_string_value(sym), ctime(&now));
723 fprintf(out_h, "/*\n"
724 " * Automatically generated C config: don't edit\n"
725 " * "PROJECT_NAME" version: %s\n"
726 " * %s"
727 " */\n"
728
729 , sym_get_string_value(sym), ctime(&now));
730
731 for_all_symbols(i, sym) {
732 sym_calc_value(sym);
733 if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
734 continue;
735 switch (sym->type) {
736 case S_BOOLEAN:
737 case S_TRISTATE:
738 switch (sym_get_tristate_value(sym)) {
739 case no:
740 break;
741 case mod:
742 fprintf(out, CONFIG_PREFIX"%s=m\n", sym->name);
743 fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
744 break;
745 case yes:
746 fprintf(out, CONFIG_PREFIX"%s=y\n", sym->name);
747 fprintf(out_h, "#define "CONFIG_PREFIX"%s 1\n", sym->name);
748 break;
749 }
750 break;
751 case S_STRING:
752 str = sym_get_string_value(sym);
753 fprintf(out, CONFIG_PREFIX"%s=\"", sym->name);
754 fprintf(out_h, "#define "CONFIG_PREFIX"%s \"", sym->name);
755 while (1) {
756 l = strcspn(str, "\"\\");
757 if (l) {
758 fwrite(str, l, 1, out);
759 fwrite(str, l, 1, out_h);
760 str += l;
761 }
762 if (!*str)
763 break;
764 fprintf(out, "\\%c", *str);
765 fprintf(out_h, "\\%c", *str);
766 str++;
767 }
768 fputs("\"\n", out);
769 fputs("\"\n", out_h);
770 break;
771 case S_HEX:
772 str = sym_get_string_value(sym);
773 if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
774 fprintf(out, CONFIG_PREFIX"%s=%s\n", sym->name, str);
775 fprintf(out_h, "#define "CONFIG_PREFIX"%s 0x%s\n", sym->name, str);
776 break;
777 }
778 case S_INT:
779 str = sym_get_string_value(sym);
780 fprintf(out, CONFIG_PREFIX"%s=%s\n", sym->name, str);
781 fprintf(out_h, "#define "CONFIG_PREFIX"%s %s\n", sym->name, str);
782 break;
783 default:
784 break;
785 }
786 }
787 fclose(out);
788 fclose(out_h);
789
790 name = getenv("KCONFIG_AUTOHEADER");
791 if (!name)
792 name = "include/linux/autoconf.h";
793 if (rename(".tmpconfig.h", name))
794 return 1;
795 name = getenv("KCONFIG_AUTOCONFIG");
796 if (!name)
797 name = "include/config/auto.conf";
798
799
800
801
802 if (rename(".tmpconfig", name))
803 return 1;
804
805 return 0;
806}
807
