reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-25 12:40:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c6b011e35e
CMake/Utilities/cmxmlrpc/xmlrpc_utf8.c
Andy Cedilnik 994bb76916 COMP: Remove warning on gcc
2005-03-06 11:23:46 -05:00

373 lines
14 KiB
C
Raw Blame History

/* Copyright (C) 2001 by Eric Kidd. 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. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR 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. */
/*=========================================================================
** XML-RPC UTF-8 Utilities
**=========================================================================
** Routines for validating, encoding and decoding UTF-8 data. We try to
** be very, very strict about invalid UTF-8 data.
**
** All of the code in this file assumes that your machine represents
** wchar_t as a 16-bit (or wider) character containing UCS-2 data. If this
** assumption is incorrect, you may need to replace this file.
**
** For lots of information on Unicode and UTF-8 decoding, see:
** http://www.cl.cam.ac.uk/~mgk25/unicode.html
*/
#include "xmlrpc_config.h"
#include "xmlrpc.h"
#ifdef HAVE_UNICODE_WCHAR
/*=========================================================================
** Tables and Constants
**=========================================================================
** We use a variety of tables and constants to help decode and validate
** UTF-8 data.
*/
/* The number of bytes in a UTF-8 sequence starting with the character used
** as the array index. A zero entry indicates an illegal initial byte.
** This table was generated using a Perl script and information from the
** UTF-8 standard.
**
** Fredrik Lundh's UTF-8 decoder Python 2.0 uses a similar table. But
** since Python 2.0 has the icky CNRI license, I regenerated this
** table from scratch and wrote my own decoder. */
static unsigned char utf8_seq_length[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0, 0
};
/* The minimum legal character value for a UTF-8 sequence of the given
** length. We have to check this to avoid accepting "overlong" UTF-8
** sequences, which use more bytes than necessary to encode a given
** character. Such sequences are commonly used by evil people to bypass
** filters and security checks. This table is based on the UTF-8-test.txt
** file by Markus Kuhn <mkuhn@acm.org>. */
static wchar_t utf8_min_char_for_length[4] = {
0, /* Length 0: Not used (meaningless) */
0x0000, /* Length 1: Not used (special-cased) */
0x0080, /* Length 2 */
0x0800 /* Length 3 */
#if 0
/* These are only useful on systems where wchar_t is 32-bits wide
** and supports full UCS-4. */
0x00010000, /* Length 4 */
0x00200000, /* Length 5 */
0x04000000 /* Length 6 */
#endif
};
/* This is the maximum legal 16-byte (UCS-2) character. Again, this
** information is based on UTF-8-test.txt. */
#define UCS2_MAX_LEGAL_CHARACTER (0xFFFD)
/* First and last UTF-16 surrogate characters. These are *not* legal UCS-2
** characters--they're used to code for UCS-4 characters when using
** UTF-16. They should never appear in decoded UTF-8 data! Again, these
** could hypothetically be used to bypass security measures on some machines.
** Based on UTF-8-test.txt. */
#define UTF16_FIRST_SURROGATE (0xD800)
#define UTF16_LAST_SURROGATE (0xDFFF)
/* Is the character 'c' a UTF-8 continuation character? */
#define IS_CONTINUATION(c) (((c) & 0xC0) == 0x80)
/* Maximum number of bytes needed to encode a supported character. */
#define MAX_ENCODED_BYTES (3)
/*=========================================================================
** decode_utf8
**=========================================================================
** Internal routine which decodes (or validates) a UTF-8 string.
** To validate, set io_buff and out_buff_len to NULL. To decode, allocate
** a sufficiently large buffer, pass it as io_buff, and pass a pointer as
** as out_buff_len. The data will be written to the buffer, and the
** length to out_buff_len.
**
** We assume that wchar_t holds a single UCS-2 character in native-endian
** byte ordering.
*/
static void
decode_utf8(xmlrpc_env * const env,
const char * const utf8_data,
size_t const utf8_len,
wchar_t * const io_buff,
size_t * const out_buff_len) {
size_t i, length, out_pos;
char init, con1, con2;
wchar_t wc;
XMLRPC_ASSERT_ENV_OK(env);
XMLRPC_ASSERT_PTR_OK(utf8_data);
XMLRPC_ASSERT((!io_buff && !out_buff_len) ||
(io_buff && out_buff_len));
/* Suppress GCC warning about possibly undefined variable. */
wc = 0;
i = 0;
out_pos = 0;
while (i < utf8_len) {
init = utf8_data[i];
if ((init & 0x80) == 0x00) {
/* Convert ASCII character to wide character. */
wc = init;
i++;
} else {
/* Look up the length of this UTF-8 sequence. */
length = utf8_seq_length[(unsigned char) init];
/* Check to make sure we have enough bytes to convert. */
if (i + length > utf8_len)
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"Truncated UTF-8 sequence");
/* Decode a multibyte UTF-8 sequence. */
switch (length) {
case 0:
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"Invalid UTF-8 initial byte");
case 2:
/* 110xxxxx 10xxxxxx */
con1 = utf8_data[i+1];
if (!IS_CONTINUATION(con1))
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"UTF-8 sequence too short");
wc = ((((wchar_t) (init & 0x1F)) << 6) |
(((wchar_t) (con1 & 0x3F))));
break;
case 3:
/* 1110xxxx 10xxxxxx 10xxxxxx */
con1 = utf8_data[i+1];
con2 = utf8_data[i+2];
if (!IS_CONTINUATION(con1) || !IS_CONTINUATION(con2))
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"UTF-8 sequence too short");
wc = ((((wchar_t) (init & 0x0F)) << 12) |
(((wchar_t) (con1 & 0x3F)) << 6) |
(((wchar_t) (con2 & 0x3F))));
break;
case 4:
/* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
case 5:
/* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
case 6:
/* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"UCS-4 characters not supported");
default:
XMLRPC_ASSERT("Error in UTF-8 decoder tables");
}
/* Advance to the end of the sequence. */
i += length;
/* Check for illegal UCS-2 characters. */
if (wc > UCS2_MAX_LEGAL_CHARACTER)
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"UCS-2 characters > U+FFFD are illegal");
/* Check for UTF-16 surrogates. */
if (UTF16_FIRST_SURROGATE <= wc && wc <= UTF16_LAST_SURROGATE)
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"UTF-16 surrogates may not appear in UTF-8 data");
/* Check for overlong sequences. */
if (wc < utf8_min_char_for_length[length])
XMLRPC_FAIL(env, XMLRPC_INVALID_UTF8_ERROR,
"Overlong UTF-8 sequence not allowed");
}
/* If we have a buffer, write our character to it. */
if (io_buff) {
io_buff[out_pos++] = wc;
}
}
/* Record the number of characters we found. */
if (out_buff_len)
*out_buff_len = out_pos;
cleanup:
if (env->fault_occurred) {
if (out_buff_len)
*out_buff_len = 0;
}
}
/*=========================================================================
** xmlrpc_validate_utf8
**=========================================================================
** Make sure that a UTF-8 string is valid.
*/
void
xmlrpc_validate_utf8 (xmlrpc_env * const env,
const char * const utf8_data,
size_t const utf8_len) {
decode_utf8(env, utf8_data, utf8_len, NULL, NULL);
}
/*=========================================================================
** xmlrpc_utf8_to_wcs
**=========================================================================
** Decode UTF-8 string to a "wide character string". This function
** returns an xmlrpc_mem_block with an element type of wchar_t. Don't
** try to intepret the block in a bytewise fashion--it won't work in
** any useful or portable fashion.
*/
xmlrpc_mem_block *xmlrpc_utf8_to_wcs (xmlrpc_env *env,
char *utf8_data,
size_t utf8_len)
{
xmlrpc_mem_block *output;
size_t wcs_length;
/* Allocate a memory block large enough to hold any possible output.
** We assume that each byte of the input may decode to a whcar_t. */
output = XMLRPC_TYPED_MEM_BLOCK_NEW(wchar_t, env, utf8_len);
XMLRPC_FAIL_IF_FAULT(env);
/* Decode the UTF-8 data. */
decode_utf8(env, utf8_data, utf8_len,
XMLRPC_TYPED_MEM_BLOCK_CONTENTS(wchar_t, output),
&wcs_length);
XMLRPC_FAIL_IF_FAULT(env);
/* Make sure we didn't overrun our buffer. */
XMLRPC_ASSERT(wcs_length <= utf8_len);
/* Correct the length of the memory block. */
XMLRPC_TYPED_MEM_BLOCK_RESIZE(wchar_t, env, output, wcs_length);
XMLRPC_FAIL_IF_FAULT(env);
cleanup:
if (env->fault_occurred) {
if (output)
xmlrpc_mem_block_free(output);
return NULL;
}
return output;
}
/*=========================================================================
** xmlrpc_utf8_to_wcs
**=========================================================================
** Encode a "wide character string" as UTF-8.
*/
xmlrpc_mem_block *xmlrpc_wcs_to_utf8 (xmlrpc_env *env,
wchar_t *wcs_data,
size_t wcs_len)
{
size_t estimate, bytes_used, i;
xmlrpc_mem_block *output;
unsigned char *buffer;
wchar_t wc;
int cwc;
XMLRPC_ASSERT_ENV_OK(env);
XMLRPC_ASSERT_PTR_OK(wcs_data);
/* Allocate a memory block large enough to hold any possible output.
** We assume that every wchar might encode to the maximum length. */
estimate = wcs_len * MAX_ENCODED_BYTES;
output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, env, estimate);
XMLRPC_FAIL_IF_FAULT(env);
/* Output our characters. */
buffer = (unsigned char*) XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output);
bytes_used = 0;
for (i = 0; i < wcs_len; i++) {
wc = wcs_data[i];
cwc = wc;
if (cwc <= 0x007F) {
buffer[bytes_used++] = wc & 0x7F;
} else if (cwc <= 0x07FF) {
/* 110xxxxx 10xxxxxx */
buffer[bytes_used++] = 0xC0 | (wc >> 6);
buffer[bytes_used++] = 0x80 | (wc & 0x3F);
} else if (cwc <= 0xFFFF) {
/* 1110xxxx 10xxxxxx 10xxxxxx */
buffer[bytes_used++] = 0xE0 | (wc >> 12);
buffer[bytes_used++] = 0x80 | ((wc >> 6) & 0x3F);
buffer[bytes_used++] = 0x80 | (wc & 0x3F);
} else {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR,
"Don't know how to encode UCS-4 characters yet");
}
}
/* Make sure we didn't overrun our buffer. */
XMLRPC_ASSERT(bytes_used <= estimate);
/* Correct the length of the memory block. */
XMLRPC_TYPED_MEM_BLOCK_RESIZE(char, env, output, bytes_used);
XMLRPC_FAIL_IF_FAULT(env);
cleanup:
if (env->fault_occurred) {
if (output)
xmlrpc_mem_block_free(output);
return NULL;
}
return output;
}
#endif /* HAVE_UNICODE_WCHAR */
Reference in New Issue View Git Blame Copy Permalink