#ifndef lint

static char *rcsid = "$Id: resconf.c,v 1.1 2003/06/04 00:26:12 marka Exp $";

#endif

/*

 * Copyright (c) 2000 Japan Network Information Center.  All rights reserved.

 *  

 * By using this file, you agree to the terms and conditions set forth bellow.

 * 

 * 			LICENSE TERMS AND CONDITIONS 

 * 

 * The following License Terms and Conditions apply, unless a different

 * license is obtained from Japan Network Information Center ("JPNIC"),

 * a Japanese association, Kokusai-Kougyou-Kanda Bldg 6F, 2-3-4 Uchi-Kanda,

 * Chiyoda-ku, Tokyo 101-0047, Japan.

 * 

 * 1. Use, Modification and Redistribution (including distribution of any

 *    modified or derived work) in source and/or binary forms is permitted

 *    under this License Terms and Conditions.

 * 

 * 2. Redistribution of source code must retain the copyright notices as they

 *    appear in each source code file, this License Terms and Conditions.

 * 

 * 3. Redistribution in binary form must reproduce the Copyright Notice,

 *    this License Terms and Conditions, in the documentation and/or other

 *    materials provided with the distribution.  For the purposes of binary

 *    distribution the "Copyright Notice" refers to the following language:

 *    "Copyright (c) 2000-2002 Japan Network Information Center.  All rights reserved."

 * 

 * 4. The name of JPNIC may not be used to endorse or promote products

 *    derived from this Software without specific prior written approval of

 *    JPNIC.

 * 

 * 5. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY JPNIC

 *    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

 *    PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL JPNIC BE LIABLE

 *    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

 *    BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 *    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 *    OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 *    ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

 */

#include <config.h>

#include <stddef.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_PWD_H

#include <pwd.h>

#endif

#include <idn/result.h>

#include <idn/assert.h>

#include <idn/logmacro.h>

#include <idn/converter.h>

#include <idn/nameprep.h>

#include <idn/normalizer.h>

#include <idn/checker.h>

#include <idn/mapper.h>

#include <idn/mapselector.h>

#include <idn/delimitermap.h>

#include <idn/localencoding.h>

#include <idn/resconf.h>

#include <idn/debug.h>

#include <idn/util.h>

#ifdef WIN32

#define MAX_PATH_SIZE		500	/* a good longer than MAX_PATH */

#define IDNVAL_CONFFILE		"ConfFile"

#else /* WIN32 */

#ifndef IDN_RESCONF_DIR

#define IDN_RESCONF_DIR		"/etc"

#endif

#define IDN_RESCONF_FILE	IDN_RESCONF_DIR "/idn.conf"

#define IDN_USER_RESCONF_FILE	"/.idnrc"

#endif /* WIN32 */

#define MAX_CONF_LINE_LENGTH	255

#define MAX_CONF_LINE_ARGS	63

#define DEFAULT_CONF_NAMEPREP		0x0001

#define DEFAULT_CONF_IDN_ENCODING	0x0010

#define DEFAULT_CONF_ALL		(DEFAULT_CONF_NAMEPREP | \

					DEFAULT_CONF_IDN_ENCODING)

#define IDN_ENCODING_CURRENT	"Punycode"

#ifdef ENABLE_MDNKIT_COMPAT

#define MDN_RESCONF_FILE	IDN_RESCONF_DIR "/mdn.conf"

#endif

struct idn_resconf {

	int local_converter_is_static;

	idn_converter_t local_converter;

	idn_converter_t idn_converter;

        idn_converter_t aux_idn_converter;

	idn_normalizer_t normalizer;

	idn_checker_t prohibit_checker;

	idn_checker_t unassigned_checker;

	idn_checker_t bidi_checker;

	idn_mapper_t mapper;

	idn_mapselector_t local_mapper;

	idn_delimitermap_t delimiter_mapper;

	int reference_count;

};

static int initialized;

#ifndef WIN32

static const char *	userhomedir(void);

#endif

static idn_result_t	open_userdefaultfile(FILE **fpp);

static idn_result_t	open_defaultfile(FILE **fpp);

static idn_result_t	parse_conf(idn_resconf_t ctx, FILE *fp);

static idn_result_t	parse_idn_encoding(idn_resconf_t ctx, char *args,

					   int lineno);

static idn_result_t	parse_local_map(idn_resconf_t ctx, char *args,

					int lineno);

static idn_result_t	parse_nameprep(idn_resconf_t ctx, char *args,

				       int lineno);

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

static void		resetconf(idn_resconf_t ctx);

#ifndef WITHOUT_ICONV

static idn_result_t	update_local_converter(idn_resconf_t ctx);

#endif

static idn_result_t	setdefaults_body(idn_resconf_t ctx, int conf_mask);

idn_result_t

idn_resconf_initialize(void) {

	idn_result_t r;

	TRACE(("idn_resconf_initialize()\n"));

	if (initialized) {

		r = idn_success;

		goto ret;

	}

	/*

	 * Initialize sub modules.

	 */

	if ((r = idn_converter_initialize()) != idn_success)

		goto ret;

	if ((r = idn_normalizer_initialize()) != idn_success)

		goto ret;

	if ((r = idn_checker_initialize()) != idn_success)

		goto ret;

	if ((r = idn_mapselector_initialize()) != idn_success)

		goto ret;

	if ((r = idn_mapper_initialize()) != idn_success)

		goto ret;

	r = idn_success;

	initialized = 1;

ret:

	TRACE(("idn_resconf_initialize(): %s\n", idn_result_tostring(r)));

	return (r);

}

idn_result_t

idn_resconf_create(idn_resconf_t *ctxp) {

	idn_resconf_t ctx = NULL;

	idn_result_t r;

	assert(ctxp != NULL);

	TRACE(("idn_resconf_create()\n"));

	if (!initialized) {

		r = idn_failure;

		goto ret;

	}

	if ((ctx = malloc(sizeof(*ctx))) == NULL) {

		r = idn_nomemory;

		goto ret;

	}

	ctx->local_converter_is_static = 0;

	ctx->local_converter = NULL;

	ctx->idn_converter = NULL;

	ctx->aux_idn_converter = NULL;

	ctx->normalizer = NULL;

	ctx->prohibit_checker = NULL;

	ctx->unassigned_checker = NULL;

	ctx->bidi_checker = NULL;

	ctx->mapper = NULL;

	ctx->local_mapper = NULL;

	ctx->reference_count = 1;

	r = idn_delimitermap_create(&ctx->delimiter_mapper);

	if (r != idn_success)

		goto ret;

	*ctxp = ctx;

	r = idn_success;

ret:

	TRACE(("idn_resconf_create(): %s\n", idn_result_tostring(r)));

	return (r);

}

char *

idn_resconf_defaultfile() {

#ifdef WIN32

	static char default_path[MAX_PATH_SIZE];

	if (idn__util_getregistrystring(idn__util_hkey_localmachine,

					IDNVAL_CONFFILE, default_path,

					sizeof(default_path))) {

		return (default_path);

	} else {

		return (NULL);

	}

#else

	return (IDN_RESCONF_FILE);

#endif

}

#ifndef WIN32

static const char *

userhomedir() {

	uid_t uid;

	struct passwd *pwd;

	uid = getuid();

	pwd = getpwuid(uid);

	if (pwd == NULL) {

		return (NULL);

	}

	return (pwd->pw_dir);

}

#endif

static idn_result_t

open_userdefaultfile(FILE **fpp) {

#ifdef WIN32

	char user_path[MAX_PATH_SIZE];

	TRACE(("open_userdefaultfile()\n"));

	if (idn__util_getregistrystring(idn__util_hkey_currentuser,

					IDNVAL_CONFFILE, user_path,

					sizeof(user_path)) == 0) {

		return (idn_nofile);

	}

	*fpp = fopen(user_path, "r");

	if (*fpp == NULL) {

		return (idn_nofile);

	}

	return (idn_success);

#else /* WIN32 */

	const char *homedir;

	char *file;

	int len;

	TRACE(("open_userdefaultfile()\n"));

	homedir = userhomedir();

	len = strlen(IDN_USER_RESCONF_FILE) + 1;

	if (homedir != NULL) {

		len += strlen(homedir);

	} else {

		return (idn_notfound);

	}

	file = (char *)malloc(sizeof(char) * len);

	if (file == NULL) {

		WARNING(("open_userdefaultfile(): malloc failed\n"));

		return (idn_nomemory);

	}

	(void)strcpy(file, homedir);

	strcat(file, IDN_USER_RESCONF_FILE);

	*fpp = fopen(file, "r");

	free(file);

	if (*fpp == NULL) {

		return (idn_nofile);

	}

	return (idn_success);

#endif /* WIN32 */

}

static idn_result_t

open_defaultfile(FILE **fpp) {

	idn_result_t r;

	const char *file;

	r = open_userdefaultfile(fpp);

	if (r == idn_nofile || r == idn_notfound) {

		TRACE(("open_defaultfile: "

		       "cannot open user configuration file\n"));

		file = idn_resconf_defaultfile();

		*fpp = fopen(file, "r");

#ifdef ENABLE_MDNKIT_COMPAT

		if (*fpp == NULL)

			*fpp = fopen(MDN_RESCONF_FILE, "r");

#endif

		if (*fpp == NULL) {

			TRACE(("open_defaultfile: "

			       "cannot open system configuration file\n"));

			return (idn_nofile);

		}

	} else if (r != idn_success) {

		return (r);

	}

	return (idn_success);

}

idn_result_t

idn_resconf_loadfile(idn_resconf_t ctx, const char *file) {

	FILE *fp = NULL;

	idn_result_t r;

	assert(ctx != NULL);

	TRACE(("idn_resconf_loadfile(file=%s)\n",

	      file == NULL ? "<null>" : file));

	resetconf(ctx);

	r = idn_delimitermap_create(&ctx->delimiter_mapper);

	if (r != idn_success) {

		goto ret;

	}

	if (file == NULL) {

		r = open_defaultfile(&fp);

		if (r == idn_nofile || r == idn_notfound) {

			r = setdefaults_body(ctx, 0);

			goto ret;

		} else if (r != idn_success) {

			goto ret;

		}

	} else {

		fp = fopen(file, "r");

		if (fp == NULL) {

			TRACE(("idn_resconf_loadfile: cannot open %-.40s\n",

			       file));

			r = idn_nofile;

			goto ret;

		}

	}

	r = parse_conf(ctx, fp);

	fclose(fp);

ret:

	TRACE(("idn_resconf_loadfile(): %s\n", idn_result_tostring(r)));

	return (r);

}

void

idn_resconf_destroy(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_destroy()\n"));

	ctx->reference_count--;

	if (ctx->reference_count <= 0) {

		resetconf(ctx);

		free(ctx);

		TRACE(("idn_resconf_destroy: the object is destroyed\n"));

	} else {

		TRACE(("idn_resconf_destroy(): "

		       "update reference count (%d->%d)\n",

		       ctx->reference_count + 1, ctx->reference_count));

	}

}

void

idn_resconf_incrref(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_incrref()\n"));

	TRACE(("idn_resconf_incrref: update reference count (%d->%d)\n",

		ctx->reference_count, ctx->reference_count + 1));

	ctx->reference_count++;

}

idn_converter_t

idn_resconf_getalternateconverter(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getalternateconverter()\n"));

	return (idn_resconf_getidnconverter(ctx));

}

idn_delimitermap_t

idn_resconf_getdelimitermap(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getdelimitermap()\n"));

	if (ctx->delimiter_mapper != NULL)

		idn_delimitermap_incrref(ctx->delimiter_mapper);

	return (ctx->delimiter_mapper);

}

idn_converter_t

idn_resconf_getidnconverter(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getidnconverter()\n"));

	if (ctx->idn_converter != NULL)

		idn_converter_incrref(ctx->idn_converter);

	return (ctx->idn_converter);

}

idn_converter_t

idn_resconf_getauxidnconverter(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getauxidnconverter()\n"));

	if (ctx->aux_idn_converter != NULL)

		idn_converter_incrref(ctx->aux_idn_converter);

	return (ctx->aux_idn_converter);

}

idn_converter_t

idn_resconf_getlocalconverter(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getlocalconverter()\n"));

#ifdef WITHOUT_ICONV

	return NULL;

#else /* WITHOUT_ICONV */

	if (update_local_converter(ctx) != idn_success)

		return (NULL);

	idn_converter_incrref(ctx->local_converter);

	return (ctx->local_converter);

#endif /* WITHOUT_ICONV */

}

idn_mapselector_t

idn_resconf_getlocalmapselector(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getlocalmapselector()\n"));

	if (ctx->local_mapper != NULL)

		idn_mapselector_incrref(ctx->local_mapper);

	return (ctx->local_mapper);

}

idn_mapper_t

idn_resconf_getmapper(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getmapper()\n"));

	if (ctx->mapper != NULL)

		idn_mapper_incrref(ctx->mapper);

	return (ctx->mapper);

}

idn_normalizer_t

idn_resconf_getnormalizer(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getnormalizer()\n"));

	if (ctx->normalizer != NULL)

		idn_normalizer_incrref(ctx->normalizer);

	return (ctx->normalizer);

}

idn_checker_t

idn_resconf_getprohibitchecker(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getprohibitchecker()\n"));

	if (ctx->prohibit_checker != NULL)

		idn_checker_incrref(ctx->prohibit_checker);

	return (ctx->prohibit_checker);

}

idn_checker_t

idn_resconf_getunassignedchecker(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getunassignedchecker()\n"));

	if (ctx->unassigned_checker != NULL)

		idn_checker_incrref(ctx->unassigned_checker);

	return (ctx->unassigned_checker);

}

idn_checker_t

idn_resconf_getbidichecker(idn_resconf_t ctx) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_getbidichecker()\n"));

	if (ctx->bidi_checker != NULL)

		idn_checker_incrref(ctx->bidi_checker);

	return (ctx->bidi_checker);

}

void

idn_resconf_setalternateconverter(idn_resconf_t ctx,

				  idn_converter_t alternate_converter) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setalternateconverter()\n"));

}

void

idn_resconf_setdelimitermap(idn_resconf_t ctx,

			    idn_delimitermap_t delimiter_mapper) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setdelimitermap()\n"));

	if (ctx->delimiter_mapper != NULL)

		idn_delimitermap_destroy(ctx->delimiter_mapper);

	ctx->delimiter_mapper = delimiter_mapper;

	if (delimiter_mapper != NULL)

		idn_delimitermap_incrref(ctx->delimiter_mapper);

}

void

idn_resconf_setidnconverter(idn_resconf_t ctx, 

			    idn_converter_t idn_converter) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setidnconverter()\n"));

	if (ctx->idn_converter != NULL)

		idn_converter_destroy(ctx->idn_converter);

	ctx->idn_converter = idn_converter;

	if (idn_converter != NULL)

		idn_converter_incrref(ctx->idn_converter);

}

void

idn_resconf_setauxidnconverter(idn_resconf_t ctx,

				idn_converter_t aux_idn_converter) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setauxidnconverter()\n"));

	if (ctx->aux_idn_converter != NULL)

		idn_converter_destroy(ctx->aux_idn_converter);

	ctx->aux_idn_converter = aux_idn_converter;

	if (aux_idn_converter != NULL)

		idn_converter_incrref(ctx->aux_idn_converter);

}

void

idn_resconf_setlocalconverter(idn_resconf_t ctx,

			      idn_converter_t local_converter) {

#ifndef WITHOUT_ICONV

	assert(ctx != NULL);

	TRACE(("idn_resconf_setlocalconverter()\n"));

	if (ctx->local_converter != NULL) {

		idn_converter_destroy(ctx->local_converter);

		ctx->local_converter = NULL;

	}

	if (local_converter == NULL)

		ctx->local_converter_is_static = 0;

	else {

		ctx->local_converter = local_converter;

		idn_converter_incrref(local_converter);

		ctx->local_converter_is_static = 1;

	}

#endif /* WITHOUT_ICONV */

}

void

idn_resconf_setlocalmapselector(idn_resconf_t ctx,

				idn_mapselector_t local_mapper) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setlocalmapselector()\n"));

	if (ctx->local_mapper != NULL)

		idn_mapselector_destroy(ctx->local_mapper);

	ctx->local_mapper = local_mapper;

	if (local_mapper != NULL)

		idn_mapselector_incrref(ctx->local_mapper);

}

void

idn_resconf_setmapper(idn_resconf_t ctx, idn_mapper_t mapper) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setmapper()\n"));

	if (ctx->mapper != NULL)

		idn_mapper_destroy(ctx->mapper);

	ctx->mapper = mapper;

	if (mapper != NULL)

		idn_mapper_incrref(ctx->mapper);

}

void

idn_resconf_setnormalizer(idn_resconf_t ctx, idn_normalizer_t normalizer) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setnormalizer()\n"));

	if (ctx->normalizer != NULL)

		idn_normalizer_destroy(ctx->normalizer);

	ctx->normalizer = normalizer;

	if (normalizer != NULL)

		idn_normalizer_incrref(ctx->normalizer);

}

void

idn_resconf_setprohibitchecker(idn_resconf_t ctx,

			       idn_checker_t prohibit_checker) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setprohibitchecker()\n"));

	if (ctx->prohibit_checker != NULL)

		idn_checker_destroy(ctx->prohibit_checker);

	ctx->prohibit_checker = prohibit_checker;

	if (prohibit_checker != NULL)

		idn_checker_incrref(ctx->prohibit_checker);

}

void

idn_resconf_setunassignedchecker(idn_resconf_t ctx,

				 idn_checker_t unassigned_checker) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setunassignedchecker()\n"));

	if (ctx->unassigned_checker != NULL)

		idn_checker_destroy(ctx->unassigned_checker);

	ctx->unassigned_checker = unassigned_checker;

	if (unassigned_checker != NULL)

		idn_checker_incrref(ctx->unassigned_checker);

}

void

idn_resconf_setbidichecker(idn_resconf_t ctx,

			   idn_checker_t bidi_checker) {

	assert(ctx != NULL);

	TRACE(("idn_resconf_setbidichecker()\n"));

	if (ctx->bidi_checker != NULL)

		idn_checker_destroy(ctx->bidi_checker);

	ctx->bidi_checker = bidi_checker;

	if (bidi_checker != NULL)

		idn_checker_incrref(ctx->bidi_checker);

}

idn_result_t

idn_resconf_setnameprepversion(idn_resconf_t ctx, const char *version)

{

	char prohibit_scheme_name[MAX_CONF_LINE_LENGTH + 1];

	char unassigned_scheme_name[MAX_CONF_LINE_LENGTH + 1];

	char bidi_scheme_name[MAX_CONF_LINE_LENGTH + 1];

	idn_mapper_t mapper = NULL;

	idn_normalizer_t normalizer = NULL;

	idn_checker_t prohibit_checker = NULL;

	idn_checker_t unassigned_checker = NULL;

	idn_checker_t bidi_checker = NULL;

	idn_result_t r;

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

	TRACE(("idn_resconf_setnameprepversion()\n"));

	/*

	 * Set canonical scheme names.

	 */

	if (strlen(version) + strlen(IDN_CHECKER_PROHIBIT_PREFIX)

	    > MAX_CONF_LINE_LENGTH) {

		r = idn_invalid_name;

		goto failure;

	}

	sprintf(prohibit_scheme_name, "%s%s",

	        IDN_CHECKER_PROHIBIT_PREFIX, version);

	if (strlen(version) + strlen(IDN_CHECKER_UNASSIGNED_PREFIX)

	    > MAX_CONF_LINE_LENGTH) {

		r = idn_invalid_name;

		goto failure;

	}

	sprintf(unassigned_scheme_name, "%s%s",

	        IDN_CHECKER_UNASSIGNED_PREFIX, version);

	if (strlen(version) + strlen(IDN_CHECKER_BIDI_PREFIX)

	    > MAX_CONF_LINE_LENGTH) {

		r = idn_invalid_name;

		goto failure;

	}

	sprintf(bidi_scheme_name, "%s%s",

	        IDN_CHECKER_BIDI_PREFIX, version);

	/*

	 * Create objects.

	 */

	r = idn_mapper_create(&mapper);

	if (r != idn_success)

		goto failure;

	r = idn_normalizer_create(&normalizer);

	if (r != idn_success)

		goto failure;

	r = idn_checker_create(&prohibit_checker);

	if (r != idn_success)

		goto failure;

	r = idn_checker_create(&unassigned_checker);

	if (r != idn_success)

		goto failure;

	r = idn_checker_create(&bidi_checker);

	if (r != idn_success)

		goto failure;

	r = idn_mapper_add(mapper, version);

	if (r != idn_success)

		goto failure;

	r = idn_normalizer_add(normalizer, version);

	if (r != idn_success)

		goto failure;

	r = idn_checker_add(prohibit_checker, prohibit_scheme_name);

	if (r != idn_success)

		goto failure;

	r = idn_checker_add(unassigned_checker, unassigned_scheme_name);

	if (r != idn_success)

		goto failure;

	r = idn_checker_add(bidi_checker, bidi_scheme_name);

	if (r != idn_success)

		goto failure;

	/*

	 * Set the objects.

	 */

	idn_resconf_setmapper(ctx, mapper);

	idn_resconf_setnormalizer(ctx, normalizer);

	idn_resconf_setprohibitchecker(ctx, prohibit_checker);

	idn_resconf_setunassignedchecker(ctx, unassigned_checker);

	idn_resconf_setbidichecker(ctx, bidi_checker);

	/*

	 * Destroy the objects.

	 */

	idn_mapper_destroy(mapper);

	idn_normalizer_destroy(normalizer);

	idn_checker_destroy(prohibit_checker);

	idn_checker_destroy(unassigned_checker);

	idn_checker_destroy(bidi_checker);

	return (idn_success);

failure:

	if (mapper != NULL)

		idn_mapper_destroy(mapper);

	if (normalizer != NULL)

		idn_normalizer_destroy(normalizer);

	if (prohibit_checker != NULL)

		idn_checker_destroy(prohibit_checker);

	if (unassigned_checker != NULL)

		idn_checker_destroy(unassigned_checker);

	if (bidi_checker != NULL)

		idn_checker_destroy(bidi_checker);

	return (r);

}

idn_result_t

idn_resconf_setalternateconvertername(idn_resconf_t ctx, const char *name,

				      int flags) {

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

	TRACE(("idn_resconf_setalternateconvertername(name=%s, flags=%d)\n",

	      name, flags));

	return (idn_success);

}

idn_result_t

idn_resconf_setidnconvertername(idn_resconf_t ctx, const char *name,

				int flags) {

	idn_converter_t idn_converter;

	idn_result_t r;

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

	TRACE(("idn_resconf_setidnconvertername(name=%s, flags=%d)\n",

	      name, flags));

	r = idn_converter_create(name, &idn_converter, flags);

	if (r != idn_success)

		return (r);

	if (ctx->idn_converter != NULL)

		idn_converter_destroy(ctx->idn_converter);

	ctx->idn_converter = idn_converter;

	return (idn_success);

}

idn_result_t

idn_resconf_setauxidnconvertername(idn_resconf_t ctx, const char *name,

				    int flags) {

	idn_converter_t aux_idn_converter;

	const char *old_name;

	idn_result_t r;

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

	TRACE(("idn_resconf_setauxidnconvertername(name=%s, flags=%d)\n",

	      name, flags));

	if (ctx->aux_idn_converter != NULL) {

	    old_name = idn_converter_localencoding(ctx->aux_idn_converter);

	    if (old_name != NULL && strcmp(old_name, name) == 0)

		return (idn_success);

	}

	r = idn_converter_create(name, &aux_idn_converter, flags);

	if (r != idn_success)

		return (r);

	if (ctx->aux_idn_converter != NULL)

		idn_converter_destroy(ctx->aux_idn_converter);

	ctx->aux_idn_converter = aux_idn_converter;

	return (idn_success);

}

idn_result_t

idn_resconf_setlocalconvertername(idn_resconf_t ctx, const char *name,

				  int flags) {

#ifdef WITHOUT_ICONV

	return idn_failure;

#else /* WITHOUT_ICONV */

	idn_converter_t local_converter;

	idn_result_t r;

	assert(ctx != NULL);

	TRACE(("idn_resconf_setlocalconvertername(name=%s, flags=%d)\n",

	      name == NULL ? "<null>" : name, flags));

	if (ctx->local_converter != NULL) {

		idn_converter_destroy(ctx->local_converter);

		ctx->local_converter = NULL;

	}

	ctx->local_converter_is_static = 0;

	if (name != NULL) {

		r = idn_converter_create(name, &local_converter, flags);

		if (r != idn_success)

			return (r);

		ctx->local_converter = local_converter;