resconf.c

bind 9.3结合mysql数据库

	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;
		ctx->local_converter_is_static = 1;
	}

	return (idn_success);

#endif /* WITHOUT_ICONV */
}

idn_result_t
idn_resconf_addalldelimitermapucs(idn_resconf_t ctx, unsigned long *v,
				  int nv) {
	idn_result_t r;

	TRACE(("idn_resconf_addalldelimitermapucs(nv=%d)\n", nv));

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

	r = idn_delimitermap_addall(ctx->delimiter_mapper, v, nv);
	return (r);
}

idn_result_t
idn_resconf_addalllocalmapselectornames(idn_resconf_t ctx, const char *tld,
					const char **names, int nnames) {
	idn_result_t r;

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

	TRACE(("idn_resconf_addalllocalmapselectorname(tld=%s, nnames=%d)\n",
	      tld, nnames));

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

	r = idn_mapselector_addall(ctx->local_mapper, tld, names, nnames);
	return (r);
}

idn_result_t
idn_resconf_addallmappernames(idn_resconf_t ctx, const char **names,
			      int nnames) {
	idn_result_t r;

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

	TRACE(("idn_resconf_addallmappername()\n"));

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

	r = idn_mapper_addall(ctx->mapper, names, nnames);
	return (r);
}

idn_result_t
idn_resconf_addallnormalizernames(idn_resconf_t ctx, const char **names,
				  int nnames) {
	idn_result_t r;

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

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

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

	r = idn_normalizer_addall(ctx->normalizer, names, nnames);
	return (r);
}

idn_result_t
idn_resconf_addallprohibitcheckernames(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_addallprohibitcheckername(nnames=%d)\n", nnames));

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

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