diff options
Diffstat (limited to 'contrib/idn/idnkit-1.0-src/lib/checker.c')
-rw-r--r-- | contrib/idn/idnkit-1.0-src/lib/checker.c | 446 |
1 files changed, 446 insertions, 0 deletions
diff --git a/contrib/idn/idnkit-1.0-src/lib/checker.c b/contrib/idn/idnkit-1.0-src/lib/checker.c new file mode 100644 index 0000000..c1e8fdf --- /dev/null +++ b/contrib/idn/idnkit-1.0-src/lib/checker.c @@ -0,0 +1,446 @@ +#ifndef lint +static char *rcsid = "$Id: checker.c,v 1.1.1.1 2003/06/04 00:25:49 marka Exp $"; +#endif + +/* + * Copyright (c) 2001,2002 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 <stdlib.h> +#include <string.h> + +#include <idn/result.h> +#include <idn/assert.h> +#include <idn/logmacro.h> +#include <idn/checker.h> +#include <idn/strhash.h> +#include <idn/debug.h> + +/* + * Type for checking scheme. + */ +typedef struct { + char *prefix; + char *parameter; + idn_checker_createproc_t create; + idn_checker_destroyproc_t destroy; + idn_checker_lookupproc_t lookup; + void *context; +} check_scheme_t; + +/* + * Standard checking schemes. + */ +static const check_scheme_t rfc3491_prohibit_scheme = { + "prohibit#RFC3491", + "RFC3491", + idn_nameprep_createproc, + idn_nameprep_destroyproc, + idn_nameprep_prohibitproc, + NULL, +}; + +static const check_scheme_t rfc3491_unasigned_scheme = { + "unassigned#RFC3491", + "RFC3491", + idn_nameprep_createproc, + idn_nameprep_destroyproc, + idn_nameprep_unassignedproc, + NULL, +}; + +static const check_scheme_t rfc3491_bidi_scheme = { + "bidi#RFC3491", + "RFC3491", + idn_nameprep_createproc, + idn_nameprep_destroyproc, + idn_nameprep_bidiproc, + NULL, +}; + +static const check_scheme_t filecheck_prohibit_scheme = { + "prohibit#fileset", + NULL, + idn__filechecker_createproc, + idn__filechecker_destroyproc, + idn__filechecker_lookupproc, + NULL, +}; + +static const check_scheme_t filecheck_unassigned_scheme = { + "unassigned#fileset", + NULL, + idn__filechecker_createproc, + idn__filechecker_destroyproc, + idn__filechecker_lookupproc, + NULL, +}; + +static const check_scheme_t *standard_check_schemes[] = { + &rfc3491_unasigned_scheme, + &rfc3491_prohibit_scheme, + &rfc3491_bidi_scheme, + &filecheck_prohibit_scheme, + &filecheck_unassigned_scheme, + NULL, +}; + +/* + * Hash table for checking schemes. + */ +static idn__strhash_t scheme_hash = NULL; + +/* + * Mapper object type. + */ +struct idn_checker { + int nschemes; + int scheme_size; + check_scheme_t *schemes; + int reference_count; +}; + +#define MAPPER_INITIAL_SCHEME_SIZE 1 + +idn_result_t +idn_checker_initialize(void) { + idn_result_t r; + check_scheme_t **scheme; + + TRACE(("idn_checker_initialize()\n")); + + if (scheme_hash != NULL) { + r = idn_success; /* already initialized */ + goto ret; + } + + r = idn__strhash_create(&scheme_hash); + if (r != idn_success) { + goto ret; + } + + for (scheme = (check_scheme_t **)standard_check_schemes; + *scheme != NULL; scheme++) { + r = idn__strhash_put(scheme_hash, (*scheme)->prefix, *scheme); + if (r != idn_success) + goto ret; + } + + r = idn_success; +ret: + if (r != idn_success) { + if (scheme_hash != NULL) { + idn__strhash_destroy(scheme_hash, NULL); + scheme_hash = NULL; + } + } + TRACE(("idn_checker_initialize(): %s\n", idn_result_tostring(r))); + return (r); +} + +idn_result_t +idn_checker_create(idn_checker_t *ctxp) { + idn_checker_t ctx = NULL; + idn_result_t r; + + assert(scheme_hash != NULL); + assert(ctxp != NULL); + + TRACE(("idn_checker_create()\n")); + + ctx = (idn_checker_t) malloc(sizeof(struct idn_checker)); + if (ctx == NULL) { + r = idn_nomemory; + goto ret; + } + + ctx->schemes = (check_scheme_t *) malloc(sizeof(check_scheme_t) + * MAPPER_INITIAL_SCHEME_SIZE); + if (ctx->schemes == NULL) { + r = idn_nomemory; + goto ret; + } + + ctx->nschemes = 0; + ctx->scheme_size = MAPPER_INITIAL_SCHEME_SIZE; + ctx->reference_count = 1; + *ctxp = ctx; + r = idn_success; +ret: + if (r != idn_success) { + if (ctx != NULL) + free(ctx->schemes); + free(ctx); + } + TRACE(("idn_checker_create(): %s\n", idn_result_tostring(r))); + return (r); +} + +void +idn_checker_destroy(idn_checker_t ctx) { + int i; + + assert(scheme_hash != NULL); + assert(ctx != NULL); + + TRACE(("idn_checker_destroy()\n")); + + ctx->reference_count--; + if (ctx->reference_count <= 0) { + TRACE(("idn_checker_destroy(): the object is destroyed\n")); + for (i = 0; i < ctx->nschemes; i++) + ctx->schemes[i].destroy(ctx->schemes[i].context); + free(ctx->schemes); + free(ctx); + } else { + TRACE(("idn_checker_destroy(): " + "update reference count (%d->%d)\n", + ctx->reference_count + 1, ctx->reference_count)); + } +} + +void +idn_checker_incrref(idn_checker_t ctx) { + assert(ctx != NULL && scheme_hash != NULL); + + TRACE(("idn_checker_incrref()\n")); + TRACE(("idn_checker_incrref: update reference count (%d->%d)\n", + ctx->reference_count, ctx->reference_count + 1)); + + ctx->reference_count++; +} + +idn_result_t +idn_checker_add(idn_checker_t ctx, const char *scheme_name) { + idn_result_t r; + check_scheme_t *scheme; + const char *scheme_prefix; + const char *scheme_parameter; + void *scheme_context = NULL; + char *buffer = NULL; + + assert(scheme_hash != NULL); + assert(ctx != NULL); + + TRACE(("idn_checker_add(scheme_name=%s)\n", + idn__debug_xstring(scheme_name, 50))); + + /* + * Split `scheme_name' into `scheme_prefix' and `scheme_parameter'. + */ + scheme_parameter = strchr(scheme_name, ':'); + if (scheme_parameter == NULL) { + scheme_prefix = scheme_name; + scheme_parameter = NULL; + } else { + ptrdiff_t scheme_prefixlen; + + scheme_prefixlen = scheme_parameter - scheme_name; + buffer = (char *) malloc(scheme_prefixlen + 1); + if (buffer == NULL) { + r = idn_nomemory; + goto ret; + } + memcpy(buffer, scheme_name, scheme_prefixlen); + *(buffer + scheme_prefixlen) = '\0'; + scheme_prefix = buffer; + scheme_parameter++; + } + + /* + * Find a scheme. + */ + if (idn__strhash_get(scheme_hash, scheme_prefix, (void **)&scheme) + != idn_success) { + ERROR(("idn_checker_add(): invalid scheme \"%-.30s\"\n", + scheme_name)); + r = idn_invalid_name; + goto ret; + } + if (scheme_parameter == NULL && scheme->parameter != NULL) + scheme_parameter = scheme->parameter; + + /* + * Add the scheme. + */ + assert(ctx->nschemes <= ctx->scheme_size); + + if (ctx->nschemes == ctx->scheme_size) { + check_scheme_t *new_schemes; + + new_schemes = (check_scheme_t *) realloc(ctx->schemes, + sizeof(check_scheme_t) * ctx->scheme_size * 2); + if (new_schemes == NULL) { + r = idn_nomemory; + goto ret; + } + ctx->schemes = new_schemes; + ctx->scheme_size *= 2; + } + + r = scheme->create(scheme_parameter, &scheme_context); + if (r != idn_success) + goto ret; + + memcpy(ctx->schemes + ctx->nschemes, scheme, sizeof(check_scheme_t)); + ctx->schemes[ctx->nschemes].context = scheme_context; + ctx->nschemes++; + r = idn_success; + +ret: + free(buffer); + if (r != idn_success) + free(scheme_context); + TRACE(("idn_checker_add(): %s\n", idn_result_tostring(r))); + return (r); +} + +idn_result_t +idn_checker_addall(idn_checker_t ctx, const char **scheme_names, + int nschemes) { + idn_result_t r; + int i; + + assert(scheme_hash != NULL); + assert(ctx != NULL && scheme_names != NULL); + + TRACE(("idn_checker_addall(nschemes=%d)\n", nschemes)); + + for (i = 0; i < nschemes; i++) { + r = idn_checker_add(ctx, (const char *)*scheme_names); + if (r != idn_success) + goto ret; + scheme_names++; + } + + r = idn_success; +ret: + TRACE(("idn_checker_addall(): %s\n", idn_result_tostring(r))); + return (r); +} + +idn_result_t +idn_checker_lookup(idn_checker_t ctx, const unsigned long *ucs4, + const unsigned long **found) { + idn_result_t r; + int i; + + assert(scheme_hash != NULL); + assert(ctx != NULL && ucs4 != NULL && found != NULL); + + TRACE(("idn_checker_lookup(ucs4=\"%s\")\n", + idn__debug_ucs4xstring(ucs4, 50))); + + /* + * Lookup. + */ + *found = NULL; + + for (i = 0; i < ctx->nschemes; i++) { + TRACE(("idn_checker_lookup(): lookup %s\n", + ctx->schemes[i].prefix)); + + r = (ctx->schemes[i].lookup)(ctx->schemes[i].context, ucs4, + found); + if (r != idn_success) + goto ret; + if (*found != NULL) + break; + } + + r = idn_success; +ret: + if (*found == NULL) { + TRACE(("idn_checker_lookup(): %s (not found)\n", + idn_result_tostring(r))); + } else { + TRACE(("idn_checker_lookup(): %s (found \\x%04lx)\n", + idn_result_tostring(r), **found)); + } + return (r); +} + +idn_result_t +idn_checker_register(const char *prefix, + idn_checker_createproc_t create, + idn_checker_destroyproc_t destroy, + idn_checker_lookupproc_t lookup) { + idn_result_t r; + check_scheme_t *scheme = NULL; + + assert(scheme_hash != NULL); + assert(prefix != NULL && create != NULL && destroy != NULL && + lookup != NULL); + + TRACE(("idn_checker_register(prefix=%s)\n", prefix)); + + scheme = (check_scheme_t *) malloc(sizeof(check_scheme_t)); + if (scheme == NULL) { + r = idn_nomemory; + goto ret; + } + + scheme->prefix = (char *) malloc(strlen(prefix) + 1); + if (scheme->prefix == NULL) { + r = idn_nomemory; + goto ret; + } + + strcpy(scheme->prefix, prefix); + scheme->parameter = NULL; + scheme->create = create; + scheme->destroy = destroy; + scheme->lookup = lookup; + + r = idn__strhash_put(scheme_hash, prefix, scheme); +ret: + if (r != idn_success) { + if (scheme != NULL) + free(scheme->prefix); + free(scheme); + } + TRACE(("idn_checker_register(): %s\n", idn_result_tostring(r))); + return (r); +} |