mech_krb5/support/utf8_conv.c

2N/A/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2N/A/*
2N/A * util/support/utf8_conv.c
2N/A *
2N/A * Copyright 2008 by the Massachusetts Institute of Technology.
2N/A * All Rights Reserved.
2N/A *
2N/A * Export of this software from the United States of America may
2N/A *   require a specific license from the United States Government.
2N/A *   It is the responsibility of any person or organization contemplating
2N/A *   export to obtain such a license before exporting.
2N/A *
2N/A * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
2N/A * distribute this software and its documentation for any purpose and
2N/A * without fee is hereby granted, provided that the above copyright
2N/A * notice appear in all copies and that both that copyright notice and
2N/A * this permission notice appear in supporting documentation, and that
2N/A * the name of M.I.T. not be used in advertising or publicity pertaining
2N/A * to distribution of the software without specific, written prior
2N/A * permission.  Furthermore if you modify this software you must label
2N/A * your software as modified software and not distribute it in such a
2N/A * fashion that it might be confused with the original M.I.T. software.
2N/A * M.I.T. makes no representations about the suitability of
2N/A * this software for any purpose.  It is provided "as is" without express
2N/A * or implied warranty.
2N/A */
2N/A/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
2N/A *
2N/A * Copyright 1998-2008 The OpenLDAP Foundation.
2N/A * All rights reserved.
2N/A *
2N/A * Redistribution and use in source and binary forms, with or without
2N/A * modification, are permitted only as authorized by the OpenLDAP
2N/A * Public License.
2N/A *
2N/A * A copy of this license is available in the file LICENSE in the
2N/A * top-level directory of the distribution or, alternatively, at
2N/A * <http://www.OpenLDAP.org/license.html>.
2N/A */
2N/A/* Portions Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved.
2N/A *
2N/A * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND
2N/A * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT
2N/A * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS
2N/A * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE"
2N/A * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION
2N/A * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP
2N/A * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT
2N/A * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
2N/A */
2N/A
2N/A/*
2N/A * UTF-8 Conversion Routines
2N/A *
2N/A * These routines convert between Wide Character and UTF-8,
2N/A * or between MultiByte and UTF-8 encodings.
2N/A *
2N/A * Both single character and string versions of the functions are provided.
2N/A * All functions return -1 if the character or string cannot be converted.
2N/A */
2N/A
2N/A#include <assert.h>
2N/A#include "k5-platform.h"
2N/A#include "k5-utf8.h"
2N/A#include "supp-int.h"
2N/A
2N/Astatic unsigned char mask[] = { 0, 0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
2N/A
2N/Astatic ssize_t
2N/Ak5_utf8s_to_ucs2s(krb5_ucs2 *ucs2str,
2N/A                  const char *utf8str,
2N/A                  size_t count,
2N/A                  int little_endian)
2N/A{
2N/A    size_t ucs2len = 0;
2N/A    size_t utflen, i;
2N/A    krb5_ucs2 ch;
2N/A
2N/A    /* If input ptr is NULL or empty... */
2N/A    if (utf8str == NULL || *utf8str == '\0') {
2N/A        *ucs2str = 0;
2N/A
2N/A        return 0;
2N/A    }
2N/A
2N/A    /* Examine next UTF-8 character.  */
2N/A    while (*utf8str && ucs2len < count) {
2N/A        /* Get UTF-8 sequence length from 1st byte */
2N/A        utflen = KRB5_UTF8_CHARLEN2(utf8str, utflen);
2N/A
2N/A        if (utflen == 0 || utflen > KRB5_MAX_UTF8_LEN)
2N/A            return -1;
2N/A
2N/A        /* First byte minus length tag */
2N/A        ch = (krb5_ucs2)(utf8str[0] & mask[utflen]);
2N/A
2N/A        for (i = 1; i < utflen; i++) {
2N/A            /* Subsequent bytes must start with 10 */
2N/A            if ((utf8str[i] & 0xc0) != 0x80)
2N/A                return -1;
2N/A
2N/A            ch <<= 6;                   /* 6 bits of data in each subsequent byte */
2N/A            ch |= (krb5_ucs2)(utf8str[i] & 0x3f);
2N/A        }
2N/A
2N/A        if (ucs2str != NULL) {
2N/A#ifdef K5_BE
2N/A#ifndef SWAP16
2N/A#define SWAP16(X)       ((((X) << 8) | ((X) >> 8)) & 0xFFFF)
2N/A#endif
2N/A            if (little_endian)
2N/A                ucs2str[ucs2len] = SWAP16(ch);
2N/A            else
2N/A#endif
2N/A                ucs2str[ucs2len] = ch;
2N/A        }
2N/A
2N/A        utf8str += utflen;      /* Move to next UTF-8 character */
2N/A        ucs2len++;              /* Count number of wide chars stored/required */
2N/A    }
2N/A
2N/A    assert(ucs2len < count);
2N/A
2N/A    if (ucs2str != NULL) {
2N/A        /* Add null terminator if there's room in the buffer. */
2N/A        ucs2str[ucs2len] = 0;
2N/A    }
2N/A
2N/A    return ucs2len;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_utf8s_to_ucs2s(const char *utf8s,
2N/A                       krb5_ucs2 **ucs2s,
2N/A                       size_t *ucs2chars)
2N/A{
2N/A    ssize_t len;
2N/A    size_t chars;
2N/A
2N/A    chars = krb5int_utf8_chars(utf8s);
2N/A    *ucs2s = (krb5_ucs2 *)malloc((chars + 1) * sizeof(krb5_ucs2));
2N/A    if (*ucs2s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_utf8s_to_ucs2s(*ucs2s, utf8s, chars + 1, 0);
2N/A    if (len < 0) {
2N/A        free(*ucs2s);
2N/A        *ucs2s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (ucs2chars != NULL) {
2N/A        *ucs2chars = chars;
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_utf8cs_to_ucs2s(const char *utf8s,
2N/A                        size_t utf8slen,
2N/A                        krb5_ucs2 **ucs2s,
2N/A                        size_t *ucs2chars)
2N/A{
2N/A    ssize_t len;
2N/A    size_t chars;
2N/A
2N/A    chars = krb5int_utf8c_chars(utf8s, utf8slen);
2N/A    *ucs2s = (krb5_ucs2 *)malloc((chars + 1) * sizeof(krb5_ucs2));
2N/A    if (*ucs2s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_utf8s_to_ucs2s(*ucs2s, utf8s, chars + 1, 0);
2N/A    if (len < 0) {
2N/A        free(*ucs2s);
2N/A        *ucs2s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (ucs2chars != NULL) {
2N/A        *ucs2chars = chars;
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_utf8s_to_ucs2les(const char *utf8s,
2N/A                         unsigned char **ucs2les,
2N/A                         size_t *ucs2leslen)
2N/A{
2N/A    ssize_t len;
2N/A    size_t chars;
2N/A
2N/A    chars = krb5int_utf8_chars(utf8s);
2N/A
2N/A    *ucs2les = (unsigned char *)malloc((chars + 1) * sizeof(krb5_ucs2));
2N/A    if (*ucs2les == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_utf8s_to_ucs2s((krb5_ucs2 *)*ucs2les, utf8s, chars + 1, 1);
2N/A    if (len < 0) {
2N/A        free(*ucs2les);
2N/A        *ucs2les = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (ucs2leslen != NULL) {
2N/A        *ucs2leslen = chars * sizeof(krb5_ucs2);
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_utf8cs_to_ucs2les(const char *utf8s,
2N/A                          size_t utf8slen,
2N/A                          unsigned char **ucs2les,
2N/A                          size_t *ucs2leslen)
2N/A{
2N/A    ssize_t len;
2N/A    size_t chars;
2N/A
2N/A    chars = krb5int_utf8c_chars(utf8s, utf8slen);
2N/A
2N/A    *ucs2les = (unsigned char *)malloc((chars + 1) * sizeof(krb5_ucs2));
2N/A    if (*ucs2les == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_utf8s_to_ucs2s((krb5_ucs2 *)*ucs2les, utf8s, chars + 1, 1);
2N/A    if (len < 0) {
2N/A        free(*ucs2les);
2N/A        *ucs2les = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (ucs2leslen != NULL) {
2N/A        *ucs2leslen = chars * sizeof(krb5_ucs2);
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/A/*-----------------------------------------------------------------------------
2N/A  Convert a wide char string to a UTF-8 string.
2N/A  No more than 'count' bytes will be written to the output buffer.
2N/A  Return the # of bytes written to the output buffer, excl null terminator.
2N/A
2N/A  ucs2len is -1 if the UCS-2 string is NUL terminated, otherwise it is the
2N/A  length of the UCS-2 string in characters
2N/A*/
2N/Astatic ssize_t
2N/Ak5_ucs2s_to_utf8s(char *utf8str, const krb5_ucs2 *ucs2str,
2N/A                  size_t count, ssize_t ucs2len, int little_endian)
2N/A{
2N/A    int len = 0;
2N/A    int n;
2N/A    char *p = utf8str;
2N/A    krb5_ucs2 empty = 0, ch;
2N/A
2N/A    if (ucs2str == NULL)        /* Treat input ptr NULL as an empty string */
2N/A        ucs2str = &empty;
2N/A
2N/A    if (utf8str == NULL)        /* Just compute size of output, excl null */
2N/A    {
2N/A        while (ucs2len == -1 ? *ucs2str : --ucs2len >= 0) {
2N/A            /* Get UTF-8 size of next wide char */
2N/A            ch = *ucs2str++;
2N/A#ifdef K5_BE
2N/A            if (little_endian)
2N/A                ch = SWAP16(ch);
2N/A#endif
2N/A
2N/A            n = krb5int_ucs2_to_utf8(ch, NULL);
2N/A            if (n < 1)
2N/A                return -1;
2N/A            if (len + n < len)
2N/A                return -1; /* overflow */
2N/A            len += n;
2N/A        }
2N/A
2N/A        return len;
2N/A    }
2N/A
2N/A    /* Do the actual conversion. */
2N/A
2N/A    n = 1;                                      /* In case of empty ucs2str */
2N/A    while (ucs2len == -1 ? *ucs2str != 0 : --ucs2len >= 0) {
2N/A        ch = *ucs2str++;
2N/A#ifdef K5_BE
2N/A        if (little_endian)
2N/A            ch = SWAP16(ch);
2N/A#endif
2N/A
2N/A        n = krb5int_ucs2_to_utf8(ch, p);
2N/A
2N/A        if (n < 1)
2N/A            break;
2N/A
2N/A        p += n;
2N/A        count -= n;                     /* Space left in output buffer */
2N/A    }
2N/A
2N/A    /* If not enough room for last character, pad remainder with null
2N/A       so that return value = original count, indicating buffer full. */
2N/A    if (n == 0) {
2N/A        while (count--)
2N/A            *p++ = 0;
2N/A    }
2N/A    /* Add a null terminator if there's room. */
2N/A    else if (count)
2N/A        *p = 0;
2N/A
2N/A    if (n == -1)                        /* Conversion encountered invalid wide char. */
2N/A        return -1;
2N/A
2N/A    /* Return the number of bytes written to output buffer, excl null. */
2N/A    return (p - utf8str);
2N/A}
2N/A
2N/Aint
2N/Akrb5int_ucs2s_to_utf8s(const krb5_ucs2 *ucs2s,
2N/A                       char **utf8s,
2N/A                       size_t *utf8slen)
2N/A{
2N/A    ssize_t len;
2N/A
2N/A    len = k5_ucs2s_to_utf8s(NULL, ucs2s, 0, -1, 0);
2N/A    if (len < 0) {
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    *utf8s = (char *)malloc((size_t)len + 1);
2N/A    if (*utf8s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_ucs2s_to_utf8s(*utf8s, ucs2s, (size_t)len + 1, -1, 0);
2N/A    if (len < 0) {
2N/A        free(*utf8s);
2N/A        *utf8s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (utf8slen != NULL) {
2N/A        *utf8slen = len;
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_ucs2les_to_utf8s(const unsigned char *ucs2les,
2N/A                         char **utf8s,
2N/A                         size_t *utf8slen)
2N/A{
2N/A    ssize_t len;
2N/A
2N/A    len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2les, 0, -1, 1);
2N/A    if (len < 0)
2N/A        return EINVAL;
2N/A
2N/A    *utf8s = (char *)malloc((size_t)len + 1);
2N/A    if (*utf8s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2les, (size_t)len + 1, -1, 1);
2N/A    if (len < 0) {
2N/A        free(*utf8s);
2N/A        *utf8s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (utf8slen != NULL) {
2N/A        *utf8slen = len;
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_ucs2cs_to_utf8s(const krb5_ucs2 *ucs2s,
2N/A                        size_t ucs2slen,
2N/A                        char **utf8s,
2N/A                        size_t *utf8slen)
2N/A{
2N/A    ssize_t len;
2N/A
2N/A    if (ucs2slen > SSIZE_MAX)
2N/A        return ERANGE;
2N/A
2N/A    len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2s, 0,
2N/A                            (ssize_t)ucs2slen, 0);
2N/A    if (len < 0)
2N/A        return EINVAL;
2N/A
2N/A    *utf8s = (char *)malloc((size_t)len + 1);
2N/A    if (*utf8s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2s,
2N/A                            (size_t)len + 1, (ssize_t)ucs2slen, 0);
2N/A    if (len < 0) {
2N/A        free(*utf8s);
2N/A        *utf8s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (utf8slen != NULL) {
2N/A        *utf8slen = len;
2N/A    }
2N/A
2N/A    return 0;
2N/A}
2N/A
2N/Aint
2N/Akrb5int_ucs2lecs_to_utf8s(const unsigned char *ucs2les,
2N/A                          size_t ucs2leslen,
2N/A                          char **utf8s,
2N/A                          size_t *utf8slen)
2N/A{
2N/A    ssize_t len;
2N/A
2N/A    if (ucs2leslen > SSIZE_MAX)
2N/A        return ERANGE;
2N/A
2N/A    len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2les, 0,
2N/A                            (ssize_t)ucs2leslen, 1);
2N/A    if (len < 0)
2N/A        return EINVAL;
2N/A
2N/A    *utf8s = (char *)malloc((size_t)len + 1);
2N/A    if (*utf8s == NULL) {
2N/A        return ENOMEM;
2N/A    }
2N/A
2N/A    len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2les,
2N/A                            (size_t)len + 1, (ssize_t)ucs2leslen, 1);
2N/A    if (len < 0) {
2N/A        free(*utf8s);
2N/A        *utf8s = NULL;
2N/A        return EINVAL;
2N/A    }
2N/A
2N/A    if (utf8slen != NULL) {
2N/A        *utf8slen = len;
2N/A    }
2N/A
2N/A    return 0;
2N/A}