1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
4 */
5
6#include <sys/mman.h>
7#include <sys/stat.h>
8#include <ctype.h>
9#include <errno.h>
10#include <fcntl.h>
11#include <limits.h>
12#include <stdarg.h>
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h>
16#include <time.h>
17#include <unistd.h>
18
19#include "lkc.h"
20
21/* return true if 'path' exists, false otherwise */
22static bool is_present(const char *path)
23{
24	struct stat st;
25
26	return !stat(path, &st);
27}
28
29/* return true if 'path' exists and it is a directory, false otherwise */
30static bool is_dir(const char *path)
31{
32	struct stat st;
33
34	if (stat(path, &st))
35		return 0;
36
37	return S_ISDIR(st.st_mode);
38}
39
40/* return true if the given two files are the same, false otherwise */
41static bool is_same(const char *file1, const char *file2)
42{
43	int fd1, fd2;
44	struct stat st1, st2;
45	void *map1, *map2;
46	bool ret = false;
47
48	fd1 = open(file1, O_RDONLY);
49	if (fd1 < 0)
50		return ret;
51
52	fd2 = open(file2, O_RDONLY);
53	if (fd2 < 0)
54		goto close1;
55
56	ret = fstat(fd1, &st1);
57	if (ret)
58		goto close2;
59	ret = fstat(fd2, &st2);
60	if (ret)
61		goto close2;
62
63	if (st1.st_size != st2.st_size)
64		goto close2;
65
66	map1 = mmap(NULL, st1.st_size, PROT_READ, MAP_PRIVATE, fd1, 0);
67	if (map1 == MAP_FAILED)
68		goto close2;
69
70	map2 = mmap(NULL, st2.st_size, PROT_READ, MAP_PRIVATE, fd2, 0);
71	if (map2 == MAP_FAILED)
72		goto close2;
73
74	if (bcmp(map1, map2, st1.st_size))
75		goto close2;
76
77	ret = true;
78close2:
79	close(fd2);
80close1:
81	close(fd1);
82
83	return ret;
84}
85
86/*
87 * Create the parent directory of the given path.
88 *
89 * For example, if 'include/config/auto.conf' is given, create 'include/config'.
90 */
91static int make_parent_dir(const char *path)
92{
93	char tmp[PATH_MAX + 1];
94	char *p;
95
96	strncpy(tmp, path, sizeof(tmp));
97	tmp[sizeof(tmp) - 1] = 0;
98
99	/* Remove the base name. Just return if nothing is left */
100	p = strrchr(tmp, '/');
101	if (!p)
102		return 0;
103	*(p + 1) = 0;
104
105	/* Just in case it is an absolute path */
106	p = tmp;
107	while (*p == '/')
108		p++;
109
110	while ((p = strchr(p, '/'))) {
111		*p = 0;
112
113		/* skip if the directory exists */
114		if (!is_dir(tmp) && mkdir(tmp, 0755))
115			return -1;
116
117		*p = '/';
118		while (*p == '/')
119			p++;
120	}
121
122	return 0;
123}
124
125static char depfile_path[PATH_MAX];
126static size_t depfile_prefix_len;
127
128/* touch depfile for symbol 'name' */
129static int conf_touch_dep(const char *name)
130{
131	int fd, ret;
132	const char *s;
133	char *d, c;
134
135	/* check overflow: prefix + name + ".h" + '\0' must fit in buffer. */
136	if (depfile_prefix_len + strlen(name) + 3 > sizeof(depfile_path))
137		return -1;
138
139	d = depfile_path + depfile_prefix_len;
140	s = name;
141
142	while ((c = *s++))
143		*d++ = (c == '_') ? '/' : tolower(c);
144	strcpy(d, ".h");
145
146	/* Assume directory path already exists. */
147	fd = open(depfile_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
148	if (fd == -1) {
149		if (errno != ENOENT)
150			return -1;
151
152		ret = make_parent_dir(depfile_path);
153		if (ret)
154			return ret;
155
156		/* Try it again. */
157		fd = open(depfile_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
158		if (fd == -1)
159			return -1;
160	}
161	close(fd);
162
163	return 0;
164}
165
166struct conf_printer {
167	void (*print_symbol)(FILE *, struct symbol *, const char *, void *);
168	void (*print_comment)(FILE *, const char *, void *);
169};
170
171static void conf_warning(const char *fmt, ...)
172	__attribute__ ((format (printf, 1, 2)));
173
174static void conf_message(const char *fmt, ...)
175	__attribute__ ((format (printf, 1, 2)));
176
177static const char *conf_filename;
178static int conf_lineno, conf_warnings;
179
180static void conf_warning(const char *fmt, ...)
181{
182	va_list ap;
183	va_start(ap, fmt);
184	fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
185	vfprintf(stderr, fmt, ap);
186	fprintf(stderr, "\n");
187	va_end(ap);
188	conf_warnings++;
189}
190
191static void conf_default_message_callback(const char *s)
192{
193	printf("#\n# ");
194	printf("%s", s);
195	printf("\n#\n");
196}
197
198static void (*conf_message_callback)(const char *s) =
199	conf_default_message_callback;
200void conf_set_message_callback(void (*fn)(const char *s))
201{
202	conf_message_callback = fn;
203}
204
205static void conf_message(const char *fmt, ...)
206{
207	va_list ap;
208	char buf[4096];
209
210	if (!conf_message_callback)
211		return;
212
213	va_start(ap, fmt);
214
215	vsnprintf(buf, sizeof(buf), fmt, ap);
216	conf_message_callback(buf);
217	va_end(ap);
218}
219
220const char *conf_get_configname(void)
221{
222	char *name = getenv("KCONFIG_CONFIG");
223
224	return name ? name : ".config";
225}
226
227static const char *conf_get_autoconfig_name(void)
228{
229	char *name = getenv("KCONFIG_AUTOCONFIG");
230
231	return name ? name : "include/config/auto.conf";
232}
233
234static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
235{
236	char *p2;
237
238	switch (sym->type) {
239	case S_TRISTATE:
240		if (p[0] == 'm') {
241			sym->def[def].tri = mod;
242			sym->flags |= def_flags;
243			break;
244		}
245		/* fall through */
246	case S_BOOLEAN:
247		if (p[0] == 'y') {
248			sym->def[def].tri = yes;
249			sym->flags |= def_flags;
250			break;
251		}
252		if (p[0] == 'n') {
253			sym->def[def].tri = no;
254			sym->flags |= def_flags;
255			break;
256		}
257		if (def != S_DEF_AUTO)
258			conf_warning("symbol value '%s' invalid for %s",
259				     p, sym->name);
260		return 1;
261	case S_STRING:
262		if (*p++ != '"')
263			break;
264		for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
265			if (*p2 == '"') {
266				*p2 = 0;
267				break;
268			}
269			memmove(p2, p2 + 1, strlen(p2));
270		}
271		if (!p2) {
272			if (def != S_DEF_AUTO)
273				conf_warning("invalid string found");
274			return 1;
275		}
276		/* fall through */
277	case S_INT:
278	case S_HEX:
279		if (sym_string_valid(sym, p)) {
280			sym->def[def].val = xstrdup(p);
281			sym->flags |= def_flags;
282		} else {
283			if (def != S_DEF_AUTO)
284				conf_warning("symbol value '%s' invalid for %s",
285					     p, sym->name);
286			return 1;
287		}
288		break;
289	default:
290		;
291	}
292	return 0;
293}
294
295#define LINE_GROWTH 16
296static int add_byte(int c, char **lineptr, size_t slen, size_t *n)
297{
298	char *nline;
299	size_t new_size = slen + 1;
300	if (new_size > *n) {
301		new_size += LINE_GROWTH - 1;
302		new_size *= 2;
303		nline = xrealloc(*lineptr, new_size);
304		if (!nline)
305			return -1;
306
307		*lineptr = nline;
308		*n = new_size;
309	}
310
311	(*lineptr)[slen] = c;
312
313	return 0;
314}
315
316static ssize_t compat_getline(char **lineptr, size_t *n, FILE *stream)
317{
318	char *line = *lineptr;
319	size_t slen = 0;
320
321	for (;;) {
322		int c = getc(stream);
323
324		switch (c) {
325		case '\n':
326			if (add_byte(c, &line, slen, n) < 0)
327				goto e_out;
328			slen++;
329			/* fall through */
330		case EOF:
331			if (add_byte('\0', &line, slen, n) < 0)
332				goto e_out;
333			*lineptr = line;
334			if (slen == 0)
335				return -1;
336			return slen;
337		default:
338			if (add_byte(c, &line, slen, n) < 0)
339				goto e_out;
340			slen++;
341		}
342	}
343
344e_out:
345	line[slen-1] = '\0';
346	*lineptr = line;
347	return -1;
348}
349
350int conf_read_simple(const char *name, int def)
351{
352	FILE *in = NULL;
353	char   *line = NULL;
354	size_t  line_asize = 0;
355	char *p, *p2;
356	struct symbol *sym;
357	int i, def_flags;
358
359	if (name) {
360		in = zconf_fopen(name);
361	} else {
362		struct property *prop;
363
364		name = conf_get_configname();
365		in = zconf_fopen(name);
366		if (in)
367			goto load;
368		sym_add_change_count(1);
369		if (!sym_defconfig_list)
370			return 1;
371
372		for_all_defaults(sym_defconfig_list, prop) {
373			if (expr_calc_value(prop->visible.expr) == no ||
374			    prop->expr->type != E_SYMBOL)
375				continue;
376			sym_calc_value(prop->expr->left.sym);
377			name = sym_get_string_value(prop->expr->left.sym);
378			in = zconf_fopen(name);
379			if (in) {
380				conf_message("using defaults found in %s",
381					 name);
382				goto load;
383			}
384		}
385	}
386	if (!in)
387		return 1;
388
389load:
390	conf_filename = name;
391	conf_lineno = 0;
392	conf_warnings = 0;
393
394	def_flags = SYMBOL_DEF << def;
395	for_all_symbols(i, sym) {
396		sym->flags |= SYMBOL_CHANGED;
397		sym->flags &= ~(def_flags|SYMBOL_VALID);
398		if (sym_is_choice(sym))
399			sym->flags |= def_flags;
400		switch (sym->type) {
401		case S_INT:
402		case S_HEX:
403		case S_STRING:
404			if (sym->def[def].val)
405				free(sym->def[def].val);
406			/* fall through */
407		default:
408			sym->def[def].val = NULL;
409			sym->def[def].tri = no;
410		}
411	}
412
413	while (compat_getline(&line, &line_asize, in) != -1) {
414		conf_lineno++;
415		sym = NULL;
416		if (line[0] == '#') {
417			if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
418				continue;
419			p = strchr(line + 2 + strlen(CONFIG_), ' ');
420			if (!p)
421				continue;
422			*p++ = 0;
423			if (strncmp(p, "is not set", 10))
424				continue;
425			if (def == S_DEF_USER) {
426				sym = sym_find(line + 2 + strlen(CONFIG_));
427				if (!sym) {
428					sym_add_change_count(1);
429					continue;
430				}
431			} else {
432				sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
433				if (sym->type == S_UNKNOWN)
434					sym->type = S_BOOLEAN;
435			}
436			if (sym->flags & def_flags) {
437				conf_warning("override: reassigning to symbol %s", sym->name);
438			}
439			switch (sym->type) {
440			case S_BOOLEAN:
441			case S_TRISTATE:
442				sym->def[def].tri = no;
443				sym->flags |= def_flags;
444				break;
445			default:
446				;
447			}
448		} else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
449			p = strchr(line + strlen(CONFIG_), '=');
450			if (!p)
451				continue;
452			*p++ = 0;
453			p2 = strchr(p, '\n');
454			if (p2) {
455				*p2-- = 0;
456				if (*p2 == '\r')
457					*p2 = 0;
458			}
459
460			sym = sym_find(line + strlen(CONFIG_));
461			if (!sym) {
462				if (def == S_DEF_AUTO)
463					/*
464					 * Reading from include/config/auto.conf
465					 * If CONFIG_FOO previously existed in
466					 * auto.conf but it is missing now,
467					 * include/config/foo.h must be touched.
468					 */
469					conf_touch_dep(line + strlen(CONFIG_));
470				else
471					sym_add_change_count(1);
472				continue;
473			}
474
475			if (sym->flags & def_flags) {
476				conf_warning("override: reassigning to symbol %s", sym->name);
477			}
478			if (conf_set_sym_val(sym, def, def_flags, p))
479				continue;
480		} else {
481			if (line[0] != '\r' && line[0] != '\n')
482				conf_warning("unexpected data: %.*s",
483					     (int)strcspn(line, "\r\n"), line);
484
485			continue;
486		}
487
488		if (sym && sym_is_choice_value(sym)) {
489			struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
490			switch (sym->def[def].tri) {
491			case no:
492				break;
493			case mod:
494				if (cs->def[def].tri == yes) {
495					conf_warning("%s creates inconsistent choice state", sym->name);
496					cs->flags &= ~def_flags;
497				}
498				break;
499			case yes:
500				if (cs->def[def].tri != no)
501					conf_warning("override: %s changes choice state", sym->name);
502				cs->def[def].val = sym;
503				break;
504			}
505			cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
506		}
507	}
508	free(line);
509	fclose(in);
510	return 0;
511}
512
513int conf_read(const char *name)
514{
515	struct symbol *sym;
516	int conf_unsaved = 0;
517	int i;
518
519	sym_set_change_count(0);
520
521	if (conf_read_simple(name, S_DEF_USER)) {
522		sym_calc_value(modules_sym);
523		return 1;
524	}
525
526	sym_calc_value(modules_sym);
527
528	for_all_symbols(i, sym) {
529		sym_calc_value(sym);
530		if (sym_is_choice(sym) || (sym->flags & SYMBOL_NO_WRITE))
531			continue;
532		if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
533			/* check that calculated value agrees with saved value */
534			switch (sym->type) {
535			case S_BOOLEAN:
536			case S_TRISTATE:
537				if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym))
538					continue;
539				break;
540			default:
541				if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
542					continue;
543				break;
544			}
545		} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
546			/* no previous value and not saved */
547			continue;
548		conf_unsaved++;
549		/* maybe print value in verbose mode... */
550	}
551
552	for_all_symbols(i, sym) {
553		if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
554			/* Reset values of generates values, so they'll appear
555			 * as new, if they should become visible, but that
556			 * doesn't quite work if the Kconfig and the saved
557			 * configuration disagree.
558			 */
559			if (sym->visible == no && !conf_unsaved)
560				sym->flags &= ~SYMBOL_DEF_USER;
561			switch (sym->type) {
562			case S_STRING:
563			case S_INT:
564			case S_HEX:
565				/* Reset a string value if it's out of range */
566				if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
567					break;
568				sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
569				conf_unsaved++;
570				break;
571			default:
572				break;
573			}
574		}
575	}
576
577	sym_add_change_count(conf_warnings || conf_unsaved);
578
579	return 0;
580}
581
582/*
583 * Kconfig configuration printer
584 *
585 * This printer is used when generating the resulting configuration after
586 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
587 * passing a non-NULL argument to the printer.
588 *
589 */
590static void
591kconfig_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
592{
593
594	switch (sym->type) {
595	case S_BOOLEAN:
596	case S_TRISTATE:
597		if (*value == 'n') {
598			bool skip_unset = (arg != NULL);
599
600			if (!skip_unset)
601				fprintf(fp, "# %s%s is not set\n",
602				    CONFIG_, sym->name);
603			return;
604		}
605		break;
606	default:
607		break;
608	}
609
610	fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, value);
611}
612
613static void
614kconfig_print_comment(FILE *fp, const char *value, void *arg)
615{
616	const char *p = value;
617	size_t l;
618
619	for (;;) {
620		l = strcspn(p, "\n");
621		fprintf(fp, "#");
622		if (l) {
623			fprintf(fp, " ");
624			xfwrite(p, l, 1, fp);
625			p += l;
626		}
627		fprintf(fp, "\n");
628		if (*p++ == '\0')
629			break;
630	}
631}
632
633static struct conf_printer kconfig_printer_cb =
634{
635	.print_symbol = kconfig_print_symbol,
636	.print_comment = kconfig_print_comment,
637};
638
639/*
640 * Header printer
641 *
642 * This printer is used when generating the `include/generated/autoconf.h' file.
643 */
644static void
645header_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
646{
647
648	switch (sym->type) {
649	case S_BOOLEAN:
650	case S_TRISTATE: {
651		const char *suffix = "";
652
653		switch (*value) {
654		case 'n':
655			break;
656		case 'm':
657			suffix = "_MODULE";
658			/* fall through */
659		default:
660			fprintf(fp, "#define %s%s%s 1\n",
661			    CONFIG_, sym->name, suffix);
662		}
663		break;
664	}
665	case S_HEX: {
666		const char *prefix = "";
667
668		if (value[0] != '0' || (value[1] != 'x' && value[1] != 'X'))
669			prefix = "0x";
670		fprintf(fp, "#define %s%s %s%s\n",
671		    CONFIG_, sym->name, prefix, value);
672		break;
673	}
674	case S_STRING:
675	case S_INT:
676		fprintf(fp, "#define %s%s %s\n",
677		    CONFIG_, sym->name, value);
678		break;
679	default:
680		break;
681	}
682
683}
684
685static void
686header_print_comment(FILE *fp, const char *value, void *arg)
687{
688	const char *p = value;
689	size_t l;
690
691	fprintf(fp, "/*\n");
692	for (;;) {
693		l = strcspn(p, "\n");
694		fprintf(fp, " *");
695		if (l) {
696			fprintf(fp, " ");
697			xfwrite(p, l, 1, fp);
698			p += l;
699		}
700		fprintf(fp, "\n");
701		if (*p++ == '\0')
702			break;
703	}
704	fprintf(fp, " */\n");
705}
706
707static struct conf_printer header_printer_cb =
708{
709	.print_symbol = header_print_symbol,
710	.print_comment = header_print_comment,
711};
712
713static void conf_write_symbol(FILE *fp, struct symbol *sym,
714			      struct conf_printer *printer, void *printer_arg)
715{
716	const char *str;
717
718	switch (sym->type) {
719	case S_UNKNOWN:
720		break;
721	case S_STRING:
722		str = sym_get_string_value(sym);
723		str = sym_escape_string_value(str);
724		printer->print_symbol(fp, sym, str, printer_arg);
725		free((void *)str);
726		break;
727	default:
728		str = sym_get_string_value(sym);
729		printer->print_symbol(fp, sym, str, printer_arg);
730	}
731}
732
733static void
734conf_write_heading(FILE *fp, struct conf_printer *printer, void *printer_arg)
735{
736	char buf[256];
737
738	snprintf(buf, sizeof(buf),
739	    "\n"
740	    "Automatically generated file; DO NOT EDIT.\n"
741	    "%s\n",
742	    rootmenu.prompt->text);
743
744	printer->print_comment(fp, buf, printer_arg);
745}
746
747/*
748 * Write out a minimal config.
749 * All values that has default values are skipped as this is redundant.
750 */
751int conf_write_defconfig(const char *filename)
752{
753	struct symbol *sym;
754	struct menu *menu;
755	FILE *out;
756
757	out = fopen(filename, "w");
758	if (!out)
759		return 1;
760
761	sym_clear_all_valid();
762
763	/* Traverse all menus to find all relevant symbols */
764	menu = rootmenu.list;
765
766	while (menu != NULL)
767	{
768		sym = menu->sym;
769		if (sym == NULL) {
770			if (!menu_is_visible(menu))
771				goto next_menu;
772		} else if (!sym_is_choice(sym)) {
773			sym_calc_value(sym);
774			if (!(sym->flags & SYMBOL_WRITE))
775				goto next_menu;
776			sym->flags &= ~SYMBOL_WRITE;
777			/* If we cannot change the symbol - skip */
778			if (!sym_is_changeable(sym))
779				goto next_menu;
780			/* If symbol equals to default value - skip */
781			if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
782				goto next_menu;
783
784			/*
785			 * If symbol is a choice value and equals to the
786			 * default for a choice - skip.
787			 * But only if value is bool and equal to "y" and
788			 * choice is not "optional".
789			 * (If choice is "optional" then all values can be "n")
790			 */
791			if (sym_is_choice_value(sym)) {
792				struct symbol *cs;
793				struct symbol *ds;
794
795				cs = prop_get_symbol(sym_get_choice_prop(sym));
796				ds = sym_choice_default(cs);
797				if (!sym_is_optional(cs) && sym == ds) {
798					if ((sym->type == S_BOOLEAN) &&
799					    sym_get_tristate_value(sym) == yes)
800						goto next_menu;
801				}
802			}
803			conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
804		}
805next_menu:
806		if (menu->list != NULL) {
807			menu = menu->list;
808		}
809		else if (menu->next != NULL) {
810			menu = menu->next;
811		} else {
812			while ((menu = menu->parent)) {
813				if (menu->next != NULL) {
814					menu = menu->next;
815					break;
816				}
817			}
818		}
819	}
820	fclose(out);
821	return 0;
822}
823
824int conf_write(const char *name)
825{
826	FILE *out;
827	struct symbol *sym;
828	struct menu *menu;
829	const char *str;
830	char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1];
831	char *env;
832	int i;
833	bool need_newline = false;
834
835	if (!name)
836		name = conf_get_configname();
837
838	if (!*name) {
839		fprintf(stderr, "config name is empty\n");
840		return -1;
841	}
842
843	if (is_dir(name)) {
844		fprintf(stderr, "%s: Is a directory\n", name);
845		return -1;
846	}
847
848	if (make_parent_dir(name))
849		return -1;
850
851	env = getenv("KCONFIG_OVERWRITECONFIG");
852	if (env && *env) {
853		*tmpname = 0;
854		out = fopen(name, "w");
855	} else {
856		snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp",
857			 name, (int)getpid());
858		out = fopen(tmpname, "w");
859	}
860	if (!out)
861		return 1;
862
863	conf_write_heading(out, &kconfig_printer_cb, NULL);
864
865	if (!conf_get_changed())
866		sym_clear_all_valid();
867
868	menu = rootmenu.list;
869	while (menu) {
870		sym = menu->sym;
871		if (!sym) {
872			if (!menu_is_visible(menu))
873				goto next;
874			str = menu_get_prompt(menu);
875			fprintf(out, "\n"
876				     "#\n"
877				     "# %s\n"
878				     "#\n", str);
879			need_newline = false;
880		} else if (!(sym->flags & SYMBOL_CHOICE) &&
881			   !(sym->flags & SYMBOL_WRITTEN)) {
882			sym_calc_value(sym);
883			if (!(sym->flags & SYMBOL_WRITE))
884				goto next;
885			if (need_newline) {
886				fprintf(out, "\n");
887				need_newline = false;
888			}
889			sym->flags |= SYMBOL_WRITTEN;
890			conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
891		}
892
893next:
894		if (menu->list) {
895			menu = menu->list;
896			continue;
897		}
898		if (menu->next)
899			menu = menu->next;
900		else while ((menu = menu->parent)) {
901			if (!menu->sym && menu_is_visible(menu) &&
902			    menu != &rootmenu) {
903				str = menu_get_prompt(menu);
904				fprintf(out, "# end of %s\n", str);
905				need_newline = true;
906			}
907			if (menu->next) {
908				menu = menu->next;
909				break;
910			}
911		}
912	}
913	fclose(out);
914
915	for_all_symbols(i, sym)
916		sym->flags &= ~SYMBOL_WRITTEN;
917
918	if (*tmpname) {
919		if (is_same(name, tmpname)) {
920			conf_message("No change to %s", name);
921			unlink(tmpname);
922			sym_set_change_count(0);
923			return 0;
924		}
925
926		snprintf(oldname, sizeof(oldname), "%s.old", name);
927		rename(name, oldname);
928		if (rename(tmpname, name))
929			return 1;
930	}
931
932	conf_message("configuration written to %s", name);
933
934	sym_set_change_count(0);
935
936	return 0;
937}
938
939/* write a dependency file as used by kbuild to track dependencies */
940static int conf_write_dep(const char *name)
941{
942	struct file *file;
943	FILE *out;
944
945	out = fopen("..config.tmp", "w");
946	if (!out)
947		return 1;
948	fprintf(out, "deps_config := \\\n");
949	for (file = file_list; file; file = file->next) {
950		if (file->next)
951			fprintf(out, "\t%s \\\n", file->name);
952		else
953			fprintf(out, "\t%s\n", file->name);
954	}
955	fprintf(out, "\n%s: \\\n"
956		     "\t$(deps_config)\n\n", conf_get_autoconfig_name());
957
958	env_write_dep(out, conf_get_autoconfig_name());
959
960	fprintf(out, "\n$(deps_config): ;\n");
961	fclose(out);
962
963	if (make_parent_dir(name))
964		return 1;
965	rename("..config.tmp", name);
966	return 0;
967}
968
969static int conf_touch_deps(void)
970{
971	const char *name, *tmp;
972	struct symbol *sym;
973	int res, i;
974
975	name = conf_get_autoconfig_name();
976	tmp = strrchr(name, '/');
977	depfile_prefix_len = tmp ? tmp - name + 1 : 0;
978	if (depfile_prefix_len + 1 > sizeof(depfile_path))
979		return -1;
980
981	strncpy(depfile_path, name, depfile_prefix_len);
982	depfile_path[depfile_prefix_len] = 0;
983
984	conf_read_simple(name, S_DEF_AUTO);
985	sym_calc_value(modules_sym);
986
987	for_all_symbols(i, sym) {
988		sym_calc_value(sym);
989		if ((sym->flags & SYMBOL_NO_WRITE) || !sym->name)
990			continue;
991		if (sym->flags & SYMBOL_WRITE) {
992			if (sym->flags & SYMBOL_DEF_AUTO) {
993				/*
994				 * symbol has old and new value,
995				 * so compare them...
996				 */
997				switch (sym->type) {
998				case S_BOOLEAN:
999				case S_TRISTATE:
1000					if (sym_get_tristate_value(sym) ==
1001					    sym->def[S_DEF_AUTO].tri)
1002						continue;
1003					break;
1004				case S_STRING:
1005				case S_HEX:
1006				case S_INT:
1007					if (!strcmp(sym_get_string_value(sym),
1008						    sym->def[S_DEF_AUTO].val))
1009						continue;
1010					break;
1011				default:
1012					break;
1013				}
1014			} else {
1015				/*
1016				 * If there is no old value, only 'no' (unset)
1017				 * is allowed as new value.
1018				 */
1019				switch (sym->type) {
1020				case S_BOOLEAN:
1021				case S_TRISTATE:
1022					if (sym_get_tristate_value(sym) == no)
1023						continue;
1024					break;
1025				default:
1026					break;
1027				}
1028			}
1029		} else if (!(sym->flags & SYMBOL_DEF_AUTO))
1030			/* There is neither an old nor a new value. */
1031			continue;
1032		/* else
1033		 *	There is an old value, but no new value ('no' (unset)
1034		 *	isn't saved in auto.conf, so the old value is always
1035		 *	different from 'no').
1036		 */
1037
1038		res = conf_touch_dep(sym->name);
1039		if (res)
1040			return res;
1041	}
1042
1043	return 0;
1044}
1045
1046int conf_write_autoconf(int overwrite)
1047{
1048	struct symbol *sym;
1049	const char *name;
1050	const char *autoconf_name = conf_get_autoconfig_name();
1051	FILE *out, *out_h;
1052	int i;
1053
1054	if (!overwrite && is_present(autoconf_name))
1055		return 0;
1056
1057	conf_write_dep("include/config/auto.conf.cmd");
1058
1059	if (conf_touch_deps())
1060		return 1;
1061
1062	out = fopen(".tmpconfig", "w");
1063	if (!out)
1064		return 1;
1065
1066	out_h = fopen(".tmpconfig.h", "w");
1067	if (!out_h) {
1068		fclose(out);
1069		return 1;
1070	}
1071
1072	conf_write_heading(out, &kconfig_printer_cb, NULL);
1073	conf_write_heading(out_h, &header_printer_cb, NULL);
1074
1075	for_all_symbols(i, sym) {
1076		sym_calc_value(sym);
1077		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
1078			continue;
1079
1080		/* write symbols to auto.conf and autoconf.h */
1081		conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1);
1082		conf_write_symbol(out_h, sym, &header_printer_cb, NULL);
1083	}
1084	fclose(out);
1085	fclose(out_h);
1086
1087	name = getenv("KCONFIG_AUTOHEADER");
1088	if (!name)
1089		name = "include/generated/autoconf.h";
1090	if (make_parent_dir(name))
1091		return 1;
1092	if (rename(".tmpconfig.h", name))
1093		return 1;
1094
1095	if (make_parent_dir(autoconf_name))
1096		return 1;
1097	/*
1098	 * This must be the last step, kbuild has a dependency on auto.conf
1099	 * and this marks the successful completion of the previous steps.
1100	 */
1101	if (rename(".tmpconfig", autoconf_name))
1102		return 1;
1103
1104	return 0;
1105}
1106
1107static int sym_change_count;
1108static void (*conf_changed_callback)(void);
1109
1110void sym_set_change_count(int count)
1111{
1112	int _sym_change_count = sym_change_count;
1113	sym_change_count = count;
1114	if (conf_changed_callback &&
1115	    (bool)_sym_change_count != (bool)count)
1116		conf_changed_callback();
1117}
1118
1119void sym_add_change_count(int count)
1120{
1121	sym_set_change_count(count + sym_change_count);
1122}
1123
1124bool conf_get_changed(void)
1125{
1126	return sym_change_count;
1127}
1128
1129void conf_set_changed_callback(void (*fn)(void))
1130{
1131	conf_changed_callback = fn;
1132}
1133
1134static bool randomize_choice_values(struct symbol *csym)
1135{
1136	struct property *prop;
1137	struct symbol *sym;
1138	struct expr *e;
1139	int cnt, def;
1140
1141	/*
1142	 * If choice is mod then we may have more items selected
1143	 * and if no then no-one.
1144	 * In both cases stop.
1145	 */
1146	if (csym->curr.tri != yes)
1147		return false;
1148
1149	prop = sym_get_choice_prop(csym);
1150
1151	/* count entries in choice block */
1152	cnt = 0;
1153	expr_list_for_each_sym(prop->expr, e, sym)
1154		cnt++;
1155
1156	/*
1157	 * find a random value and set it to yes,
1158	 * set the rest to no so we have only one set
1159	 */
1160	def = (rand() % cnt);
1161
1162	cnt = 0;
1163	expr_list_for_each_sym(prop->expr, e, sym) {
1164		if (def == cnt++) {
1165			sym->def[S_DEF_USER].tri = yes;
1166			csym->def[S_DEF_USER].val = sym;
1167		}
1168		else {
1169			sym->def[S_DEF_USER].tri = no;
1170		}
1171		sym->flags |= SYMBOL_DEF_USER;
1172		/* clear VALID to get value calculated */
1173		sym->flags &= ~SYMBOL_VALID;
1174	}
1175	csym->flags |= SYMBOL_DEF_USER;
1176	/* clear VALID to get value calculated */
1177	csym->flags &= ~(SYMBOL_VALID);
1178
1179	return true;
1180}
1181
1182void set_all_choice_values(struct symbol *csym)
1183{
1184	struct property *prop;
1185	struct symbol *sym;
1186	struct expr *e;
1187
1188	prop = sym_get_choice_prop(csym);
1189
1190	/*
1191	 * Set all non-assinged choice values to no
1192	 */
1193	expr_list_for_each_sym(prop->expr, e, sym) {
1194		if (!sym_has_value(sym))
1195			sym->def[S_DEF_USER].tri = no;
1196	}
1197	csym->flags |= SYMBOL_DEF_USER;
1198	/* clear VALID to get value calculated */
1199	csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES);
1200}
1201
1202bool conf_set_all_new_symbols(enum conf_def_mode mode)
1203{
1204	struct symbol *sym, *csym;
1205	int i, cnt, pby, pty, ptm;	/* pby: probability of bool     = y
1206					 * pty: probability of tristate = y
1207					 * ptm: probability of tristate = m
1208					 */
1209
1210	pby = 50; pty = ptm = 33; /* can't go as the default in switch-case
1211				   * below, otherwise gcc whines about
1212				   * -Wmaybe-uninitialized */
1213	if (mode == def_random) {
1214		int n, p[3];
1215		char *env = getenv("KCONFIG_PROBABILITY");
1216		n = 0;
1217		while( env && *env ) {
1218			char *endp;
1219			int tmp = strtol( env, &endp, 10 );
1220			if( tmp >= 0 && tmp <= 100 ) {
1221				p[n++] = tmp;
1222			} else {
1223				errno = ERANGE;
1224				perror( "KCONFIG_PROBABILITY" );
1225				exit( 1 );
1226			}
1227			env = (*endp == ':') ? endp+1 : endp;
1228			if( n >=3 ) {
1229				break;
1230			}
1231		}
1232		switch( n ) {
1233		case 1:
1234			pby = p[0]; ptm = pby/2; pty = pby-ptm;
1235			break;
1236		case 2:
1237			pty = p[0]; ptm = p[1]; pby = pty + ptm;
1238			break;
1239		case 3:
1240			pby = p[0]; pty = p[1]; ptm = p[2];
1241			break;
1242		}
1243
1244		if( pty+ptm > 100 ) {
1245			errno = ERANGE;
1246			perror( "KCONFIG_PROBABILITY" );
1247			exit( 1 );
1248		}
1249	}
1250	bool has_changed = false;
1251
1252	for_all_symbols(i, sym) {
1253		if (sym_has_value(sym) || (sym->flags & SYMBOL_VALID))
1254			continue;
1255		switch (sym_get_type(sym)) {
1256		case S_BOOLEAN:
1257		case S_TRISTATE:
1258			has_changed = true;
1259			switch (mode) {
1260			case def_yes:
1261				sym->def[S_DEF_USER].tri = yes;
1262				break;
1263			case def_mod:
1264				sym->def[S_DEF_USER].tri = mod;
1265				break;
1266			case def_no:
1267				if (sym->flags & SYMBOL_ALLNOCONFIG_Y)
1268					sym->def[S_DEF_USER].tri = yes;
1269				else
1270					sym->def[S_DEF_USER].tri = no;
1271				break;
1272			case def_random:
1273				sym->def[S_DEF_USER].tri = no;
1274				cnt = rand() % 100;
1275				if (sym->type == S_TRISTATE) {
1276					if (cnt < pty)
1277						sym->def[S_DEF_USER].tri = yes;
1278					else if (cnt < (pty+ptm))
1279						sym->def[S_DEF_USER].tri = mod;
1280				} else if (cnt < pby)
1281					sym->def[S_DEF_USER].tri = yes;
1282				break;
1283			default:
1284				continue;
1285			}
1286			if (!(sym_is_choice(sym) && mode == def_random))
1287				sym->flags |= SYMBOL_DEF_USER;
1288			break;
1289		default:
1290			break;
1291		}
1292
1293	}
1294
1295	sym_clear_all_valid();
1296
1297	/*
1298	 * We have different type of choice blocks.
1299	 * If curr.tri equals to mod then we can select several
1300	 * choice symbols in one block.
1301	 * In this case we do nothing.
1302	 * If curr.tri equals yes then only one symbol can be
1303	 * selected in a choice block and we set it to yes,
1304	 * and the rest to no.
1305	 */
1306	if (mode != def_random) {
1307		for_all_symbols(i, csym) {
1308			if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
1309			    sym_is_choice_value(csym))
1310				csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
1311		}
1312	}
1313
1314	for_all_symbols(i, csym) {
1315		if (sym_has_value(csym) || !sym_is_choice(csym))
1316			continue;
1317
1318		sym_calc_value(csym);
1319		if (mode == def_random)
1320			has_changed |= randomize_choice_values(csym);
1321		else {
1322			set_all_choice_values(csym);
1323			has_changed = true;
1324		}
1325	}
1326
1327	return has_changed;
1328}
1329
1330void conf_rewrite_mod_or_yes(enum conf_def_mode mode)
1331{
1332	struct symbol *sym;
1333	int i;
1334	tristate old_val = (mode == def_y2m) ? yes : mod;
1335	tristate new_val = (mode == def_y2m) ? mod : yes;
1336
1337	for_all_symbols(i, sym) {
1338		if (sym_get_type(sym) == S_TRISTATE &&
1339		    sym->def[S_DEF_USER].tri == old_val)
1340			sym->def[S_DEF_USER].tri = new_val;
1341	}
1342	sym_clear_all_valid();
1343}
1344