resconf.c

bind-3.2.

		r = idn_checker_add(ctx->prohibit_checker, long_name);
		if (r != idn_success)
			return (r);
	}

	return (idn_success);
}

idn_result_t
idn_resconf_addallunassignedcheckernames(idn_resconf_t ctx, const char **names,
					 int nnames) {
	char long_name[MAX_CONF_LINE_LENGTH + 1];
	idn_result_t r;
	int i;

	assert(ctx != NULL && names != NULL);

	TRACE(("idn_resconf_addallunassignedcheckername(nnames=%d)\n",
	      nnames));

	if (ctx->unassigned_checker == NULL) {
		r = idn_checker_create(&(ctx->unassigned_checker));
		if (r != idn_success)
			return (r);
	}

	for (i = 0; i < nnames; i++, names++) {
		if (strlen(*names) + strlen(IDN_CHECKER_UNASSIGNED_PREFIX)
			> MAX_CONF_LINE_LENGTH) {
			return (idn_invalid_name);
		}
		strcpy(long_name, IDN_CHECKER_UNASSIGNED_PREFIX);
		strcat(long_name, *names);

		r = idn_checker_add(ctx->unassigned_checker, long_name);
		if (r != idn_success)
			return (r);
	}

	return (idn_success);
}

idn_result_t
idn_resconf_addallbidicheckernames(idn_resconf_t ctx, const char **names,
				   int nnames) {
	char long_name[MAX_CONF_LINE_LENGTH + 1];
	idn_result_t r;
	int i;

	assert(ctx != NULL && names != NULL);

	TRACE(("idn_resconf_addallbidicheckername(nnames=%d)\n", nnames));

	if (ctx->bidi_checker == NULL) {
		r = idn_checker_create(&(ctx->bidi_checker));
		if (r != idn_success)
			return (r);
	}

	for (i = 0; i < nnames; i++, names++) {
		if (strlen(*names) + strlen(IDN_CHECKER_BIDI_PREFIX)
			> MAX_CONF_LINE_LENGTH) {
			return (idn_invalid_name);
		}
		strcpy(long_name, IDN_CHECKER_BIDI_PREFIX);
		strcat(long_name, *names);

		r = idn_checker_add(ctx->bidi_checker, long_name);
		if (r != idn_success)
			return (r);
	}

	return (idn_success);
}

static idn_result_t
parse_conf(idn_resconf_t ctx, FILE *fp) {
	char line[MAX_CONF_LINE_LENGTH + 1];
	int lineno = 0;
	char *argv[3];
	int argc;
	idn_result_t r;
	int conf_mask = 0;

	TRACE(("parse_conf()\n"));

	/*
	 * Parse config file.  parsing of 'idn-encoding' line is
	 * postponed because 'alias-file' line must be processed
	 * before them.
	 */
	while (fgets(line, sizeof(line), fp) != NULL) {
		char *newline;

		lineno++;
		newline = strpbrk(line, "\r\n");
		if (newline != NULL)
			*newline = '\0';
		else if (fgetc(fp) != EOF) {
			ERROR(("libidnkit: too long line \"%-.30s\", "
			       "line %d\n", line, lineno));
			return (idn_invalid_syntax);
		}

		argc = split_args(line, argv, 2);
		if (argc == -1) {
			ERROR(("libidnkit: syntax error, line %d\n", lineno));
			return (idn_invalid_syntax);
		} else if (argc == 0 || argv[0][0] == '#') {
			continue;
		} else if (argc == 1) {
			ERROR(("libidnkit: syntax error, line %d\n", lineno));
			return (idn_invalid_syntax);
		}

		if (strcmp(argv[0], "idn-encoding") == 0) {
			if (conf_mask & DEFAULT_CONF_IDN_ENCODING) {
				ERROR(("libidnkit: \"%s\" redefined, "
				       "line %d\n", argv[0], lineno));
				r = idn_invalid_syntax;
			} else {
				conf_mask |= DEFAULT_CONF_IDN_ENCODING;
				r = parse_idn_encoding(ctx, argv[1], lineno);
			}
		} else if (strcmp(argv[0], "local-map") == 0) {
			r = parse_local_map(ctx, argv[1], lineno);

		} else if (strcmp(argv[0], "nameprep") == 0) {
			if (conf_mask & DEFAULT_CONF_NAMEPREP) {
				ERROR(("libidnkit: \"%s\" redefined, "
				       "line %d\n", argv[0], lineno));
				r = idn_invalid_syntax;
			} else {
				conf_mask |= DEFAULT_CONF_NAMEPREP;
				r = parse_nameprep(ctx, argv[1], lineno);
			}
		} else if (strcmp(argv[0], "nameprep-map") == 0 ||
			   strcmp(argv[0], "nameprep-normalize") == 0 ||
			   strcmp(argv[0], "nameprep-prohibit") == 0 ||
			   strcmp(argv[0], "nameprep-unassigned") == 0 ||
			   strcmp(argv[0], "alias-file") == 0 ||
			   strcmp(argv[0], "encoding-alias-file") == 0 ||
			   strcmp(argv[0], "normalize") == 0 ||
			   strcmp(argv[0], "server-encoding") == 0 ||
		           strcmp(argv[0], "alternate-encoding") == 0 ||
			   strcmp(argv[0], "delimiter-map") == 0) {
			WARNING(("libidnkit: obsolete command \"%s\", line %d "
			         "(ignored)\n", argv[0], lineno));
			r = idn_success;
		} else {
			ERROR(("libidnkit: unknown command \"%-.30s\", "
			       "line %d\n", argv[0], lineno));
			r = idn_invalid_syntax;
		}
		if (r != idn_success)
			return (r);
	}

	lineno++;

	if (conf_mask != DEFAULT_CONF_ALL) {
		return setdefaults_body(ctx, conf_mask);
	}

	return (idn_success);
}

static idn_result_t
parse_idn_encoding(idn_resconf_t ctx, char *args, int lineno) {
	idn_result_t r;
	char *argv[MAX_CONF_LINE_ARGS + 1];
	int argc;

	argc = split_args(args, argv, MAX_CONF_LINE_ARGS + 1);

	if (argc != 1) {
		ERROR(("libidnkit: wrong # of args for idn-encoding, "
		       "line %d\n", lineno));
		return (idn_invalid_syntax);
	}

	r = idn_converter_create(argv[0], &ctx->idn_converter,
				 IDN_CONVERTER_DELAYEDOPEN |
				 IDN_CONVERTER_RTCHECK);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create idn converter, %s, "
		       "line %d\n", idn_result_tostring(r), lineno));
	}

	return (r);
}

static idn_result_t
parse_local_map(idn_resconf_t ctx, char *args, int lineno) {
	idn_result_t r;
	char *argv[MAX_CONF_LINE_ARGS + 1];
	int argc;
	int i;

	argc = split_args(args, argv, MAX_CONF_LINE_ARGS + 1);

	if (argc < 2 || argc > MAX_CONF_LINE_ARGS) {
		ERROR(("libidnkit: wrong # of args for local-map, line %d\n",
		       lineno));
		return (idn_invalid_syntax);
	}

	if (ctx->local_mapper == NULL) {
		r = idn_mapselector_create(&ctx->local_mapper);
		if (r != idn_success) {
			ERROR(("libidnkit: cannot create local mapper, %s, "
			       "line %d\n", idn_result_tostring(r), lineno));
			return (r);
		}
	}

	for (i = 1; i < argc; i++) {
		r = idn_mapselector_add(ctx->local_mapper, argv[0], argv[i]);
		if (r == idn_invalid_name) {
			ERROR(("libidnkit: map scheme unavailable \"%-.30s\""
			       " or invalid TLD \"%-.30s\", line %d\n",
			       argv[i], argv[0], lineno));
			return (r);
		} else if (r != idn_success) {
			return (r);
		}
	}

	return (idn_success);
}

static idn_result_t
parse_nameprep(idn_resconf_t ctx, char *args, int lineno) {
	idn_result_t r;
	char *argv[MAX_CONF_LINE_ARGS + 1];
	char scheme_name[MAX_CONF_LINE_LENGTH + 1];
	int argc;

	argc = split_args(args, argv, MAX_CONF_LINE_ARGS + 1);

	if (argc != 1) {
		ERROR(("libidnkit: wrong # of args for nameprep, line %d\n",
		       lineno));
		return (idn_invalid_syntax);
	}

	/*
	 * Set mapper.
	 */
	r = idn_mapper_create(&ctx->mapper);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create mapper, %s, line %d\n",
		       idn_result_tostring(r), lineno));
		return (r);
	}

	r = idn_mapper_add(ctx->mapper, argv[0]);
	if (r == idn_invalid_name) {
		ERROR(("libidnkit: map scheme unavailable \"%-.30s\", "
		       "line %d\n", argv[0], lineno));
		return (r);
	} else if (r != idn_success) {
		return (r);
	}

	/*
	 * Set normalizer.
	 */
	r = idn_normalizer_create(&ctx->normalizer);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create normalizer, %s, line %d\n",
		       idn_result_tostring(r), lineno));
		return (r);
	}

	r = idn_normalizer_add(ctx->normalizer, argv[0]);
	if (r == idn_invalid_name) {
		ERROR(("libidnkit: unknown normalization scheme \"%-.30s\", "
		       "line %d\n", argv[0], lineno));
		return (r);
	} else if (r != idn_success) {
		return (r);
	}

	/*
	 * Set prohibit checker.
	 */
	r = idn_checker_create(&ctx->prohibit_checker);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create prohibit checker, %s, "
		       "line %d\n", idn_result_tostring(r), lineno));
		return (r);
	}

	sprintf(scheme_name, "%s%s", IDN_CHECKER_PROHIBIT_PREFIX, argv[0]);
	r = idn_checker_add(ctx->prohibit_checker, scheme_name);
	if (r == idn_invalid_name) {
		ERROR(("libidnkit: unknown prohibit scheme \"%-.30s\", "
		       "line %d\n", argv[0], lineno));
		return (r);
	} else if (r != idn_success) {
		return (r);
	}

	/*
	 * Set unassigned checker.
	 */
	r = idn_checker_create(&ctx->unassigned_checker);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create unassigned checker, %s, "
		       "line %d\n", idn_result_tostring(r), lineno));
		return (r);
	}

	sprintf(scheme_name, "%s%s", IDN_CHECKER_UNASSIGNED_PREFIX, argv[0]);
	r = idn_checker_add(ctx->unassigned_checker, scheme_name);
	if (r == idn_invalid_name) {
		ERROR(("libidnkit: unknown unassigned scheme \"%-.30s\", "
		       "line %d\n", argv[0], lineno));
		return (r);
	} else if (r != idn_success) {
		return (r);
	}

	/*
	 * Set bidi checker.
	 */
	r = idn_checker_create(&ctx->bidi_checker);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create bidi checker, %s, line %d\n",
		       idn_result_tostring(r), lineno));
		return (r);
	}

	sprintf(scheme_name, "%s%s", IDN_CHECKER_BIDI_PREFIX, argv[0]);
	r = idn_checker_add(ctx->bidi_checker, scheme_name);
	if (r == idn_invalid_name) {
		ERROR(("libidnkit: unknown bidi scheme \"%-.30s\", "
		       "line %d\n", argv[0], lineno));
		return (r);
	} else if (r != idn_success) {
		return (r);
	}

	return (idn_success);
}

static int
split_args(char *s, char **av, int max_ac) {
	int ac;
	int i;

	for (ac = 0; *s != '\0' && ac < max_ac; ac++) {
		if (ac > 0)
			*s++ = '\0';
		while (isspace((unsigned char)*s))
			s++;
		if (*s == '\0')
			break;
		if (*s == '"' || *s == '\'') {
			int qc = *s++;
			av[ac] = s;
			while (*s != qc) {
				if (*s == '\0')
					return (-1);
				s++;
			}
		} else {
			av[ac] = s;
			while (*s != '\0' && !isspace((unsigned char)*s))
				s++;
		}
	}

	for (i = ac; i < max_ac; i++)
		av[i] = NULL;

	return (ac);
}

static void
resetconf(idn_resconf_t ctx) {
#ifndef WITHOUT_ICONV
	idn_resconf_setlocalconverter(ctx, NULL);
#endif
	idn_resconf_setidnconverter(ctx, NULL);
	idn_resconf_setauxidnconverter(ctx, NULL);
	idn_resconf_setdelimitermap(ctx, NULL);
	idn_resconf_setlocalmapselector(ctx, NULL);
	idn_resconf_setmapper(ctx, NULL);
	idn_resconf_setnormalizer(ctx, NULL);
	idn_resconf_setprohibitchecker(ctx, NULL);
	idn_resconf_setunassignedchecker(ctx, NULL);
	idn_resconf_setbidichecker(ctx, NULL);
}

#ifndef WITHOUT_ICONV
static idn_result_t
update_local_converter(idn_resconf_t ctx) {
	idn_result_t r;
	const char *old_encoding;
	const char *new_encoding;

	/*
	 * We don't update local converter, if the converter is set
	 * by idn_resconf_setlocalconverter() or
	 * idn_resconf_setlocalconvertername().
	 */
	if (ctx->local_converter_is_static)
		return (idn_success);

	/*
	 * Update the local converter if the local encoding is changed.
	 */
	old_encoding = (ctx->local_converter != NULL) ?
		       idn_converter_localencoding(ctx->local_converter) :
		       NULL;
	new_encoding = idn_localencoding_name();
	if (new_encoding == NULL) {
		ERROR(("cannot determine local codeset name\n"));
		return (idn_notfound);
	}

	if (old_encoding != NULL &&
	    new_encoding != NULL &&
	    strcmp(old_encoding, new_encoding) == 0) {
		return (idn_success);
	}

	if (ctx->local_converter != NULL) {
		idn_converter_destroy(ctx->local_converter);
		ctx->local_converter = NULL;
	}

	r = idn_converter_create(new_encoding,
				 &ctx->local_converter,
				 IDN_CONVERTER_RTCHECK);
	return (r);
}
#endif

idn_result_t
idn_resconf_setdefaults(idn_resconf_t ctx)
{
	idn_result_t r;

	assert(ctx != NULL);

	TRACE(("idn_resconf_setdefaults()\n"));

	resetconf(ctx);
	r = idn_delimitermap_create(&ctx->delimiter_mapper);
	if (r != idn_success) {
		ERROR(("libidnkit: cannot create delimiter mapper, %s\n",
		       idn_result_tostring(r)));
		return (r);
	}

	return setdefaults_body(ctx, 0);
}

static idn_result_t
setdefaults_body(idn_resconf_t ctx, int conf_mask) {
	idn_result_t r;

	TRACE(("setdefaults_body()\n"));
	assert(ctx != NULL);

	if (!(conf_mask & DEFAULT_CONF_NAMEPREP)) {
		TRACE(("set default nameprep\n"));
		r = idn_resconf_setnameprepversion(ctx, IDN_NAMEPREP_CURRENT);
		if (r != idn_success) {
			return (r);
		}
	}
	if (!(conf_mask & DEFAULT_CONF_IDN_ENCODING)) {
		TRACE(("set default idn encoding\n"));
		r = idn_converter_create(IDN_ENCODING_CURRENT,
					 &ctx->idn_converter,
					 IDN_CONVERTER_DELAYEDOPEN |
					 IDN_CONVERTER_RTCHECK);
		if (r != idn_success) {
			ERROR(("libidnkit: cannot create idn converter, %s\n",
			       idn_result_tostring(r)));
			return (r);
		}
	}

	return (idn_success);
}