[thirdparty/openssl.git] / crypto / asn1 / a_mbstr.c

/* a_mbstr.c */
/*
 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
 * 1999.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED 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 THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS 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 DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include <ctype.h>
#include "cryptlib.h"
#include <openssl/asn1.h>

static int traverse_string(const unsigned char *p, int len, int inform,
                           int (*rfunc) (unsigned long value, void *in),
                           void *arg);
static int in_utf8(unsigned long value, void *arg);
static int out_utf8(unsigned long value, void *arg);
static int type_str(unsigned long value, void *arg);
static int cpy_asc(unsigned long value, void *arg);
static int cpy_bmp(unsigned long value, void *arg);
static int cpy_univ(unsigned long value, void *arg);
static int cpy_utf8(unsigned long value, void *arg);
static int is_printable(unsigned long value);

/*
 * These functions take a string in UTF8, ASCII or multibyte form and a mask
 * of permissible ASN1 string types. It then works out the minimal type
 * (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) and
 * creates a string of the correct type with the supplied data. Yes this is
 * horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
 * size limits too.
 */

int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
                       int inform, unsigned long mask)
{
    return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
}

int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
                        int inform, unsigned long mask,
                        long minsize, long maxsize)
{
    int str_type;
    int ret;
    char free_out;
    int outform, outlen = 0;
    ASN1_STRING *dest;
    unsigned char *p;
    int nchar;
    char strbuf[32];
    int (*cpyfunc) (unsigned long, void *) = NULL;
    if (len == -1)
        len = strlen((const char *)in);
    if (!mask)
        mask = DIRSTRING_TYPE;

    /* First do a string check and work out the number of characters */
    switch (inform) {

    case MBSTRING_BMP:
        if (len & 1) {
            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
                    ASN1_R_INVALID_BMPSTRING_LENGTH);
            return -1;
        }
        nchar = len >> 1;
        break;

    case MBSTRING_UNIV:
        if (len & 3) {
            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
                    ASN1_R_INVALID_UNIVERSALSTRING_LENGTH);
            return -1;
        }
        nchar = len >> 2;
        break;

    case MBSTRING_UTF8:
        nchar = 0;
        /* This counts the characters and does utf8 syntax checking */
        ret = traverse_string(in, len, MBSTRING_UTF8, in_utf8, &nchar);
        if (ret < 0) {
            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_INVALID_UTF8STRING);
            return -1;
        }
        break;

    case MBSTRING_ASC:
        nchar = len;
        break;

    default:
        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_UNKNOWN_FORMAT);
        return -1;
    }

    if ((minsize > 0) && (nchar < minsize)) {
        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_SHORT);
        BIO_snprintf(strbuf, sizeof strbuf, "%ld", minsize);
        ERR_add_error_data(2, "minsize=", strbuf);
        return -1;
    }

    if ((maxsize > 0) && (nchar > maxsize)) {
        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_LONG);
        BIO_snprintf(strbuf, sizeof strbuf, "%ld", maxsize);
        ERR_add_error_data(2, "maxsize=", strbuf);
        return -1;
    }

    /* Now work out minimal type (if any) */
    if (traverse_string(in, len, inform, type_str, &mask) < 0) {
        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_ILLEGAL_CHARACTERS);
        return -1;
    }

    /* Now work out output format and string type */
    outform = MBSTRING_ASC;
    if (mask & B_ASN1_PRINTABLESTRING)
        str_type = V_ASN1_PRINTABLESTRING;
    else if (mask & B_ASN1_IA5STRING)
        str_type = V_ASN1_IA5STRING;
    else if (mask & B_ASN1_T61STRING)
        str_type = V_ASN1_T61STRING;
    else if (mask & B_ASN1_BMPSTRING) {
        str_type = V_ASN1_BMPSTRING;
        outform = MBSTRING_BMP;
    } else if (mask & B_ASN1_UNIVERSALSTRING) {
        str_type = V_ASN1_UNIVERSALSTRING;
        outform = MBSTRING_UNIV;
    } else {
        str_type = V_ASN1_UTF8STRING;
        outform = MBSTRING_UTF8;
    }
    if (!out)
        return str_type;
    if (*out) {
        free_out = 0;
        dest = *out;
        if (dest->data) {
            dest->length = 0;
            OPENSSL_free(dest->data);
            dest->data = NULL;
        }
        dest->type = str_type;
    } else {
        free_out = 1;
        dest = ASN1_STRING_type_new(str_type);
        if (!dest) {
            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
            return -1;
        }
        *out = dest;
    }
    /* If both the same type just copy across */
    if (inform == outform) {
        if (!ASN1_STRING_set(dest, in, len)) {
            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
            return -1;
        }
        return str_type;
    }

    /* Work out how much space the destination will need */
    switch (outform) {
    case MBSTRING_ASC:
        outlen = nchar;
        cpyfunc = cpy_asc;
        break;

    case MBSTRING_BMP:
        outlen = nchar << 1;
        cpyfunc = cpy_bmp;
        break;

    case MBSTRING_UNIV:
        outlen = nchar << 2;
        cpyfunc = cpy_univ;
        break;

    case MBSTRING_UTF8:
        outlen = 0;
        traverse_string(in, len, inform, out_utf8, &outlen);
        cpyfunc = cpy_utf8;
        break;
    }
    if (!(p = OPENSSL_malloc(outlen + 1))) {
        if (free_out)
            ASN1_STRING_free(dest);
        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
        return -1;
    }
    dest->length = outlen;
    dest->data = p;
    p[outlen] = 0;
    traverse_string(in, len, inform, cpyfunc, &p);
    return str_type;
}

/*
 * This function traverses a string and passes the value of each character to
 * an optional function along with a void * argument.
 */

static int traverse_string(const unsigned char *p, int len, int inform,
                           int (*rfunc) (unsigned long value, void *in),
                           void *arg)
{
    unsigned long value;
    int ret;
    while (len) {
        if (inform == MBSTRING_ASC) {
            value = *p++;
            len--;
        } else if (inform == MBSTRING_BMP) {
            value = *p++ << 8;
            value |= *p++;
            len -= 2;
        } else if (inform == MBSTRING_UNIV) {
            value = ((unsigned long)*p++) << 24;
            value |= ((unsigned long)*p++) << 16;
            value |= *p++ << 8;
            value |= *p++;
            len -= 4;
        } else {
            ret = UTF8_getc(p, len, &value);
            if (ret < 0)
                return -1;
            len -= ret;
            p += ret;
        }
        if (rfunc) {
            ret = rfunc(value, arg);
            if (ret <= 0)
                return ret;
        }
    }
    return 1;
}

/* Various utility functions for traverse_string */

/* Just count number of characters */

static int in_utf8(unsigned long value, void *arg)
{
    int *nchar;
    nchar = arg;
    (*nchar)++;
    return 1;
}

/* Determine size of output as a UTF8 String */

static int out_utf8(unsigned long value, void *arg)
{
    int *outlen;
    outlen = arg;
    *outlen += UTF8_putc(NULL, -1, value);
    return 1;
}

/*
 * Determine the "type" of a string: check each character against a supplied
 * "mask".
 */

static int type_str(unsigned long value, void *arg)
{
    unsigned long types;
    types = *((unsigned long *)arg);
    if ((types & B_ASN1_PRINTABLESTRING) && !is_printable(value))
        types &= ~B_ASN1_PRINTABLESTRING;
    if ((types & B_ASN1_IA5STRING) && (value > 127))
        types &= ~B_ASN1_IA5STRING;
    if ((types & B_ASN1_T61STRING) && (value > 0xff))
        types &= ~B_ASN1_T61STRING;
    if ((types & B_ASN1_BMPSTRING) && (value > 0xffff))
        types &= ~B_ASN1_BMPSTRING;
    if (!types)
        return -1;
    *((unsigned long *)arg) = types;
    return 1;
}

/* Copy one byte per character ASCII like strings */

static int cpy_asc(unsigned long value, void *arg)
{
    unsigned char **p, *q;
    p = arg;
    q = *p;
    *q = (unsigned char)value;
    (*p)++;
    return 1;
}

/* Copy two byte per character BMPStrings */

static int cpy_bmp(unsigned long value, void *arg)
{
    unsigned char **p, *q;
    p = arg;
    q = *p;
    *q++ = (unsigned char)((value >> 8) & 0xff);
    *q = (unsigned char)(value & 0xff);
    *p += 2;
    return 1;
}

/* Copy four byte per character UniversalStrings */

static int cpy_univ(unsigned long value, void *arg)
{
    unsigned char **p, *q;
    p = arg;
    q = *p;
    *q++ = (unsigned char)((value >> 24) & 0xff);
    *q++ = (unsigned char)((value >> 16) & 0xff);
    *q++ = (unsigned char)((value >> 8) & 0xff);
    *q = (unsigned char)(value & 0xff);
    *p += 4;
    return 1;
}

/* Copy to a UTF8String */

static int cpy_utf8(unsigned long value, void *arg)
{
    unsigned char **p;
    int ret;
    p = arg;
    /* We already know there is enough room so pass 0xff as the length */
    ret = UTF8_putc(*p, 0xff, value);
    *p += ret;
    return 1;
}

/* Return 1 if the character is permitted in a PrintableString */
static int is_printable(unsigned long value)
{
    int ch;
    if (value > 0x7f)
        return 0;
    ch = (int)value;
    /*
     * Note: we can't use 'isalnum' because certain accented characters may
     * count as alphanumeric in some environments.
     */
#ifndef CHARSET_EBCDIC
    if ((ch >= 'a') && (ch <= 'z'))
        return 1;
    if ((ch >= 'A') && (ch <= 'Z'))
        return 1;
    if ((ch >= '0') && (ch <= '9'))
        return 1;
    if ((ch == ' ') || strchr("'()+,-./:=?", ch))
        return 1;
#else                           /* CHARSET_EBCDIC */
    if ((ch >= os_toascii['a']) && (ch <= os_toascii['z']))
        return 1;
    if ((ch >= os_toascii['A']) && (ch <= os_toascii['Z']))
        return 1;
    if ((ch >= os_toascii['0']) && (ch <= os_toascii['9']))
        return 1;
    if ((ch == os_toascii[' ']) || strchr("'()+,-./:=?", os_toebcdic[ch]))
        return 1;
#endif                          /* CHARSET_EBCDIC */
    return 0;
}
Commit	Line	Data
462f79ec	1	/* a_mbstr.c */
40720ce3 MC	2	/*
	3	* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
	4	* 1999.
462f79ec DSH	5	*/
	6	/* ====================================================================
	7	* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
40720ce3	14	* notice, this list of conditions and the following disclaimer.
462f79ec DSH	15	*
	16	* 2. Redistributions in binary form must reproduce the above copyright
	17	* notice, this list of conditions and the following disclaimer in
	18	* the documentation and/or other materials provided with the
	19	* distribution.
	20	*
	21	* 3. All advertising materials mentioning features or use of this
	22	* software must display the following acknowledgment:
	23	* "This product includes software developed by the OpenSSL Project
	24	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	25	*
	26	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	27	* endorse or promote products derived from this software without
	28	* prior written permission. For written permission, please contact
	29	* licensing@OpenSSL.org.
	30	*
	31	* 5. Products derived from this software may not be called "OpenSSL"
	32	* nor may "OpenSSL" appear in their names without prior written
	33	* permission of the OpenSSL Project.
	34	*
	35	* 6. Redistributions of any form whatsoever must retain the following
	36	* acknowledgment:
	37	* "This product includes software developed by the OpenSSL Project
	38	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	39	*
	40	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	41	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	43	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	44	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	45	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	46	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	47	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	49	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	50	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	51	* OF THE POSSIBILITY OF SUCH DAMAGE.
	52	* ====================================================================
	53	*
	54	* This product includes cryptographic software written by Eric Young
	55	* (eay@cryptsoft.com). This product includes software written by Tim
	56	* Hudson (tjh@cryptsoft.com).
	57	*
	58	*/
	59
	60	#include <stdio.h>
f769ce3e	61	#include <ctype.h>
462f79ec DSH	62	#include "cryptlib.h"
	63	#include <openssl/asn1.h>
	64
042a93e4	65	static int traverse_string(const unsigned char *p, int len, int inform,
40720ce3 MC	66	int (rfunc) (unsigned long value, void in),
40720ce3 MC	67	void *arg);
462f79ec DSH	68	static int in_utf8(unsigned long value, void *arg);
	69	static int out_utf8(unsigned long value, void *arg);
	70	static int type_str(unsigned long value, void *arg);
	71	static int cpy_asc(unsigned long value, void *arg);
	72	static int cpy_bmp(unsigned long value, void *arg);
	73	static int cpy_univ(unsigned long value, void *arg);
	74	static int cpy_utf8(unsigned long value, void *arg);
	75	static int is_printable(unsigned long value);
	76
40720ce3 MC	77	/*
	78	* These functions take a string in UTF8, ASCII or multibyte form and a mask
	79	* of permissible ASN1 string types. It then works out the minimal type
	80	* (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) and
	81	* creates a string of the correct type with the supplied data. Yes this is
	82	* horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
	83	* size limits too.
462f79ec DSH	84	*/
462f79ec DSH	85
042a93e4	86	int ASN1_mbstring_copy(ASN1_STRING *out, const unsigned char in, int len,
40720ce3	87	int inform, unsigned long mask)
f769ce3e	88	{
40720ce3	89	return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
f769ce3e DSH	90	}
	91
	92	int ASN1_mbstring_ncopy(ASN1_STRING *out, const unsigned char in, int len,
40720ce3 MC	93	int inform, unsigned long mask,
40720ce3 MC	94	long minsize, long maxsize)
462f79ec	95	{
40720ce3 MC	96	int str_type;
	97	int ret;
	98	char free_out;
	99	int outform, outlen = 0;
	100	ASN1_STRING *dest;
	101	unsigned char *p;
	102	int nchar;
	103	char strbuf[32];
	104	int (cpyfunc) (unsigned long, void ) = NULL;
	105	if (len == -1)
	106	len = strlen((const char *)in);
	107	if (!mask)
	108	mask = DIRSTRING_TYPE;
	109
	110	/* First do a string check and work out the number of characters */
	111	switch (inform) {
	112
	113	case MBSTRING_BMP:
	114	if (len & 1) {
	115	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
	116	ASN1_R_INVALID_BMPSTRING_LENGTH);
	117	return -1;
	118	}
	119	nchar = len >> 1;
	120	break;
	121
	122	case MBSTRING_UNIV:
	123	if (len & 3) {
	124	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
	125	ASN1_R_INVALID_UNIVERSALSTRING_LENGTH);
	126	return -1;
	127	}
	128	nchar = len >> 2;
	129	break;
	130
	131	case MBSTRING_UTF8:
	132	nchar = 0;
	133	/* This counts the characters and does utf8 syntax checking */
	134	ret = traverse_string(in, len, MBSTRING_UTF8, in_utf8, &nchar);
	135	if (ret < 0) {
	136	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_INVALID_UTF8STRING);
	137	return -1;
	138	}
	139	break;
	140
	141	case MBSTRING_ASC:
	142	nchar = len;
	143	break;
	144
	145	default:
	146	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_UNKNOWN_FORMAT);
	147	return -1;
	148	}
	149
	150	if ((minsize > 0) && (nchar < minsize)) {
	151	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_SHORT);
	152	BIO_snprintf(strbuf, sizeof strbuf, "%ld", minsize);
	153	ERR_add_error_data(2, "minsize=", strbuf);
	154	return -1;
	155	}
	156
	157	if ((maxsize > 0) && (nchar > maxsize)) {
	158	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_LONG);
	159	BIO_snprintf(strbuf, sizeof strbuf, "%ld", maxsize);
160	ERR_add_error_data(2, "maxsize=", strbuf);
161	return -1;
162	}
163
164	/* Now work out minimal type (if any) */
165	if (traverse_string(in, len, inform, type_str, &mask) < 0) {
166	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_ILLEGAL_CHARACTERS);
167	return -1;
168	}
169
170	/* Now work out output format and string type */
171	outform = MBSTRING_ASC;
172	if (mask & B_ASN1_PRINTABLESTRING)
173	str_type = V_ASN1_PRINTABLESTRING;
174	else if (mask & B_ASN1_IA5STRING)
175	str_type = V_ASN1_IA5STRING;
176	else if (mask & B_ASN1_T61STRING)
177	str_type = V_ASN1_T61STRING;
178	else if (mask & B_ASN1_BMPSTRING) {
179	str_type = V_ASN1_BMPSTRING;
180	outform = MBSTRING_BMP;
181	} else if (mask & B_ASN1_UNIVERSALSTRING) {
182	str_type = V_ASN1_UNIVERSALSTRING;
183	outform = MBSTRING_UNIV;
184	} else {
185	str_type = V_ASN1_UTF8STRING;
186	outform = MBSTRING_UTF8;
187	}
188	if (!out)
189	return str_type;
190	if (*out) {
191	free_out = 0;
192	dest = *out;
193	if (dest->data) {
194	dest->length = 0;
195	OPENSSL_free(dest->data);
196	dest->data = NULL;
197	}
198	dest->type = str_type;
199	} else {
200	free_out = 1;
201	dest = ASN1_STRING_type_new(str_type);
202	if (!dest) {
203	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
204	return -1;
205	}
206	*out = dest;
207	}
208	/* If both the same type just copy across */
209	if (inform == outform) {
210	if (!ASN1_STRING_set(dest, in, len)) {
211	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
212	return -1;
213	}
214	return str_type;
215	}
216
217	/* Work out how much space the destination will need */
218	switch (outform) {
219	case MBSTRING_ASC:
220	outlen = nchar;
221	cpyfunc = cpy_asc;
222	break;
223
224	case MBSTRING_BMP:
225	outlen = nchar << 1;
226	cpyfunc = cpy_bmp;
227	break;
228
229	case MBSTRING_UNIV:
230	outlen = nchar << 2;
231	cpyfunc = cpy_univ;
232	break;
233
234	case MBSTRING_UTF8:
235	outlen = 0;
236	traverse_string(in, len, inform, out_utf8, &outlen);
237	cpyfunc = cpy_utf8;
238	break;
239	}
240	if (!(p = OPENSSL_malloc(outlen + 1))) {
241	if (free_out)
242	ASN1_STRING_free(dest);
243	ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
244	return -1;
245	}
246	dest->length = outlen;
247	dest->data = p;
248	p[outlen] = 0;
249	traverse_string(in, len, inform, cpyfunc, &p);
250	return str_type;
462f79ec DSH	251	}
462f79ec DSH	252
40720ce3 MC	253	/*
	254	* This function traverses a string and passes the value of each character to
	255	* an optional function along with a void * argument.
462f79ec DSH	256	*/
462f79ec DSH	257
042a93e4	258	static int traverse_string(const unsigned char *p, int len, int inform,
40720ce3 MC	259	int (rfunc) (unsigned long value, void in),
40720ce3 MC	260	void *arg)
462f79ec	261	{
40720ce3 MC	262	unsigned long value;
	263	int ret;
	264	while (len) {
	265	if (inform == MBSTRING_ASC) {
	266	value = *p++;
	267	len--;
	268	} else if (inform == MBSTRING_BMP) {
	269	value = *p++ << 8;
	270	value \|= *p++;
	271	len -= 2;
	272	} else if (inform == MBSTRING_UNIV) {
	273	value = ((unsigned long)*p++) << 24;
	274	value \|= ((unsigned long)*p++) << 16;
	275	value \|= *p++ << 8;
	276	value \|= *p++;
	277	len -= 4;
	278	} else {
	279	ret = UTF8_getc(p, len, &value);
	280	if (ret < 0)
	281	return -1;
	282	len -= ret;
	283	p += ret;
	284	}
	285	if (rfunc) {
	286	ret = rfunc(value, arg);
	287	if (ret <= 0)
	288	return ret;
	289	}
	290	}
	291	return 1;
462f79ec DSH	292	}
	293
	294	/* Various utility functions for traverse_string */
	295
	296	/* Just count number of characters */
	297
	298	static int in_utf8(unsigned long value, void *arg)
	299	{
40720ce3 MC	300	int *nchar;
	301	nchar = arg;
	302	(*nchar)++;
	303	return 1;
462f79ec DSH	304	}
	305
	306	/* Determine size of output as a UTF8 String */
	307
	308	static int out_utf8(unsigned long value, void *arg)
	309	{
40720ce3 MC	310	int *outlen;
	311	outlen = arg;
	312	*outlen += UTF8_putc(NULL, -1, value);
	313	return 1;
462f79ec DSH	314	}
462f79ec DSH	315
40720ce3 MC	316	/*
	317	* Determine the "type" of a string: check each character against a supplied
	318	* "mask".
462f79ec DSH	319	*/
	320
	321	static int type_str(unsigned long value, void *arg)
	322	{
40720ce3 MC	323	unsigned long types;
	324	types = ((unsigned long )arg);
	325	if ((types & B_ASN1_PRINTABLESTRING) && !is_printable(value))
	326	types &= ~B_ASN1_PRINTABLESTRING;
	327	if ((types & B_ASN1_IA5STRING) && (value > 127))
	328	types &= ~B_ASN1_IA5STRING;
	329	if ((types & B_ASN1_T61STRING) && (value > 0xff))
	330	types &= ~B_ASN1_T61STRING;
	331	if ((types & B_ASN1_BMPSTRING) && (value > 0xffff))
	332	types &= ~B_ASN1_BMPSTRING;
	333	if (!types)
	334	return -1;
	335	((unsigned long )arg) = types;
	336	return 1;
462f79ec DSH	337	}
	338
	339	/* Copy one byte per character ASCII like strings */
	340
	341	static int cpy_asc(unsigned long value, void *arg)
	342	{
40720ce3 MC	343	unsigned char *p, q;
	344	p = arg;
	345	q = *p;
	346	*q = (unsigned char)value;
	347	(*p)++;
	348	return 1;
462f79ec DSH	349	}
	350
	351	/* Copy two byte per character BMPStrings */
	352
	353	static int cpy_bmp(unsigned long value, void *arg)
	354	{
40720ce3 MC	355	unsigned char *p, q;
	356	p = arg;
	357	q = *p;
	358	*q++ = (unsigned char)((value >> 8) & 0xff);
	359	*q = (unsigned char)(value & 0xff);
	360	*p += 2;
	361	return 1;
462f79ec DSH	362	}
	363
	364	/* Copy four byte per character UniversalStrings */
	365
	366	static int cpy_univ(unsigned long value, void *arg)
	367	{
40720ce3 MC	368	unsigned char *p, q;
	369	p = arg;
	370	q = *p;
	371	*q++ = (unsigned char)((value >> 24) & 0xff);
	372	*q++ = (unsigned char)((value >> 16) & 0xff);
	373	*q++ = (unsigned char)((value >> 8) & 0xff);
	374	*q = (unsigned char)(value & 0xff);
	375	*p += 4;
	376	return 1;
462f79ec DSH	377	}
	378
	379	/* Copy to a UTF8String */
	380
	381	static int cpy_utf8(unsigned long value, void *arg)
	382	{
40720ce3 MC	383	unsigned char **p;
	384	int ret;
	385	p = arg;
	386	/* We already know there is enough room so pass 0xff as the length */
	387	ret = UTF8_putc(*p, 0xff, value);
	388	*p += ret;
	389	return 1;
462f79ec DSH	390	}
	391
	392	/* Return 1 if the character is permitted in a PrintableString */
	393	static int is_printable(unsigned long value)
	394	{
40720ce3 MC	395	int ch;
	396	if (value > 0x7f)
	397	return 0;
	398	ch = (int)value;
	399	/*
	400	* Note: we can't use 'isalnum' because certain accented characters may
	401	* count as alphanumeric in some environments.
	402	*/
97d8e82c	403	#ifndef CHARSET_EBCDIC
40720ce3 MC	404	if ((ch >= 'a') && (ch <= 'z'))
	405	return 1;
	406	if ((ch >= 'A') && (ch <= 'Z'))
	407	return 1;
	408	if ((ch >= '0') && (ch <= '9'))
	409	return 1;
	410	if ((ch == ' ') \|\| strchr("'()+,-./:=?", ch))
	411	return 1;
	412	#else /* CHARSET_EBCDIC */
	413	if ((ch >= os_toascii['a']) && (ch <= os_toascii['z']))
	414	return 1;
	415	if ((ch >= os_toascii['A']) && (ch <= os_toascii['Z']))
	416	return 1;
	417	if ((ch >= os_toascii['0']) && (ch <= os_toascii['9']))
	418	return 1;
	419	if ((ch == os_toascii[' ']) \|\| strchr("'()+,-./:=?", os_toebcdic[ch]))
	420	return 1;
	421	#endif /* CHARSET_EBCDIC */
	422	return 0;
462f79ec	423	}